python-sdk: report only what generation produced

Workspace.changes(from:) reads a file that exists only on the sparse host base
as newly added, so generate(ws).changes(ws) described the workspace base as well
as the generated context: every generate claimed to add the module's own
dagger.json, which the engine owns and had not touched. Traced to
workspaceChangesBetween in core/schema/workspace.go, where the `from` side
carries no overlay; the engine fix is in flight.

Take the generated context straight from the engine, which computes it
correctly, and re-root it at the caller's cwd by hand. Generation stages its own
local dependency closure again, since generatedContextChangeset does not resolve
it the way generate(ws) did, and generateAll merges each module's changeset
rather than threading one workspace through all of them.

Re-rooting cannot express a path outside the cwd, so a changeset holding one
raises instead of silently dropping it and leaving that module ungenerated.

Revert to the native idiom once the engine reports a sparse base correctly.

Signed-off-by: Yves Brissaud <yves@dagger.io>

Author: eunomie

.dagger/modules/e2e/main.dang

@@ -253,6 +253,31 @@ type E2e {
   Generating an existing module should produce generated files rooted at that
   module without touching unrelated paths.
   """
+  """
+  Generation should report only what generation produced.
+
+  A module's own config is engine-owned and already on disk, so a changeset that
+  claims to add it is describing the workspace base rather than the generated
+  context.
+  """
+  pub generateSkipsEngineConfigCheck(ws: Workspace!): Void @check {
+    let config = generateModulePath + "/dagger.json"
+
+    let single = pythonSdk.mod(ws, path: generateModulePath).generate
+    assert(
+      contains(single.addedPaths, config) == false,
+      "generate reported the engine-owned dagger.json as added",
+    )
+
+    let all = pythonSdk.generateAll(ws)
+    assert(
+      contains(all.addedPaths, config) == false,
+      "generateAll reported the engine-owned dagger.json as added",
+    )
+
+    null
+  }
+
   pub generateCheck(ws: Workspace!): Void @check {
     let changes = pythonSdk.mod(ws, path: generateModulePath).generate
 

mod.dang

@@ -58,7 +58,41 @@ type Mod {
     if (skipGenerate) {
       ws.changes(ws)
     } else {
-      ws.moduleSource("/" + rootPath).generate(ws).changes(ws)
+      # Stage the local dependency closure so this module's codegen sees
+      # up-to-date dependency bindings. The staged workspace is only an input:
+      # the generated context is diffed against the base it was generated from,
+      # so the dependencies' own codegen does not ride along.
+      let stagedWs = ws.withChanges(ws.moduleSource("/" + rootPath).generateLocalDependencies(ws))
+      atCwd(stagedWs.moduleSource("/" + rootPath).generatedContextChangeset)
+    }
+  }
+
+  """
+  Re-root a workspace-rooted changeset at the client's cwd.
+
+  The engine roots a generated context at the workspace, but a returned
+  changeset is applied relative to the caller's cwd, so without this every path
+  would land nested under the cwd a second time.
+
+  `Workspace.changes(from:)` is the native API for this. On v1.0.0-beta.10 it
+  reads a file that exists only on the sparse host base as newly added, so a
+  module's own `dagger.json` is reported as something generation produced, and
+  the rooting stays explicit here until the engine side is fixed.
+  """
+  let atCwd(changes: Changeset!): Changeset! {
+    let cwd = ws.cwd.trimPrefix("/").trimSuffix("/")
+    if (cwd == "" or cwd == ".") {
+      changes
+    } else {
+      # A cwd-relative changeset cannot express a path outside the cwd — a
+      # module found above it, say — and re-rooting would silently drop it,
+      # leaving that module never regenerated. Fail loudly instead.
+      let outside = (changes.addedPaths + changes.modifiedPaths + changes.removedPaths)
+        .filter { p => p != cwd and p.trimPrefix(cwd + "/") == p }
+      if (outside.length > 0) {
+        raise "generated changes fall outside the current directory " + cwd + ": " + outside.join(", ")
+      }
+      changes.after.directory(cwd).changes(changes.before.directory(cwd))
     }
   }
 }

python-sdk.dang

@@ -216,11 +216,10 @@ type PythonSdk {
   Modules with the generate skip marker are skipped.
   """
   pub generateAll(ws: Workspace!): Changeset! @generate {
-    modules(ws)
-      .filter { mod => mod.skipGenerate == false }
-      .reduce(ws) { stagedWs, mod =>
-        stagedWs.moduleSource("/" + mod.rootPath).generate(stagedWs)
-      }
-      .changes(ws)
+    changeset.withChangesets(
+      modules(ws)
+        .filter { mod => mod.skipGenerate == false }
+        .map { mod => mod.generate },
+    )
   }
 }