okmodel 0.5.1 → 0.6.0

package/dist/shared/x3jc53kg.js

@@ -0,0 +1,220 @@
+import {
+  encodeUuid,
+  decodeUuid
+} from "./2jd1sn0e.js";
+import {
+  encodeText,
+  decodeText
+} from "./ed0b8k4s.js";
+import {
+  snakeCase
+} from "./rpycarcr.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/view/client.ts
+var globalViews = new WeakMap;
+function viewGlobalReason(model) {
+  return globalViews.get(model);
+}
+function viewMentions(query, name) {
+  let pattern = '(^|[^A-Za-z0-9_])"?';
+  for (const char of name) {
+    if ("\\^$[]().*+?|{}".includes(char))
+      pattern += "\\";
+    pattern += char;
+  }
+  pattern += '"?(?![A-Za-z0-9_])';
+  return new RegExp(pattern).test(query);
+}
+function viewClient(name, columns, query, tenancy, refresh = "plain") {
+  const field = camelCase(name);
+  const marked = readGlobal(name, tenancy);
+  return {
+    field,
+    install(model, scope, tables, casing, scoped) {
+      if (Object.hasOwn(model, field)) {
+        throw new OkmError2("OKM1023", `View ${name} uses the client name ${field}.`, {
+          fix: { summary: "Give the view a name that no table uses." }
+        });
+      }
+      const exposes = exposesKey(columns, scope);
+      if (scope !== undefined && readsTenant(query, tables, casing, scoped)) {
+        if (!exposes && marked === undefined) {
+          throw new OkmError2("OKM1820", `View ${name} reads a tenant table and does not expose ${scope.key}.`, {
+            fix: {
+              summary: "Expose the tenant key so the predicate can be applied, or declare global(reason)."
+            }
+          });
+        }
+        if (exposes) {
+          scope.scopeView(field);
+          scoped.add(name);
+        }
+      }
+      const built = {
+        name: field,
+        sql: name,
+        primary: [],
+        uniques: [],
+        columns: columnModels(columns, scope),
+        relations: []
+      };
+      if (marked !== undefined)
+        globalViews.set(built, marked);
+      model[field] = built;
+    },
+    hook(target, ctx) {
+      if (ctx.table === field && ctx.session !== undefined) {
+        if (refresh !== "plain")
+          target.refresh = refreshHandle(ctx.session, name, refresh);
+        return;
+      }
+      publish(field, target, ctx);
+    }
+  };
+}
+function refreshHandle(session, name, mode) {
+  const concurrently = mode === "concurrently";
+  return () => lazyRefresh(() => import("./8etn7d8w.js").then((mod) => mod.refreshView(session, name, concurrently)));
+}
+function lazyRefresh(run) {
+  let pending;
+  const once = () => {
+    pending ??= run();
+    return pending;
+  };
+  const self = {
+    then(onFulfilled, onRejected) {
+      return once().then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return self.then(undefined, onRejected);
+    },
+    finally(fn) {
+      return self.then((value) => {
+        fn();
+        return value;
+      }, (error) => {
+        fn();
+        throw error;
+      });
+    },
+    "~refresh": true
+  };
+  return self;
+}
+function publish(field, target, ctx) {
+  if (ctx.tables === undefined || ctx.table !== undefined)
+    return;
+  const handle = ctx.tables[field];
+  if (typeof handle !== "object" || handle === null)
+    return;
+  const source = handle;
+  const views = target.views;
+  const map = typeof views === "object" && views !== null ? views : {};
+  map[field] = {
+    find: source.find,
+    one: source.one,
+    count: source.count,
+    exists: source.exists,
+    ...typeof source.refresh === "function" ? { refresh: source.refresh } : {}
+  };
+  target.views = map;
+  delete ctx.tables[field];
+  delete target[field];
+}
+function columnModels(columns, tenancy) {
+  const seen = new Set;
+  const models = [];
+  for (const column of columns) {
+    const field = fieldName(column.name, tenancy);
+    if (seen.has(field)) {
+      throw new OkmError2("OKM1020", `View column ${column.name} repeats ${field}.`, {
+        fix: { summary: "Declare each output column once." }
+      });
+    }
+    seen.add(field);
+    const uuid = column.type.toLowerCase() === "uuid";
+    const key = tenancy !== undefined && field === tenancy.key;
+    models.push({
+      field,
+      sql: column.name,
+      dataType: column.type,
+      encode: uuid ? (value) => encodeUuid(textValue(value)) : (value) => encodeText(textValue(value)),
+      decode: uuid ? decodeUuid : decodeText,
+      hidden: false,
+      sensitive: false,
+      guarded: key,
+      writable: false,
+      guardUpdate: false
+    });
+  }
+  return models;
+}
+function exposesKey(columns, tenancy) {
+  if (tenancy === undefined)
+    return false;
+  return columns.some((column) => fieldName(column.name, tenancy) === tenancy.key);
+}
+function readsTenant(query, tables, casing, scoped) {
+  for (const name of scoped) {
+    if (viewMentions(query, name))
+      return true;
+  }
+  for (const table of tables) {
+    const mark = table.options?.tenancy;
+    if (isGlobalMark(mark))
+      continue;
+    const sql = casing === "snake" ? snakeCase(table.name) : table.name;
+    if (viewMentions(query, sql) || viewMentions(query, table.name))
+      return true;
+  }
+  return false;
+}
+function readGlobal(name, tenancy) {
+  if (tenancy === undefined)
+    return;
+  if (!isGlobalMark(tenancy)) {
+    throw new OkmError2("OKM1020", `View ${name} tenancy must be global("reason").`, {
+      fix: { summary: 'Pass global("reason") from okmodel/tenancy, or omit tenancy.' }
+    });
+  }
+  return tenancy.reason;
+}
+function isGlobalMark(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return record.kind === "global" && typeof record.reason === "string" && record.reason.trim().length > 0;
+}
+function fieldName(column, tenancy) {
+  const field = camelCase(column);
+  if (tenancy !== undefined && (column === tenancy.key || field === tenancy.key))
+    return tenancy.key;
+  return field;
+}
+function camelCase(name) {
+  let out = "";
+  let upper = false;
+  for (const char of name) {
+    if (char === "_") {
+      upper = out.length > 0;
+      continue;
+    }
+    out += upper ? char.toUpperCase() : char;
+    upper = false;
+  }
+  return out;
+}
+function textValue(value) {
+  if (typeof value !== "string") {
+    throw new OkmError2("OKM1121", "A view column value must be text.", {
+      fix: { summary: "Pass a string." }
+    });
+  }
+  return value;
+}
+
+export { viewGlobalReason, viewMentions, viewClient };

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

