@nanobpm/urban 0.20.0 → 0.22.0

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

@@ -0,0 +1,306 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createNodeHost } from "../../adapters/node.ts";
+import { isRecord } from "../guards.ts";
+import { runDataOp } from "./dataops.ts";
+
+// A project fixture: nano.app.json declaring one sqlite source with a migrations dir, plus a
+// couple of migration files. runDataOp is called with root "." against a host anchored at `dir`
+// (the same pattern `urban data` uses in the CLI), so paths resolve inside the fixture.
+async function fixture(): Promise<{ dir: string; cleanup: () => Promise<void> }> {
+  const dir = await mkdtemp(join(tmpdir(), "urban-dataops-"));
+  await mkdir(join(dir, "db", "migrations"), { recursive: true });
+  await writeFile(
+    join(dir, "nano.app.json"),
+    JSON.stringify({
+      schemaVersion: 1,
+      id: "shop",
+      name: "Shop",
+      data: {
+        default: "app",
+        sources: { app: { driver: "sqlite", url: "file:./db/app.db", migrations: "db/migrations" } },
+      },
+    }),
+  );
+  await writeFile(
+    join(dir, "db", "migrations", "001_orders.sql"),
+    "CREATE TABLE orders (id INTEGER PRIMARY KEY, total INTEGER NOT NULL);",
+  );
+  await writeFile(
+    join(dir, "db", "migrations", "002_customers.sql"),
+    "CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT NOT NULL, order_id INTEGER REFERENCES orders(id));",
+  );
+  return { dir, cleanup: () => rm(dir, { recursive: true, force: true }) };
+}
+
+const run = (dir: string, req: Parameters<typeof runDataOp>[3]) =>
+  runDataOp(createNodeHost({ cwd: dir }), ".", "nano.app.json", req);
+
+function expectRecords(value: unknown): Record<string, unknown>[] {
+  if (!Array.isArray(value) || !value.every(isRecord)) {
+    throw new TypeError("expected an array of records");
+  }
+  return value;
+}
+
+test("sources lists declared datasources and the default", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    const r = await run(dir, { op: "sources" });
+    assert.equal(r.default, "app");
+    assert.deepEqual(r.sources, [
+      { name: "app", driver: "sqlite", url: "file:./db/app.db", migrations: "db/migrations" },
+    ]);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("migrations lists pending files, migrate applies them, then schema reflects them", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    // Before migrating: both files pending, schema empty.
+    const before = await run(dir, { op: "migrations" });
+    assert.equal(before.dir, "db/migrations");
+    const beforeEntries = expectRecords(before.entries);
+    assert.deepEqual(
+      beforeEntries.map((e) => [e.name, e.applied]),
+      [["001_orders.sql", false], ["002_customers.sql", false]],
+    );
+    assert.deepEqual(await run(dir, { op: "schema" }), { tables: [] });
+
+    // migrate applies both in filename order.
+    const migrated = await run(dir, { op: "migrate" });
+    assert.deepEqual(migrated, { applied: ["001_orders.sql", "002_customers.sql"], pending: 0 });
+
+    // migrations now reports them applied (with timestamps).
+    const after = await run(dir, { op: "migrations" });
+    assert.ok(expectRecords(after.entries).every((e) => e.applied && typeof e.appliedAt === "string"));
+
+    // A second migrate is idempotent.
+    assert.deepEqual(await run(dir, { op: "migrate" }), { applied: [], pending: 0 });
+
+    // schema introspects the live DB — the migrations ledger table is excluded, FKs surface.
+    const schema = await run(dir, { op: "schema" });
+    const tables = expectRecords(schema.tables);
+    assert.deepEqual(tables.map((t) => t.name), ["customers", "orders"]);
+    const customers = tables.find((t) => t.name === "customers");
+    assert.ok(customers);
+    assert.deepEqual(customers.foreignKeys, [
+      { column: "order_id", refTable: "orders", refColumn: "id", onDelete: "" },
+    ]);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("migrations honours an absolute migrations dir (root is not wrongly prefixed)", async () => {
+  // A manifest may declare an absolute migrations path (e.g. a Node host pointing at a shared
+  // location). It must be used as-is, not joined onto the app root — this guards the
+  // `resolveAppPath` routing in both the `migrations` op and `applyMigrations`.
+  const dir = await mkdtemp(join(tmpdir(), "urban-dataops-abs-"));
+  try {
+    const absMigrations = join(dir, "db", "migrations");
+    await mkdir(absMigrations, { recursive: true });
+    await writeFile(
+      join(dir, "nano.app.json"),
+      JSON.stringify({
+        schemaVersion: 1,
+        id: "shop",
+        name: "Shop",
+        data: {
+          default: "app",
+          sources: {
+            app: { driver: "sqlite", url: "file:./db/app.db", migrations: absMigrations },
+          },
+        },
+      }),
+    );
+    await writeFile(
+      join(absMigrations, "001_orders.sql"),
+      "CREATE TABLE orders (id INTEGER PRIMARY KEY, total INTEGER NOT NULL);",
+    );
+
+    const before = await run(dir, { op: "migrations" });
+    assert.equal(before.dir, absMigrations);
+    const beforeEntries = expectRecords(before.entries);
+    assert.deepEqual(
+      beforeEntries.map((e) => [e.name, e.applied]),
+      [["001_orders.sql", false]],
+    );
+
+    const migrated = await run(dir, { op: "migrate" });
+    assert.deepEqual(migrated, { applied: ["001_orders.sql"], pending: 0 });
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("exec then query round-trips rows with JSON-safe values", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    await run(dir, { op: "migrate" });
+    const ins = await run(dir, {
+      op: "exec",
+      sql: "INSERT INTO orders (id, total) VALUES (?, ?)",
+      params: [1, 4200],
+    });
+    assert.equal(ins.changed, 1);
+    assert.equal(ins.lastInsertId, 1);
+
+    const q = await run(dir, { op: "query", sql: "SELECT id, total FROM orders" });
+    assert.deepEqual(q.columns, ["id", "total"]);
+    assert.deepEqual(q.rows, [{ id: 1, total: 4200 }]);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("script runs statements atomically and rolls back on failure", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    await run(dir, { op: "migrate" });
+    await run(dir, { op: "exec", sql: "INSERT INTO orders (id, total) VALUES (1, 10)" });
+
+    // A failing script (second statement is invalid) rolls back the first.
+    await assert.rejects(
+      run(dir, {
+        op: "script",
+        statements: ["UPDATE orders SET total = 99 WHERE id = 1", "UPDATE nope SET x = 1"],
+      }),
+    );
+    const after = await run(dir, { op: "query", sql: "SELECT total FROM orders WHERE id = 1" });
+    assert.equal(expectRecords(after.rows)[0].total, 10, "the first UPDATE was rolled back");
+
+    // A valid multi-statement script commits and reports the changed-row count.
+    const ok = await run(dir, {
+      op: "script",
+      statements: ["UPDATE orders SET total = 20 WHERE id = 1"],
+    });
+    assert.equal(ok.changed, 1);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("opening a read op does not apply migrations (schema stays empty until migrate)", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    // `schema`/`query` must not silently migrate — the DB manager opens the panel read-only.
+    assert.deepEqual(await run(dir, { op: "schema" }), { tables: [] });
+    const mig = await run(dir, { op: "migrations" });
+    assert.ok(expectRecords(mig.entries).every((e) => !e.applied), "listing migrations did not apply them");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("listing migrations is side-effect-free (does not create the ledger table)", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    // Listing must not mutate the schema — the ledger table stays absent until `migrate`.
+    await run(dir, { op: "migrations" });
+    const ledger = await run(dir, {
+      op: "query",
+      sql: "SELECT name FROM sqlite_master WHERE type='table' AND name='_urban_migrations'",
+    });
+    assert.deepEqual(ledger.rows, [], "listing migrations must not create the ledger table");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("migrations treats a missing migrations dir as an empty list", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    await rm(join(dir, "db", "migrations"), { recursive: true, force: true });
+    const mig = await run(dir, { op: "migrations" });
+    assert.equal(mig.dir, "db/migrations");
+    assert.deepEqual(mig.entries, [], "a missing dir lists no migrations instead of throwing");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("domaintypes is not yet implemented and errors clearly", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    await assert.rejects(run(dir, { op: "domaintypes" }), /not yet implemented/);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("an unknown op and an unknown source error", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    // "nope" is deliberately not a member of DataOp — parse past the compile-time union to
+    // exercise runDataOp's runtime `default` guard against unknown ops reaching it (e.g. a
+    // hand-rolled JSON request off the wire).
+    const badRequest: Parameters<typeof runDataOp>[3] = JSON.parse('{"op":"nope"}');
+    await assert.rejects(run(dir, badRequest), /unknown op/);
+    await assert.rejects(run(dir, { op: "schema", source: "ghost" }), /no such data source/);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("an invalid manifest fails with ManifestValidationError (consistent with the app runtime)", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "urban-dataops-bad-"));
+  try {
+    // A source declared without a url: valid JSON, but the runtime binding rule rejects it —
+    // just as createUrbanApp/runFromEnv would, rather than failing confusingly downstream.
+    await writeFile(
+      join(dir, "nano.app.json"),
+      JSON.stringify({
+        schemaVersion: 1,
+        id: "shop",
+        name: "Shop",
+        data: { default: "app", sources: { app: { driver: "sqlite" } } },
+      }),
+    );
+    await assert.rejects(run(dir, { op: "sources" }), /Invalid Urban manifest[\s\S]*data\.sources\.app\.url/);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("a failing source open names which datasource failed", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "urban-dataops-openfail-"));
+  try {
+    // url points into a directory that does not exist: openSqliteSource fails fast, and
+    // openGateway prefixes the datasource name so the error is actionable (like provisionSqlite).
+    await writeFile(
+      join(dir, "nano.app.json"),
+      JSON.stringify({
+        schemaVersion: 1,
+        id: "shop",
+        name: "Shop",
+        data: { default: "app", sources: { app: { driver: "sqlite", url: "file:./nope/app.db" } } },
+      }),
+    );
+    await assert.rejects(run(dir, { op: "schema" }), /datasource "app":/);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("an absolute --manifest path is honoured as-is (not re-prefixed with root)", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    // root is irrelevant when the manifest path is absolute — it must not be prefixed onto it.
+    const r = await runDataOp(
+      createNodeHost({ cwd: dir }),
+      "/some/unrelated/root",
+      join(dir, "nano.app.json"),
+      { op: "sources" },
+    );
+    assert.equal(r.default, "app");
+    assert.deepEqual(expectRecords(r.sources).map((s) => s.name), ["app"]);
+  } finally {
+    await cleanup();
+  }
+});

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

@@ -0,0 +1,292 @@
+// dataops — the DB-manager op protocol behind `urban data`. A single JSON request is
+// dispatched against a manifest datasource and a single JSON result is returned; the CLI
+// (`urban data`, cli.ts) wraps it in the `{ ok, ... }` stdin/stdout envelope. This is the
+// runtime-agnostic core the Nano console re-points its **Data** panel (Tables / SQL /
+// Migrations) at, replacing the vendored `nano-generated/data-cli.ts` (host dry-out #576).
+//
+// Every op runs THROUGH the same datasource seam the app runtime uses (`openSqliteSource` +
+// `makeGateway`), so the panel browses exactly what the named source resolves to — never a
+// parallel path. Read/list ops open the source WITHOUT applying migrations (opening the DB
+// manager must not silently mutate the schema); `migrate` applies pending migrations on the
+// shared `_urban_migrations` ledger.
+//
+//   Request:  { op, source?, sql?, params?, statements? }
+//   op = "sources" | "schema" | "query" | "exec" | "script" | "migrations" | "migrate"
+//      | "domaintypes"
+//
+// `domaintypes` (live-schema reification + shape resolution) is a known protocol op but is
+// intentionally NOT handled here yet — it is ported to `urban data` in a follow-up (PR 2 of
+// #576) and errors clearly for now.
+
+import type { HostContext, SqliteDb } from "../host.ts";
+import { isRecord } from "../guards.ts";
+import type { AppManifest, DataSource as ManifestDataSource } from "../manifest.ts";
+import { loadManifest } from "../manifest.ts";
+import { validateManifest } from "../validate.ts";
+import { makeGateway, type DataSource as GatewayDataSource } from "./gateway.ts";
+import { applyMigrations, MIGRATIONS_TABLE, openSqliteSource, resolveAppPath } from "./datasource.ts";
+
+/** The DB-manager op protocol's known op set. `domaintypes` is part of the protocol but is not
+ * yet handled here (it errors clearly — see the file header); every other op is dispatched by
+ * `runDataOp`. Typing `op` as this union (instead of `string`) gives SDK/console callers
+ * type-safety and catches typos at compile time. */
+export type DataOp =
+  | "sources"
+  | "schema"
+  | "query"
+  | "exec"
+  | "script"
+  | "migrations"
+  | "migrate"
+  | "domaintypes";
+
+export interface DataRequest {
+  op: DataOp;
+  source?: string;
+  sql?: string;
+  params?: unknown[];
+  statements?: string[];
+}
+
+/** One datasource the manifest declares, resolved against the environment (env templates in
+ * `driver`/`url` are already expanded by `loadManifest`). Mirrors the console's `ResolvedSource`
+ * so the panel's datasource picker is unchanged. */
+export interface ResolvedSource {
+  name: string;
+  driver: string;
+  url: string;
+  migrations?: string;
+}
+
+const DEFAULT_MIGRATIONS_DIR = "db/migrations";
+
+/** JSON-safe a value: BigInt → number (when lossless) or string, recursing objects/arrays. SQLite
+ * reports `lastInsertRowid` (and INTEGER columns) as BigInt, which `JSON.stringify` cannot encode. */
+export function jsonSafe(v: unknown): unknown {
+  if (typeof v === "bigint") {
+    return v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)
+      ? Number(v)
+      : v.toString();
+  }
+  if (Array.isArray(v)) return v.map(jsonSafe);
+  if (v && typeof v === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, val] of Object.entries(v)) out[k] = jsonSafe(val);
+    return out;
+  }
+  return v;
+}
+
+/** Column order across a row set: first-seen order, unioned over every row (rows may be ragged). */
+function columnsOf(rows: Record<string, unknown>[]): string[] {
+  const seen = new Set<string>();
+  const cols: string[] = [];
+  for (const r of rows) {
+    for (const k of Object.keys(r)) {
+      if (!seen.has(k)) {
+        seen.add(k);
+        cols.push(k);
+      }
+    }
+  }
+  return cols;
+}
+
+/** Split a script on `;` boundaries, dropping blank and comment-only fragments. Minimal DDL
+ * splitter (ADR 0024 "minimal dialect stance"); does not parse semicolons inside string literals. */
+function splitStatements(sql: string): string[] {
+  return sql
+    .split(";")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0 && !s.split("\n").every((l) => l.trim().startsWith("--")));
+}
+
+/** List every declared datasource plus the default's name (no connection opened). */
+export function listSources(manifest: AppManifest): { default?: string; sources: ResolvedSource[] } {
+  const data = manifest.data;
+  const sources: ResolvedSource[] = Object.entries(data?.sources ?? {}).map(([name, raw]) => ({
+    name,
+    driver: String(raw.driver),
+    url: raw.url,
+    migrations: raw.migrations,
+  }));
+  return { default: data?.default, sources };
+}
+
+/** Resolve the source a request names (the default, or the sole source, when unnamed). */
+function pickSource(manifest: AppManifest, name?: string): { name: string; src: ManifestDataSource } {
+  const data = manifest.data;
+  const sources = data?.sources ?? {};
+  const chosen = name || data?.default || Object.keys(sources)[0];
+  if (!chosen) throw new Error("no data source specified and none declared in the manifest");
+  const src = sources[chosen];
+  if (!src) throw new Error(`no such data source "${chosen}"`);
+  return { name: chosen, src };
+}
+
+/** Open the requested source's gateway WITHOUT applying migrations (opening the DB manager must
+ * not mutate the schema). The caller closes the returned handle. */
+async function openGateway(
+  host: HostContext,
+  root: string,
+  manifest: AppManifest,
+  name?: string,
+): Promise<{ gw: GatewayDataSource; db: SqliteDb }> {
+  const { name: chosen, src } = pickSource(manifest, name);
+  if (String(src.driver) !== "sqlite") {
+    throw new Error(
+      `data source "${chosen}" uses driver "${String(src.driver)}"; only "sqlite" is implemented`,
+    );
+  }
+  let db: SqliteDb;
+  try {
+    db = await openSqliteSource(host, root, src.url);
+  } catch (err) {
+    // Prefix the source name onto openSqliteSource's runtime-agnostic message so the CLI/console
+    // error names which datasource failed (mirrors provisionSqlite).
+    throw new Error(`datasource "${chosen}": ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return { gw: makeGateway(db), db };
+}
+
+/**
+ * Resolve a `--manifest` argument against the app `root`. An absolute path (POSIX `/abs/…`, a
+ * Windows drive-letter `C:\…` or a UNC `\\host\share\…`) is honoured as-is; a relative path is
+ * joined onto `root`. Delegates to `resolveAppPath` so manifest and datasource path resolution
+ * share one cross-platform implementation and can't drift.
+ */
+function resolveManifestPath(root: string, manifestPath: string): string {
+  return resolveAppPath(root, manifestPath);
+}
+
+/**
+ * Dispatch one DB-manager op against the app at `root`. Returns the op's result object (the CLI
+ * wraps it as `{ ok: true, ...result }`); throws on a handled error (wrapped as `{ ok: false }`).
+ */
+export async function runDataOp(
+  host: HostContext,
+  root: string,
+  manifestPath: string,
+  req: DataRequest,
+): Promise<Record<string, unknown>> {
+  const manifest = validateManifest(
+    await loadManifest(host, resolveManifestPath(root, manifestPath)),
+  );
+
+  switch (req.op) {
+    case "sources": {
+      const { sources, default: def } = listSources(manifest);
+      return { default: def, sources };
+    }
+    case "schema": {
+      const { gw, db } = await openGateway(host, root, manifest, req.source);
+      try {
+        return { tables: await gw.schema() };
+      } finally {
+        db.close();
+      }
+    }
+    case "query": {
+      const { gw, db } = await openGateway(host, root, manifest, req.source);
+      try {
+        const rows: Record<string, unknown>[] = await gw.query(req.sql ?? "", req.params ?? []);
+        const safeRows: unknown[] = rows.map(jsonSafe);
+        return { columns: columnsOf(rows), rows: safeRows };
+      } finally {
+        db.close();
+      }
+    }
+    case "exec": {
+      const { gw, db } = await openGateway(host, root, manifest, req.source);
+      try {
+        const result = jsonSafe(await gw.exec(req.sql ?? "", req.params ?? []));
+        return isRecord(result) ? result : {};
+      } finally {
+        db.close();
+      }
+    }
+    case "script": {
+      // Run several statements atomically in one transaction — the console's structure editor
+      // uses this for the SQLite 12-step table rebuild (create → copy → drop → rename), so a
+      // mid-rebuild failure rolls back and leaves the table untouched. Statements come pre-split
+      // from the caller; `?`-params are not threaded (DDL needs none).
+      const { gw, db } = await openGateway(host, root, manifest, req.source);
+      try {
+        const statements = Array.isArray(req.statements)
+          ? req.statements
+          : splitStatements(req.sql ?? "");
+        let changed = 0;
+        await gw.tx(async (t) => {
+          for (const stmt of statements) {
+            if (stmt.trim()) changed += (await t.exec(stmt)).changed;
+          }
+        });
+        return { changed };
+      } finally {
+        db.close();
+      }
+    }
+    case "migrations": {
+      const { name, src } = pickSource(manifest, req.source);
+      const relDir = src.migrations ?? DEFAULT_MIGRATIONS_DIR;
+      const absDir = resolveAppPath(root, relDir);
+      // `migrations` is a read/list op: treat a missing dir as no migrations (mirrors
+      // applyMigrations) instead of throwing on host.listDir.
+      const files = (await host.exists(absDir))
+        ? (await host.listDir(absDir)).filter((f) => f.endsWith(".sql")).sort()
+        : [];
+      const { gw, db } = await openGateway(host, root, manifest, name);
+      try {
+        // Do not create the ledger table here — listing migrations must not mutate the
+        // schema. If the ledger doesn't exist yet, nothing has been applied.
+        const ledgerExists =
+          (
+            await gw.query(
+              `SELECT name FROM sqlite_master WHERE type='table' AND name='${MIGRATIONS_TABLE}'`,
+            )
+          ).length > 0;
+        const applied = ledgerExists
+          ? new Map<string, string>(
+              (await gw.query(`SELECT name, applied_at FROM ${MIGRATIONS_TABLE}`)).map((r) => [
+                String(r.name),
+                String(r.applied_at),
+              ]),
+            )
+          : new Map<string, string>();
+        return {
+          dir: relDir,
+          entries: files.map((name) => ({
+            name,
+            applied: applied.has(name),
+            appliedAt: applied.get(name) ?? null,
+          })),
+        };
+      } finally {
+        db.close();
+      }
+    }
+    case "migrate": {
+      const { name, src } = pickSource(manifest, req.source);
+      const { db } = await openGateway(host, root, manifest, name);
+      try {
+        const applied = await applyMigrations(
+          host,
+          db,
+          root,
+          src.migrations ?? DEFAULT_MIGRATIONS_DIR,
+        );
+        return { applied, pending: 0 };
+      } finally {
+        db.close();
+      }
+    }
+    case "domaintypes": {
+      throw new Error(
+        "`domaintypes` is not yet implemented in `urban data` — the Nano console still serves it " +
+          "(tracked as PR 2 of nano-bpm#576)",
+      );
+    }
+    default:
+      throw new Error(`unknown op "${req.op}"`);
+  }
+}

package/src/runtime/core/modules/datasource.migrations.test.ts

@@ -10,7 +10,16 @@ import type { EngineClient } from "../host.ts";
 import type { AppManifest } from "../manifest.ts";
 
 // provisionData never touches the engine — a bare stub is enough for these datasource tests.
-const noEngine = {} as EngineClient;
+const noEngine: EngineClient = {
+  deployResources: async () => ({ deployed: 0 }),
+  createInstance: async () => ({ processInstanceKey: "pi" }),
+  cancelInstance: async () => {},
+  publishMessage: async () => {},
+  searchUserTasks: async () => [],
+  completeUserTask: async () => {},
+  registerWorker: async (jobType) => ({ jobType, unsubscribe: async () => {} }),
+  close: async () => {},
+};
 
 async function fixture(migrations: Record<string, string>): Promise<string> {
   const dir = await mkdtemp(join(tmpdir(), "urban-mig-"));
@@ -22,7 +31,7 @@ async function fixture(migrations: Record<string, string>): Promise<string> {
 }
 
 function ctx(dir: string): RuntimeContext {
-  const manifest = {
+  const manifest: AppManifest = {
     schemaVersion: 1,
     id: "mig-fixture",
     name: "Migration Fixture",
@@ -30,7 +39,7 @@ function ctx(dir: string): RuntimeContext {
       default: "app",
       sources: { app: { driver: "sqlite", url: "file:./app.db", migrations: "db/migrations" } },
     },
-  } as unknown as AppManifest;
+  };
   return { manifest, host: createNodeHost({ cwd: dir, log: () => {} }), engine: noEngine, root: "." };
 }