@nanobpm/urban 0.90.1 → 0.91.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nanobpm/urban",
-	"version": "0.90.1",
+	"version": "0.91.0",
 	"description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
 	"license": "Apache-2.0",
 	"type": "module",

package/src/cli.test.ts

@@ -1,7 +1,14 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { cmdData } from "./cli.ts";
 import { isRecord } from "./runtime/core/guards.ts";
+import { createNodeHost } from "./runtime/adapters/node.ts";
+import { runDataOp } from "./runtime/core/modules/dataops.ts";
 
 // The `urban data` gateway's contract (see cmdData's docstring): *every* reply — including an
 // unreadable request — is a parseable `{ ok: false, error }` envelope on stdout AND the process
@@ -41,3 +48,85 @@ test("urban data exits 0 with a parseable envelope on an unreadable request", as
   if (typeof reply.error !== "string") throw new TypeError("expected string error");
   assert.match(reply.error, /^bad request: /);
 });
+
+// Regression guard for nanobpm/nano-ide#549: `urban data`'s success path prints the full reply
+// with `console.log`, then the top-level runner calls `process.exit(code)`. In Node, stdout
+// connected to a *pipe* is asynchronous — an immediate `process.exit` abandons anything still
+// buffered, truncating the reply at the OS pipe-buffer boundary (65536 bytes on Linux) so the
+// console host fails to `JSON.parse` it ("EOF … column 65536"). The fix drains stdout before the
+// explicit exit. This test spawns the real CLI on a datasource whose query result serialises to
+// well over 64 KB, reads the piped stdout, and asserts the parent parses a complete envelope whose
+// byte length matches the untruncated JSON. It FAILS before the fix (truncated at 65536) and
+// passes after.
+test("urban data streams a > 64 KB reply without truncation through an explicit process.exit", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "urban-data-large-"));
+  try {
+    await mkdir(join(dir, "db", "migrations"), { recursive: true });
+    await writeFile(
+      join(dir, "nano.app.json"),
+      JSON.stringify({
+        schemaVersion: 1,
+        id: "big",
+        name: "Big",
+        data: {
+          default: "app",
+          sources: { app: { driver: "sqlite", url: "file:./db/app.db", migrations: "db/migrations" } },
+        },
+      }),
+    );
+    await writeFile(
+      join(dir, "db", "migrations", "001_big.sql"),
+      "CREATE TABLE big (id INTEGER PRIMARY KEY, payload TEXT NOT NULL);",
+    );
+    // 2000 rows × ~128-char payload → a query reply of roughly 300 KB, comfortably past the 64 KB
+    // pipe boundary. A single recursive-CTE INSERT (no inner `;`) so the migration splitter keeps
+    // it as one statement.
+    await writeFile(
+      join(dir, "db", "migrations", "002_seed.sql"),
+      "INSERT INTO big (id, payload) WITH RECURSIVE seq(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM seq WHERE n < 2000) SELECT n, printf('%0128d', n) FROM seq;",
+    );
+
+    const host = createNodeHost({ cwd: dir });
+    await runDataOp(host, ".", "nano.app.json", { op: "migrate" });
+    const query = { op: "query", sql: "SELECT * FROM big ORDER BY id" } as const;
+    const result = await runDataOp(host, ".", "nano.app.json", query);
+    const expected = `${JSON.stringify({ ok: true, ...result })}\n`;
+    const expectedBytes = Buffer.byteLength(expected);
+    assert.ok(
+      expectedBytes > 65536,
+      `fixture too small (${expectedBytes} bytes) to exercise the pipe-buffer boundary`,
+    );
+
+    const cli = fileURLToPath(new URL("./cli.ts", import.meta.url));
+    const { stdout, code, signal } = await new Promise<{
+      stdout: Buffer;
+      code: number | null;
+      signal: NodeJS.Signals | null;
+    }>((resolve, reject) => {
+      const child = spawn(
+        process.execPath,
+        ["--experimental-strip-types", cli, "data", "--root", dir],
+        { stdio: ["pipe", "pipe", "inherit"] },
+      );
+      const chunks: Buffer[] = [];
+      child.stdout.on("data", (c: Buffer) => chunks.push(c));
+      child.on("error", reject);
+      child.on("close", (code, signal) => resolve({ stdout: Buffer.concat(chunks), code, signal }));
+      child.stdin.end(JSON.stringify(query));
+    });
+
+    assert.equal(signal, null, `CLI killed by signal ${signal}`);
+    assert.equal(code, 0, `CLI exited ${code}, expected 0`);
+    assert.equal(
+      stdout.byteLength,
+      expectedBytes,
+      `stdout truncated: got ${stdout.byteLength} bytes, expected ${expectedBytes}`,
+    );
+    const reply: unknown = JSON.parse(stdout.toString("utf8"));
+    assert.ok(isRecord(reply));
+    assert.equal(reply.ok, true);
+    assert.deepEqual(reply, { ok: true, ...result });
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/cli.ts

@@ -22,6 +22,7 @@ import {
   selectHost,
 } from "./runtime/index.ts";
 import { denoGlobal, processGlobal } from "./runtime/adapters/globals.ts";
+import type { WritableStdio } from "./runtime/adapters/globals.ts";
 import { errorMessage, isRecord } from "./runtime/core/guards.ts";
 import { scaffold, slugify } from "create-urban-app";
 import type { DataRequest } from "./runtime/index.ts";
@@ -446,6 +447,31 @@ export async function main(argv: string[]): Promise<number> {
   }
 }
 
