@nanobpm/urban 0.31.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.31.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;
+}