@nanobpm/urban 0.79.0 → 0.81.0

package/src/runtime/core/modules/open-user-tasks-store.test.ts

@@ -154,3 +154,14 @@ test("syncInstance is atomic — it composes inside an existing transaction and
 test("the DSL projection name is stable and unprefixed (usable in `exists(...)`)", () => {
   assert.equal(OPEN_USER_TASKS_PROJECTION, "urban_open_user_tasks");
 });
+
+test("instanceKeys returns each distinct instance with ≥1 open task (and drops one when cleared)", async () => {
+  await withStore((store) => {
+    assert.deepEqual(store.instanceKeys(), []); // empty projection
+    store.syncInstance("pi-1", [task("ut-1"), task("ut-2")]); // two tasks, one instance
+    store.syncInstance("pi-2", [task("ut-3")]);
+    assert.deepEqual(store.instanceKeys().sort(), ["pi-1", "pi-2"]); // distinct, not per-task
+    store.clearInstance("pi-1"); // answered/terminated
+    assert.deepEqual(store.instanceKeys(), ["pi-2"]); // retired key no longer listed
+  });
+});

package/src/runtime/core/modules/open-user-tasks-store.ts

@@ -144,6 +144,17 @@ export class OpenUserTasksStore {
     this.#db.run(`DELETE FROM ${OPEN_USER_TASKS_TABLE} WHERE process_instance_key = ?`, [processInstanceKey]);
   }
 
+  /** Every distinct instance key currently projected as having ≥1 open user task. Used by the
+   *  reconciler to re-probe (and, when answered, RETIRE) keys that have dropped out of a binding's
+   *  `activeStatuses` allow-list — a projected row must be retired independently of the base-row
+   *  selector, or an answered escalation's row would linger and the derived edge tear (ADR 0065). */
+  instanceKeys(): string[] {
+    const rows = this.#db.all<{ process_instance_key: string }>(
+      `SELECT DISTINCT process_instance_key FROM ${OPEN_USER_TASKS_TABLE}`,
+    );
+    return rows.map((r) => r.process_instance_key);
+  }
+
   /** True iff the instance currently has any open user task — the "parked on a human" predicate. */
   hasOpenTask(processInstanceKey: string): boolean {
     if (!processInstanceKey) return false;

package/src/runtime/core/modules/pages.test.ts

@@ -1950,3 +1950,102 @@ test("the nested serve declines (does not shadow) a same-path trigger route regi
   assert.equal(hook.status, 202);
   assert.deepEqual(JSON.parse(hook.body ?? "{}"), { queued: true });
 });
