main.dang

"""
Manage Dagger modules that use the Java SDK (new self-contained code organisation).

Modules created by `init` use the self-contained layout: the Java SDK is vendored
as source and code is generated into the module (see `generate`), and the module
runtime is this repository's build/package-only runtime
(`github.com/dagger/java-sdk/runtime`). Because the generated files are committed,
the runtime skips codegen at module load and just builds and packages the
committed sources.
"""
type JavaSdk {
  """
  Runtime source written into the dagger-module.toml of new Java modules.
  """
  pub targetRuntime: String! { "github.com/dagger/java-sdk/runtime" }

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

  """
  Commit the compiled Dagger Java SDK as a jar into each generated module so its
  runtime build compiles only the module's own code against the jar instead of
  recompiling the vendored SDK sources. The sources stay checked in for IDE use.
  Opt-in (set `settings.vendorSdkJar = true` under `[modules.java-sdk]` in the
  workspace dagger.toml) because it adds a committed binary artifact.
  """
  pub vendorSdkJar: Boolean! = false

  """
  Initialize Java-owned files for a new Dagger module.
  """
  pub initModule(
    ws: Workspace!,
    name: String!,
    path: String!,
  ): Changeset! {
    let rawPath = 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 before = if (modPath == ".") {
      ws.directory("/", include: ["**"])
    } else {
      ws.directory("/", include: [modPath + "/**"])
    }
    before.withDirectory(modPath, renderedTemplate(name, "default")).changes(before)
  }

  """
  Render a Java init template, substituting the requested module name.
  """
  let renderedTemplate(name: String!, template: String!): Directory! {
    container
      .from("golang:1.25-alpine")
      .withoutEntrypoint
      .withMountedCache("/go/pkg/mod", cacheVolume("go-mod"))
      .withMountedCache("/root/.cache/go-build", cacheVolume("go-build"))
      .withDirectory(
        "/helper",
        currentModule.source.directory("helpers/render-java-template"),
      )
      .withDirectory("/template", currentModule.source.directory("templates/" + template))
      .withWorkdir("/helper")
      .withExec(["go", "build", "-o", "/usr/local/bin/render-java-template", "."])
      .withExec(["render-java-template", name, "/template", "/rendered"])
      .directory("/rendered")
  }

  """
  Generate all discovered new-style Java SDK modules (runs at `dagger generate`).
  """
  pub generateAll(ws: Workspace!): Changeset! @generate {
    changeset.withChangesets(
      currentModule.asSDK.modules.{{path}}
        .map { m => Mod(path: m.path, ws: ws, skipGenerateFilename: skipGenerateFilename, vendorSdkJar: vendorSdkJar) }
        .filter { mod => mod.skipGenerate(ws) == false }
        .map { mod => mod.generate(ws) },
    )
  }
}