okmodel 0.5.0 → 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/{7p2wbz7f.js → x72jb7ad.js}

@@ -6,7 +6,7 @@ import {
   acquireTimeout2,
   errorField2,
   mapDriverError2
-} from "./kyxb62mc.js";
+} from "./31vm914h.js";
 export {
   DriverError2 as DriverError,
   acquireTimeout2 as acquireTimeout,

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

@@ -1,25 +1,26 @@
-import"./8bwbwy8h.js";
+import"./qq3899ht.js";
 import"./n442h54c.js";
-import"./wqem4jed.js";
+import"./wkme6tep.js";
 import {
-  listTargets,
+  projectPath,
   loadConfig
-} from "./xdpj5kkm.js";
-import"./ayz64vzj.js";
-import"./8xsbagad.js";
+} from "./t3g0k88x.js";
+import {
+  listTargets
+} 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("./gdh9mrtp.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/{47xzb9fc.js → y2t3jktd.js}

@@ -1,7 +1,7 @@
 import {
   withHttp,
   attachHttp
-} from "./bt9sfq0z.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/{h8ne16fq.js → ys0xzyaj.js}

@@ -17,7 +17,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./qgvt8nx1.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/{fb00y8fp.js → zm0mafk4.js}

@@ -1,17 +1,20 @@
+import {
+  DriverError2
+} from "./31vm914h.js";
 import {
   send,
   connectClient
-} from "./6p5k20sm.js";
+} from "./1z04fa85.js";
 import {
   isConnectionLost
-} from "./tbszx8mz.js";
+} from "./gwn6v667.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";
@@ -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("./b066g80h.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/wqem4jed.js";
+import"../shared/wkme6tep.js";
 import {
   formatFindings,
   hasError,
@@ -9,9 +9,11 @@ import {
   generateProject,
   planProject,
   checkProject
-} from "../shared/xdpj5kkm.js";
-import"../shared/ayz64vzj.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";
@@ -22,14 +24,28 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/tooling/migrate/commands.ts
-function formatFailure(error) {
-  return `${error.code}: ${error.message}
-${error.fix.summary}
+function formatFailure(error, verbose = false) {
+  const mapped = sessionFailure(error) ?? OkmError2.from(error);
+  let text = `error ${mapped.code}: ${mapped.message}
+${mapped.fix.summary}
+`;
+  if (verbose && error instanceof Error && error.stack !== undefined) {
+    text += `${error.stack}
 `;
+  }
+  return text;
 }
 async function run(argv, io) {
   const cwd = io?.cwd ?? process.cwd();
   const stdout = io?.stdout ?? ((text) => process.stdout.write(text));
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+    stdout(commandsTable());
+    return;
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    stdout(commandHelp(argv.filter((arg) => arg !== "--help" && arg !== "-h")));
+    return;
+  }
   const [command, ...rest] = argv;
   if (command === "build") {
     const directory = await buildProject(cwd);
@@ -57,12 +73,12 @@ async function run(argv, io) {
     return;
   }
   if (command === "dev") {
-    const { devProject } = await import("../shared/fyqkk1m0.js");
+    const { devProject } = await import("../shared/xq0mvhts.js");
     stdout(await devProject(cwd));
     return;
   }
   if (command === "push") {
-    const { pushProject } = await import("../shared/rasvvzgz.js");
+    const { pushProject } = await import("../shared/1nw1f3vs.js");
     stdout(await pushProject(cwd, invoke(splitFlags(rest))));
     return;
   }
@@ -81,17 +97,17 @@ async function run(argv, io) {
       return;
     }
     if (sub === "apply") {
-      const { applyProject } = await import("../shared/rasvvzgz.js");
+      const { applyProject } = await import("../shared/1nw1f3vs.js");
       stdout(await applyProject(cwd, invoke(parsed), stdout));
       return;
     }
     if (sub === "status") {
-      const { statusProject } = await import("../shared/bzsjtd7c.js");
+      const { statusProject } = await import("../shared/wynzeggs.js");
       stdout(await statusProject(cwd, invoke(parsed)));
       return;
     }
     if (sub === "check") {
-      const { checkMigrations } = await import("../shared/r73pt594.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;
@@ -104,13 +120,13 @@ async function run(argv, io) {
         fix: { summary: "Pass okm seed <file>." }
       });
     }
-    const { seedProject } = await import("../shared/jdgqqx31.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/qy9rdq0g.js");
+    const { doctorProject } = await import("../shared/wt5rzv1h.js");
     stdout(await doctorProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
@@ -122,7 +138,7 @@ async function run(argv, io) {
       });
     }
     if (sub === "list" || sub === "check") {
-      const { extProject } = await import("../shared/990a291j.js");
+      const { extProject } = await import("../shared/p6bjzq9q.js");
       stdout(await extProject(cwd, sub, invoke(splitFlags(rest.slice(1)))));
       return;
     }
@@ -210,6 +226,42 @@ function splitFlags(args) {
     statementTimeoutMs
   };
 }
+var COMMANDS = [
+  ["build", "Write the schema build."],
+  ["check", "Lint the schema and compare it with one target."],
+  ["dev", "Watch the schema and reload."],
+  ["doctor [code]", "Print a target report, or one error code."],
+  ["ext list", "List extensions the server can install."],
+  ["ext check", "Compare declared extensions with the server."],
+  ["generate [name]", "Write the next migration."],
+  ["migrate plan <name>", "Print the plan and its lock estimates."],
+  ["migrate apply", "Apply pending migrations."],
+  ["migrate status", "Print whether the target is current."],
+  ["migrate check", "Replay migration history in a scratch schema."],
+  ["push", "Apply the schema diff to one target."],
+  ["seed <file>", "Run a seed file on one target."]
+];
+function commandsTable() {
+  const lines = ["okm <command>", ""];
+  for (const [name, summary] of COMMANDS)
+    lines.push(`  ${name.padEnd(24)} ${summary}`);
+  lines.push("", "okm <command> --help prints that command.", "");
+  return `${lines.join(`
+`)}
+`;
+}
+function commandHelp(argv) {
+  const key = argv.join(" ");
+  const found = COMMANDS.find(([name]) => name === key || name.startsWith(`${key} `));
+  if (found === undefined) {
+    return `Unknown command ${key}.
+
+${commandsTable()}`;
+  }
+  return `${found[0]}
+${found[1]}
+`;
+}
 function numberFlag(flag, value) {
   const parsed = value === undefined ? Number.NaN : Number(value);
   if (!Number.isFinite(parsed) || parsed < 0) {
@@ -220,22 +272,43 @@ 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 if (process.argv.length > 2) {
+} else {
   try {
     await run(process.argv.slice(2));
   } catch (error) {
-    if (error instanceof OkmError2) {
-      process.stderr.write(formatFailure(error));
-      process.exitCode = 1;
-    } else {
-      throw error;
-    }
+    const verbose = process.argv.includes("--verbose") || process.env.OKM_DEBUG === "1";
+    process.stderr.write(formatFailure(error, verbose));
+    process.exitCode = 1;
   }
 }
 function readPackageVersion(path) {