okmodel 0.4.0 → 0.5.1

package/dist/shared/{kafaa5zv.js → r2sp8hrc.js}

@@ -1,16 +1,16 @@
 import {
   isConnectionLost
-} from "./tbszx8mz.js";
+} from "./pf0d8f77.js";
 import {
   openClient,
   withHttp,
   settleCall
-} from "./kkzwp3d2.js";
+} from "./hf22e0wt.js";
 import {
   rejectKeys,
   isRecord,
   fail
-} from "./xrfnq5k8.js";
+} from "./gbtcc2d7.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -92,6 +92,9 @@ class Frame {
   }
 }
 async function tx(session, args) {
+  if (typeof args[0] === "function" && args.length > 1) {
+    fail("OKM1120", "options go first: tx(options, fn).");
+  }
   const fn = typeof args[0] === "function" ? args[0] : args[1];
   const given = typeof args[0] === "function" ? {} : args[0] ?? {};
   try {
@@ -312,8 +315,16 @@ function held(session, frame, after, depth) {
   };
   const pool = depth === 0 ? {
     capabilities: base.capabilities,
-    execute: (text, params, options) => guarded(() => frame.conn.execute(text, params, stoppable(frame, options)), false),
-    batch: (statements, options) => guarded(() => frame.conn.batch(statements, stoppable(frame, options)), true),
+    execute: (text, params, options) => {
+      if (options?.route === "replica")
+        replicaInside();
+      return guarded(() => frame.conn.execute(text, params, stoppable(frame, options)), false);
+    },
+    batch: (statements, options) => {
+      if (options?.route === "replica")
+        replicaInside();
+      return guarded(() => frame.conn.batch(statements, stoppable(frame, options)), true);
+    },
     stats: () => base.stats(),
     close: () => Promise.resolve()
   } : base;
@@ -364,13 +375,22 @@ function lockKey(key) {
   return ["select pg_advisory_xact_lock($1::bigint)", String(key)];
 }
 function callOf(options) {
-  if (options?.signal === undefined && options?.timeout === undefined)
+  if (options?.signal === undefined && options?.timeout === undefined && options?.route === undefined) {
     return;
+  }
   return {
-    ...options.signal !== undefined ? { signal: options.signal } : {},
-    ...options.timeout !== undefined ? { timeout: options.timeout } : {}
+    ...options?.signal !== undefined ? { signal: options.signal } : {},
+    ...options?.timeout !== undefined ? { timeout: options.timeout } : {},
+    ...options?.route !== undefined ? { route: options.route } : {}
   };
 }
+function replicaInside() {
+  throw new OkmError2("OKM1840", "This operation needs the primary.", {
+    fix: {
+      summary: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
+    }
+  });
+}
 export {
   tx
 };

package/dist/shared/{fb00y8fp.js → r8x5qhd7.js}

@@ -1,17 +1,17 @@
 import {
   send,
   connectClient
-} from "./6p5k20sm.js";
+} from "./96qcj21c.js";
 import {
   isConnectionLost
-} from "./tbszx8mz.js";
+} from "./pf0d8f77.js";
 import {
   WireSession
-} from "./zvbjc949.js";
+} from "./4az561fn.js";
 import {
   rejectClosed,
   runCall
-} from "./rrstp3kb.js";
+} from "./cgbamx3e.js";
 
 // src/adapters/pg/nodepostgres-extra.ts
 var RESET_ALL = "RESET ALL";
@@ -43,7 +43,7 @@ async function checkout(held) {
   return {
     execute: (text, params, options) => guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch))),
     batch: (statements, options) => guard(() => runCall(isClosed(), options, async (watch) => {
-      const { runAtomicBatch } = await import("./b066g80h.js");
+      const { runAtomicBatch } = await import("./efmy2gcg.js");
       return runAtomicBatch(session, statements, watch);
     })),
     cancel() {

package/dist/shared/{yjw02enp.js → sdc7r2ww.js}

@@ -1,12 +1,13 @@
-import"./8jb4ymh2.js";
+import"./8bwbwy8h.js";
 import"./n442h54c.js";
-import"./wqem4jed.js";
+import"./krxx77g0.js";
 import {
-  listTargets,
   loadConfig
-} from "./q6zsyh31.js";
-import"./n5y9zyj1.js";
-import"./41kv2xdm.js";
+} from "./qv2ydck9.js";
+import {
+  listTargets
+} from "./ga3sfy93.js";
+import"./8xsbagad.js";
 
 // src/tooling/migrate/dev.ts
 import { mkdirSync } from "node:fs";
