okmodel 0.8.0 → 0.9.0

package/dist/shared/{bah9nbg3.js → npdftanb.js}

@@ -86,7 +86,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./v1wad97q.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./wvtjg5m3.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -121,7 +121,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./k86n8vq3.js"), table, options, base, view);
+        return lazyRead(session, () => import("./8jesqsrk.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -135,10 +135,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./6m78c8ss.js"), table, options, base, view);
+      return lazyRead(session, () => import("./5kyb3tqx.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./n05z9nwz.js"), table, options, base, view);
+      return lazyRead(session, () => import("./xtsydxjg.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -151,9 +151,9 @@ function tableApi(session, table, view, uses) {
     }
   };
   for (const walk of ["descendants", "ancestors"]) {
-    api[walk] = (id, options) => lazyRead(session, () => import("./wz2a78mp.js"), table, { id, walk, options }, base, view);
+    api[walk] = (id, options) => lazyRead(session, () => import("./c3mvnq7a.js"), table, { id, walk, options }, base, view);
   }
-  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./p5nh3r8q.js"), table, { id, relation, ids, options }, base, view, true);
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./aksb89mn.js"), table, { id, relation, ids, options }, base, view, true);
   const hooks = session.schema.hooks;
   if (hooks !== undefined) {
     for (const hook of hooks) {
@@ -173,13 +173,13 @@ function tableApi(session, table, view, uses) {
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./e8zyaqvj.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./ds229x4r.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./qd9hhd8f.js");
+  writers ??= import("./8n688yjg.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -372,7 +372,7 @@ function readHandle(session, table, call, mods, decode, extra) {
 }
 function streamLazy(session, call, mods, view, batch) {
   return async function* () {
-    const { streamRows } = await import("./jebgrkeq.js");
+    const { streamRows } = await import("./tw1nvvfj.js");
     yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
   }();
 }
@@ -405,16 +405,8 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./fjpnhqan.js");
-  let rows;
-  try {
-    const result = await pool.execute(server.versionQuery, undefined, options);
-    rows = result.rows;
-  } catch (error) {
-    const { mapPostgresError } = await import("./63qtkrca.js");
-    throw mapPostgresError(error, mapOptions(http, false, schema));
-  }
-  await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
+  const { acceptServer } = await import("./zdqf8k5d.js");
+  await acceptServer(pool, schema, http, requireMeta, options, source);
 }
 async function mapError(session, error) {
   if (error instanceof OkmError2) {
@@ -504,4 +496,4 @@ function logged(session, error) {
   return error;
 }
 
-export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, settleCall };
+export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, mapOptions, settleCall };

package/dist/shared/{16kvjebh.js → pg4ezgyf.js}

@@ -1,12 +1,16 @@
 import {
   catalogFileText2
 } from "./12z7aznj.js";
+import {
+  artifactDir,
+  readText
+} from "./yybhre6n.js";
 import {
   OkmError2
 } from "./52szzakm.js";
 
 // src/runtime/drift.ts
-async function assertCompatible(pool, schema, recordedHash, source, options) {
+async function assertCompatible(pool, schema, recordedHash, source, options, namespace = "public") {
   const code = await codeHash(schema, source);
   if (code.hash === recordedHash)
     return;
@@ -32,8 +36,8 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
       loadTrustedCatalog(text, code.hash);
     });
   }
-  const { assertDrift } = await import("./5mtf6cj3.js");
-  await assertDrift(pool, code.hash, recordedHash, options);
+  const { assertDrift } = await import("./mvmm3xpb.js");
+  await assertDrift(pool, code.hash, recordedHash, options, namespace);
 }
 async function codeHash(schema, source) {
   if (source.catalog !== undefined) {
@@ -63,29 +67,6 @@ async function readHashFile(catalogDir) {
   const hash = catalogFileText2(text, "catalog.hash").trim();
   return hash.length === 0 ? undefined : hash;
 }
-function artifactDir(catalogDir) {
-  if (catalogDir !== undefined)
-    return catalogDir.replace(/[/\\]+$/, "");
-  const cwd = globalThis.process?.cwd?.() ?? ".";
-  return `${cwd}/.okm`;
-}
-async function readText(path) {
-  const bun = globalThis.Bun;
-  if (bun !== undefined) {
-    const file = bun.file(path);
-    if (!await file.exists())
-      return;
-    return file.text();
-  }
-  const loader = globalThis.process?.getBuiltinModule;
-  if (loader === undefined)
-    return;
-  try {
-    return await loader("node:fs/promises").readFile(path, "utf8");
-  } catch {
-    return;
-  }
-}
 export {
   assertCompatible
 };

package/dist/{tooling/shared/08kemxjd.js → shared/pgsak1yw.js}

@@ -2,7 +2,7 @@ import {
   resetSession2,
   resetQueried2,
   refuseWhenLost2
-} from "./4d2w25vw.js";
+} from "./99qp9vtg.js";
 export {
   refuseWhenLost2 as refuseWhenLost,
   resetQueried2 as resetQueried,

package/dist/shared/{jp36k7dp.js → qvwwp1mp.js}

@@ -1,42 +1,50 @@
 import {
   parseCatalog2
 } from "./12z7aznj.js";
+import {
+  quoteIdent2
+} from "./fk9vef30.js";
 import"./n442h54c.js";
 import"./cm3w0ywp.js";
-import"./35q0n9tz.js";
+import"./dd5pmnky.js";
 import {
   watchReserved2
-} from "./wcrheftc.js";
+} from "./bphrgwz9.js";
 import {
   ensureMigrationTables2
-} from "./pan0370z.js";
+} from "./ccsmhv9r.js";
 import {
   sealViews,
   catalogQuery2,
   managedRoleOptions2
-} from "./mkrn359n.js";
+} from "./90sg0w5a.js";
 import {
   assumeRole,
   grantSchema,
   assertSchemaUsageLanded,
   catalogsEqual,
   snapshotDifference
-} from "./mnvjvqyp.js";
+} from "./3456242y.js";
 import {
   roleExists
-} from "./kj9d8maq.js";
+} from "./jpybhf98.js";
 import {
   introspectSchema
-} from "./p3xbdcvt.js";
+} from "./myk8fswx.js";
 import {
   projectPath,
+  loadSnapshots,
+  assertSnapshots,
+  assertLiveExternal,
   loadMigrations,
   readMigrationPlan,
+  lintReprints,
   lintMigrationDirectory,
+  formatFindings,
   hasError,
   lintRefusal,
   openProject
-} from "./f4jy1j7x.js";
+} from "./2zdxkt7b.js";
 import {
   sqlStatements,
   transactionControl,
@@ -51,13 +59,10 @@ import {
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./dpc2r7rb.js";
+} from "./6nae0spm.js";
 import {
   isConnectionLost
 } from "./cnkky55j.js";
-import {
-  quoteIdent
-} from "./sjk86yrx.js";
 import {
   catalog,
   isDomain
@@ -77,6 +82,7 @@ import { join } from "node:path";
 import postgres from "postgres";
 async function replayCheckHistory(url, scratch, config, allowPooler, history) {
   const skips = [];
+  const reprints = [];
   let stop;
   await inCheckTransaction(url, scratch, config, allowPooler, async (sql) => {
     const connection = driverOf(sql);
@@ -88,7 +94,10 @@ async function replayCheckHistory(url, scratch, config, allowPooler, history) {
       await replayMigration(sql, connection, scratch, config, migration, session, skips);
       await restoreSession(sql, session);
       const runner = catalogQuery2(sql);
-      const live = await introspectSchema(runner, scratch, "public", managedRoleOptions2(config.roles));
+      const live = await introspectSchema(runner, scratch, config.namespace ?? "public", managedRoleOptions2(config.roles));
+      for (const item of lintReprints(migration.catalog, live, migration.steps)) {
+        reprints.push({ ...item, place: `${migration.id} ${item.place}` });
+      }
       const sealed = await sealViews(runner, migration.catalog);
       const back = planMigration({ before: live, after: sealed, name: migration.id });
       if (back.steps.length === 0)
@@ -97,7 +106,7 @@ async function replayCheckHistory(url, scratch, config, allowPooler, history) {
       return;
     }
   });
-  return stop === undefined ? { skips } : { skips, stop };
+  return stop === undefined ? { skips, reprints } : { skips, reprints, stop };
 }
 async function proveCheckSnapshot(url, provided, replayed, config, allowPooler, history) {
   const head = history.at(-1);
@@ -115,10 +124,10 @@ async function proveCheckSnapshot(url, provided, replayed, config, allowPooler,
     await runSteps(sql, connection, provided, config.roles?.migration, {
       id: "snapshot",
       catalog: head.catalog,
-      steps: retargetSteps(planned.steps, provided)
+      steps: retargetSteps(planned.steps, provided, config.namespace ?? "public")
     }, session, []);
     await restoreSession(sql, session);
-    return introspectSchema(catalogQuery2(sql), provided, "public", managedRoleOptions2(config.roles));
+    return introspectSchema(catalogQuery2(sql), provided, config.namespace ?? "public", managedRoleOptions2(config.roles));
   });
   const again = await inCheckTransaction(url, replayed, config, allowPooler, async (sql) => {
     const connection = driverOf(sql);
@@ -127,17 +136,17 @@ async function proveCheckSnapshot(url, provided, replayed, config, allowPooler,
       await replayMigration(sql, connection, replayed, config, migration, session, []);
     }
     await restoreSession(sql, session);
-    return introspectSchema(catalogQuery2(sql), replayed, "public", managedRoleOptions2(config.roles));
+    return introspectSchema(catalogQuery2(sql), replayed, config.namespace ?? "public", managedRoleOptions2(config.roles));
   });
   return snapshotDifference(installed, again);
 }
-function retargetSteps(steps, schema) {
-  const from = `${quoteIdent("public")}.`;
-  const to = `${quoteIdent(schema)}.`;
-  const fromDefaults = `in schema ${quoteIdent("public")} `;
-  const toDefaults = `in schema ${quoteIdent(schema)} `;
-  const fromSchema = `on schema ${quoteIdent("public")}`;
-  const toSchema = `on schema ${quoteIdent(schema)}`;
+function retargetSteps(steps, schema, source = "public") {
+  const from = `${quoteIdent2(source)}.`;
+  const to = `${quoteIdent2(schema)}.`;
+  const fromDefaults = `in schema ${quoteIdent2(source)} `;
+  const toDefaults = `in schema ${quoteIdent2(schema)} `;
+  const fromSchema = `on schema ${quoteIdent2(source)}`;
+  const toSchema = `on schema ${quoteIdent2(schema)}`;
   return steps.map((step) => ({
     ...step,
     sql: step.sql.replaceAll(from, to).replaceAll(fromDefaults, toDefaults).replaceAll(fromSchema, toSchema),
@@ -173,9 +182,9 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     await reserved.unsafe("begin");
     open = true;
     xid = await readXid(reserved);
-    await reserved.unsafe(`create schema ${quoteIdent(scratch)}`);
+    await reserved.unsafe(`create schema ${quoteIdent2(scratch)}`);
     created = true;
-    await reserved.unsafe(`set local search_path to ${quoteIdent(scratch)}`);
+    await reserved.unsafe(`set local search_path to ${quoteIdent2(scratch)}`);
     await setLocalTimeout(reserved, "lock_timeout", config.timeouts?.lock);
     await setLocalTimeout(reserved, "statement_timeout", config.timeouts?.statement);
     await ownScratch(reserved, scratch, config.roles?.migration);
@@ -271,7 +280,7 @@ async function dropScratch(url, scratch) {
     onnotice: () => {}
   });
   try {
-    await sql.unsafe(`drop schema if exists ${quoteIdent(scratch)} cascade`);
+    await sql.unsafe(`drop schema if exists ${quoteIdent2(scratch)} cascade`);
     const rows = await sql`
       select nspname from pg_namespace where nspname = ${scratch}
     `;
@@ -299,7 +308,7 @@ async function restoreSession(sql, session) {
   delete session.setRole;
 }
 async function replayMigration(sql, connection, scratch, config, migration, session, skips) {
-  await runSteps(sql, connection, scratch, config.roles?.migration, { ...migration, steps: retargetSteps(migration.steps, scratch) }, session, skips);
+  await runSteps(sql, connection, scratch, config.roles?.migration, { ...migration, steps: retargetSteps(migration.steps, scratch, config.namespace ?? "public") }, session, skips);
 }
 async function runSteps(sql, connection, scratch, migrationRole, migration, session, skips) {
   for (let index = 0;index < migration.steps.length; index += 1) {
@@ -326,7 +335,7 @@ async function runSteps(sql, connection, scratch, migrationRole, migration, sess
       if (created !== undefined && created === migrationRole) {
         if (!existed) {
           await grantSchema(connection, scratch, created);
-          await connection.execute(`grant select, insert, update on okm_meta, okm_history, okm_backfill to ${quoteIdent(created)}`);
+          await connection.execute(`grant select, insert, update on okm_meta, okm_history, okm_backfill to ${quoteIdent2(created)}`);
         }
         await assumeRole(connection, created, session);
       }
@@ -378,7 +387,7 @@ async function ownScratch(sql, scratch, role) {
   const exists = await sql.unsafe("select exists (select 1 from pg_roles where rolname = $1) as ok", [role]);
   const present = cell(exists[0], "ok");
   if (present === "t" || present === "true") {
-    await sql.unsafe(`alter schema ${quoteIdent(scratch)} owner to ${quoteIdent(role)}`);
+    await sql.unsafe(`alter schema ${quoteIdent2(scratch)} owner to ${quoteIdent2(role)}`);
   }
 }
 async function setLocalTimeout(sql, name, ms) {
@@ -476,6 +485,8 @@ async function checkMigrations(cwd, flags, options) {
       }
     });
   }
+  assertSnapshots(cwd, opened.config, opened.built.catalog);
+  await assertLiveExternal(target.url, opened.built.catalog, loadSnapshots(cwd, opened.config));
   const directory = projectPath(cwd, opened.config.migrations ?? "migrations");
   const history = readHistory(directory);
   const previous = previousFailures(history);
@@ -490,16 +501,21 @@ async function checkMigrations(cwd, flags, options) {
       throwFailure([equivalence]);
   }
   const replayed = await replayHistory(opened.config, target.url, flags, history);
+  const reprintErrors = replayed.reprints.filter((item) => item.severity === "error");
+  const reprintWarnings = replayed.reprints.filter((item) => item.severity === "warning");
   const failures = [...replayed.failures, ...previous, ...stale, ...lint];
+  if (reprintErrors.length > 0) {
+    const refusal = lintRefusal(reprintErrors);
+    failures.push({ code: refusal.code, message: refusal.message, fix: refusal.fix.summary });
+  }
   if (failures.length > 0)
-    throwFailure(failures);
+    throwFailure(failures, reprintWarnings);
   const summary = `ok ${String(history.length)} migrations
 `;
-  if (replayed.skips.length === 0)
-    return summary;
-  return `${summary}${replayed.skips.join(`
+  const skipped = replayed.skips.length === 0 ? "" : `${replayed.skips.join(`
 `)}
 `;
+  return `${summary}${skipped}${formatFindings(reprintWarnings)}`;
 }
 function previousCatalogGaps(before, after) {
   const afterBy = new Map(after.objects.map((object) => [identityKey2(object.identity), object]));
@@ -597,14 +613,16 @@ ${difference}`,
 }
 async function replayHistory(config, url, flags, history) {
   if (history.length === 0)
-    return { failures: [], skips: [] };
+    return { failures: [], skips: [], reprints: [] };
   const scratch = `${CHECK_SCHEMA_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
   const outcome = await replayCheckHistory(url, scratch, config, flags.allowPooler || config.allowPooler === true, history);
-  if (outcome.stop === undefined)
-    return { failures: [], skips: outcome.skips };
+  if (outcome.stop === undefined) {
+    return { failures: [], skips: outcome.skips, reprints: outcome.reprints };
+  }
   return {
     failures: [historyFailure(history, outcome.stop.index, outcome.stop.back)],
-    skips: outcome.skips
+    skips: outcome.skips,
+    reprints: outcome.reprints
   };
 }
 function refuseTransactionControl(history) {
@@ -676,13 +694,16 @@ function readHistory(directory) {
     catalog: parseCatalog2(readFileSync(join(directory, `${migration.id}.catalog.json`), "utf8"))
   }));
 }
-function throwFailure(failures) {
+function throwFailure(failures, warnings = []) {
   const first = failures[0];
   if (first === undefined)
     throw new Error("okm migrate check has no failure to report.");
   const message = failures.length === 1 ? first.message : failures.map((failure) => `${failure.code} ${failure.message}`).join(`
 `);
-  throw new OkmError2(first.code, message, { fix: { summary: first.fix } });
+  const notes = formatFindings(warnings).trim();
+  const text = notes.length === 0 ? message : `${message}
+${notes}`;
+  throw new OkmError2(first.code, text, { fix: { summary: first.fix } });
 }
 function checkedKind(kind) {
   return kind === "table" || kind === "column" || kind === "constraint" || kind === "type";