+/**
+ * Flush a Node writable stdio stream, resolving once its buffered writes have drained to the OS.
+ * `process.stdout`/`stderr` connected to a *pipe* is asynchronous in Node: `console.log` buffers
+ * the write and an immediate `process.exit()` abandons anything not yet handed to the OS, so a
+ * large reply (> the 64 KB pipe buffer on Linux) is silently truncated. Writing an empty chunk and
+ * waiting for its completion callback drains the prior writes first. Deno's stdio has no such
+ * `write(chunk, cb)` shape (its `console.log` is synchronous), so its absence is a no-op flush.
+ */
+function flushStream(stream: WritableStdio | undefined): Promise<void> {
+  return new Promise((resolve) => {
+    if (!stream || typeof stream.write !== "function") {
+      resolve();
+      return;
+    }
+    stream.write("", () => resolve());
+  });
+}
+
+/** Drain both stdout and stderr before an explicit `process.exit` so no buffered output is lost. */
+async function flushStdio(): Promise<void> {
+  const p = processGlobal();
+  if (!p) return;
+  await Promise.all([flushStream(p.stdout), flushStream(p.stderr)]);
+}
+
 const proc = processGlobal();
 const deno = denoGlobal();
 const importMetaMain: unknown = Reflect.get(import.meta, "main");
