mod.dang

"""
A Dagger module that uses the Python SDK.
"""
type Mod {
  """
  Workspace-root-relative path of this module root.
  """
  pub rootPath: String!

  """
  The workspace this module belongs to.
  """
  let ws: Workspace!

  """
  Marker filename that skips generate when found at or above this module root.
  """
  let skipGenerateFilename: String!

  """
  Module root relative to the client's cwd.
  """
  pub path: String! {
    let cwd = ws.cwd.trimPrefix("/").trimSuffix("/")
    if (rootPath == cwd) {
      "."
    } else if (cwd == "") {
      rootPath
    } else if (rootPath.trimPrefix(cwd + "/") != rootPath) {
      rootPath.trimPrefix(cwd + "/")
    } else if (rootPath == "." or cwd.trimPrefix(rootPath + "/") != cwd) {
      let depth = if (rootPath == ".") { 0 } else { rootPath.split("/").length }
      cwd.split("/").dropFirst(depth).map { segment => ".." }.join("/")
    } else {
      rootPath
    }
  }

  """
  Whether this module or an ancestor contains the configured generate skip marker.
  """
  pub skipGenerate: Boolean! {
    ws.findUp(name: skipGenerateFilename, from: rootPath) != null
  }

  """
  Manage this module's Python build configuration (pyproject.toml).
  """
  pub config: ModConfig! {
    ModConfig(path: rootPath, ws: ws)
  }

  """
  Generate this module.
  If the generate skip marker is present, the changeset is empty.
  """
  pub generate: Changeset! {
    if (skipGenerate) {
      ws.changes(ws)
    } else {
      # Stage the local dependency closure so this module's codegen sees
      # up-to-date dependency bindings. It is only an input to resolving the
      # module source, never the diff baseline, so the dependencies' codegen
      # does not ride along.
      let stagedWs = ws.withChanges(
        ws.moduleSource("/" + rootPath).generateLocalDependencies(ws),
      )
      let generated = if (isModern) {
        # A dagger-module.toml module is generated here, by this SDK's own code
        # generator. Its runtime generates nothing, so asking the engine for a
        # generated context would come back empty.
        vendoredDir(stagedWs)
      } else {
        # A pre-1.0 module keeps being generated by the runtime its dagger.json
        # names, which is the engine's builtin Python SDK.
        stagedWs
          .moduleSource("/" + rootPath)
          .generatedContextDirectory
          .directory(rootPath)
      }

      # The generated context holds only generated files, and withNewDirectory
      # replaces rather than layers, so merge it onto the module first.
      # Workspace.changes then reports just the difference, rooted at the
      # caller's cwd.
      ws.withNewDirectory(
        "/" + rootPath,
        ws.directory("/" + rootPath).withDirectory(".", generated),
      ).changes(ws)
    }
  }

  """
  Whether this module uses the 1.0 dagger-module.toml config.
  """
  let isModern: Boolean! {
    let configPath = if (rootPath == ".") { "dagger-module.toml" } else { rootPath + "/dagger-module.toml" }
    ws.directory("/", include: [configPath]).exists(configPath)
  }

  """
  This SDK's client library, with bindings generated against the module's own
  schema, laid out the way it is vendored into a module.

  A module-rooted directory holding only `sdk/`, so the caller can merge it onto
  the module without touching anything else the module owns.
  """
  let vendoredDir(stagedWs: Workspace!): Directory! {
    let schemaJSON = stagedWs.moduleSource("/" + rootPath).introspectionSchemaJSON

    directory.withDirectory(
      vendorDirName,
      library.withFile(generatedBindingsPath, bindings(schemaJSON)),
    )
  }

  """
  Client bindings generated from a module's schema by this SDK's code generator.
  """
  let bindings(schemaJSON: File!): File! {
    codegenBase
      .withMountedFile(schemaPath, schemaJSON)
      .withExec([
        "uv", "run", "--isolated", "--frozen", "--package", "codegen",
        "python", "-m", "codegen", "generate", "-i", schemaPath, "-o", "/gen.py",
      ])
      .file("/gen.py")
  }

  """
  Container with this SDK's client library and code generator mounted.
  """
  let codegenBase: Container! {
    container
      .from(codegenImage)
      .withoutEntrypoint
      .withMountedCache("/root/.cache/uv", cacheVolume("python-sdk-uv"))
      .withEnvVariable("UV_LINK_MODE", "copy")
      .withDirectory("/sdk", codegenSource)
      .withWorkdir("/sdk")
  }

  """
  What the code generator needs to run: the library plus the generator itself,
  and the lock that pins the generator's own dependencies.
  """
  let codegenSource: Directory! {
    currentModule.source.directory("sdk").filter(include: [
      "pyproject.toml",
      "uv.lock",
      "src/**/*.py",
      "src/**/*.typed",
      "codegen/pyproject.toml",
      "codegen/**/*.py",
    ])
  }

  """
  What a module actually needs vendored: the importable client library, its
  license, and a project file describing just that.

  The code generator runs in this SDK, never in a module, and the library's own
  lock pins the generator's development environment rather than the module's.
  """
  let library: Directory! {
    currentModule.source
      .directory("sdk")
      .filter(include: [
        "LICENSE",
        "README.md",
        "src/**/*.py",
        "src/**/*.typed",
        # The library imports this under suppress(ModuleNotFoundError) and says
        # it "doesn't make sense in modules": it provisions an engine for a
        # standalone script, which a module already has.
        "!src/dagger/provisioning/**",
      ])
      .withFile("pyproject.toml", libraryPyproject)
  }

  """
  The library's project file with its development sections removed.

  As published, it declares the code generator as a uv workspace member and a
  dev dependency. Vendoring that verbatim without the generator makes `uv`
  refuse to install the library at all, so the sections that only describe
  developing this SDK are dropped.
  """
  let libraryPyproject: File! {
    codegenBase
      .withFile(stripScriptPath, currentModule.source.file("helpers/vendor-pyproject/strip_dev_sections.py"))
      .withExec(["python", stripScriptPath, "pyproject.toml", "/library-pyproject.toml"])
      .file("/library-pyproject.toml")
  }

  let stripScriptPath: String! = "/strip-dev-sections.py"

  let vendorDirName: String! = "sdk"
  let generatedBindingsPath: String! = "src/dagger/client/gen.py"
  let schemaPath: String! = "/schema.json"
  let codegenImage: String! = "ghcr.io/astral-sh/uv:python3.14-alpine"
}