okmodel 0.5.1 → 0.6.0

package/dist/shared/{5enne4ma.js → hazqqecq.js}

@@ -2,23 +2,23 @@ import {
   catalog,
   enumType,
   sameEnumLabels
-} from "./g7ez901n.js";
+} from "./ywspezzx.js";
 import {
-  snakeCase,
-  emittedTypeName,
-  rejectLater
-} from "./ntneex2a.js";
-import {
-  withLocation
-} from "./k7dwkhvq.js";
+  isRelationCall
+} from "./k68eedmy.js";
 import {
   encodeText,
   decodeText
-} from "./4m9fn52z.js";
+} from "./ed0b8k4s.js";
+import {
+  snakeCase,
+  emittedTypeName,
+  rejectLater
+} from "./rpycarcr.js";
 import {
   ColumnBuilder2,
   formatType
-} from "./c9z5g0fm.js";
+} from "./ywr8hmey.js";
 import {
   definition,
   unavailable
@@ -26,6 +26,9 @@ import {
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
+import {
+  withLocation
+} from "./y6jdds7g.js";
 import {
   staticNamespace2,
   table3,
@@ -34,7 +37,7 @@ import {
   constraint2,
   sequence2,
   compareText
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   assertIdentifier2,
   fitIdentifier2,
@@ -49,85 +52,6 @@ import {
   readClientGenerator
 } from "./rwmrejjz.js";
 
-// src/dialects/pg/through.ts
-var emit = (planner, schema, relation, child, sink, parent, alias, depth) => {
-  const through = relation.through;
-  const join = through === undefined ? undefined : planner.indexes(schema).get(through.table);
-  if (through === undefined || join === undefined) {
-    return catalogError2("OKM1020", `Relation ${relation.name} names a join table that is not in the schema.`);
-  }
-  const { quote } = planner;
-  const joinAlias = `j${alias}`;
-  sink.mark(`via:${through.table}`);
-  sink.text(`${quote(join.model.sql)} ${joinAlias} join ${quote(child.model.sql)} ${alias} on `);
-  for (let index = 0;index < through.local.length; index += 1) {
-    const local = through.local[index];
-    const remote = through.remote[index];
-    if (local === undefined || remote === undefined)
-      continue;
-    if (index > 0)
-      sink.text(" and ");
-    sink.text(`${alias}.${quote(remote)} = ${joinAlias}.${quote(local)}`);
-  }
-  sink.text(" where ");
-  planner.join(sink, parent, joinAlias, relation);
-  planner.where(schema, join, undefined, sink, joinAlias, depth + 1, true);
-};
-function resolveThrough(scope, table, through, from, to) {
-  for (const name of [table, through]) {
-    if (!scope.tables.includes(name)) {
-      throwNamed2("OKM1020", name, scope.tables, `Relation ${scope.owner}.${scope.name} names ${name}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
-    }
-  }
-  const toOwner = pick(scope, through, scope.owner, from, `${scope.owner}.${scope.name}`, "from");
-  const toTable = pick(scope, through, table, to, `${scope.owner}.${scope.name}`, "to");
-  if (toOwner === toTable) {
-    catalogError2("OKM1021", `Relation ${scope.owner}.${scope.name} uses ${toOwner.fromField} on ${through} for both ends. Pass from and to.`);
-  }
-  return {
-    name: scope.name,
-    kind: "many",
-    table,
-    local: toOwner.remote,
-    remote: toOwner.local,
-    through: { table: through, local: toTable.local, remote: toTable.remote, emit }
-  };
-}
-function pick(scope, through, target, field, label, end) {
-  const matches = scope.edges.filter((edge) => edge.fromTable === through && edge.toTable === target && (field === undefined || edge.fromField === field));
-  const [only] = matches;
-  if (matches.length === 1 && only !== undefined)
-    return only;
-  const fields = matches.map((edge) => edge.fromField).sort();
-  catalogError2("OKM1021", `Relation ${label} through ${through} is ambiguous at ${end}. Accepted columns: ${fields.length === 0 ? "(none)" : fields.join(", ")}.`);
-}
-
-// src/dialects/pg/relations.ts
-function one2(table, field) {
-  return { kind: "one", table, field };
-}
-function many2(table, field) {
-  return { kind: "many", table, field };
-}
-function isRelationCall(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  if (!("kind" in value) || !("table" in value))
-    return false;
-  const kind = value.kind;
-  return (kind === "one" || kind === "many") && typeof value.table === "string";
-}
-function manyThrough2(table, options) {
-  const { through, from, to } = options;
-  return {
-    kind: "many",
-    table,
-    field: undefined,
-    through,
-    resolve: (scope) => resolveThrough(scope, table, through, from, to)
-  };
-}
-
 // src/dialects/pg/compile.ts
 function compileColumn(builder, input) {
   const state = builder.state;
@@ -212,7 +136,7 @@ function readTenancy(value) {
     definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
   }
   const record = value;
-  if (record.strategy !== "column" || typeof record.rewrite !== "function") {
+  if (typeof record.rewrite !== "function") {
     definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
   }
   return value;
@@ -557,7 +481,7 @@ function compileTable(item, namespace, casing, codecs, requires, idDefault, jobs
       references: column.state.references,
       encode: column.state.encode,
       decode: decode === decodeText ? undefined : decode,
-      hidden: column.state.hidden,
+      hidden: column.state.filterable === true ? "filter" : column.state.hidden,
       sensitive: column.state.sensitive,
       guarded: column.state.guarded,
       writable: column.state.guarded !== true && column.state.omitWrite !== true && column.state.generated === undefined,
@@ -1127,4 +1051,4 @@ function list(names) {
   return names.length === 0 ? "(none)" : names.join(", ");
 }
 
-export { one2, many2, manyThrough2, schema2, addSchemaHook };
+export { schema2, addSchemaHook };

package/dist/shared/{jwtxdj06.js → j3rkk835.js}

@@ -1,11 +1,17 @@
+import {
+  DriverError2
+} from "./31vm914h.js";
+import {
+  noTimeout2
+} from "./8dqhth8c.js";
 import {
   send2,
   reserve,
   park
-} from "./k8v5v5wj.js";
+} from "./32cnm7kn.js";
 import {
   isConnectionLost
-} from "./pf0d8f77.js";
+} from "./gwn6v667.js";
 import {
   WireSession
 } from "./4az561fn.js";
@@ -27,18 +33,28 @@ async function checkout(held) {
     counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
   });
   let lost = false;
-  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 && bunClosed(error.message)) {
+      lost = true;
+      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");
-      return runAtomicBatch(session, statements, watch);
-    })),
+    execute: (text, params, options) => {
+      noTimeout2(options);
+      return guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      noTimeout2(options);
+      return guard(() => runCall(isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./ag4c7516.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
     async release() {
       if (released)
         return;
@@ -48,12 +64,19 @@ async function checkout(held) {
           await reset(session, reserved);
       } finally {
         counters.reserved = Math.max(0, counters.reserved - 1);
-        if (!lost)
+        if (lost)
+          await held.sql.unsafe("select 1").catch(() => {
+            return;
+          });
+        else
           await park(held.parked, reserved);
       }
     }
   };
 }
+function bunClosed(message) {
+  return message === "Connection closed" || message === "connection must be a PostgresSQLConnection";
+}
 async function reset(session, sql) {
   const run = (text) => sql.unsafe(text);
   if (session.depth() > 0)

package/dist/shared/{hf22e0wt.js → j60w0dvr.js}

@@ -7,7 +7,7 @@ import {
   decodeResult,
   logicalIntent,
   appliedRules
-} from "./gbtcc2d7.js";
+} from "./2z7wv5tj.js";
 import {
   OkmError2,
   safe2,
@@ -85,7 +85,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./r2sp8hrc.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./5d8t84hg.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -120,7 +120,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./tm5ab8we.js"), table, options, base, view);
+        return lazyRead(session, () => import("./r11n8grd.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -134,10 +134,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./6rk2gen5.js"), table, options, base, view);
+      return lazyRead(session, () => import("./pjr6xrm5.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./kfjp0gck.js"), table, options, base, view);
+      return lazyRead(session, () => import("./venqrjna.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -167,13 +167,13 @@ function tableApi(session, table, view, uses) {
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./aj2qxyhj.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./sbdme3vy.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./qm7cdtvr.js");
+  writers ??= import("./2cg3wnxc.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -279,7 +279,7 @@ function lazyRead(session, load, table, options, mods, view) {
   });
 }
 async function decodeRows(plan, rows, table) {
-  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./nkaxvt9q.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./ys0xzyaj.js")).decodeIncluded(plan, rows, table);
 }
 function readHandle(session, table, call, mods, decode, extra) {
   let prepared;
@@ -354,7 +354,7 @@ function readHandle(session, table, call, mods, decode, extra) {
 }
 function streamLazy(session, call, prepare) {
   return async function* () {
-    const { streamRows } = await import("./zqrnhwsq.js");
+    const { streamRows } = await import("./3qnhc7w5.js");
     yield* streamRows(session, call, prepare, (error) => logged(session, error));
   }();
 }
@@ -391,14 +391,14 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./47x8x9ze.js");
+  const server = await import("./y2t3jktd.js");
   let rows;
   try {
     const result = await pool.execute(server.versionQuery, undefined, options);
     rows = result.rows;
   } catch (error) {
-    const { mapPostgresError } = await import("./51mvgj8w.js");
-    throw mapPostgresError(error, mapOptions(http, false));
+    const { mapPostgresError } = await import("./d5azex6s.js");
+    throw mapPostgresError(error, mapOptions(http, false, schema));
   }
   await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
 }
@@ -406,8 +406,8 @@ async function mapError(session, error) {
   if (error instanceof OkmError2) {
     return session.http === undefined ? error : new OkmError2(error.code, error.message, { ...errorFields(error), http: session.http });
   }
-  const { mapPostgresError } = await import("./51mvgj8w.js");
-  return mapPostgresError(error, mapOptions(session.http, session.includeValues));
+  const { mapPostgresError } = await import("./d5azex6s.js");
+  return mapPostgresError(error, mapOptions(session.http, session.includeValues, session.schema));
 }
 function errorFields(error) {
   return {
@@ -420,7 +420,7 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./cr74e96e.js").then(() => {
+  operatorSql ??= import("./n076ydsc.js").then(() => {
     return;
   });
   return operatorSql;
@@ -428,7 +428,7 @@ function loadOperatorSql() {
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./nkaxvt9q.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./ys0xzyaj.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {
@@ -469,10 +469,11 @@ function callOptions(input, statement) {
     ...route !== undefined ? { route } : {}
   };
 }
-function mapOptions(http, includeValues) {
+function mapOptions(http, includeValues, schema) {
   return {
     ...http !== undefined ? { http } : {},
-    ...includeValues ? { includeValues: true } : {}
+    ...includeValues ? { includeValues: true } : {},
+    schema
   };
 }
 async function settleCall(session, error) {

package/dist/shared/{ycatkxmq.js → jgqj11w4.js}

@@ -1,6 +1,6 @@
 import {
   extensionObject
-} from "./8ktwd3rh.js";
+} from "./r3j8s5y0.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/k68eedmy.js

@@ -0,0 +1,85 @@
+import {
+  catalogError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/dialects/pg/through.ts
+var emit = (planner, schema, relation, child, sink, parent, alias, depth) => {
+  const through = relation.through;
+  const join = through === undefined ? undefined : planner.indexes(schema).get(through.table);
+  if (through === undefined || join === undefined) {
+    return catalogError2("OKM1020", `Relation ${relation.name} names a join table that is not in the schema.`);
+  }
+  const { quote } = planner;
+  const joinAlias = `j${alias}`;
+  sink.mark(`via:${through.table}`);
+  sink.text(`${quote(join.model.sql)} ${joinAlias} join ${quote(child.model.sql)} ${alias} on `);
+  for (let index = 0;index < through.local.length; index += 1) {
+    const local = through.local[index];
+    const remote = through.remote[index];
+    if (local === undefined || remote === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(`${alias}.${quote(remote)} = ${joinAlias}.${quote(local)}`);
+  }
+  sink.text(" where ");
+  planner.join(sink, parent, joinAlias, relation);
+  planner.where(schema, join, undefined, sink, joinAlias, depth + 1, true);
+};
+function resolveThrough(scope, table, through, from, to) {
+  for (const name of [table, through]) {
+    if (!scope.tables.includes(name)) {
+      throwNamed2("OKM1020", name, scope.tables, `Relation ${scope.owner}.${scope.name} names ${name}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
+    }
+  }
+  const toOwner = pick(scope, through, scope.owner, from, `${scope.owner}.${scope.name}`, "from");
+  const toTable = pick(scope, through, table, to, `${scope.owner}.${scope.name}`, "to");
+  if (toOwner === toTable) {
+    catalogError2("OKM1021", `Relation ${scope.owner}.${scope.name} uses ${toOwner.fromField} on ${through} for both ends. Pass from and to.`);
+  }
+  return {
+    name: scope.name,
+    kind: "many",
+    table,
+    local: toOwner.remote,
+    remote: toOwner.local,
+    through: { table: through, local: toTable.local, remote: toTable.remote, emit }
+  };
+}
+function pick(scope, through, target, field, label, end) {
+  const matches = scope.edges.filter((edge) => edge.fromTable === through && edge.toTable === target && (field === undefined || edge.fromField === field));
+  const [only] = matches;
+  if (matches.length === 1 && only !== undefined)
+    return only;
+  const fields = matches.map((edge) => edge.fromField).sort();
+  catalogError2("OKM1021", `Relation ${label} through ${through} is ambiguous at ${end}. Accepted columns: ${fields.length === 0 ? "(none)" : fields.join(", ")}.`);
+}
+
+// src/dialects/pg/relations.ts
+function one2(table, field) {
+  return { kind: "one", table, field };
+}
+function many2(table, field) {
+  return { kind: "many", table, field };
+}
+function isRelationCall(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("kind" in value) || !("table" in value))
+    return false;
+  const kind = value.kind;
+  return (kind === "one" || kind === "many") && typeof value.table === "string";
+}
+function manyThrough2(table, options) {
+  const { through, from, to } = options;
+  return {
+    kind: "many",
+    table,
+    field: undefined,
+    through,
+    resolve: (scope) => resolveThrough(scope, table, through, from, to)
+  };
+}
+
+export { one2, many2, isRelationCall, manyThrough2 };

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

@@ -1,6 +1,6 @@
 import {
   FUNCTION_ARG_TYPES
-} from "./fancm5pt.js";
+} from "./vjpnzwjz.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -9,6 +9,8 @@ import {
 async function assertRoleHealth(runner, roles, objects) {
   const managed = new Set((roles.managed ?? []).map((role) => role.name));
   const named = [roles.migration, roles.app];
+  if (roles.reporting !== undefined)
+    named.push(roles.reporting);
   for (const name of named) {
     if (managed.has(name))
       continue;
@@ -22,15 +24,16 @@ async function assertRoleHealth(runner, roles, objects) {
   if (managed.size > 0)
     await assertCreateRole(runner, await currentUser(runner));
   for (const object of objects) {
-    if (object.kind !== "grant" || object.identity.role !== roles.app)
+    if (object.kind !== "grant")
       continue;
+    if (managed.has(object.identity.role) && !await roleExists(runner, object.identity.role)) {
+      continue;
+    }
     await assertGrant(runner, object);
   }
 }
 async function assertCreateRole(runner, role) {
-  const result = await runner.execute("select rolcreaterole from pg_roles where rolname = $1", [
-    role
-  ]);
+  const result = await runner.execute("select rolsuper or rolcreaterole from pg_roles where rolname = $1", [role]);
   if (!truthy(result.rows[0]?.[0])) {
     throw new OkmError2("forbidden", `Role ${role} lacks CREATEROLE. Nothing was changed.`, {
       kind: "forbidden",
@@ -62,11 +65,36 @@ async function assertGrant(runner, object) {
       missing(object, `${schema}.${fn}`);
     return;
   }
-  if (target.kind === "namespace")
+  if (target.kind === "namespace") {
+    const allowed = await runner.execute(`select exists (
+         select 1 from pg_namespace n
+         cross join lateral aclexplode(n.nspacl) as a
+         where n.nspname = $2
+           and a.privilege_type = $3
+           and (
+             a.grantee = 0
+             or a.grantee = (select oid from pg_roles where rolname = $1)
+           )
+       )`, [object.identity.role, schema, privilege]);
+    if (!truthy(allowed.rows[0]?.[0]))
+      missing(object, `schema ${schema}`);
     return;
+  }
   const relkinds = target.kind === "sequence" ? "'S'" : target.kind === "view" ? "'v'" : target.kind === "materializedView" ? "'m'" : "'r', 'p'";
   if (!await relationExists(runner, schema, target.name, relkinds))
     return;
+  const column = /^(SELECT|UPDATE)\(([^)]*)\)$/.exec(privilege);
+  const listed = column?.[2];
+  const base = column?.[1];
+  if (listed !== undefined && base !== undefined) {
+    const names = listed.split(",").filter((name) => name.length > 0);
+    for (const name of names) {
+      const allowed = await runner.execute("select has_column_privilege($1, format('%I.%I', $2::text, $3::text), $4, $5)", [object.identity.role, schema, target.name, name, base]);
+      if (!truthy(allowed.rows[0]?.[0]))
+        missing(object, `${schema}.${target.name}.${name}`);
+    }
+    return;
+  }
   const probe = target.kind === "sequence" ? "select has_sequence_privilege($1, format('%I.%I', $2::text, $3::text), $4)" : "select has_table_privilege($1, format('%I.%I', $2::text, $3::text), $4)";
   const allowed = await runner.execute(probe, [
     object.identity.role,

package/dist/shared/{0t22wwh1.js → mb2ycs1p.js}

@@ -1,3 +1,6 @@
+import {
+  effectivePredicate
+} from "./b3awxn7h.js";
 import {
   stack
 } from "./672t5vym.js";
@@ -12,10 +15,9 @@ import {
   indexes,
   quote,
   isRecord,
-  effectivePredicate,
   registerFailFix,
   fail
-} from "./gbtcc2d7.js";
+} from "./2z7wv5tj.js";
 import {
   safetyInstalled,
   runSafety

package/dist/shared/{cr74e96e.js → n076ydsc.js}

@@ -11,7 +11,7 @@ import {
   quote,
   isRecord,
   fail
-} from "./gbtcc2d7.js";
+} from "./2z7wv5tj.js";
 import {
   isOperator,
   operatorName,