@@ -19,7 +20,7 @@ async function devProject(cwd) {
 `;
   const directory = join(cwd, config.out ?? ".okm", "dev-db");
   mkdirSync(directory, { recursive: true });
-  const { open } = await import("./gdh9mrtp.js");
+  const { open } = await import("./f5cw5q5r.js");
   const pool = await open({ dataDir: directory });
   try {
     await pool.execute("select 1");

package/dist/shared/sycnx8gt.js

@@ -0,0 +1,289 @@
+import {
+  cellText,
+  VIEW_DEPENDENCIES,
+  viewDependencyEdges,
+  PUBLIC,
+  introspectSchema
+} from "./fancm5pt.js";
+import {
+  planMigration,
+  assertDirectConnection,
+  assertStableBackend
+} from "./ga3sfy93.js";
+import {
+  quoteIdent,
+  createObjectSql
+} from "./8xsbagad.js";
+import {
+  normaliseViewQuery,
+  viewObject,
+  materializedViewObject
+} from "./y005b761.js";
+import {
+  catalog
+} from "./g7ez901n.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/drift.ts
+import postgres from "postgres";
+
+// src/dialects/pg/view/scratch.ts
+var SCRATCH = "okm_view_seal";
+var VIEW_SHAPE = `
+  select c.relname as name, c.relkind as kind, pg_get_viewdef(c.oid, true) as query,
+    (
+      select coalesce(string_agg(
+        a.attname || '|' || format_type(a.atttypid, a.atttypmod),
+        E'\\n' order by a.attnum
+      ), '')
+      from pg_attribute a
+      where a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped
+    ) as columns
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname = $1 and c.relkind in ('v', 'm')
+`;
+async function sealViews(runner, source) {
+  const views = source.objects.filter((object) => object.kind === "view" || object.kind === "materializedView");
+  if (views.length === 0)
+    return source;
+  await dropScratch(runner);
+  await runner.query(`create schema ${quoteIdent(SCRATCH)}`);
+  const previous = await runner.query(`select current_setting('search_path') as path`);
+  const saved = cellText(previous[0]?.path);
+  const path = await scratchSearchPath(runner, source);
+  try {
+    await runner.query(`select set_config('search_path', $1, false)`, [path]);
+    await createObjects(runner, source, "type");
+    for (const object of source.objects) {
+      if (object.kind !== "table")
+        continue;
+      await runner.query(stubTable(object, source));
+    }
+    await createObjects(runner, source, "function");
+    await createViews(runner, views);
+    const shapes = await runner.query(VIEW_SHAPE, [SCRATCH]);
+    const deps = await runner.query(VIEW_DEPENDENCIES, [SCRATCH]);
+    const edges = viewDependencyEdges(deps, PUBLIC, source.objects);
+    const byName = new Map(shapes.map((row) => [cellText(row.name), row]));
+    const next = source.objects.map((object) => {
+      if (object.kind !== "view" && object.kind !== "materializedView")
+        return object;
+      const row = byName.get(object.identity.name);
+      if (row === undefined) {
+        throw new OkmError2("OKM1020", `View ${object.identity.name} was not created in the scratch schema.`, {
+          fix: { summary: "The query has to run against the tables in this schema." }
+        });
+      }
+      const columns = readColumns(object, cellText(row.columns));
+      const query = normaliseViewQuery(cellText(row.query));
+      const dependencies = edges.get(object.identity.name) ?? [];
+      if (object.kind === "view") {
+        return viewObject({
+          namespace: object.identity.namespace,
+          name: object.identity.name,
+          columns,
+          query,
+          owner: object.owner,
+          provenance: object.provenance,
+          dependencies
+        });
+      }
+      return materializedViewObject({
+        namespace: object.identity.namespace,
+        name: object.identity.name,
+        columns,
+        query,
+        owner: object.owner,
+        provenance: object.provenance,
+        dependencies,
+        ...object.definition.refresh !== undefined ? { refresh: object.definition.refresh } : {}
+      });
+    });
+    return catalog(next);
+  } finally {
+    await runner.query(`select set_config('search_path', $1, false)`, [saved]).catch(() => {
+      return;
+    });
+    await dropScratch(runner);
+  }
+}
+async function scratchSearchPath(runner, source) {
+  const names = new Set;
+  for (const object of source.objects) {
+    if (object.kind !== "column")
+      continue;
+    const bare = object.definition.dataType.split(".").pop()?.replace(/\(.*$/, "").replace(/\[\]$/, "").trim().toLowerCase();
+    if (bare !== undefined && bare.length > 0)
+      names.add(bare);
+  }
+  const extra = [];
+  if (names.size > 0) {
+    const rows = await runner.query(`select distinct n.nspname as schema
+       from pg_type t
+       join pg_namespace n on n.oid = t.typnamespace
+       where t.typname = any(string_to_array($1, E'\\x1f'))
+         and n.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')`, [[...names].join("\x1F")]);
+    for (const row of rows) {
+      const schema = cellText(row.schema);
+      if (schema.length > 0 && schema !== "public" && schema !== SCRATCH)
+        extra.push(schema);
+    }
+  }
+  extra.sort();
+  return [SCRATCH, ...extra, "public"].map((name) => quoteIdent(name)).join(", ");
+}
+async function createObjects(runner, source, kind) {
+  for (const object of source.objects) {
+    if (object.kind !== kind)
+      continue;
+    const statement = createObjectSql(object, SCRATCH);
+    if (statement !== undefined)
+      await runner.query(statement);
+  }
+}
+async function createViews(runner, views) {
+  const pending = [...views];
+  let last = "";
+  for (let pass = 0;pass < views.length && pending.length > 0; pass += 1) {
+    const failed = [];
+    let created = 0;
+    for (const object of pending) {
+      const sql = object.kind === "materializedView" ? `create materialized view ${quoteIdent(object.identity.name)} as ${object.definition.query} with no data` : `create view ${quoteIdent(object.identity.name)} as ${object.definition.query}`;
+      try {
+        await runner.query(sql);
+        created += 1;
+      } catch (error) {
+        last = error instanceof Error ? error.message : String(error);
+        failed.push(object);
+      }
+    }
+    if (created === 0) {
+      throw new OkmError2("OKM1020", `View ${failed[0]?.identity.name ?? ""} could not be created. ${last}`, {
+        fix: { summary: "The query has to run against the tables in this schema." }
+      });
+    }
+    pending.length = 0;
+    pending.push(...failed);
+  }
+}
+function stubTable(object, source) {
+  const columns = source.objects.filter((item) => item.kind === "column" && item.identity.parent.name === object.identity.name);
+  const lines = columns.map((column) => `${quoteIdent(column.identity.name)} ${column.definition.dataType}`);
+  return `create table ${quoteIdent(object.identity.name)} (${lines.join(", ")})`;
+}
+function readColumns(object, printed) {
+  const live = printed.length === 0 ? [] : printed.split(`
+`);
+  const declared = object.definition.columns;
+  if (live.length !== declared.length) {
+    throw mismatch(object.identity.name, declared.map((column) => column.name).join(", "), printed);
+  }
+  return declared.map((column, index) => {
+    const line = live[index] ?? "";
+    const splitAt = line.indexOf("|");
+    const name = splitAt < 0 ? line : line.slice(0, splitAt);
+    const type = splitAt < 0 ? "" : line.slice(splitAt + 1);
+    if (name !== column.name || type !== column.dataType) {
+      throw mismatch(object.identity.name, `${column.name}:${column.dataType}`, live[index] ?? "");
+    }
+    return column;
+  });
+}
+function mismatch(view, declared, live) {
+  return new OkmError2("OKM1020", `View ${view} declares ${declared} and the database has ${live}.`, { fix: { summary: "Declare the columns the query returns, in that order, with those types." } });
+}
+async function dropScratch(runner) {
+  const present = await runner.query(`select 1 as ok from pg_namespace where nspname = $1`, [
+    SCRATCH
+  ]);
+  if (present.length === 0)
+    return;
+  const rows = await runner.query(`
+    select c.relname as name, c.relkind as kind
+    from pg_class c
+    join pg_namespace n on n.oid = c.relnamespace
+    where n.nspname = $1 and c.relkind in ('v', 'm', 'r')
+  `, [SCRATCH]);
+  const views = rows.filter((row) => cellText(row.kind) === "v" || cellText(row.kind) === "m");
+  for (let pass = 0;pass < Math.max(views.length, 1); pass += 1) {
+    for (const row of views) {
+      const kind = cellText(row.kind) === "m" ? "materialized view" : "view";
+      try {
+        await runner.query(`drop ${kind} if exists ${quoteIdent(SCRATCH)}.${quoteIdent(cellText(row.name))}`);
+      } catch {}
+    }
+  }
+  for (const row of rows) {
+    if (cellText(row.kind) !== "r")
+      continue;
+    await runner.query(`drop table if exists ${quoteIdent(SCRATCH)}.${quoteIdent(cellText(row.name))}`);
+  }
+  await runner.query(`drop schema if exists ${quoteIdent(SCRATCH)} cascade`);
+}
+
+// src/tooling/migrate/drift.ts
+async function assertAuthorDrift2(url, author, roles, allowPooler = false) {
+  assertDirectConnection(url, allowPooler);
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  try {
+    await assertStableBackend(async () => {
+      const rows = await sql`select pg_backend_pid()::text as pid`;
+      return rows[0]?.pid ?? "";
+    }, allowPooler);
+    const present = await sql`
+      select to_regclass('public.okm_meta')::text as reg
+    `;
+    if (present[0]?.reg == null)
+      return;
+    const runner = catalogQuery2(sql);
+    const authorOnServer = await sealViews(runner, author);
+    const live = await introspectSchema(runner, "public", "public", managedRoleOptions2(roles));
+    const plan = planMigration({ before: live, after: authorOnServer, name: "check" });
+    if (plan.steps.length === 0)
+      return;
+    throw new OkmError2("OKM1520", `The database differs from the schema.
+${plan.steps.map((step) => step.sql).join(`
+`)}`, {
+      fix: {
+        summary: "Change the schema or the database so okm check reports no difference."
+      }
+    });
+  } finally {
+    await sql.end({ timeout: 5 });
+  }
+}
+function catalogQuery2(sql) {
+  return {
+    async query(text, params) {
+      const rows = await sql.unsafe(text, params === undefined ? undefined : [...params]);
+      return rows.map((row) => {
+        const copy = {};
+        for (const [key, value] of Object.entries(row))
+          copy[key] = value;
+        return copy;
+      });
+    }
+  };
+}
+function managedRoleOptions2(roles) {
+  const names = managedRoleNames(roles);
+  return names === undefined ? undefined : { managedRoles: names };
+}
+function managedRoleNames(roles) {
+  if (roles === undefined)
+    return;
+  const names = new Set([roles.migration, roles.app]);
+  for (const role of roles.managed ?? [])
+    names.add(role.name);
+  return [...names];
+}
+
+export { sealViews, assertAuthorDrift2, catalogQuery2, managedRoleOptions2 };