@@ -1,26 +1,26 @@
-import"./8bwbwy8h.js";
+import"./qq3899ht.js";
 import"./n442h54c.js";
-import"./krxx77g0.js";
+import"./wkme6tep.js";
 import {
+  projectPath,
   loadConfig
-} from "./qv2ydck9.js";
+} from "./t3g0k88x.js";
 import {
   listTargets
-} from "./ga3sfy93.js";
-import"./8xsbagad.js";
+} from "./ttmg09vd.js";
+import"./9s0ypp87.js";
 
 // src/tooling/migrate/dev.ts
 import { mkdirSync } from "node:fs";
-import { join } from "node:path";
 async function devProject(cwd) {
   const config = await loadConfig(cwd);
   const named = listTargets(config).find((target) => target.name === "dev");
   if (named !== undefined)
     return `target ${named.name}
 `;
-  const directory = join(cwd, config.out ?? ".okm", "dev-db");
+  const directory = projectPath(cwd, config.out ?? ".okm", "dev-db");
   mkdirSync(directory, { recursive: true });
-  const { open } = await import("./f5cw5q5r.js");
+  const { open } = await import("./g90m9b0g.js");
   const pool = await open({ dataDir: directory });
   try {
     await pool.execute("select 1");

package/dist/shared/xqve9598.js

@@ -0,0 +1,53 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/owner.ts
+var MARKS = new WeakMap;
+function withOwner2(table, owner) {
+  if (owner !== "external" && owner !== "ignored") {
+    throw new OkmError2("invalid", `Table owner ${String(owner)} is not external or ignored.`, {
+      kind: "invalid",
+      fix: { summary: "Pass external or ignored. Omit the mark for a managed table." }
+    });
+  }
+  MARKS.set(table, owner);
+  return table;
+}
+function tableOwner(table) {
+  return MARKS.get(table);
+}
+function stampOwnership(source, marks) {
+  if (marks.size === 0)
+    return source;
+  let changed = false;
+  const objects = source.objects.map((object) => {
+    const owner = ownerFor(object, marks);
+    if (owner === undefined || object.owner === owner)
+      return object;
+    changed = true;
+    return { ...object, owner };
+  });
+  if (!changed)
+    return source;
+  return { version: source.version, objects };
+}
+function ownerFor(object, marks) {
+  if (object.kind === "table")
+    return marks.get(object.identity.name);
+  if (object.kind === "column" || object.kind === "index" || object.kind === "constraint" || object.kind === "trigger" || object.kind === "policy") {
+    return marks.get(object.identity.parent.name);
+  }
+  if (object.kind === "sequence") {
+    for (const edge of object.dependencies) {
+      if (edge.target.kind !== "table")
+        continue;
+      const owner = marks.get(edge.target.name);
+      if (owner !== undefined)
+        return owner;
+    }
+  }
+  return;
+}
+
+export { withOwner2, tableOwner, stampOwnership };

package/dist/shared/{47x8x9ze.js → y2t3jktd.js}

@@ -1,7 +1,7 @@
 import {
   withHttp,
   attachHttp
-} from "./hf22e0wt.js";
+} from "./j60w0dvr.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -31,7 +31,7 @@ async function acceptServer(pool, schema, rows, http, requireMeta, options, sour
       }));
     }
   } else {
-    const { assertCompatible } = await import("./z2rnngj4.js");
+    const { assertCompatible } = await import("./ek2wt2dz.js");
     try {
       await assertCompatible(pool, schema, recorded, source, options);
     } catch (error) {

package/dist/shared/{9x25fxhc.js → y34a8714.js}

@@ -3,7 +3,7 @@ import {
   assertNamespace2,
   normaliseEdges,
   assertProvenance
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   assertIdentifier2
 } from "./nfzc5z0w.js";

package/dist/shared/{k7dwkhvq.js → y6jdds7g.js}

@@ -4,9 +4,12 @@ function callerLocation(skip) {
 `);
   if (lines === undefined)
     return;
+  return locationFromLines(lines, skip);
+}
+function locationFromLines(lines, skip) {
   let left = skip;
   for (const line of lines) {
-    const slash = line.lastIndexOf("/");
+    const slash = Math.max(line.lastIndexOf("/"), line.lastIndexOf("\\"));
     if (slash < 0)
       continue;
     const tail = line.slice(slash + 1);

package/dist/shared/{nkaxvt9q.js → ys0xzyaj.js}

@@ -17,7 +17,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./gbtcc2d7.js";
+} from "./2z7wv5tj.js";
 import {
   throwNamed2
 } from "./52szzakm.js";

package/dist/shared/{c9z5g0fm.js → ywr8hmey.js}

@@ -135,8 +135,11 @@ class ColumnBuilder2 {
   guarded() {
     return rebuild(this.state, { guarded: true });
   }
-  hidden() {
-    return rebuild(this.state, { hidden: true });
+  hidden(options) {
+    return rebuild(this.state, {
+      hidden: true,
+      ...options?.filterable === true ? { filterable: true } : {}
+    });
   }
   sensitive() {
     return rebuild(this.state, { sensitive: true });

package/dist/shared/{g7ez901n.js → ywspezzx.js}

@@ -5,7 +5,7 @@ import {
   normaliseEdges,
   compareText,
   assertProvenance
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   CATALOG_VERSION2
 } from "./4e4c6vq2.js";

package/dist/shared/{9m80mkac.js → ze4hxsmy.js}

@@ -1,6 +1,6 @@
 import {
   ColumnBuilder2
-} from "./c9z5g0fm.js";
+} from "./ywr8hmey.js";
 import {
   definition
 } from "./tmbdywx0.js";

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

@@ -1,10 +1,13 @@
+import {
+  DriverError2
+} from "./31vm914h.js";
 import {
   send,
   connectClient
-} from "./96qcj21c.js";
+} from "./1z04fa85.js";
 import {
   isConnectionLost
-} from "./pf0d8f77.js";
+} from "./gwn6v667.js";
 import {
   WireSession
 } from "./4az561fn.js";
@@ -34,16 +37,19 @@ async function checkout(held) {
   }, () => {
     counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
   }, local);
-  const guard = (run) => lost ? rejectClosed("The connection was lost.") : run().catch((error) => {
+  const guard = (run) => lost ? rejectClosed("CONNECTION_CLOSED") : run().catch((error) => {
     if (isConnectionLost(error))
       lost = true;
+    if (error instanceof Error && error.message.includes("Connection terminated")) {
+      throw new DriverError2("CONNECTION_CLOSED", { cause: error });
+    }
     throw error;
   });
   let released = false;
   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("./efmy2gcg.js");
+      const { runAtomicBatch } = await import("./ag4c7516.js");
       return runAtomicBatch(session, statements, watch);
     })),
     cancel() {

package/dist/shared/{y005b761.js → zy8r7qvz.js}

@@ -3,7 +3,7 @@ import {
   assertNamespace2,
   normaliseEdges,
   assertProvenance
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   assertIdentifier2,
   fitIdentifier2,
@@ -23,7 +23,11 @@ function viewObject(input) {
   const query = readQuery(input.name, input.query);
   assertNamespace2(namespace);
   assertProvenance(input.provenance);
-  const definition = { columns, query };
+  const definition = {
+    columns,
+    query,
+    ...input.securityInvoker === true ? { securityInvoker: true } : {}
+  };
   return {
     kind: "view",
     identity: { kind: "view", namespace, name: input.name },

package/dist/tooling/cli.js

@@ -1,6 +1,6 @@
-import"../shared/8bwbwy8h.js";
+import"../shared/qq3899ht.js";
 import"../shared/n442h54c.js";
-import"../shared/krxx77g0.js";
+import"../shared/wkme6tep.js";
 import {
   formatFindings,
   hasError,
@@ -9,9 +9,11 @@ import {
   generateProject,
   planProject,
   checkProject
-} from "../shared/qv2ydck9.js";
-import"../shared/ga3sfy93.js";
-import"../shared/8xsbagad.js";
+} from "../shared/t3g0k88x.js";
+import {
+  sessionFailure
+} from "../shared/ttmg09vd.js";
+import"../shared/9s0ypp87.js";
 import {
   OkmError2
 } from "../shared/52szzakm.js";
@@ -23,7 +25,7 @@ import { fileURLToPath } from "node:url";
 
 // src/tooling/migrate/commands.ts
 function formatFailure(error, verbose = false) {
-  const mapped = OkmError2.from(error);
+  const mapped = sessionFailure(error) ?? OkmError2.from(error);
   let text = `error ${mapped.code}: ${mapped.message}
 ${mapped.fix.summary}
 `;
@@ -71,12 +73,12 @@ async function run(argv, io) {
     return;
   }
   if (command === "dev") {
-    const { devProject } = await import("../shared/sdc7r2ww.js");
+    const { devProject } = await import("../shared/xq0mvhts.js");
     stdout(await devProject(cwd));
     return;
   }
   if (command === "push") {
-    const { pushProject } = await import("../shared/q58y17hy.js");
+    const { pushProject } = await import("../shared/1nw1f3vs.js");
     stdout(await pushProject(cwd, invoke(splitFlags(rest))));
     return;
   }
@@ -95,17 +97,17 @@ async function run(argv, io) {
       return;
     }
     if (sub === "apply") {
-      const { applyProject } = await import("../shared/q58y17hy.js");
+      const { applyProject } = await import("../shared/1nw1f3vs.js");
       stdout(await applyProject(cwd, invoke(parsed), stdout));
       return;
     }
     if (sub === "status") {
-      const { statusProject } = await import("../shared/6mnp99hx.js");
+      const { statusProject } = await import("../shared/wynzeggs.js");
       stdout(await statusProject(cwd, invoke(parsed)));
       return;
     }
     if (sub === "check") {
-      const { checkMigrations } = await import("../shared/7zwwyh0v.js");
+      const { checkMigrations } = await import("../shared/09p049xa.js");
       const provision = parsed.flags.includes("--provision") || rest.slice(1).includes("--provision");
       stdout(await checkMigrations(cwd, invoke(parsed), { provision }));
       return;
@@ -118,13 +120,13 @@ async function run(argv, io) {
         fix: { summary: "Pass okm seed <file>." }
       });
     }
-    const { seedProject } = await import("../shared/2pqx26h8.js");
+    const { seedProject } = await import("../shared/3fqwmr09.js");
     stdout(await seedProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
   if (command === "doctor") {
     const parsed = splitFlags(rest);
-    const { doctorProject } = await import("../shared/ps7a6h14.js");
+    const { doctorProject } = await import("../shared/wt5rzv1h.js");
     stdout(await doctorProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
@@ -136,7 +138,7 @@ async function run(argv, io) {
       });
     }
     if (sub === "list" || sub === "check") {
-      const { extProject } = await import("../shared/janx09m5.js");
+      const { extProject } = await import("../shared/p6bjzq9q.js");
       stdout(await extProject(cwd, sub, invoke(splitFlags(rest.slice(1)))));
       return;
     }
@@ -270,10 +272,34 @@ function numberFlag(flag, value) {
   return parsed;
 }
 
+// src/tooling/node-version.ts
+function nodeSupportsConfigTypes(version) {
+  const match = /^v(\d+)\.(\d+)/.exec(version);
+  if (match === null)
+    return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  if (major > 22)
+    return true;
+  if (major < 22)
+    return false;
+  return minor >= 18;
+}
+function nodeStartupMessage(version, bunRuntime) {
+  if (bunRuntime || nodeSupportsConfigTypes(version))
+    return;
+  return `okm needs Node.js >=22.18 to load a .ts config (type stripping). This process is ${version}. Run bun --bun okm to use the Bun runtime.
+`;
+}
+
 // src/tooling/cli.ts
 var here = dirname(fileURLToPath(import.meta.url));
 var packageJsonPath = join(here, "..", "..", "package.json");
-if (process.argv.includes("--version")) {
+var nodeProblem = nodeStartupMessage(process.version, process.versions.bun !== undefined);
+if (nodeProblem !== undefined) {
+  process.stderr.write(nodeProblem);
+  process.exitCode = 1;
+} else if (process.argv.includes("--version")) {
   process.stdout.write(`${readPackageVersion(packageJsonPath)}
 `);
 } else {

package/dist/tooling/migrate/apply.d.ts

@@ -49,6 +49,14 @@ export type ApplyRequest = {
      * `SET ROLE` before any statement. That statement is not a plan step.
      */
     readonly migrationRole?: string;
+    /**
+     * Application role.
+     *
+     * After the plan, this role receives `SELECT` on `okm_meta` and nothing
+     * else. `connect()` can then read the stored hash. Check scratch paths
+     * leave this unset.
+     */
+    readonly appRole?: string;
     /**
      * Schema the migration role may create in.
      *
@@ -95,6 +103,12 @@ export type ApplyReport = {
     /** Set when the runner issued `SET ROLE` at session start. */
     readonly setRole?: string;
 };
+/**
+ * Creates `okm_meta`, `okm_history`, and `okm_backfill` when they are absent.
+ *
+ * @param execute - Runs one statement on the apply or check connection
+ */
+export declare function ensureMigrationTables(execute: (sql: string) => Promise<unknown>): Promise<void>;
 /**
  * Groups pending steps into the transactions apply will run.
  *

package/dist/tooling/migrate/check.d.ts

@@ -1,10 +1,9 @@
 /**
  * `okm migrate check` proves a migration history is sound (D196).
  *
- * The command replays every file into a scratch schema through
- * {@link applyTarget}, then plans the introspected schema back to that
- * file's catalog. It also checks the previous catalog, the head, and the
- * linter. Nothing here changes apply.
+ * The command replays every file into a scratch schema inside one transaction
+ * and rolls that transaction back. It also checks the previous catalog, the
+ * head, and the linter. Nothing here changes apply.
  */
 import type { Catalog } from "../../contracts/catalog/types.js";
 import { type MigrationClass } from "./classify.js";

package/dist/tooling/migrate/classify.d.ts

@@ -76,6 +76,10 @@ export declare const STEP_CLASS: {
     readonly "rename-sequence": "contract";
     readonly "backfill-expand": "expand";
     readonly "backfill-contract": "contract";
+    readonly "enable-rls": "expand";
+    readonly "create-policy": "expand";
+    readonly "drop-policy": "contract";
+    readonly "disable-rls": "contract";
     readonly "raw-sql": "unclassified";
 };
 /** A planner operation. */

package/dist/tooling/migrate/config.d.ts

@@ -59,10 +59,11 @@ export type MigrateConfig = {
         readonly statementTimeoutMs?: number;
     };
     /**
-     * Migration role and application role.
+     * Migration role, application role, and the optional reporting role.
      *
      * A name is external unless it is also listed in `managed`. The plan creates
-     * a managed role and never drops one.
+     * a managed role and never drops one. `reporting` receives select only.
+     * `columns` grants select or update on named columns.
      */
     readonly roles?: RolesInput;
 };

package/dist/tooling/migrate/files.d.ts

@@ -2,7 +2,7 @@
  * Migration files on disk: SQL from {@link formatPlan} plus the catalog hash.
  */
 import { parseCatalog } from "../../contracts/catalog/document.js";
-import { type PlanStep } from "./plan.js";
+import { type MigrationPlan, type PlanStep } from "./plan.js";
 /** One migration the applier can run and resume. */
 export type StoredMigration = {
     readonly id: string;
@@ -25,6 +25,16 @@ export type StoredMigration = {
  * @returns Migrations in apply order
  */
 export declare function loadMigrations(directory: string): readonly StoredMigration[];
+/**
+ * Reads one migration SQL file.
+ *
+ * Line endings and a UTF-8 BOM are normalized. A non-empty file with no steps
+ * and no `-- no steps` line is refused.
+ *
+ * @param path - `*.sql` path
+ * @returns The plan
+ */
+export declare function readMigrationPlan(path: string): MigrationPlan;
 /**
  * Loads the last migration's catalog, which is the head snapshot.
  *