+
+// ── engine-declared forms in a dataGrid detail (ADR 0026 / #457) ────────────
+// The pages surface exposes the SAME two seams the taskInbox surface uses:
+//   GET  /app/actions/form?formKey=…   → resolve a deployed .form's form-js schema
+//   POST /app/actions/complete         → complete the row's user task
+// so one grid can render the several different typed forms a heterogeneous task
+// inbox carries, instead of duplicating each into a page-local `detail.form`.
+
+/** A recording engine for the form-resolution + completion seams. `resolveForm`
+ * supplies the getForm result while the wrapper still records every call, so a test
+ * can assert BOTH the resolved schema and the exact `{formKey, formId}` the shared
+ * presence gate passed through. */
+function formEngine(
+  resolveForm: (input: { formKey?: string; formId?: string }) => Awaited<ReturnType<EngineClient["getForm"]>> = () => null,
+): {
+  engine: EngineClient;
+  formCalls: { formKey?: string; formId?: string }[];
+  completeCalls: { userTaskKey: string; variables?: Record<string, unknown> }[];
+} {
+  const formCalls: { formKey?: string; formId?: string }[] = [];
+  const completeCalls: { userTaskKey: string; variables?: Record<string, unknown> }[] = [];
+  const { engine } = fakeEngine();
+  const withSeams: EngineClient = {
+    ...engine,
+    async getForm(input: { formKey?: string; formId?: string }) {
+      formCalls.push(input);
+      return resolveForm(input);
+    },
+    async completeUserTask(userTaskKey: string, variables?: Record<string, unknown>) {
+      completeCalls.push({ userTaskKey, variables });
+    },
+  };
+  return { engine: withSeams, formCalls, completeCalls };
+}
+
+function formRouter(engine: EngineClient) {
+  const routes = createPagesRoutes({ pagesDir: "pages", homePage: "home", sourceName: "app" }, {
+    db: fakeDb(),
+    engine,
+    readPage: async () => JSON.stringify({ title: "Home", nodes: [] }),
+    listPages: async () => ["home"],
+  });
+  return makeRouter(routes);
+}
+
+test("GET /app/actions/form resolves a row's engine formKey to its form-js schema", async () => {
+  const schema = { type: "default", components: [{ type: "textfield", key: "note" }] };
+  const { engine, formCalls } = formEngine((input) => ({ formKey: input.formKey, schema }));
+  const res = await formRouter(engine)(req("GET", "/app/actions/form", { query: "formKey=form-123" }));
+  assert.equal(res.status, 200);
+  assert.deepEqual(JSON.parse(res.body ?? "{}").schema, schema);
+  assert.deepEqual(formCalls, [{ formKey: "form-123", formId: undefined }]);
+});
+
+test("GET /app/actions/form 400s when neither formKey nor formId is present (shared presence gate)", async () => {
+  const { engine } = formEngine();
+  const res = await formRouter(engine)(req("GET", "/app/actions/form"));
+  assert.equal(res.status, 400);
+  const blank = await formRouter(engine)(req("GET", "/app/actions/form", { query: "formKey=%20%20" }));
+  assert.equal(blank.status, 400, "a whitespace-only formKey is absent per the host.ts presence rule");
+});
+
+test("GET /app/actions/form 204s when the form can't be resolved (client falls back to bare completion)", async () => {
+  // getForm returns null (default) → 204, matching the taskInbox no-form fallback.
+  const { engine } = formEngine();
+  const res = await formRouter(engine)(req("GET", "/app/actions/form", { query: "formKey=missing" }));
+  assert.equal(res.status, 204);
+  assert.equal(res.body ?? "", "");
+});
+
+test("POST /app/actions/complete completes the row's user task with the submitted variables", async () => {
+  const { engine, completeCalls } = formEngine();
+  const res = await formRouter(engine)(
+    req("POST", "/app/actions/complete", { body: { userTaskKey: "ut-9", variables: { note: "ok" } } }),
+  );
+  assert.equal(res.status, 200);
+  assert.deepEqual(JSON.parse(res.body ?? "{}"), { ok: true });
+  assert.deepEqual(completeCalls, [{ userTaskKey: "ut-9", variables: { note: "ok" } }]);
+});
+
+test("POST /app/actions/complete supports the no-form bare completion (empty variables)", async () => {
+  const { engine, completeCalls } = formEngine();
+  const res = await formRouter(engine)(req("POST", "/app/actions/complete", { body: { userTaskKey: "ut-1" } }));
+  assert.equal(res.status, 200);
+  assert.deepEqual(completeCalls, [{ userTaskKey: "ut-1", variables: undefined }]);
+});
+
+test("POST /app/actions/complete 400s without a userTaskKey", async () => {
+  const { engine, completeCalls } = formEngine();
+  const res = await formRouter(engine)(req("POST", "/app/actions/complete", { body: { variables: {} } }));
+  assert.equal(res.status, 400);
+  assert.equal(completeCalls.length, 0, "no completion is attempted for a keyless body");
+});
+
+test("the pages shell embeds the shared form-js renderer (NanoFormJs) for engine forms", async () => {
+  const res = await dispatch("GET", "/");
+  assert.match(res.body ?? "", /NanoFormJs/, "the shell exposes the shared renderer as a global");
+  assert.match(res.body ?? "", /function renderForm/, "the shared renderer is embedded, not forked");
+});

package/src/runtime/core/modules/pages.ts

@@ -31,8 +31,11 @@ import type { EngineClient } from "../host.ts";
 import { html, json, type Route } from "../router.ts";
 import { cancelInstanceReconciling, type CancelInstanceResult } from "./cancel.ts";
 import { apiDocsPath } from "./api.ts";
+import { FORMJS_JS } from "./formjs.gen.ts";
+import { completeUserTaskResponse, resolveFormResponse } from "./forms.ts";
 import { quoteIdent } from "./gateway.ts";
 import { RENDERER_JS } from "./runtime.gen.ts";
+import { isSqlIdentifier } from "../read-model.ts";
 
 /** The subset of the datasource gateway the page runtime needs. */
 export interface PagesDataSource {
@@ -181,10 +184,10 @@ async function serveAsset(
   }
 }
 
-/** A SQL identifier guard — a table name must be a bare identifier *and* a known table
- * (checked against `schema()`), so `/app/data/:table` can never inject SQL. */
-const IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
-
+/** A table name must be a bare SQL identifier ({@link isSqlIdentifier}, the runtime-wide single source
+ * of truth) *and* a known table (checked against `schema()`), so `/app/data/:table` can never inject
+ * SQL. Reusing the shared guard (rather than a private regex) keeps this surface from drifting from
+ * manifest / read-model / data-source identifier validation. */
 // A query flag (e.g. ?count=1) is "on" when present and not one of the falsy
 // spellings. A bare `?count` (empty string) still counts as on, so a caller can
 // opt in without inventing a value.