package/dist/shared/{hcmdtwgh.js → szm0cksa.js}

@@ -1,3 +1,6 @@
+import {
+  FUNCTION_ARG_TYPES
+} from "./fancm5pt.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -92,7 +95,7 @@ async function functionExists(runner, schema, name, args) {
   const result = await runner.execute(`select 1 from pg_proc p
      join pg_namespace n on n.oid = p.pronamespace
      where n.nspname = $1 and p.proname = $2
-       and replace(pg_get_function_identity_arguments(p.oid), ' ', '') = $3`, [schema, name, args]);
+       and ${FUNCTION_ARG_TYPES} = $3`, [schema, name, args]);
   return result.rows.length > 0;
 }
 function truthy(value) {

package/dist/shared/{zg24x0hm.js → tm5ab8we.js}

@@ -3,10 +3,10 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./kkzwp3d2.js";
+} from "./hf22e0wt.js";
 import {
   fail
-} from "./xrfnq5k8.js";
+} from "./gbtcc2d7.js";
 import {
   OkmError2,
   throwNamed2
@@ -27,6 +27,14 @@ function build(session, table, options, mods, view) {
 }
 function plan(session, table, options, mods, view) {
   const { lock, wait, ...rest } = options;
+  const forced = session.pool.forcedRoute;
+  if (rest.route === "replica" || forced === "replica") {
+    throw new OkmError2("OKM1840", "A locking read needs the primary.", {
+      fix: {
+        summary: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
+      }
+    });
+  }
   if (session.tx === undefined) {
     throw new OkmError2("OKM1830", "A row lock needs a transaction. find was called outside tx().", {
       fix: { summary: "Move the find into tx(): the lock lasts until the transaction ends." }

package/dist/shared/{ygem90rn.js → v36c5g6p.js}

@@ -1,9 +1,9 @@
 import {
   renderCatalog
-} from "./41kv2xdm.js";
+} from "./8xsbagad.js";
 import {
   createClient
-} from "./kkzwp3d2.js";
+} from "./hf22e0wt.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -12,10 +12,15 @@ import {
 var tenantProbe = "00000000-0000-4000-8000-000000000001";
 function readFacts(schema) {
   const foreign = foreignKeys(schema.catalog);
+  const tables = new Set;
+  for (const object of schema.catalog.objects) {
+    if (object.kind === "table")
+      tables.add(object.identity.name);
+  }
   const facts = [];
   for (const name of Object.keys(schema.model)) {
     const model = schema.model[name];
-    if (model === undefined)
+    if (model === undefined || !tables.has(model.sql))
       continue;
     const keys = foreign.get(model.sql) ?? [];
     facts.push({
@@ -458,6 +463,9 @@ function fieldOf(facts, sql) {
 function cacheKey(table, tenant) {
   return `${tenant ?? "*"}:${table}`;
 }
+function forgetCached(host, table, tenant) {
+  host.cache.delete(cacheKey(table, tenant));
+}
 function refOf(value) {
   if (typeof value !== "object" || value === null || !(REF in value))
     return;
@@ -497,14 +505,14 @@ function isRow(value) {
 }
 
 // src/tooling/testing/isolation.ts
-var TENANT_A = "00000000-0000-4000-8000-00000000000a";
-var TENANT_B = "00000000-0000-4000-8000-00000000000b";
 async function isolation(host) {
   const saved = host.cache;
   host.cache = new Map;
   try {
     const checked = [];
     const skipped = [];
+    const tenantA = crypto.randomUUID();
+    const tenantB = crypto.randomUUID();
     for (const facts of host.facts.values()) {
       if (facts.globalReason !== undefined) {
         skipped.push({ table: facts.name, reason: facts.globalReason });
@@ -512,7 +520,7 @@ async function isolation(host) {
       }
       if (!facts.tenant)
         continue;
-      await checkTable(host, facts);
+      await checkTable(host, facts, tenantA, tenantB);
       checked.push(facts.name);
     }
     return { checked, skipped };
@@ -520,25 +528,68 @@ async function isolation(host) {
     host.cache = saved;
   }
 }
-async function checkTable(host, facts) {
+async function checkTable(host, facts, tenantA, tenantB) {
   const key = host.schema.tenancy?.key;
   if (key === undefined)
     return;
-  const row = await insertRow(host, facts.name, { [key]: TENANT_B }, undefined, TENANT_B);
+  if (host.definitions.size > 0 && !host.definitions.has(facts.name)) {
+    throw new OkmError2("invalid", `Factory ${facts.name} is missing.`, {
+      fix: { summary: `Add ${facts.name} to factories().` }
+    });
+  }
+  const row = await insertRow(host, facts.name, { [key]: tenantB }, undefined, tenantB);
   const where = primaryWhere(facts, row, key);
-  const client = openTenant(host, TENANT_A);
+  const client = openTenant(host, tenantA);
   const handle = tableHandle2(client, facts.name);
-  const found = await handle.find({ where, limit: 1 });
-  const rows = asRows(found);
+  try {
+    await readTenant(facts, handle, where);
+    const set = updateSet(host, facts, row);
+    if (set !== undefined) {
+      const updated = asCount(await handle.update({ where, set }));
+      if (updated > 0)
+        leak(facts.name, "update", { count: updated });
+      if (typeof client.batch === "function") {
+        const batched = await client.batch([handle.update({ where, set })]);
+        if (Array.isArray(batched) && batched.some((item) => asCount(item) > 0)) {
+          leak(facts.name, "batch", batched);
+        }
+      }
+    }
+    const removed = asCount(await handle.delete({ where }));
+    if (removed > 0)
+      leak(facts.name, "delete", { count: removed });
+  } finally {
+    const owner = tableHandle2(openTenant(host, tenantB), facts.name);
+    await owner.delete({ where }).catch(() => {
+      return;
+    });
+    forgetCached(host, facts.name, tenantB);
+  }
+}
+async function readTenant(facts, handle, where) {
+  const query = handle.find({ where, limit: 1 });
+  const rows = asRows(await query);
   if (rows.length > 0)
     leak(facts.name, "find", rows[0]);
+  const streamed = handle.find({ where, limit: 1 });
+  if (typeof streamed.stream === "function") {
+    try {
+      for await (const item of streamed.stream()) {
+        if (isRow2(item))
+          leak(facts.name, "stream", item);
+      }
+    } catch (error) {
+      if (!(error instanceof OkmError2) || error.code !== "OKM1111")
+        throw error;
+    }
+  }
   const one = await handle.one({ where });
   if (isRow2(one))
     leak(facts.name, "one", one);
-  const counted = asCount(await handle.count());
+  const counted = asCount(await handle.count({ where }));
   if (counted > 0)
     leak(facts.name, "count", { count: counted });
-  const exists = await handle.exists();
+  const exists = await handle.exists({ where });
   if (exists === true)
     leak(facts.name, "exists", { exists: true });
   const relation = facts.relations[0];
@@ -547,15 +598,28 @@ async function checkTable(host, facts) {
     if (isRow2(included))
       leak(facts.name, "include", included);
   }
-  const set = updateSet(host, facts, row);
-  if (set !== undefined) {
-    const updated = asCount(await handle.update({ where, set }));
-    if (updated > 0)
-      leak(facts.name, "update", { count: updated });
+  if (typeof handle.aggregate === "function") {
+    const aggregated = await handle.aggregate({ where, count: true });
+    if (Array.isArray(aggregated)) {
+      for (const item of aggregated) {
+        if (isRow2(item) && asCount(item) > 0)
+          leak(facts.name, "aggregate", item);
+      }
+    }
+  }
+  if (typeof handle.page === "function") {
+    const orderField = Object.keys(where)[0];
+    if (orderField !== undefined) {
+      const paged = await handle.page({
+        where,
+        orderBy: { [orderField]: "asc" },
+        limit: 5
+      });
+      if (isRow2(paged) && Array.isArray(paged.items) && paged.items.length > 0) {
+        leak(facts.name, "page", paged.items[0]);
+      }
+    }
   }
-  const deleted = asCount(await handle.delete({ where }));
-  if (deleted > 0)
-    leak(facts.name, "delete", { count: deleted });
 }
 function includeOf(relation) {
   if (relation.kind === "many")