@nanobpm/urban 0.96.1 → 0.96.3

package/src/toolkit/scaffold/workers.test.ts

@@ -146,6 +146,19 @@ test("planWorkerScaffold: skips a task type declared external (out-of-process wo
   assert.equal(reasons["senior:review"], "external");
 });
 
+test("planWorkerScaffold: skips an inline-handled (w.run) task type — never stubs a hosted handler (nano-ide#595)", () => {
+  // A code-first `w.run` step's handler lives inline in the flow and is hosted by the in-process
+  // Worker; scaffolding a throwing stub for its job type would put a second, always-failing worker
+  // on the same job type. The derivation reports those types, and the planner must skip them.
+  const models = [
+    model("a.bpmn", "greet", serviceTask("hello", "greet:hello"), serviceTask("B", "greet:ship")),
+  ];
+  const { plans, skipped } = planWorkerScaffold(models, [], [], [], ["greet:hello"]);
+  assert.deepEqual(plans.map((p) => p.taskType), ["greet:ship"]);
+  const reasons = Object.fromEntries(skipped.map((s) => [s.taskType, s.reason]));
+  assert.equal(reasons["greet:hello"], "inline");
+});
+
 test("planWorkerScaffold: colliding slugs get a numeric suffix", () => {
   const m = model("a.bpmn", "p", serviceTask("A", "orders.charge"), serviceTask("B", "orders-charge"));
   const { plans } = planWorkerScaffold([m], [], []);
@@ -258,6 +271,58 @@ test("scaffoldWorkers is idempotent: a second --write run is a no-op", async ()
   assert.equal(JSON.stringify(io.files), snapshot, "files unchanged on re-run");
 });
 
+test("scaffoldWorkers skips inline-handled (w.run) task types — no stub, no wiring (nano-ide#595)", async () => {
+  const files = {
+    "/app/nano.app.json": JSON.stringify({
+      id: "demo",
+      models: { processes: ["processes/*.bpmn"] },
+    }),
+    "/app/processes/p.bpmn": model("p.bpmn", "greet",
+      serviceTask("hello", "greet:hello"),
+      serviceTask("B", "greet:notify"),
+    ).xml,
+  };
+  const io = memIO(files);
+  const run = await scaffoldWorkers({ root: "/app", io, write: true, inlineTaskTypes: ["greet:hello"] });
+  // Only the external (un-hosted) task is scaffolded; the inline one is skipped entirely.
+  assert.deepEqual(run.outcomes.map((o) => o.taskType), ["greet:notify"]);
+  assert.ok(run.skipped.some((s) => s.taskType === "greet:hello" && s.reason === "inline"));
+  assert.equal(io.files["/app/workers/greet-hello/worker.ts"], undefined, "inline task gets no stub");
+  const manifest = JSON.parse(io.files["/app/nano.app.json"]);
+  assert.ok(
+    !manifest.workers?.some((w: { taskType: string }) => w.taskType === "greet:hello"),
+    "inline task is never wired into workers[]",
+  );
+});
+
+test("scaffoldWorkers prefers an in-memory derived model over a stale disk copy at the same path (nano-ide#595)", async () => {
+  // `--check`/`--no-models` runs never write the derived `.bpmn`, so a derived model's path can
+  // hold a STALE disk copy. Planning from disk would miss newly added external tasks and keep
+  // removed ones. The in-memory model must win — the same precedence `collectAll` (gen.ts) gives
+  // the type-contract derivers.
+  const files = {
+    "/app/nano.app.json": JSON.stringify({
+      id: "demo",
+      models: { processes: ["processes/*.bpmn"] },
+    }),
+    // Stale disk copy: still has the REMOVED task, lacks the ADDED one.
+    "/app/processes/p.bpmn": model("p.bpmn", "p", serviceTask("Old", "t.removed")).xml,
+  };
+  const io = memIO(files);
+  const derived = model("processes/p.bpmn", "p", serviceTask("New", "t.added"));
+  const run = await scaffoldWorkers({ root: "/app", io, write: true, extraModels: [derived] });
+  // The fresh model is planned from: the added task is scaffolded, the removed one is not.
+  assert.deepEqual(run.outcomes.map((o) => o.taskType), ["t.added"]);
+  assert.ok(io.files["/app/workers/t-added/worker.ts"], "added task gets a stub");
+  assert.equal(io.files["/app/workers/t-removed/worker.ts"], undefined, "removed task gets no stub");
+  const manifest = JSON.parse(io.files["/app/nano.app.json"]);
+  assert.deepEqual(
+    manifest.workers?.map((w: { taskType: string }) => w.taskType),
+    ["t.added"],
+    "only the fresh model's task is wired",
+  );
+});
+
 test("scaffoldWorkers reads manifest.externalTaskTypes and skips those (never scaffolds/wires)", async () => {
   const files = {
     "/app/nano.app.json": JSON.stringify({

package/src/toolkit/scaffold/workers.ts

@@ -39,7 +39,7 @@ export interface WorkerStubPlan {
   manifestEntry: StubManifestEntry;
 }
 
-export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external";
+export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external" | "inline";
 
 export interface SkippedWorker {
   taskType: string;
@@ -118,16 +118,20 @@ export function renderWorkerStub(
 /**
  * Plan write-once handler stubs from the models. A stub is planned for each service-task
  * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, NOT
- * declared external (serviced by an out-of-process worker), and not a duplicate of one already
- * planned. `declaredTypeIds` are the manifest `types` ids — an envelope `in`/`out` is typed only
- * when it names one (matching the worker-io deriver). `externalTaskTypes` are the manifest's
- * declared external task types, which the app owns the model for but deliberately does not host.
+ * declared external (serviced by an out-of-process worker), NOT inline-handled (a code-first
+ * `w.run` step whose handler the app's in-process Worker already serves — nano-ide#595), and
+ * not a duplicate of one already planned. `declaredTypeIds` are the manifest `types` ids — an
+ * envelope `in`/`out` is typed only when it names one (matching the worker-io deriver).
+ * `externalTaskTypes` are the manifest's declared external task types, which the app owns the
+ * model for but deliberately does not host. `inlineTaskTypes` are the flow-derived inline
+ * (`w.run`) job types (`deriveModels().inlineTaskTypes`).
  */
 export function planWorkerScaffold(
   models: ModelSource[],
   workers: ScaffoldWorker[] = [],
   declaredTypeIds: Iterable<string> = [],
   externalTaskTypes: Iterable<string> = [],
+  inlineTaskTypes: Iterable<string> = [],
 ): WorkerScaffoldPlan {
   const wired = new Set(
     workers
@@ -136,6 +140,7 @@ export function planWorkerScaffold(
   );
   const declared = new Set(declaredTypeIds);
   const external = new Set(externalTaskTypes);
+  const inline = new Set(inlineTaskTypes);
 
   const plans: WorkerStubPlan[] = [];
   const skipped: SkippedWorker[] = [];
@@ -153,6 +158,10 @@ export function planWorkerScaffold(
         skipped.push({ taskType, reason: "external" });
         continue;
       }
+      if (inline.has(taskType)) {
+        skipped.push({ taskType, reason: "inline" });
+        continue;
+      }
       if (wired.has(taskType)) {
         skipped.push({ taskType, reason: "already-wired" });
         continue;

package/src/toolkit/scaffold.ts

@@ -5,6 +5,7 @@
 
 import type { GenIO } from "./gen.ts";
 import { joinPath, readModels } from "./gen.ts";
+import type { ModelSource } from "./derivers/worker-io.ts";
 import {
   planWorkerScaffold,
   type ScaffoldWorker,
@@ -50,6 +51,22 @@ export interface ScaffoldOptions {
   manifestFile?: string;
   /** Apply changes (create files + patch manifest). Default false = dry-run. */
   write?: boolean;
+  /**
+   * Job types of inline-handled (`w.run`) code-first steps — the set the app's in-process
+   * Worker already serves (nano-ide#595). The planner skips these with reason `"inline"` so
+   * `urban gen` never scaffolds a throwing stub that competes with the real handler. Pass
+   * `deriveModels().inlineTaskTypes` (the `generate` composition does).
+   */
+  inlineTaskTypes?: Iterable<string>;
+  /**
+   * Extra in-memory models to plan against in addition to the on-disk ones `readModels`
+   * resolves (nano-ide#595). A code-first app's derived `.bpmn` lives under
+   * `resources/processes/`, which `readModels` does NOT resolve when the manifest declares a
+   * `models` block (e.g. `models.workflows`) without `models.processes` — a declared block
+   * suppresses the `resources/` convention. Pass `deriveModels().models` so the scaffolder
+   * plans from the same fused model set the type-contract derivers saw.
+   */
+  extraModels?: ModelSource[];
 }
 
 export type StubStatus = "created" | "would-create" | "kept";
@@ -87,14 +104,23 @@ export async function scaffoldWorkers(opts: ScaffoldOptions): Promise<ScaffoldRu
   // Preserve the manifest's own indentation when we patch it back (default tab, matching the
   // scaffold's Biome config), so wiring a worker never reformats the file out from under lint.
   const manifestIndent = detectJsonIndent(manifestRaw);
-  const models = await readModels(root, io, manifest);
+  const diskModels = await readModels(root, io, manifest);
   const declaredTypeIds = Object.keys(manifest.types ?? {});
 
+  // Fuse on-disk models with any in-memory extras (code-first derived models — see
+  // `ScaffoldOptions.extraModels`), deduped by path with the IN-MEMORY model winning: a derived
+  // model whose path also exists on disk may be stale there (`--check`/`--no-models` never write
+  // it), so planning from the disk copy would miss newly added tasks and keep removed ones. This
+  // mirrors the precedence `collectAll` (gen.ts) gives the type-contract derivers.
+  const extraPaths = new Set((opts.extraModels ?? []).map((m) => m.path));
+  const models = [...diskModels.filter((m) => !extraPaths.has(m.path)), ...(opts.extraModels ?? [])];
+
   const { plans, skipped } = planWorkerScaffold(
     models,
     manifest.workers ?? [],
     declaredTypeIds,
     manifest.externalTaskTypes ?? [],
+    opts.inlineTaskTypes ?? [],
   );
 
   const outcomes: StubOutcome[] = [];