@@ -367,7 +370,7 @@ export function createPagesRoutes(opts: PagesOptions, deps: PagesDeps): Route[]
       // v1 exposes only the injected default datasource; a request naming any other
       // source is rejected rather than silently served off the default.
       if (source !== sourceName) return json({ error: `unknown datasource "${source}"` }, 404);
-      if (!IDENT.test(table)) return json({ error: "invalid table name" }, 400);
+      if (!isSqlIdentifier(table)) return json({ error: "invalid table name" }, 400);
       let tables: Set<string>;
       try {
         tables = await knownTables();
@@ -545,6 +548,28 @@ export function createPagesRoutes(opts: PagesOptions, deps: PagesDeps): Route[]
     },
   });
 
+  // ── GET /app/actions/form  &  POST /app/actions/complete (ADR 0026, #457) ───
+  // Engine-declared forms in a `dataGrid` detail drawer. A grid whose `detail`
+  // opts into `engineForm` resolves the selected row's `form_key` here and
+  // completes the row's user task here — the SAME two seams the `taskInbox`
+  // surface uses, reused (not forked) via `forms.ts` so the resolution gate and
+  // the completion contract can't drift between the two surfaces. This closes the
+  // form-duplication drift class: the grid renders the authoritative deployed
+  // `.form` rather than a hand-authored page-local `detail.form` copy.
+  routes.push({
+    method: "GET",
+    path: "/app/actions/form",
+    source: "surface:pages",
+    handler: (req) =>
+      resolveFormResponse(engine, req.query.get("formKey") ?? undefined, req.query.get("formId") ?? undefined),
+  });
+  routes.push({
+    method: "POST",
+    path: "/app/actions/complete",
+    source: "surface:pages",
+    handler: async (req) => completeUserTaskResponse(engine, await req.text()),
+  });
+
   // ── nested (multi-appView) sidecars (#442) ──────────────────────────────
   // An app with more than one `appView` cannot share the four FLAT sidecar names above:
   // each view ships its own SUBDIR sidecar — e.g. `pages/cockpit.page.json` →
@@ -668,6 +693,7 @@ function rendererShell(homePage: string, apiDocsPath?: string): string {
 </head>
 <body>${apiDocsBadge}
   <main id="page" data-home="${escapeAttr(homePage)}"><p class="pc-empty">Loading…</p></main>
+  <script>${FORMJS_JS}</script>
   <script type="module" src=".${RUNTIME_JS_PATH}"></script>
 </body>
 </html>`;
@@ -736,6 +762,19 @@ body { margin:0; font:15px/1.5 system-ui,sans-serif; padding:2rem; max-width:64r
 .pc-field-check input { width:auto; padding:0; accent-color:var(--nano-accent); cursor:pointer; }
 .pc-btn { padding:.5rem .9rem; border:0; border-radius:.4rem; background:var(--nano-accent); color:var(--nano-on-accent); font:inherit; cursor:pointer; }
 .pc-btn:disabled { opacity:.5; cursor:default; }
+/* The shared engine-form renderer (NanoFormJs, ADR 0026/#457) styled to match the
+   page runtime's native detail controls. njf-* are its stable class names; both
+   this surface and the taskInbox page style the same renderer output. */
+.njf-form { display:flex; flex-direction:column; gap:.4rem; margin-top:.5rem; }
+.njf-heading { font-size:1rem; margin:0 0 .25rem; }
+.njf-text { color:var(--nano-text-muted); margin:.25rem 0; }
+.njf-field { display:flex; flex-direction:column; gap:.25rem; }
+.njf-field label { font-size:.8rem; color:var(--nano-text-muted); }
+.njf-field input:not([type=checkbox]):not([type=radio]), .njf-field textarea, .njf-field select { padding:.5rem .6rem; border:1px solid var(--nano-edge); border-radius:.4rem; font:inherit; background:var(--nano-inset); color:var(--nano-text); max-width:24rem; }
+.njf-actions { display:flex; gap:.5rem; margin-top:.4rem; }
+.njf-actions button { padding:.5rem .9rem; border:0; border-radius:.4rem; background:var(--nano-accent); color:var(--nano-on-accent); font:inherit; cursor:pointer; }
+.njf-msg { font-size:.85rem; margin-top:.35rem; }
+.njf-msg.err { color:var(--nano-danger); }
 .pc-msg { font-size:.85rem; margin-top:.5rem; min-height:1.2em; }
 .pc-msg.err { color:var(--nano-danger); }
 .pc-msg.ok { color:var(--nano-ok); }