@nanobpm/urban 0.17.0 → 0.18.0

package/dist/toolkit/models.js

@@ -0,0 +1,142 @@
+// Model derivation for code-first apps — the toolkit's one *executing* edge.
+//
+// Unlike the pure derivers (migrations, domain, worker I/O), which transform strings, this
+// imports the app's `workflows/*.ts`, turns each `defineFlow` into executable BPMN via
+// `@nanobpm/workflow` (`toBpmn` + `bpmn-auto-layout` DI), and writes `processes/<id>.bpmn`.
+// Executing the app's TypeScript needs a runtime module loader, so this is gated on the
+// optional `GenIO.importModule` (present on Node with type-stripping, and on Deno). When the
+// loader is absent — or the app authors its models directly (model-first) — derivation is a
+// no-op and the rest of `urban gen` proceeds on the authored/derived models unchanged.
+import { toDeployableBpmn } from "@nanobpm/workflow";
+import { expandPattern, joinPath } from "./gen.js";
+/** Default source glob for code-first flows (matches the code-first scaffold layout). */
+export const DEFAULT_WORKFLOW_PATTERNS = ["workflows/*.ts"];
+/** Default output dir for derived models (matches the model-first scaffold, so a derived
+ * model is ejectable to model-first and picked up by `models.processes: ["processes/*.bpmn"]`). */
+export const PROCESSES_DIR = "processes";
+/** Marker stamped into every derived `.bpmn` (an XML comment) so re-gen overwrites and the
+ * stale sweep deletes ONLY derived output — never an authored, human-owned model. */
+export const MODEL_PROVENANCE = "Generated by @nanobpm/urban from workflows/*.ts — do not edit; edit the flow and re-run `urban gen`.";
+/** A `defineFlow` export: has a string `id` and an `imperative`/`declarative` `kind`. */
+export function isWorkflow(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const o = v;
+    return typeof o.id === "string" && (o.kind === "imperative" || o.kind === "declarative");
+}
+/** Sanitize a flow id into a safe `.bpmn` filename (mirrors the host generator). */
+export function bpmnFilename(id) {
+    return `${id.replace(/[^A-Za-z0-9._-]/g, "-")}.bpmn`;
+}
+/** The directory derived models are written to: the dir of the first `models.processes`
+ * glob if the manifest declares one, else the `processes/` default. */
+export function processesOutDir(manifest) {
+    for (const pat of manifest.models?.processes ?? []) {
+        const star = pat.indexOf("*");
+        const slash = star === -1 ? pat.lastIndexOf("/") : pat.lastIndexOf("/", star);
+        if (slash > 0)
+            return pat.slice(0, slash);
+    }
+    return PROCESSES_DIR;
+}
+/** Insert the provenance marker as an XML comment right after the `<?xml … ?>` prolog. */
+function withProvenance(xml) {
+    const comment = `<!-- ${MODEL_PROVENANCE} -->`;
+    const m = xml.match(/^\uFEFF?\s*<\?xml[^>]*\?>/);
+    if (m)
+        return `${m[0]}\n${comment}\n${xml.slice(m[0].length).replace(/^\r?\n/, "")}`;
+    return `${comment}\n${xml}`;
+}
+function emptyDerived(outDir) {
+    return {
+        artifacts: [],
+        models: [],
+        ids: [],
+        list: [],
+        outDir,
+        attempted: false,
+        incomplete: false,
+        errors: [],
+    };
+}
+function messageOf(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/** Append an actionable hint when a `.ts` import fails because the runtime can't strip types. */
+function importHint(rel, e) {
+    const base = messageOf(e);
+    const code = e?.code ?? "";
+    const looksLikeNoTsLoader = rel.endsWith(".ts") &&
+        (code === "ERR_UNKNOWN_FILE_EXTENSION" || /Unknown file extension "\.ts"/.test(base));
+    if (!looksLikeNoTsLoader)
+        return base;
+    return (`${base}\n    ↳ importing TypeScript workflows needs a runtime that strips types: ` +
+        "Node ≥22.18 (default) or `node --experimental-strip-types`, or run under Deno.");
+}
+/**
+ * Derive executable BPMN models from an app's code-first `workflows/*.ts`.
+ *
+ * Returns everything in-memory (artifacts + `ModelSource`s + ids). The caller decides whether
+ * to write the `.bpmn` to disk (`urban gen` / `urban derive`) or keep them in memory to feed
+ * the type-contract derivers only (`urban gen --no-models`) or preview them (`urban derive
+ * --stdout`). Never throws on a bad workflow: a failing module is recorded in `errors`,
+ * `incomplete` is set, and the sweep is suppressed so a partial failure can't delete good models.
+ */
+export async function deriveModels(root, io, manifest) {
+    const outDir = processesOutDir(manifest);
+    const importModule = io.importModule;
+    if (!importModule)
+        return emptyDerived(outDir);
+    const patterns = manifest.models?.workflows ?? DEFAULT_WORKFLOW_PATTERNS;
+    const files = [];
+    for (const pat of patterns) {
+        for (const rel of await expandPattern(root, io, pat))
+            files.push(rel);
+    }
+    if (files.length === 0)
+        return emptyDerived(outDir);
+    const out = { ...emptyDerived(outDir), attempted: true };
+    // id → { source file, workflow ref } — distinguishes a genuine re-export (same
+    // object under two export names) from a true collision (two distinct flows, one id).
+    const byId = new Map();
+    for (const rel of files.sort()) {
+        let mod;
+        try {
+            mod = await importModule(joinPath(root, rel));
+        }
+        catch (e) {
+            out.incomplete = true;
+            out.errors.push({ path: rel, message: importHint(rel, e) });
+            continue;
+        }
+        for (const value of Object.values(mod)) {
+            if (!isWorkflow(value))
+                continue;
+            const id = value.id;
+            const prior = byId.get(id);
+            if (prior) {
+                if (prior.ref === value && prior.rel === rel)
+                    continue; // genuine intra-module re-export
+                out.incomplete = true;
+                const where = prior.rel === rel ? "also defined in the same module" : `also defined in ${prior.rel}`;
+                out.errors.push({ path: rel, message: `duplicate flow id "${id}" (${where})` });
+                continue;
+            }
+            byId.set(id, { rel, ref: value });
+            try {
+                const semantic = await toDeployableBpmn(value);
+                const xml = withProvenance(semantic);
+                const path = `${outDir}/${bpmnFilename(id)}`;
+                out.artifacts.push({ path, content: xml });
+                out.models.push({ path, xml });
+                out.list.push({ id, kind: value.kind, xml });
+                out.ids.push(id);
+            }
+            catch (e) {
+                out.incomplete = true;
+                out.errors.push({ path: rel, message: `deriving "${id}": ${messageOf(e)}` });
+            }
+        }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.17.0",
+  "version": "0.18.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.ts

@@ -2,7 +2,8 @@
 //
 //   urban new <name>     scaffold a new app (delegates to create-urban-app)
 //   urban check          load + validate the manifest, report issues
-//   urban gen            derive generated artifacts (migrations, worker I/O)
+//   urban gen            derive generated artifacts (migrations, worker I/O, code-first models)
+//   urban derive         derive code-first models only (workflows/*.ts → processes/*.bpmn)
 //   urban run            materialize + serve the app (deploy, data, workers, surfaces, triggers)
 //   urban dev            like run, plus watch sources and hot-reload on change
 //   urban deploy         deploy models only, then exit
@@ -19,7 +20,7 @@ import {
   selectHost,
 } from "./runtime/index.ts";
 import { scaffold, slugify } from "create-urban-app";
-import { createNodeGenIO, runGen, scaffoldWorkers } from "./toolkit/index.ts";
+import { createNodeGenIO, previewModels, runGen, scaffoldWorkers } from "./toolkit/index.ts";
 import { pathToFileURL } from "node:url";
 import { readFileSync } from "node:fs";
 
@@ -44,6 +45,8 @@ interface Flags {
   check: boolean;
   write: boolean;
   deno: boolean;
+  models: boolean;
+  stdout: boolean;
   style?: "model" | "code";
   help: boolean;
   version: boolean;
@@ -51,7 +54,7 @@ interface Flags {
 }
 
 function parse(argv: string[]): Flags {
-  const f: Flags = { root: ".", manifest: "nano.app.json", check: false, write: false, deno: false, help: false, version: false, _: [] };
+  const f: Flags = { root: ".", manifest: "nano.app.json", check: false, write: false, deno: false, models: true, stdout: false, help: false, version: false, _: [] };
   const need = (i: number, flag: string): string => {
     const v = argv[i];
     if (v === undefined || v.startsWith("-")) throw new Error(`flag ${flag} requires a value`);
@@ -64,6 +67,9 @@ function parse(argv: string[]): Flags {
     else if (a === "--check") f.check = true;
     else if (a === "--write") f.write = true;
     else if (a === "--deno") f.deno = true;
+    else if (a === "--no-models") f.models = false;
+    else if (a === "--models") f.models = true;
+    else if (a === "--stdout") f.stdout = true;
     else if (a === "--code-first") f.style = "code";
     else if (a === "--style") {
       const v = need(++i, a);
@@ -92,7 +98,10 @@ Usage:
   urban new <name> [--root <path>] [--deno] [--style model|code]    scaffold a new Urban app
                                     (--code-first is shorthand for --style code)
   urban check                       validate the manifest
-  urban gen [--check]               derive artifacts (migrations, worker-io)
+  urban gen [--check] [--no-models] derive artifacts (migrations, worker-io, + code-first models)
+                                    (--no-models: skip writing derived .bpmn; type-contracts only)
+  urban derive [--check|--stdout]   derive code-first models only (workflows/*.ts → processes/*.bpmn)
+                                    (--stdout: print {models,incomplete} JSON without writing)
   urban stubs [--write]             scaffold write-once handler stubs from the model
   urban run                         materialize + serve the app
   urban dev                         run + watch sources, hot-reload on change
@@ -125,7 +134,12 @@ async function cmdCheck(f: Flags): Promise<number> {
 
 async function cmdGen(f: Flags): Promise<number> {
   const io = createNodeGenIO();
-  const res = await runGen({ root: f.root, io, manifestFile: f.manifest, check: f.check });
+  const res = await runGen({ root: f.root, io, manifestFile: f.manifest, check: f.check, emitModels: f.models });
+  if (res.incomplete) {
+    console.error(`✖ ${res.modelErrors.length} workflow(s) failed to derive:`);
+    for (const e of res.modelErrors) console.error(`  • ${e.path}: ${e.message}`);
+    return 1;
+  }
   if (f.check) {
     if (res.drift.length === 0) {
       console.log(`✔ generated artifacts are up to date (${res.artifacts.length} checked)`);
@@ -140,6 +154,55 @@ async function cmdGen(f: Flags): Promise<number> {
   return 0;
 }
 
+async function cmdDerive(f: Flags): Promise<number> {
+  // `urban derive` IS model derivation, so `--no-models` is contradictory. Reject it explicitly
+  // rather than silently ignoring it (flags are global, so it's easy to pass by accident).
+  if (!f.models) {
+    console.error(
+      "✖ `urban derive` derives models — `--no-models` is contradictory. Use `urban gen --no-models` for type-contracts only.",
+    );
+    return 2;
+  }
+  const io = createNodeGenIO();
+
+  // Non-writing preview: emit `{ models: [{ id, kind, xml }], incomplete }` to stdout for the
+  // console's read-only model viewer (never touches `processes/`).
+  if (f.stdout) {
+    const d = await previewModels({ root: f.root, io, manifestFile: f.manifest });
+    process.stdout.write(
+      JSON.stringify({
+        models: d.list.map((m) => ({ id: m.id, kind: m.kind, xml: m.xml })),
+        incomplete: d.incomplete,
+      }) + "\n",
+    );
+    if (d.incomplete) {
+      for (const e of d.errors) console.error(`  • ${e.path}: ${e.message}`);
+      return 1;
+    }
+    return 0;
+  }
+
+  // Derive + write models only (skip the type-contract derivers); `generate_models` delegates here.
+  const res = await runGen({ root: f.root, io, manifestFile: f.manifest, check: f.check, modelsOnly: true });
+  if (res.incomplete) {
+    console.error(`✖ ${res.modelErrors.length} workflow(s) failed to derive:`);
+    for (const e of res.modelErrors) console.error(`  • ${e.path}: ${e.message}`);
+    return 1;
+  }
+  if (f.check) {
+    if (res.drift.length === 0) {
+      console.log(`✔ derived models are up to date (${res.artifacts.length} checked)`);
+      return 0;
+    }
+    console.error(`✖ ${res.drift.length} derived model(s) are out of date — run \`urban derive\`:`);
+    for (const p of res.drift) console.error(`  • ${p}`);
+    return 1;
+  }
+  console.log(`✔ derived ${res.artifacts.length} model(s):`);
+  for (const a of res.artifacts) console.log(`  • ${a.path}`);
+  return 0;
+}
+
 async function cmdStubs(f: Flags): Promise<number> {
   const io = createNodeGenIO();
   const run = await scaffoldWorkers({ root: f.root, io, manifestFile: f.manifest, write: f.write });
@@ -243,6 +306,8 @@ export async function main(argv: string[]): Promise<number> {
       return cmdCheck(f);
     case "gen":
       return cmdGen(f);
+    case "derive":
+      return cmdDerive(f);
     case "stubs":
       return cmdStubs(f);
     case "run":

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

@@ -0,0 +1,140 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  emitDomainModel,
+  emitDomain,
+  deriveDomain,
+  sourcesFromManifest,
+  registryFromManifest,
+  sqliteAffinityToTs,
+  interfaceName,
+  type SourceSchema,
+  type TableMeta,
+  type DomainTypeRegistry,
+} from "./domain.ts";
+import type { ToolkitManifest } from "./migrations.ts";
+
+// Goldens captured verbatim from the console's `emitDomainModel` (server domain_types.ts) via
+// Deno — this IS the per-emitter drift gate (ADR 0053): the toolkit must be byte-identical.
+const GOLDENS: Record<string, string> = JSON.parse("{\n  \"empty\": \"// AUTO-GENERATED by nanobpmn from the datasource schema (ADR 0029 §4.1).\\n// Do not edit — regenerated from the live tables. Erased at `deno compile`.\\n// eslint-disable\\n\\nexport interface DomainTables {}\\n\",\n  \"tablesOnly\": \"// AUTO-GENERATED by nanobpmn from the datasource schema (ADR 0029 §4.1).\\n// Do not edit — regenerated from the live tables. Erased at `deno compile`.\\n// eslint-disable\\n\\nexport interface Customers {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  email: string;\\n  /** TEXT */\\n  tier: string | null;\\n}\\n\\nexport interface OrderItems {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** INTEGER */\\n  qty: number;\\n  /** REAL */\\n  \\\"unit price\\\": number | null;\\n}\\n\\n/** Every table keyed by its wire name — index it for a row type. */\\nexport interface DomainTables {\\n  \\\"customers\\\": Customers;\\n  \\\"order_items\\\": OrderItems;\\n}\\n\",\n  \"typesOnly\": \"// AUTO-GENERATED by nanobpmn from the datasource schema (ADR 0029 §4.1).\\n// Do not edit — regenerated from the live tables. Erased at `deno compile`.\\n// eslint-disable\\n\\nexport interface DomainTables {}\\n\\n/** Declared (transient) domain types from the manifest `types` registry (ADR 0029 §4.2), keyed by id. */\\nexport interface DomainTypes {\\n  \\\"taxReturn\\\": {\\n    year: number;\\n    notes?: string;\\n    lines: DomainTypes[\\\"lineItem\\\"][];\\n  };\\n  \\\"lineItem\\\": {\\n    \\\"line no\\\": number;\\n    amount: number;\\n  };\\n}\\n\",\n  \"both\": \"// AUTO-GENERATED by nanobpmn from the datasource schema (ADR 0029 §4.1).\\n// Do not edit — regenerated from the live tables. Erased at `deno compile`.\\n// eslint-disable\\n\\nexport interface Greetings {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  who: string;\\n  /** TEXT */\\n  message: string;\\n  /** TEXT */\\n  createdAt: string | null;\\n}\\n\\n/** Every table keyed by its wire name — index it for a row type. */\\nexport interface DomainTables {\\n  \\\"greetings\\\": Greetings;\\n}\\n\\n/** Declared (transient) domain types from the manifest `types` registry (ADR 0029 §4.2), keyed by id. */\\nexport interface DomainTypes {\\n  \\\"greeting\\\": {\\n    who: string;\\n    message: string;\\n    createdAt?: string;\\n  };\\n}\\n\",\n  \"multi\": \"// AUTO-GENERATED by nanobpmn from the datasource schemas (ADR 0029 §4.1/§6).\\n// Do not edit — regenerated from the live tables. Erased at `deno compile`.\\n// eslint-disable\\n\\nexport interface AppCustomers {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  email: string;\\n}\\n\\nexport interface AnalyticsEvents {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  kind: string;\\n}\\n\\n/** Every datasource keyed by alias, then table by wire name. */\\nexport interface DomainSources {\\n  \\\"app\\\": {\\n    \\\"customers\\\": AppCustomers;\\n  };\\n  \\\"analytics\\\": {\\n    \\\"events\\\": AnalyticsEvents;\\n  };\\n}\\n\\n/** The default datasource's tables — index by wire name. */\\nexport type DomainTables = DomainSources[\\\"analytics\\\"];\\n\"\n}");
+
+const col = (name: string, type: string, notNull: boolean, primaryKey: boolean) =>
+  ({ name, type, notNull, primaryKey });
+const table = (name: string, cols: TableMeta["columns"]): TableMeta => ({ name, columns: cols, indexes: [], foreignKeys: [] });
+
+test("emitDomainModel: empty app → bare DomainTables (byte-parity)", () => {
+  assert.equal(emitDomainModel([], undefined, {}), GOLDENS.empty);
+});
+
+test("emitDomainModel: table spine only (byte-parity)", () => {
+  const sources: SourceSchema[] = [{ source: "app", tables: [
+    table("customers", [col("id","INTEGER",false,true), col("email","TEXT",true,false), col("tier","TEXT",false,false)]),
+    table("order_items", [col("id","INTEGER",false,true), col("qty","INTEGER",true,false), col("unit price","REAL",false,false)]),
+  ]}];
+  assert.equal(emitDomainModel(sources, "app", {}), GOLDENS.tablesOnly);
+});
+
+test("emitDomainModel: registry only — nominal ref, list, optional, non-ident key (byte-parity)", () => {
+  const types: DomainTypeRegistry = {
+    taxReturn: { fields: { year: { type: "integer" }, notes: { type: "string", optional: true }, lines: { type: "lineItem", list: true } } },
+    lineItem: { fields: { "line no": { type: "integer" }, amount: { type: "number" } } },
+  };
+  assert.equal(emitDomainModel([], undefined, types), GOLDENS.typesOnly);
+});
+
+test("emitDomainModel: table + registry coexist for same type (byte-parity)", () => {
+  const sources: SourceSchema[] = [{ source: "app", tables: [
+    table("greetings", [col("id","INTEGER",false,true), col("who","TEXT",true,false), col("message","TEXT",true,false), col("createdAt","TEXT",false,false)]),
+  ]}];
+  const types: DomainTypeRegistry = { greeting: { table: "greetings", fields: { who: { type: "string" }, message: { type: "string" }, createdAt: { type: "datetime", optional: true } } } };
+  assert.equal(emitDomainModel(sources, "app", types), GOLDENS.both);
+});
+
+test("emitDomainModel: multi-source → DomainSources + DomainTables alias to default (byte-parity)", () => {
+  const sources: SourceSchema[] = [
+    { source: "app", tables: [ table("customers", [col("id","INTEGER",false,true), col("email","TEXT",true,false)]) ] },
+    { source: "analytics", tables: [ table("events", [col("id","INTEGER",false,true), col("kind","TEXT",true,false)]) ] },
+  ];
+  assert.equal(emitDomainModel(sources, "analytics", {}), GOLDENS.multi);
+});
+
+// --- manifest bridge: code-first derivation reproduces the console output --------------------
+
+test("emitDomain: manifest types drive BOTH the table spine and the registry (byte-parity)", () => {
+  const manifest: ToolkitManifest = {
+    data: { default: "app" },
+    types: { greeting: { table: "greetings", fields: {
+      who: { type: "string" }, message: { type: "string" }, createdAt: { type: "datetime", optional: true },
+    } } },
+  };
+  // The manifest 'greeting' type yields DomainTables["greetings"] (id + fields) and
+  // DomainTypes["greeting"] (declared fields only) — identical to the console's `both` case.
+  assert.equal(emitDomain(manifest), GOLDENS.both);
+});
+
+test("sourcesFromManifest: implicit id PK + field affinity + nullability", () => {
+  const manifest: ToolkitManifest = { data: { default: "app" }, types: {
+    greeting: { table: "greetings", fields: { who: { type: "string" }, createdAt: { type: "datetime", optional: true } } },
+  } };
+  const [src] = sourcesFromManifest(manifest);
+  assert.equal(src.source, "app");
+  assert.deepEqual(src.tables[0], table("greetings", [
+    col("id", "INTEGER", false, true),
+    col("who", "TEXT", true, false),
+    col("createdAt", "TEXT", false, false),
+  ]));
+});
+
+test("sourcesFromManifest: table name defaults to the type id; types group by source", () => {
+  const manifest: ToolkitManifest = { data: { default: "app" }, types: {
+    order: { fields: { total: { type: "number" } } },
+    event: { source: "analytics", fields: { kind: { type: "string" } } },
+  } };
+  const sources = sourcesFromManifest(manifest);
+  assert.deepEqual(sources.map((s) => s.source), ["app", "analytics"]);
+  assert.equal(sources[0].tables[0].name, "order");
+  assert.equal(sources[1].tables[0].name, "event");
+});
+
+test("registryFromManifest: declared fields only (no persisted id); type defaults to string", () => {
+  const manifest: ToolkitManifest = { types: {
+    greeting: { table: "greetings", fields: { who: {}, note: { type: "string", optional: true } } },
+  } };
+  assert.deepEqual(registryFromManifest(manifest), {
+    greeting: { table: "greetings", fields: { who: { type: "string", optional: undefined, list: undefined }, note: { type: "string", optional: true, list: undefined } } },
+  });
+});
+
+test("registryFromManifest + emitDomain: the `list` modifier is preserved as `T[]`", () => {
+  const manifest: ToolkitManifest = { types: {
+    order: { fields: { tags: { type: "string", list: true } } },
+  } };
+  // The bridge must forward `list` (not drop it) so the emitter can project the repeated field.
+  assert.equal(registryFromManifest(manifest).order.fields.tags.list, true);
+  assert.match(emitDomain(manifest), /tags: string\[\];/);
+});
+
+test("deriveDomain: emits domain-rows.d.ts only when the manifest declares types", () => {
+  assert.deepEqual(deriveDomain({}), []);
+  assert.deepEqual(deriveDomain({ types: {} }), []);
+  const arts = deriveDomain({ data: { default: "app" }, types: { greeting: { table: "greetings", fields: { who: { type: "string" } } } } });
+  assert.equal(arts.length, 1);
+  assert.equal(arts[0].path, "nano-generated/domain-rows.d.ts");
+});
+
+test("sqliteAffinityToTs: SQLite affinity rules with boolean/datetime overrides", () => {
+  assert.equal(sqliteAffinityToTs("INTEGER"), "number");
+  assert.equal(sqliteAffinityToTs("TEXT"), "string");
+  assert.equal(sqliteAffinityToTs("REAL"), "number");
+  assert.equal(sqliteAffinityToTs("BLOB"), "Uint8Array");
+  assert.equal(sqliteAffinityToTs("BOOLEAN"), "boolean");
+  assert.equal(sqliteAffinityToTs("DATETIME"), "string");
+  assert.equal(sqliteAffinityToTs("NUMERIC"), "number");
+  assert.equal(sqliteAffinityToTs(""), "unknown");
+});
+
+test("interfaceName: PascalCases + sanitises table names to identifiers", () => {
+  assert.equal(interfaceName("order_items"), "OrderItems");
+  assert.equal(interfaceName("customers"), "Customers");
+  assert.equal(interfaceName("2024_events"), "T_2024Events");
+});