typescript-sdk.dang

enum Runtime {
  NODE
  BUN
  DENO
}

type TypescriptSdk {
  let tsPattern = "\"sdk\"\\s*:\\s*\\{[^}]*\"source\"\\s*:\\s*\"typescript\""

  """
  Marker filename that skips generate when found at or above a TypeScript SDK module root.
  """
  pub skipGenerateFilename: String! = ".dagger-typescript-sdk-skip-generate"

  """
  Return every Dagger module whose sdk.source is "typescript".
  """
  pub modules(ws: Workspace!): [Mod!]! {
    ws
      .directory("/", include: ["**/dagger.json"])
      .search(
        pattern: tsPattern,
        globs: ["**/dagger.json"],
        filesOnly: true,
        multiline: true,
        dotall: true,
      )
      .{filePath}
      .map { configPath =>
        mod(
          ws,
          if (configPath.filePath == "dagger.json") { "." } else { configPath.filePath.trimSuffix("/dagger.json") },
          findUp: false,
        )
      }
  }

  """
  Return the TypeScript SDK module at or above a workspace path.

  When `findUp` is true, `path` may point inside the module.
  """
  pub mod(ws: Workspace!, path: String! = ".", findUp: Boolean! = true): Mod! {
    let modPath = if (findUp) {
      let foundConfigPath = ws.findUp("dagger.json", path)
      if (foundConfigPath == null) {
        raise "no Dagger module found containing path: " + path
      } else {
        let configPath = foundConfigPath.trimPrefix("/")
        if (
          ws
            .directory("/", include: [configPath])
            .file(configPath)
            .search(
              pattern: tsPattern,
              multiline: true,
              dotall: true,
              limit: 1,
            )
            .{id}
            .length == 0
        ) {
          raise "Dagger module does not use the TypeScript SDK: " + path
        } else if (configPath == "dagger.json") {
          "."
        } else {
          configPath.trimSuffix("/dagger.json")
        }
      }
    } else {
      path.trimPrefix("/")
    }

    Mod(
      path: modPath,
      ws: ws,
      skipGenerateFilename: skipGenerateFilename,
    )
  }

  """
  Create a new TypeScript SDK Dagger module and return the files to write.

  By default, the new module is created under the nearest `.dagger` directory
  visible from the current workspace path:

    <nearest .dagger>/modules/<name>

  Pass `path` to choose a different module location. The target path must not
  already contain a Dagger module.

  Pass `template` to materialize files from templates/<template>. The empty
  default uses this module's default template.

  By default, future generated SDK files are checked into version control. Pass
  `ignoreGenerated` to configure generation to add generated SDK paths to
  .gitignore instead.
  """
  pub init(ws: Workspace!, name: String!, path: String! = "", template: String! = "", runtime: Runtime! = Runtime.NODE, ignoreGenerated: Boolean! = false): Changeset! {
    let rawPath = if (path == "") {
      let daggerDir = ws.findUp(".dagger", ".")
      if (daggerDir == null) {
        ".dagger/modules/" + name
      } else {
        daggerDir.trimPrefix("/") + "/modules/" + name
      }
    } else {
      path.trimPrefix("./").trimPrefix("/")
    }

    let modPath = if (rawPath == "" or rawPath == ".") {
      "."
    } else if (rawPath == ".." or rawPath.trimPrefix("../") != rawPath) {
      raise "path escapes workspace: " + rawPath
    } else {
      rawPath.trimSuffix("/")
    }

    let configPath = if (modPath == ".") { "dagger.json" } else { modPath + "/dagger.json" }
    let selectedTemplate = "default" # Add templates selection
    let fork = polyfill.workspace(ws).fork

    if (ws.directory("/", include: [configPath]).exists(configPath)) {
      raise "module already exists: " + modPath
    } else if (currentModule.source.exists("templates/" + selectedTemplate) == false) {
      raise "unknown init template: " + template
    } else {
      let includePrefix = if (modPath == ".") { "" } else { modPath + "/" }
      let existing = ws.directory("/", include: [
        includePrefix + "package.json",
        includePrefix + "tsconfig.json",
        includePrefix + "deno.json",
        includePrefix + "bun.lock",
      ])

      let config = "{\n  \"name\": " + toJSON(name) + ",\n  \"engineVersion\": \"latest\",\n  \"sdk\": {\n    \"source\": \"typescript\"\n  },\n  \"codegen\": {\n    \"automaticGitignore\": " + toJSON(ignoreGenerated) + "\n  }\n}\n"
      let templateSource = if (selectedTemplate == "default") {
        renderedDefaultTemplate(name, runtime, existing, modPath)
      } else {
        currentModule.source.directory("templates/" + selectedTemplate)
      }
      let seeded = fork
        .withDirectory(modPath, templateSource)
        .withNewFile(configPath, config)

      seeded.changes
    }
  }

  """
  Return init templates tracked by this module.

  Templates live under templates/<name> and are materialized into the new
  module. Passing an empty template to init uses the module default.
  """
  pub templates: [Template!]! {
    if (currentModule.source.exists("templates")) {
      let root = currentModule.source.directory("templates")
      root.entries.map { name =>
        Template(
          name: name.trimSuffix("/"),
          source: root.directory(name),
        )
      }
    } else {
      directory.entries.map { name =>
        Template(
          name: name,
          source: directory,
        )
      }
    }
  }

  """
  Render the default TypeScript template with the requested module name and runtime.

  Seeds index.ts from the common template, then layers in runtime-specific
  config files via the config-updator helper. The config-updator reads
  existing user config files (rooted at modPath in `existing`) so any user
  customizations are preserved; only Dagger-required keys are added or
  refreshed.
  """
  let renderedDefaultTemplate(name: String!, runtime: Runtime!, existing: Directory!, modPath: String!): Directory! {
    let existingPrefix = if (modPath == ".") { "/existing/" } else { "/existing/" + modPath + "/" }
    let wsPrefix = if (modPath == ".") { "" } else { modPath + "/" }

    let builder = container
      .from("golang:1.25-alpine")
      .withoutEntrypoint
      .withMountedCache("/go/pkg/mod", cacheVolume("go-mod"))
      .withMountedCache("/root/.cache/go-build", cacheVolume("go-build"))
      .withDirectory("/helpers/render-template", currentModule.source.directory("helpers/render-template"))
      .withDirectory("/helpers/config-updator", currentModule.source.directory("helpers/config-updator"))
      .withDirectory("/template", currentModule.source.directory("templates/default"))
      .withDirectory("/existing", existing)
      .withWorkdir("/helpers/render-template")
      .withExec(["go", "build", "-o", "/usr/local/bin/render-template", "."])
      .withWorkdir("/helpers/config-updator")
      .withExec(["go", "build", "-o", "/usr/local/bin/config-updator", "."])
      .withExec(["render-template", name, "/template", "/rendered"])

    let withConfig = if (runtime == Runtime.NODE) {
      builder
        .withExec(["config-updator", "package-json", existingPrefix + "package.json", "/rendered/package.json"])
        .withExec(["config-updator", "tsconfig", existingPrefix + "tsconfig.json", "/rendered/tsconfig.json"])
    } else if (runtime == Runtime.BUN) {
      # The Dagger TypeScript runtime picks bun over node by spotting bun.lock,
      # so we emit an empty one for a fresh init. If the workspace already has
      # one we leave it alone (overlay semantics via init's withDirectory).
      let nodeConfig = builder
        .withExec(["config-updator", "package-json", existingPrefix + "package.json", "/rendered/package.json"])
        .withExec(["config-updator", "tsconfig", existingPrefix + "tsconfig.json", "/rendered/tsconfig.json"])
      if (existing.exists(wsPrefix + "bun.lock")) {
        nodeConfig
      } else {
        nodeConfig.withExec(["touch", "/rendered/bun.lock"])
      }
    } else {
      builder
        .withExec(["config-updator", "deno-config", existingPrefix + "deno.json", "/rendered/deno.json"])
    }

    withConfig.directory("/rendered")
  }

  """
  Generate all discovered Go SDK modules.
  Modules with the generate skip marker are skipped.
  """
  pub generateAll(ws: Workspace!): Changeset! @generate {
    let pws = polyfill.workspace(ws)

    modules(ws)
      .filter { mod => mod.skipGenerate(ws) == false }
      .reduce(pws.fork) { fork, mod =>
        fork.merge(pws.moduleSource(mod.path).generate)
      }
      .changes
  }
}