@nanobpm/urban 0.20.0 → 0.22.0

package/src/toolkit/addConnector.ts

@@ -13,6 +13,7 @@
 // unit-testable.
 
 import type { GenIO } from "./gen.ts";
+import { errorMessage, isRecord } from "../runtime/core/guards.ts";
 
 /** A config field a pack declares (subset of ext-types `ConfigField`). */
 interface PackConfigField {
@@ -90,9 +91,9 @@ export async function addConnector(opts: AddConnectorOptions): Promise<AddConnec
   }
   let pack: PackManifest;
   try {
-    pack = JSON.parse(await io.readText(packManifestPath)) as PackManifest;
+    pack = JSON.parse(await io.readText(packManifestPath));
   } catch (err) {
-    throw new Error(`failed to parse ${packManifestPath}: ${(err as Error).message}`);
+    throw new Error(`failed to parse ${packManifestPath}: ${errorMessage(err)}`);
   }
   if (typeof pack.id !== "string" || !pack.id) {
     throw new Error(`${packManifestPath} has no string "id" (a pack must declare its id).`);
@@ -123,7 +124,7 @@ export async function addConnector(opts: AddConnectorOptions): Promise<AddConnec
   try {
     app = JSON.parse(await io.readText(appManifestPath));
   } catch (err) {
-    throw new Error(`failed to parse ${appManifestPath}: ${(err as Error).message}`);
+    throw new Error(`failed to parse ${appManifestPath}: ${errorMessage(err)}`);
   }
   if (app === null || typeof app !== "object" || Array.isArray(app)) {
     throw new Error(`${appManifestPath} is not a JSON object.`);
@@ -168,10 +169,10 @@ export async function addConnector(opts: AddConnectorOptions): Promise<AddConnec
       // A pre-existing connection of this name must be a compatible object of the
       // same pack `type`; otherwise wiring workers to it would produce an invalid
       // or misleading manifest. Fail loudly instead of silently reusing it.
-      if (existing === null || typeof existing !== "object" || Array.isArray(existing)) {
+      if (!isRecord(existing)) {
         throw new Error(`connection "${connection}" already exists and is not an object.`);
       }
-      const conn = existing as Record<string, unknown>;
+      const conn = existing;
       if (conn.type !== undefined && conn.type !== pack.id) {
         throw new Error(
           `connection "${connection}" already exists with type "${String(conn.type)}", ` +

package/src/toolkit/derivers/messages.test.ts

@@ -134,10 +134,12 @@ const XML = `<?xml version="1.0"?>
 
 test("scanModelMessages extracts message name + envelope; a self-closing message is name-only", () => {
   const m = scanModelMessages(XML);
-  const placed = m.find((x) => x.messageName === "OrderPlaced") as MessageIo;
+  const placed = m.find((x) => x.messageName === "OrderPlaced");
+  assert.ok(placed);
   assert.ok(placed);
   assert.equal(placed.inputType, "Order");
-  const ping = m.find((x) => x.messageName === "Ping") as MessageIo;
+  const ping = m.find((x) => x.messageName === "Ping");
+  assert.ok(ping);
   assert.ok(ping);
   assert.equal(ping.inputType, undefined);
 });

package/src/toolkit/derivers/worker-io.test.ts

@@ -40,13 +40,15 @@ const XML = `<?xml version="1.0"?>
 
 test("scanModelWorkers extracts task type, element id, process, and envelope io", () => {
   const w = scanModelWorkers(XML);
-  const charge = w.find((x) => x.taskType === "orders.charge") as WorkerIo;
+  const charge = w.find((x) => x.taskType === "orders.charge");
+  assert.ok(charge);
   assert.ok(charge);
   assert.equal(charge.elementId, "Charge");
   assert.equal(charge.process, "orders");
   assert.equal(charge.in, "Payment");
   assert.equal(charge.out, "Receipt");
-  const notify = w.find((x) => x.taskType === "orders.notify") as WorkerIo;
+  const notify = w.find((x) => x.taskType === "orders.notify");
+  assert.ok(notify);
   assert.equal(notify.in, undefined);
   assert.equal(notify.out, undefined);
 });

package/src/toolkit/fsio.ts

@@ -50,7 +50,8 @@ export function createNodeGenIO(): GenIO {
         // stat failed (e.g. a virtual path); fall back to no cache key and let import() surface it.
       }
       const href = `${pathToFileURL(abs).href}${version}`;
-      return import(href) as Promise<Record<string, unknown>>;
+      const mod: Promise<Record<string, unknown>> = import(href);
+      return mod;
     },
   };
 }

package/src/toolkit/gen.ts

@@ -110,9 +110,9 @@ async function collectAll(opts: GenOptions): Promise<{ artifacts: DerivedArtifac
   const { root, io } = opts;
   const emitModels = opts.emitModels ?? true;
   const manifestPath = join(root, opts.manifestFile ?? "nano.app.json");
-  const manifest = JSON.parse(await io.readText(manifestPath)) as ToolkitManifest & {
+  const manifest: ToolkitManifest & {
     models?: { processes?: string[]; workflows?: string[] };
-  };
+  } = JSON.parse(await io.readText(manifestPath));
 
   const artifacts: DerivedArtifact[] = [];
 
@@ -186,8 +186,8 @@ export { dirOf, join as joinPath };
 export async function previewModels(opts: GenOptions): Promise<DerivedModels> {
   const { root, io } = opts;
   const manifestPath = join(root, opts.manifestFile ?? "nano.app.json");
-  const manifest = JSON.parse(await io.readText(manifestPath)) as {
+  const manifest: {
     models?: { processes?: string[]; workflows?: string[] };
-  };
+  } = JSON.parse(await io.readText(manifestPath));
   return deriveModels(root, io, manifest);
 }

package/src/toolkit/models.test.ts

@@ -93,7 +93,7 @@ test("deriveModels turns workflows/*.ts into a provenance-stamped processes/<id>
 
 test("deriveModels is a no-op without a module loader (pure/IDE callers)", async () => {
   const io = memIO({ "/app/workflows/greet.ts": "// source" });
-  delete (io as { importModule?: unknown }).importModule;
+  delete io.importModule;
   const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
   assert.equal(d.attempted, false);
   assert.equal(d.artifacts.length, 0);

package/src/toolkit/models.ts

@@ -14,6 +14,7 @@ import type { DerivedArtifact } from "./artifact.ts";
 import type { GenIO } from "./gen.ts";
 import { expandPattern, joinPath } from "./gen.ts";
 import type { ModelSource } from "./derivers/worker-io.ts";
+import { isRecord } from "../runtime/core/guards.ts";
 
 /** Default source glob for code-first flows (matches the code-first scaffold layout). */
 export const DEFAULT_WORKFLOW_PATTERNS = ["workflows/*.ts"];
@@ -34,9 +35,7 @@ export interface ModelsManifest {
 
 /** A `defineFlow` export: has a string `id` and an `imperative`/`declarative` `kind`. */
 export function isWorkflow(v: unknown): v is Workflow {
-  if (!v || typeof v !== "object") return false;
-  const o = v as { id?: unknown; kind?: unknown };
-  return typeof o.id === "string" && (o.kind === "imperative" || o.kind === "declarative");
+  return isRecord(v) && typeof v.id === "string" && (v.kind === "imperative" || v.kind === "declarative");
 }
 
 /** Sanitize a flow id into a safe `.bpmn` filename (mirrors the host generator). */
@@ -113,7 +112,7 @@ function messageOf(e: unknown): string {
 /** Append an actionable hint when a `.ts` import fails because the runtime can't strip types. */
 function importHint(rel: string, e: unknown): string {
   const base = messageOf(e);
-  const code = (e as { code?: string })?.code ?? "";
+  const code = isRecord(e) && typeof e.code === "string" ? e.code : "";
   const looksLikeNoTsLoader =
     rel.endsWith(".ts") &&
     (code === "ERR_UNKNOWN_FILE_EXTENSION" || /Unknown file extension "\.ts"/.test(base));

package/src/toolkit/scaffold.ts

@@ -57,7 +57,7 @@ export async function scaffoldWorkers(opts: ScaffoldOptions): Promise<ScaffoldRu
   const manifestFile = opts.manifestFile ?? "nano.app.json";
   const manifestPath = joinPath(root, manifestFile);
 
-  const manifest = JSON.parse(await io.readText(manifestPath)) as ScaffoldManifest;
+  const manifest: ScaffoldManifest = JSON.parse(await io.readText(manifestPath));
   const models = await readModels(root, io, manifest);
   const declaredTypeIds = Object.keys(manifest.types ?? {});