@nanobpm/urban 0.40.2 → 0.42.0

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

@@ -73,9 +73,18 @@ export interface PagesDeps {
   cancel?(processInstanceKey: string): Promise<CancelInstanceResult>;
 }
 
-/** A JavaScript-body response (the renderer module served at /app/runtime.js). */
-function javascript(body: string, status = 200): { status: number; headers: Record<string, string>; body: string } {
-  return { status, headers: { "content-type": "text/javascript; charset=utf-8" }, body };
+/** A JavaScript-body response (the renderer module served at the fingerprinted
+ * `/app/runtime.<hash>.js`, and its `/app/runtime.js` back-compat route). */
+function javascript(
+  body: string,
+  status = 200,
+  extraHeaders?: Record<string, string>,
+): { status: number; headers: Record<string, string>; body: string } {
+  return {
+    status,
+    headers: { "content-type": "text/javascript; charset=utf-8", ...extraHeaders },
+    body,
+  };
 }
 
 /** A SQL identifier guard — a table name must be a bare identifier *and* a known table
@@ -130,15 +139,30 @@ export function createPagesRoutes(opts: PagesOptions, deps: PagesDeps): Route[]
 
   const routes: Route[] = [];
   const shell = html(rendererShell(homePage, opts.apiDocsPath));
+  // The shell must never be pinned by the browser: it carries the *current* fingerprinted
+  // runtime URL, so a stale shell would keep pointing at an old module hash. `no-cache` forces
+  // a revalidation on every load; the shell body is tiny, and the expensive module it references
+  // is what gets the long-lived immutable caching (via its content-hashed URL).
+  shell.headers = { ...shell.headers, "cache-control": "no-cache" };
 
   // ── the renderer shell + module ─────────────────────────────────────────
   routes.push({ method: "GET", path: "/", source: "surface:pages", handler: () => shell });
   routes.push({ method: "GET", path: "/index.html", source: "surface:pages", handler: () => shell });
+  // The fingerprinted module URL (referenced by the shell): unique per content, so cache it hard.
+  routes.push({
+    method: "GET",
+    path: RUNTIME_JS_PATH,
+    source: "surface:pages",
+    handler: () => javascript(RENDERER_JS, 200, { "cache-control": IMMUTABLE_CACHE }),
+  });
+  // Back-compat / defence in depth: the legacy unhashed URL keeps working, but is served
+  // `no-cache` so any client (or cached shell) that still requests it always revalidates and
+  // gets the current bytes instead of replaying a heuristically-cached older copy.
   routes.push({
     method: "GET",
     path: "/app/runtime.js",
     source: "surface:pages",
-    handler: () => javascript(RENDERER_JS),
+    handler: () => javascript(RENDERER_JS, 200, { "cache-control": "no-cache" }),
   });
 
   // ── GET /app/pages (index of available pages) ───────────────────────────
@@ -422,7 +446,7 @@ function rendererShell(homePage: string, apiDocsPath?: string): string {
   // UI for free). `target="_blank"` + hardened `rel` so the docs open without giving the docs
   // tab a handle back to this window (reverse-tabnabbing).
   //
-  // The href must be DOCUMENT-relative, exactly like the `./app/runtime.js` script tag below:
+  // The href must be DOCUMENT-relative, exactly like the `./app/runtime.<hash>.js` script tag below:
   // the shell is served at the app's mount root (always a trailing "/"), which is the origin
   // root for a direct run (CLI on :3000) but a path prefix under the Nano console's reverse
   // proxy (/console/app-view/<name>/). A root-absolute "/app/api-docs" would escape that prefix
@@ -446,7 +470,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 type="module" src="./app/runtime.js"></script>
+  <script type="module" src=".${RUNTIME_JS_PATH}"></script>
 </body>
 </html>`;
 }
@@ -501,7 +525,9 @@ body { margin:0; font:15px/1.5 system-ui,sans-serif; padding:2rem; max-width:64r
 .pc-card h2 { font-size:1rem; margin:0 0 .75rem; }
 .pc-field { display:flex; flex-direction:column; gap:.25rem; margin-bottom:.6rem; }
 .pc-field label { font-size:.8rem; color:var(--nano-text-muted); }
-.pc-field input { padding:.5rem .6rem; border:1px solid var(--nano-edge); border-radius:.4rem; font:inherit; background:var(--nano-inset); color:var(--nano-text); }
+.pc-field input:not([type=checkbox]) { padding:.5rem .6rem; border:1px solid var(--nano-edge); border-radius:.4rem; font:inherit; background:var(--nano-inset); color:var(--nano-text); }
+.pc-field-check label { display:flex; flex-direction:row; align-items:center; gap:.5rem; font-size:.9rem; color:var(--nano-text); cursor:pointer; }
+.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; }
 .pc-msg { font-size:.85rem; margin-top:.5rem; min-height:1.2em; }
@@ -809,8 +835,24 @@ function renderActionForm(node) {
   const inputs = new Map();
   const fieldTypes = new Map();
   for (const f of p.fields || []) {
-    const kind = f.type === "number" ? "number" : "text";
+    const kind = f.type === "checkbox" ? "checkbox" : (f.type === "number" ? "number" : "text");
     fieldTypes.set(f.key, kind);
+    if (kind === "checkbox") {
+      // A boolean field renders a real checkbox; its default checked state comes
+      // from default/checked on the field (unset -> unchecked). We record that on
+      // the input's defaultChecked so a post-submit reset can restore it without a
+      // side map that could drift from the actual input.
+      const checked = f.default === true || f.checked === true;
+      const input = el("input", { type: "checkbox" });
+      input.defaultChecked = checked;
+      input.checked = checked;
+      inputs.set(f.key, input);
+      // Input-first, wrapped in the label so the whole row is a click target.
+      card.append(
+        el("div", { class: "pc-field pc-field-check" }, el("label", {}, input, " " + (f.label || f.key))),
+      );
+      continue;
+    }
     const attrs = { type: kind, placeholder: f.label || f.key };
     if (kind === "number") {
       attrs.inputmode = "numeric";
@@ -827,7 +869,11 @@ function renderActionForm(node) {
   btn.addEventListener("click", async () => {
     const variables = Object.create(null);
     for (const [k, input] of inputs) {
-      if (fieldTypes.get(k) === "number") {
+      if (fieldTypes.get(k) === "checkbox") {
+        // Always emit a real boolean (checked -> true / false), never a string,
+        // so a strict equality check on the action side sees the intended value.
+        variables[k] = input.checked === true;
+      } else if (fieldTypes.get(k) === "number") {
         const t = String(input.value).trim();
         // Blank → omit so the action-side default applies; a non-finite parse
         // (NaN/Infinity) is also omitted rather than smuggling a raw string
@@ -850,7 +896,12 @@ function renderActionForm(node) {
       msg.className = "pc-msg ok";
       msg.textContent = (p.action && p.action.successLabel) ||
         (res && res.processInstanceKey != null ? "Started (instance " + res.processInstanceKey + ")" : "Done");
-      for (const input of inputs.values()) input.value = "";
+      for (const [k, input] of inputs) {
+        // Text/number inputs clear; a checkbox resets to its declared default,
+        // read straight off the input's defaultChecked (no side map to drift).
+        if (fieldTypes.get(k) === "checkbox") input.checked = input.defaultChecked;
+        else input.value = "";
+      }
       document.dispatchEvent(new CustomEvent("pc:refresh"));
     } catch (e) {
       msg.className = "pc-msg err"; msg.textContent = String(e.message || e);
@@ -1328,3 +1379,25 @@ async function renderPage() {
 window.addEventListener("hashchange", renderPage);
 renderPage();
 `;
+
+/** A tiny, dependency-free FNV-1a hash → 8 hex chars. Used to fingerprint the renderer
+ *  module's URL so a content change busts the browser cache. Environment-agnostic (no
+ *  `crypto` import) so the runtime stays loadable under Node, Deno, and the embedded host. */
+function fnv1aHex(s: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+// The renderer module is served at a *content-fingerprinted* URL. The shell references this exact
+// path, so whenever `RENDERER_JS` changes (e.g. an Urban upgrade in a marketplace/Studio update)
+// the URL changes with it and the browser fetches the new module instead of silently replaying a
+// heuristically-cached copy of the old one — the failure that made a "Cancel" button (and every
+// other page action) do nothing after an upgrade until a hard refresh. Because the URL is unique
+// per content, the response itself is served `immutable` with a one-year max-age.
+const RUNTIME_JS_HASH = fnv1aHex(RENDERER_JS);
+const RUNTIME_JS_PATH = `/app/runtime.${RUNTIME_JS_HASH}.js`;
+const IMMUTABLE_CACHE = "public, max-age=31536000, immutable";

package/src/runtime/index.ts

@@ -54,8 +54,10 @@ export type {
   WorkerSubscription,
 } from "./core/host.ts";
 export type { AppApi, Mounted, RuntimeContext } from "./core/context.ts";
-// Structured logging surface (see core/logger.ts): the shape of `AppApi.log`.
-export type { Logger, LogLevel, LogFields } from "./core/logger.ts";
+// Structured logging surface (see core/logger.ts): the shape of `AppApi.log`, plus `createLogger`
+// so consumers can build a Logger for a custom sink or a no-op test double (`createLogger(() => {})`).
+export { createLogger } from "./core/logger.ts";
+export type { Logger, LogLevel, LogFields, LogSink } from "./core/logger.ts";
 
 // BPMN error contract: a handler throws `BpmnError(code)` to raise a modelled
 // error routed to an error boundary (ADR 0050), instead of a retryable failure.

package/src/toolkit/gen.test.ts

@@ -257,3 +257,35 @@ test("collectArtifacts resolves an ABSOLUTE api.spec at its own path, not root-r
   const res = await collectArtifacts({ root: "/app", io });
   assert.ok(res.map((a) => a.path).includes("nano-generated/api-io.d.ts"));
 });
+
+test("runGen warns when a requestBody schema is shared across operations, but never fails", async () => {
+  const manifest = JSON.stringify({ id: "demo", data: { default: "app" }, api: { spec: "openapi.json" } });
+  const openapi = JSON.stringify({
+    openapi: "3.1.0",
+    components: { schemas: { StartVariables: { type: "object", properties: { pr: { type: "string" }, url: { type: "string" }, issue: { type: "string" } } } } },
+    paths: {
+      "/convergence": { post: { operationId: "startConvergenceLoop", requestBody: { content: { "application/json": { schema: { $ref: "#/components/schemas/StartVariables" } } } }, responses: { "200": {} } } },
+      "/fanout": { post: { operationId: "startPlanFanout", requestBody: { content: { "application/json": { schema: { $ref: "#/components/schemas/StartVariables" } } } }, responses: { "200": {} } } },
+    },
+  });
+  const io = memIO({ "/app/nano.app.json": manifest, "/app/openapi.json": openapi });
+  const res = await runGen({ root: "/app", io });
+
+  assert.equal(res.incomplete, false); // advisory only — gen still succeeds
+  assert.equal(res.warnings.length, 1, `one shared-body warning: ${JSON.stringify(res.warnings)}`);
+  assert.match(res.warnings[0], /StartVariables/);
+  assert.match(res.warnings[0], /startConvergenceLoop, startPlanFanout/);
+  // A clean spec (distinct bodies) produces no warning.
+  const clean = memIO({
+    "/app/nano.app.json": manifest,
+    "/app/openapi.json": JSON.stringify({
+      openapi: "3.1.0",
+      components: { schemas: { A: { type: "object" }, B: { type: "object" } } },
+      paths: {
+        "/a": { post: { operationId: "opA", requestBody: { content: { "application/json": { schema: { $ref: "#/components/schemas/A" } } } }, responses: { "200": {} } } },
+        "/b": { post: { operationId: "opB", requestBody: { content: { "application/json": { schema: { $ref: "#/components/schemas/B" } } } }, responses: { "200": {} } } },
+      },
+    }),
+  });
+  assert.deepEqual((await runGen({ root: "/app", io: clean })).warnings, []);
+});

package/src/toolkit/gen.ts

@@ -11,7 +11,7 @@ import { deriveWorkerBindings, type ModelSource } from "./derivers/worker-io.ts"
 import { deriveMeta } from "./derivers/meta.ts";
 import { deriveMessageBindings } from "./derivers/messages.ts";
 import { deriveApi } from "./derivers/api.ts";
-import { parseSpec } from "../openapi/spec.ts";
+import { parseSpec, sharedRequestBodySchemas } from "../openapi/spec.ts";
 import { deriveModels, type DerivedModels, type ModelError, MODEL_PROVENANCE } from "./models.ts";
 
 /** Minimal filesystem port. Node/Deno impls live in `fsio.ts`. */
@@ -57,6 +57,9 @@ export interface GenResult {
   incomplete: boolean;
   /** Per-file model-derivation errors (empty on success). */
   modelErrors: ModelError[];
+  /** Non-fatal spec-hygiene warnings (e.g. a requestBody schema shared by >1 operation). Empty on
+   *  a clean spec. Surfaced by the CLI but never fail gen/check — advisory only. */
+  warnings: string[];
 }
 
 function join(root: string, rel: string): string {
@@ -118,7 +121,7 @@ export async function collectArtifacts(opts: GenOptions): Promise<DerivedArtifac
 
 /** Internal: collect artifacts AND the model-derivation details (needed by `runGen` for the
  * incomplete signal + the provenance-scoped stale sweep). */
-async function collectAll(opts: GenOptions): Promise<{ artifacts: DerivedArtifact[]; derived: DerivedModels }> {
+async function collectAll(opts: GenOptions): Promise<{ artifacts: DerivedArtifact[]; derived: DerivedModels; warnings: string[] }> {
   const { root, io } = opts;
   const emitModels = opts.emitModels ?? true;
   const manifestPath = join(root, opts.manifestFile ?? "nano.app.json");
@@ -128,6 +131,7 @@ async function collectAll(opts: GenOptions): Promise<{ artifacts: DerivedArtifac
   } = JSON.parse(await io.readText(manifestPath));
 
   const artifacts: DerivedArtifact[] = [];
+  const warnings: string[] = [];
 
   // 1. types → migrations + domain row types (DomainTables spine + DomainTypes registry)
   if (!opts.modelsOnly && manifest.types && Object.keys(manifest.types).length > 0) {
@@ -164,15 +168,25 @@ async function collectAll(opts: GenOptions): Promise<{ artifacts: DerivedArtifac
     const opsDir = typeof manifest.api?.dir === "string" && manifest.api.dir.trim().length > 0
       ? manifest.api.dir.trim()
       : undefined;
-    artifacts.push(...deriveApi(parseSpec(specText), opsDir, manifest.api?.eject === true));
+    const doc = parseSpec(specText);
+    artifacts.push(...deriveApi(doc, opsDir, manifest.api?.eject === true));
+    // Non-fatal spec-hygiene: a requestBody schema reused by >1 operation can't be tightened into
+    // per-operation discriminated variants — flag it so the author can split it (never fail gen).
+    for (const { ref, operationIds } of sharedRequestBodySchemas(doc)) {
+      warnings.push(
+        `requestBody schema ${ref} is shared by ${operationIds.length} operations ` +
+          `(${operationIds.join(", ")}). A single schema can't model per-operation discriminants — ` +
+          "consider splitting it into named variants + oneOf (additionalProperties:false) per operation.",
+      );
+    }
   }
 
-  return { artifacts: sortArtifacts(artifacts), derived };
+  return { artifacts: sortArtifacts(artifacts), derived, warnings };
 }
 
 /** Run the derivers and write artifacts (or, with `check`, report drift without writing). */
 export async function runGen(opts: GenOptions & { check?: boolean }): Promise<GenResult> {
-  const { artifacts, derived } = await collectAll(opts);
+  const { artifacts, derived, warnings } = await collectAll(opts);
   const { root, io } = opts;
   const emitModels = opts.emitModels ?? true;
   const drift: string[] = [];
@@ -224,7 +238,7 @@ export async function runGen(opts: GenOptions & { check?: boolean }): Promise<Ge
     }
   }
 
-  return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors };
+  return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors, warnings };
 }
 
 export { dirOf, join as joinPath };