@@ -462,11 +488,15 @@ if (importMetaMain === true || nodeMain) {
     else if (deno?.exit) deno.exit(code);
   };
   main(argv).then(
-    (code) => {
-      if (code >= 0) exit(code);
+    async (code) => {
+      if (code >= 0) {
+        await flushStdio();
+        exit(code);
+      }
     },
-    (err) => {
+    async (err) => {
       console.error(errorMessage(err));
+      await flushStdio();
       exit(1);
     },
   );

package/src/runtime/adapters/globals.ts

@@ -8,10 +8,22 @@ export interface DenoRuntimeGlobal {
   addSignalListener?: (sig: string, cb: () => void) => void;
 }
 
+/**
+ * The subset of a Node writable stdio stream (`process.stdout` / `process.stderr`) we depend on:
+ * a `write` that accepts a completion callback fired once the chunk has flushed to the OS. Deno's
+ * stdio streams do not expose this shape; callers treat its absence as "already synchronous, no
+ * flush needed" (see `flushStdio` in cli.ts).
+ */
+export interface WritableStdio {
+  write?: (chunk: string, cb: () => void) => void;
+}
+
 export interface ProcessRuntimeGlobal {
   argv?: string[];
   exit?: (code: number) => void;
   stdin?: AsyncIterable<Uint8Array | string> & { setEncoding?(encoding: string): void };
+  stdout?: WritableStdio;
+  stderr?: WritableStdio;
   on?: (sig: string, cb: () => void) => void;
 }
 

package/src/runtime/browser/runtime.browser.js

@@ -1955,9 +1955,17 @@ function buildEngineForm(cfg, row, onSuccess) {
   const formKey = row[cfg.formKeyField || "form_key"];
   const box = el("div", { class: "pc-subform" });
   const msg = el("p", { class: "njf-msg", role: "status", "aria-live": "polite" });
+  // Optional page-author knob: route completion through the app's own canonical
+  // door instead of the runtime's generic seam. Defaults to /app/actions/complete
+  // when unset (existing pages unchanged). Same trust class as detail.form's
+  // action.path; rebased through apiUrl() by getJSON like every other page fetch.
+  const completePath =
+    typeof cfg.completePath === "string" && cfg.completePath.trim() !== ""
+      ? cfg.completePath.trim()
+      : "/app/actions/complete";
   /** @param {Record<string, any>} variables */
   const complete = (variables) =>
-    getJSON("/app/actions/complete", {
+    getJSON(completePath, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify({ userTaskKey, variables }),

package/src/runtime/browser/runtime.engineform.test.ts

@@ -84,6 +84,7 @@ test("buildEngineForm resolves the row's formKey and completes with the entered
   assert.ok(input, "the deployed form-js schema was rendered by the shared renderer");
   input!.value = "done";
   const form = created.find((n) => n.tagName === "FORM");
+  assert.ok(form, "the deployed schema rendered a form element to submit");
   await form!.fire("submit");
   await new Promise((r) => setTimeout(r, 0));
   const completeReq = calls.find((c) => c.url.includes("/app/actions/complete"));
@@ -116,6 +117,7 @@ test("buildEngineForm surfaces a completion failure in the rendered-form path",
   assert.ok(msg, "a failed completion is surfaced to the operator (not silent)");
   assert.notEqual(msg!.textContent, "", "the error message element has text");
   const submit = created.find((n) => n.tagName === "BUTTON" && n.type === "submit");
+  assert.ok(submit, "the completion path rendered a submit button");
   assert.equal(submit!.disabled, false, "the submit button is re-enabled so the operator can retry");
 });
 
@@ -156,3 +158,101 @@ test("buildEngineForm degrades to bare completion when the formKey resolves to n
   const button = created.find((n) => n.tagName === "BUTTON" && n.textContent === "Complete");
   assert.ok(button, "a 204 (no form) falls back to the bare completion button");
 });
+
+test("buildEngineForm routes the rendered-form completion through a configured completePath", async (t) => {
+  const created: FakeElement[] = [];
+  const calls: FetchCall[] = [];
+  t.after(installFakeDom(created));
+  t.after(
+    installFakeFetch((url) => {
+      if (url.includes("/app/actions/form")) {
+        return { status: 200, json: { schema: { components: [{ type: "textfield", key: "note" }] } } };
+      }
+      return { status: 200, json: { ok: true } };
+    }, calls),
+  );
+  const box = buildEngineForm(
+    { ...CFG, completePath: "/app/api/actions/complete-user-task" },
+    { form_key: "form-c", user_task_key: "ut-c" },
+    () => {},
+  );
+  assert.ok(box);
+  await new Promise((r) => setTimeout(r, 0));
+  const input = created.find((n) => n.tagName === "INPUT");
+  assert.ok(input, "the deployed form-js schema was rendered by the shared renderer");
+  input!.value = "done";
+  const form = created.find((n) => n.tagName === "FORM");
+  assert.ok(form, "the deployed schema rendered a form element to submit");
+  await form!.fire("submit");
+  await new Promise((r) => setTimeout(r, 0));
+  const completeReq = calls.find((c) => c.url.includes("/app/api/actions/complete-user-task"));
+  assert.ok(completeReq, "completion POSTs to the configured completePath, not the generic seam");
+  assert.equal(completeReq!.method, "POST");
+  assert.deepEqual(completeReq!.body, { userTaskKey: "ut-c", variables: { note: "done" } });
+  assert.equal(
+    calls.some((c) => c.url.includes("/app/actions/complete")),
+    false,
+    "the generic seam is not called when completePath is set",
+  );
+});
+
+test("buildEngineForm routes the bare completion through a configured completePath", async (t) => {
+  const created: FakeElement[] = [];
+  const calls: FetchCall[] = [];
+  t.after(installFakeDom(created));
+  t.after(installFakeFetch(() => ({ status: 200, json: { ok: true } }), calls));
+  const box = buildEngineForm(
+    { ...CFG, completePath: "/app/custom-complete" },
+    { user_task_key: "ut-b" },
+    () => {},
+  );
+  assert.ok(box);
+  const button = created.find((n) => n.tagName === "BUTTON");
+  assert.ok(button, "the bare completion path rendered a Complete button");
+  await button!.fire("click");
+  await new Promise((r) => setTimeout(r, 0));
+  const completeReq = calls.find((c) => c.url.includes("/app/custom-complete"));
+  assert.ok(completeReq, "the bare button completes via the configured completePath");
+  assert.equal(completeReq!.body.userTaskKey, "ut-b");
+  assert.deepEqual(completeReq!.body.variables, {}, "bare completion sends empty variables");
+  assert.equal(
+    calls.some((c) => c.url.includes("/app/actions/complete")),
+    false,
+    "the generic seam is not called when completePath is set",
+  );
+});
+
+test("buildEngineForm falls back to the generic seam when completePath is empty/absent", async (t) => {
+  const created: FakeElement[] = [];
+  const calls: FetchCall[] = [];
+  t.after(installFakeDom(created));
+  t.after(installFakeFetch(() => ({ status: 200, json: { ok: true } }), calls));
+  // An empty-string completePath is treated as absent (default seam preserved).
+  const box = buildEngineForm({ ...CFG, completePath: "" }, { user_task_key: "ut-d" }, () => {});
+  assert.ok(box);
+  const button = created.find((n) => n.tagName === "BUTTON");
+  assert.ok(button, "the bare completion path rendered a Complete button");
+  await button!.fire("click");
+  await new Promise((r) => setTimeout(r, 0));
+  const completeReq = calls.find((c) => c.url.includes("/app/actions/complete"));
+  assert.ok(completeReq, "an empty completePath still targets the default /app/actions/complete seam");
+  assert.equal(completeReq!.body.userTaskKey, "ut-d");
+});
+
+test("buildEngineForm treats a whitespace-only completePath as absent", async (t) => {
+  const created: FakeElement[] = [];
+  const calls: FetchCall[] = [];
+  t.after(installFakeDom(created));
+  t.after(installFakeFetch(() => ({ status: 200, json: { ok: true } }), calls));
+  // A whitespace-only completePath is normalized away so it never becomes an
+  // unintended relative fetch target — the default seam is preserved.
+  const box = buildEngineForm({ ...CFG, completePath: "   " }, { user_task_key: "ut-e" }, () => {});
+  assert.ok(box);
+  const button = created.find((n) => n.tagName === "BUTTON");
+  assert.ok(button, "the bare completion path rendered a Complete button");
+  await button!.fire("click");
+  await new Promise((r) => setTimeout(r, 0));
+  const completeReq = calls.find((c) => c.url.includes("/app/actions/complete"));
+  assert.ok(completeReq, "a whitespace-only completePath still targets the default /app/actions/complete seam");
+  assert.equal(completeReq!.body.userTaskKey, "ut-e");
+});