@nanobpm/urban 0.30.0 → 0.31.1

package/dist/runtime/adapters/deno.js

@@ -12,8 +12,10 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { resolveModulePath } from "../core/module-path.js";
 function sqliteParams(params) {
     return params.map((param) => {
         if (param === null ||
@@ -67,7 +69,8 @@ export function createDenoHost(opts = {}) {
             return wrapSqlite(db);
         },
         importModule: (p) => {
-            const href = pathToFileURL(abs(p)).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
+            const resolved = resolveModulePath(abs(p), existsSync);
+            const href = pathToFileURL(resolved).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
             const mod = import(__rewriteRelativeImportExtension(href));
             return mod;
         },

package/dist/runtime/adapters/node.js

@@ -17,6 +17,7 @@ import { isAbsolute, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { DatabaseSync } from "node:sqlite";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { resolveModulePath } from "../core/module-path.js";
 function sqliteParams(params) {
     return params.map((param) => {
         if (param === null ||
@@ -115,7 +116,8 @@ export function createNodeHost(opts = {}) {
             return wrapNodeSqlite(db);
         },
         importModule: (p) => {
-            const href = pathToFileURL(abs(p)).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
+            const resolved = resolveModulePath(abs(p), existsSync);
+            const href = pathToFileURL(resolved).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
             const mod = import(__rewriteRelativeImportExtension(href));
             return mod;
         },

package/dist/runtime/core/module-path.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Candidate extensions tried, in order, for an extensionless module path. Compiled outputs come
+ * first (`.js`/`.mjs`/`.cjs`, matching the connector-SDK precedent) so a mixed source+build tree
+ * resolves to the importable JS rather than a TS file that fails on a runtime without
+ * type-stripping; a from-source tree falls through to the TS variants (`.ts`/`.mts`/`.cts`). The
+ * source group mirrors the extensions {@link hasModuleExtension} treats as already-extensioned.
+ */
+export declare const MODULE_EXTENSION_CANDIDATES: readonly [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+/**
+ * If `path` already has a JS/TS extension, return it unchanged. Otherwise return the first
+ * `${path}${ext}` (ext ∈ {@link MODULE_EXTENSION_CANDIDATES}) that `exists`, so an extensionless
+ * delegate path resolves to its real source/compiled file. When none exists, return `path`
+ * unchanged so the underlying loader surfaces its own (accurate) "module not found" error rather
+ * than a guessed extension masking it.
+ */
+export declare function resolveModulePath(path: string, exists: (candidate: string) => boolean): string;

package/dist/runtime/core/module-path.js

@@ -0,0 +1,43 @@
+// Resolve a module path that may have been authored WITHOUT a file extension.
+//
+// The OpenAPI delegate surface (ADR 0058) builds a delegate import path from `<dir>/<operationId>`
+// — and an `operationId` cannot carry a file extension (it must be a single safe path segment, and
+// it doubles as a TS type stem). Node's ESM resolver (including `--experimental-strip-types`) and
+// Deno both require an explicit extension for a file: URL, so a bare `import(".../operations/getX")`
+// fails with a "cannot find module" error even though `.../operations/getX.ts` exists. `actions[]`
+// don't hit this because the manifest carries the extension (`"module": "actions/x.ts"`).
+//
+// This mirrors the connector-SDK shim resolution (`connectorShimUrl` in adapters/node.ts): probe
+// the on-disk candidates, PREFERRING a compiled `.js` (the published / `urban run` path, importable
+// on plain Node without TypeScript type-stripping) over the from-source `.ts` (node strip-types /
+// Deno), so both resolve the same author-written `<dir>/<operationId>` path. Preferring compiled
+// first matters in a mixed source+build tree: if both exist and the process has no type-stripping,
+// selecting `.ts` would fail even though `.js` was importable.
+/**
+ * Candidate extensions tried, in order, for an extensionless module path. Compiled outputs come
+ * first (`.js`/`.mjs`/`.cjs`, matching the connector-SDK precedent) so a mixed source+build tree
+ * resolves to the importable JS rather than a TS file that fails on a runtime without
+ * type-stripping; a from-source tree falls through to the TS variants (`.ts`/`.mts`/`.cts`). The
+ * source group mirrors the extensions {@link hasModuleExtension} treats as already-extensioned.
+ */
+export const MODULE_EXTENSION_CANDIDATES = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+/** True when the path already ends in a JS/TS module extension (.ts/.js/.mts/.cts/.mjs/.cjs). */
+function hasModuleExtension(path) {
+    return /\.[cm]?[jt]s$/i.test(path);
+}
+/**
+ * If `path` already has a JS/TS extension, return it unchanged. Otherwise return the first
+ * `${path}${ext}` (ext ∈ {@link MODULE_EXTENSION_CANDIDATES}) that `exists`, so an extensionless
+ * delegate path resolves to its real source/compiled file. When none exists, return `path`
+ * unchanged so the underlying loader surfaces its own (accurate) "module not found" error rather
+ * than a guessed extension masking it.
+ */
+export function resolveModulePath(path, exists) {
+    if (hasModuleExtension(path))
+        return path;
+    for (const ext of MODULE_EXTENSION_CANDIDATES) {
+        if (exists(path + ext))
+            return path + ext;
+    }
+    return path;
+}

package/dist/runtime/core/modules/pages.js

@@ -580,12 +580,20 @@ function renderText(node) {
   return el(v === "heading" ? "h1" : "p", { class: cls }, node.props.text || "");
 }
 
-// A grid td cell. When the column declares linkField, the cell text (the
-// column's own value) becomes a link to the URL held in that other field,
-// opened in a new tab. Only http(s) hrefs are linked — anything else (e.g. a
-// javascript: URL smuggled through row data) falls back to plain text — and
-// external links get rel=noopener noreferrer so the opened page can't reach
-// window.opener. Shared by the top-level grid and child grids.
+// A grid td cell. Two column-declared linking modes, checked in order:
+//   1. linkField — the cell text becomes a link to the URL held in that other
+//      field. Only http(s) hrefs are linked (a javascript:/other-scheme URL
+//      smuggled through row data falls back to plain text).
+//   2. link: { kind: "processExplorer", keyField } — a structured, engine-aware
+//      link: the cell text links to the Nano console's explorer view for the
+//      process instance whose key is held in the row's keyField. The console
+//      path is constructed HERE (never taken from row data) and the key is
+//      URL-encoded, so row data can't smuggle a path or scheme; only a
+//      non-empty key (after trimming surrounding whitespace) produces a link.
+//      Unknown link kinds fall back to plain text so an unrecognised schema
+//      can't render a broken anchor.
+// Both open in a new tab with rel=noopener noreferrer so the opened page can't
+// reach window.opener. Shared by the top-level grid and child grids.
 function gridCell(col, row) {
   const text = row[col.field] == null ? "" : String(row[col.field]);
   if (col.linkField) {
@@ -598,6 +606,18 @@ function gridCell(col, row) {
       );
     }
   }
+  if (col.link && col.link.kind === "processExplorer" && col.link.keyField) {
+    const key = row[col.link.keyField];
+    const keyStr = key == null ? "" : String(key).trim();
+    if (text !== "" && keyStr !== "") {
+      const href = "/console/explorer?instance=" + encodeURIComponent(keyStr);
+      return el(
+        "td",
+        {},
+        el("a", { class: "pc-link", href, target: "_blank", rel: "noopener noreferrer" }, text),
+      );
+    }
+  }
   return el("td", {}, text);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "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/runtime/adapters/deno.ts

@@ -5,6 +5,7 @@
 
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
 import { AsyncLocalStorage } from "node:async_hooks";
 import type {
@@ -15,6 +16,7 @@ import type {
   HttpServer,
   SqliteDb,
 } from "../core/host.ts";
+import { resolveModulePath } from "../core/module-path.ts";
 
 type SqliteParam = string | number | bigint | Uint8Array | null;
 
@@ -102,8 +104,9 @@ export function createDenoHost(opts: DenoHostOptions = {}): HostContext {
       return wrapSqlite(db);
     },
     importModule: (p) => {
+      const resolved = resolveModulePath(abs(p), existsSync);
       const href =
-        pathToFileURL(abs(p)).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
+        pathToFileURL(resolved).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
       const mod: Promise<Record<string, unknown>> = import(href);
       return mod;
     },

package/src/runtime/adapters/node.ts

@@ -19,6 +19,7 @@ import type {
   SqliteDb,
   WatchHandle,
 } from "../core/host.ts";
+import { resolveModulePath } from "../core/module-path.ts";
 
 type SqliteParam = string | number | bigint | Uint8Array | null;
 
@@ -138,8 +139,9 @@ export function createNodeHost(opts: NodeHostOptions = {}): HostContext {
       return wrapNodeSqlite(db);
     },
     importModule: (p) => {
+      const resolved = resolveModulePath(abs(p), existsSync);
       const href =
-        pathToFileURL(abs(p)).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
+        pathToFileURL(resolved).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
       const mod: Promise<Record<string, unknown>> = import(href);
       return mod;
     },

package/src/runtime/core/module-path.test.ts

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { MODULE_EXTENSION_CANDIDATES, resolveModulePath } from "./module-path.ts";
+import { createNodeHost } from "../adapters/node.ts";
+
+test("resolveModulePath leaves an already-extensioned path untouched", () => {
+  const never = () => {
+    throw new Error("exists() must not be consulted for an extensioned path");
+  };
+  assert.equal(resolveModulePath("/a/b/x.ts", never), "/a/b/x.ts");
+  assert.equal(resolveModulePath("/a/b/x.js", never), "/a/b/x.js");
+  assert.equal(resolveModulePath("/a/b/x.mjs", never), "/a/b/x.mjs");
+  assert.equal(resolveModulePath("/a/b/x.cjs", never), "/a/b/x.cjs");
+  assert.equal(resolveModulePath("/a/b/x.mts", never), "/a/b/x.mts");
+  assert.equal(resolveModulePath("/a/b/x.cts", never), "/a/b/x.cts");
+});
+
+test("resolveModulePath appends the first candidate extension that exists", () => {
+  const present = new Set(["/ops/getX.js"]);
+  const resolved = resolveModulePath("/ops/getX", (c) => present.has(c));
+  assert.equal(resolved, "/ops/getX.js");
+});
+
+test("resolveModulePath prefers a compiled .js over .ts when both exist", () => {
+  // Matches the connector-SDK precedent (connectorShimUrl): a mixed source+build tree must
+  // resolve to the importable .js so it works on plain Node without TypeScript type-stripping.
+  const present = new Set(["/ops/getX.ts", "/ops/getX.js"]);
+  const resolved = resolveModulePath("/ops/getX", (c) => present.has(c));
+  assert.equal(resolved, "/ops/getX.js");
+  assert.equal(MODULE_EXTENSION_CANDIDATES[0], ".js");
+});
+
+test("resolveModulePath returns the path unchanged when nothing exists", () => {
+  const resolved = resolveModulePath("/ops/missing", () => false);
+  assert.equal(resolved, "/ops/missing");
+});
+
+test("createNodeHost.importModule loads an extensionless .ts delegate from disk", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "urban-import-"));
+  try {
+    writeFileSync(
+      join(dir, "getVersion.ts"),
+      "export const marker = 'from-ts';\nexport default { marker };\n",
+    );
+    const host = createNodeHost({ cwd: dir });
+    // Path carries NO extension — mirrors how the OpenAPI delegate surface builds
+    // `<dir>/<operationId>`. Without extension probing this throws ERR_MODULE_NOT_FOUND.
+    const mod = await host.importModule(join(dir, "getVersion"));
+    assert.equal(mod.marker, "from-ts");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/runtime/core/module-path.ts

@@ -0,0 +1,44 @@
+// Resolve a module path that may have been authored WITHOUT a file extension.
+//
+// The OpenAPI delegate surface (ADR 0058) builds a delegate import path from `<dir>/<operationId>`
+// — and an `operationId` cannot carry a file extension (it must be a single safe path segment, and
+// it doubles as a TS type stem). Node's ESM resolver (including `--experimental-strip-types`) and
+// Deno both require an explicit extension for a file: URL, so a bare `import(".../operations/getX")`
+// fails with a "cannot find module" error even though `.../operations/getX.ts` exists. `actions[]`
+// don't hit this because the manifest carries the extension (`"module": "actions/x.ts"`).
+//
+// This mirrors the connector-SDK shim resolution (`connectorShimUrl` in adapters/node.ts): probe
+// the on-disk candidates, PREFERRING a compiled `.js` (the published / `urban run` path, importable
+// on plain Node without TypeScript type-stripping) over the from-source `.ts` (node strip-types /
+// Deno), so both resolve the same author-written `<dir>/<operationId>` path. Preferring compiled
+// first matters in a mixed source+build tree: if both exist and the process has no type-stripping,
+// selecting `.ts` would fail even though `.js` was importable.
+
+/**
+ * Candidate extensions tried, in order, for an extensionless module path. Compiled outputs come
+ * first (`.js`/`.mjs`/`.cjs`, matching the connector-SDK precedent) so a mixed source+build tree
+ * resolves to the importable JS rather than a TS file that fails on a runtime without
+ * type-stripping; a from-source tree falls through to the TS variants (`.ts`/`.mts`/`.cts`). The
+ * source group mirrors the extensions {@link hasModuleExtension} treats as already-extensioned.
+ */
+export const MODULE_EXTENSION_CANDIDATES = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"] as const;
+
+/** True when the path already ends in a JS/TS module extension (.ts/.js/.mts/.cts/.mjs/.cjs). */
+function hasModuleExtension(path: string): boolean {
+  return /\.[cm]?[jt]s$/i.test(path);
+}
+
+/**
+ * If `path` already has a JS/TS extension, return it unchanged. Otherwise return the first
+ * `${path}${ext}` (ext ∈ {@link MODULE_EXTENSION_CANDIDATES}) that `exists`, so an extensionless
+ * delegate path resolves to its real source/compiled file. When none exists, return `path`
+ * unchanged so the underlying loader surfaces its own (accurate) "module not found" error rather
+ * than a guessed extension masking it.
+ */
+export function resolveModulePath(path: string, exists: (candidate: string) => boolean): string {
+  if (hasModuleExtension(path)) return path;
+  for (const ext of MODULE_EXTENSION_CANDIDATES) {
+    if (exists(path + ext)) return path + ext;
+  }
+  return path;
+}

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

@@ -189,6 +189,23 @@ test("renderer wires a column's linkField to a new-tab anchor", async () => {
   assert.match(js, /rel: "noopener noreferrer"/);
 });
 
+test("renderer wires a column's processExplorer link to the console explorer", async () => {
+  const res = await dispatch("GET", "/app/runtime.js");
+  const js = res.body ?? "";
+  // A column declaring `link: { kind: "processExplorer", keyField }` renders its
+  // text as a link to the Nano console's explorer for the process instance whose
+  // key is held in that field. Guard the whole shape so the primitive can't
+  // silently regress: the discriminant + keyField are read, the key is trimmed
+  // (whitespace-only keys don't produce a link), the console path is constructed
+  // here (not from row data), the trimmed key is URL-encoded, and the anchor
+  // opens in a new tab with a hardened rel.
+  assert.match(js, /col\.link && col\.link\.kind === "processExplorer" && col\.link\.keyField/);
+  assert.match(js, /String\(key\)\.trim\(\)/);
+  assert.match(js, /"\/console\/explorer\?instance="\s*\+\s*encodeURIComponent\(keyStr\)/);
+  assert.match(js, /target:\s*"_blank"/);
+  assert.match(js, /rel:\s*"noopener noreferrer"/);
+});
+
 test("the renderer honours numeric actionForm fields", async () => {
   const res = await dispatch("GET", "/app/runtime.js");
   const js = res.body ?? "";

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

@@ -621,12 +621,20 @@ function renderText(node) {
   return el(v === "heading" ? "h1" : "p", { class: cls }, node.props.text || "");
 }
 
-// A grid td cell. When the column declares linkField, the cell text (the
-// column's own value) becomes a link to the URL held in that other field,
-// opened in a new tab. Only http(s) hrefs are linked — anything else (e.g. a
-// javascript: URL smuggled through row data) falls back to plain text — and
-// external links get rel=noopener noreferrer so the opened page can't reach
-// window.opener. Shared by the top-level grid and child grids.
+// A grid td cell. Two column-declared linking modes, checked in order:
+//   1. linkField — the cell text becomes a link to the URL held in that other
+//      field. Only http(s) hrefs are linked (a javascript:/other-scheme URL
+//      smuggled through row data falls back to plain text).
+//   2. link: { kind: "processExplorer", keyField } — a structured, engine-aware
+//      link: the cell text links to the Nano console's explorer view for the
+//      process instance whose key is held in the row's keyField. The console
+//      path is constructed HERE (never taken from row data) and the key is
+//      URL-encoded, so row data can't smuggle a path or scheme; only a
+//      non-empty key (after trimming surrounding whitespace) produces a link.
+//      Unknown link kinds fall back to plain text so an unrecognised schema
+//      can't render a broken anchor.
+// Both open in a new tab with rel=noopener noreferrer so the opened page can't
+// reach window.opener. Shared by the top-level grid and child grids.
 function gridCell(col, row) {
   const text = row[col.field] == null ? "" : String(row[col.field]);
   if (col.linkField) {
@@ -639,6 +647,18 @@ function gridCell(col, row) {
       );
     }
   }
+  if (col.link && col.link.kind === "processExplorer" && col.link.keyField) {
+    const key = row[col.link.keyField];
+    const keyStr = key == null ? "" : String(key).trim();
+    if (text !== "" && keyStr !== "") {
+      const href = "/console/explorer?instance=" + encodeURIComponent(keyStr);
+      return el(
+        "td",
+        {},
+        el("a", { class: "pc-link", href, target: "_blank", rel: "noopener noreferrer" }, text),
+      );
+    }
+  }
   return el("td", {}, text);
 }