okmodel 0.5.0 → 0.6.0

package/dist/shared/{kdkxh3kb.js → p248q79y.js}

@@ -1,15 +1,9 @@
 import {
-  serializeCatalog2,
-  catalogHash2,
-  startupCatalog2,
-  parseCatalog2
-} from "./8bwbwy8h.js";
+  serializeCatalog2
+} from "./qq3899ht.js";
 import {
   roleExists
-} from "./szm0cksa.js";
-import {
-  assertTargetPolicy
-} from "./xdpj5kkm.js";
+} from "./knmes2kh.js";
 import {
   canonicalTypeName,
   createdRoleName,
@@ -20,29 +14,30 @@ import {
   checkedCast,
   omitManagedObjects,
   planMigration,
-  parsePlan
-} from "./ayz64vzj.js";
+  sessionFailure,
+  assertTargetPolicy
+} from "./ttmg09vd.js";
 import {
   quoteIdent,
   qualify
-} from "./8xsbagad.js";
+} from "./9s0ypp87.js";
 import {
   alignExtensionVersions
-} from "./8ktwd3rh.js";
+} from "./r3j8s5y0.js";
 import {
   catalog,
   isDomain
-} from "./g7ez901n.js";
+} from "./ywspezzx.js";
 import {
   snakeCase
-} from "./jsd07prz.js";
+} from "./rpycarcr.js";
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
 import {
   identityKey2,
   identityLabel2
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -78,6 +73,16 @@ async function assumeRole(connection, role, session) {
   await connection.execute(`set role ${quoteIdent(role)}`);
   session.setRole = role;
 }
+async function grantAppMeta(connection, role, session) {
+  if (role === undefined)
+    return;
+  const previous = session.setRole;
+  if (previous !== undefined)
+    await connection.execute("reset role");
+  await connection.execute(`grant select on okm_meta to ${quoteIdent(role)}`);
+  if (previous !== undefined)
+    await connection.execute(`set role ${quoteIdent(previous)}`);
+}
 async function grantSchema(connection, schema, role) {
   await connection.execute(`grant usage, create on schema ${quoteIdent(schema)} to ${quoteIdent(role)}`);
 }
@@ -100,9 +105,10 @@ async function runUnit(connection, unit, run, session) {
         await rebuildInvalidIndex(connection, item.step.sql);
         const created = createdRoleName(item.step.sql);
         const existed = created !== undefined && await roleExists(connection, created);
-        if (created === undefined)
+        if (created === undefined) {
           await connection.execute(item.step.sql);
-        else if (!existed)
+          await assertSchemaUsageLanded(connection, item.step.sql);
+        } else if (!existed)
           await connection.execute(createRoleOnce(item.step.sql));
         if (created !== undefined && created === run.migrationRole) {
           if (!existed) {
@@ -305,11 +311,39 @@ function concurrentIndexName(sql) {
   const match = /^create\s+(?:unique\s+)?index\s+concurrently\s+(?:if\s+not\s+exists\s+)?(?:"([^"]+)"|([A-Za-z_][\w$]*))/i.exec(sql.trim());
   return match?.[1] ?? match?.[2];
 }
+var SCHEMA_USAGE = /^\s*grant\s+usage\s+on\s+schema\s+(?:"((?:[^"]|"")*)"|([A-Za-z_][\w$]*))\s+to\s+(?:"((?:[^"]|"")*)"|([A-Za-z_][\w$]*))\s*;?\s*$/i;
+async function assertSchemaUsageLanded(connection, sql) {
+  const match = SCHEMA_USAGE.exec(sql.trim());
+  if (match === null)
+    return;
+  const schema = (match[1] ?? match[2] ?? "").replaceAll('""', '"');
+  const role = (match[3] ?? match[4] ?? "").replaceAll('""', '"');
+  const found = await connection.execute(`select exists (
+       select 1
+       from pg_namespace n
+       cross join lateral aclexplode(n.nspacl) a
+       join pg_roles r on r.oid = a.grantee
+       where n.nspname = $1 and r.rolname = $2 and a.privilege_type = 'USAGE'
+     )`, [schema, role]);
+  const landed = found.rows[0]?.[0];
+  if (landed === "t" || landed === "true")
+    return;
+  throw new OkmError2("OKM1825", `Grant usage on schema ${schema} to ${role} did not take effect.`, {
+    kind: "forbidden",
+    fix: {
+      summary: `Make the migration role the owner of schema ${schema}. ALTER SCHEMA ${quoteIdent(schema)} OWNER TO <migration role>.`
+    }
+  });
+}
 function failStep(unit, index, error) {
+  const lost = sessionFailure(error);
+  if (lost !== undefined) {
+    return new OkmError2(lost.code, `Migration ${unit.migrationId} failed at step ${String(index + 1)}: ${lost.message}`, { kind: lost.kind, cause: error, fix: lost.fix });
+  }
   if (error instanceof OkmError2)
     return error;
   const message = error instanceof Error ? error.message : "The step failed.";
-  return new OkmError2("invalid", `Migration ${unit.migrationId} failed at step ${String(index)}: ${message}`, {
+  return new OkmError2("invalid", `Migration ${unit.migrationId} failed at step ${String(index + 1)}: ${message}`, {
     cause: error,
     fix: { summary: "Fix the step and run apply again. Finished steps are not repeated." }
   });
@@ -362,44 +396,6 @@ function delay(ms) {
   });
 }
 
-// src/tooling/migrate/files.ts
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-function loadMigrations(directory) {
-  if (!existsSync(directory))
-    return [];
-  const names = readdirSync(directory).filter((file) => file.endsWith(".sql")).sort();
-  const migrations = [];
-  for (const file of names) {
-    const id = file.slice(0, -".sql".length);
-    const catalogPath = join(directory, `${id}.catalog.json`);
-    if (!existsSync(catalogPath)) {
-      throw new OkmError2("invalid", `Migration ${id} is missing its catalog snapshot.`, {
-        fix: {
-          summary: "Generate the migration again so the SQL and the catalog are written together."
-        }
-      });
-    }
-    const plan = parsePlan(readFileSync(join(directory, file), "utf8"));
-    const stored = parseCatalog2(readFileSync(catalogPath, "utf8"));
-    const startup = startupCatalog2(stored);
-    const hash = catalogHash2(startup);
-    migrations.push(startup === stored ? { id, catalogHash: hash, steps: plan.steps } : { id, catalogHash: hash, legacyHash: catalogHash2(stored), steps: plan.steps });
-  }
-  return migrations;
-}
-function loadHeadSnapshot(directory) {
-  const migrations = loadMigrations(directory);
-  const last = migrations.at(-1);
-  if (last === undefined)
-    return;
-  return {
-    id: last.id,
-    catalogHash: last.catalogHash,
-    catalog: parseCatalog2(readFileSync(join(directory, `${last.id}.catalog.json`), "utf8"))
-  };
-}
-
 // src/tooling/migrate/reference.ts
 function readReference(tables, casing, head) {
   const declared = [];
@@ -590,8 +586,10 @@ async function installSnapshot(connection, head, schema, reference, session, mig
       return;
     await connection.execute("begin");
     began = true;
-    for (const sql of batch)
+    for (const sql of batch) {
       await connection.execute(sql);
+      await assertSchemaUsageLanded(connection, sql);
+    }
     await connection.execute("commit");
     began = false;
     batch.length = 0;
@@ -613,6 +611,7 @@ async function installSnapshot(connection, head, schema, reference, session, mig
       } else {
         await flush();
         await connection.execute(sql);
+        await assertSchemaUsageLanded(connection, sql);
       }
       if (created !== undefined && created === migrationRole) {
         await flush();
@@ -755,4 +754,4 @@ function normaliseFunction(object) {
   };
 }
 
-export { runTarget, assumeRole, statementOutsideTransaction, loadMigrations, loadHeadSnapshot, readReference, referenceInserts, catalogsEqual, provisionMark, expandProvisioned, provisionHistoryIsKnown, installSnapshot, snapshotDifference };
+export { runTarget, assumeRole, grantAppMeta, grantSchema, assertSchemaUsageLanded, statementOutsideTransaction, readReference, referenceInserts, catalogsEqual, provisionMark, expandProvisioned, provisionHistoryIsKnown, installSnapshot, snapshotDifference };

package/dist/shared/{990a291j.js → p6bjzq9q.js}

@@ -1,19 +1,22 @@
 import {
   open2
-} from "./wqem4jed.js";
-import"./8bwbwy8h.js";
+} from "./wkme6tep.js";
+import"./qq3899ht.js";
 import"./n442h54c.js";
 import {
-  assertTargetPolicy,
-  selectTarget,
   openProject
-} from "./xdpj5kkm.js";
-import"./ayz64vzj.js";
-import"./8xsbagad.js";
+} from "./t3g0k88x.js";
+import {
+  sessionFailure,
+  finishQuiet,
+  assertTargetPolicy,
+  selectTarget
+} from "./ttmg09vd.js";
+import"./9s0ypp87.js";
 import {
   isExactVersion,
   compareExtensionVersions
-} from "./8ktwd3rh.js";
+} from "./r3j8s5y0.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -28,8 +31,10 @@ async function extProject(cwd, command, flags) {
     if (command === "list")
       return formatList(await readExtensions(pool));
     return formatCheck(opened.built.catalog.objects, await readExtensions(pool));
+  } catch (error) {
+    throw sessionFailure(error) ?? error;
   } finally {
-    await pool.close();
+    await finishQuiet(() => pool.close());
   }
 }
 var LIST_SQL = `

package/dist/shared/{h4nqvjkp.js → pjr6xrm5.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./bt9sfq0z.js";
+} from "./j60w0dvr.js";
 import {
   selectedColumns,
   parseOrder,
@@ -15,7 +15,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./qgvt8nx1.js";
+} from "./2z7wv5tj.js";
 import {
   OkmError2,
   throwNamed2

package/dist/shared/pz6rj8ay.js

@@ -0,0 +1,212 @@
+import {
+  tag
+} from "./cn0n68ft.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/filter-parse.ts
+var PARSED = [
+  "eq",
+  "in",
+  "inList",
+  "notIn",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "between",
+  "startsWith",
+  "endsWith",
+  "contains",
+  "like",
+  "ilike",
+  "not",
+  "containedBy",
+  "overlaps",
+  "hasKey",
+  "hasAnyKey"
+];
+var PARSED_OPS = `,${PARSED.join(",")},`;
+var PARSED_FIX = "Use eq, in, notIn, lt, lte, gt, gte, between, startsWith, endsWith, contains, like, ilike, not, containedBy, overlaps, hasKey, or hasAnyKey.";
+function parseQuery(allow, sort, query, relations) {
+  if (typeof query !== "object" || query === null || Array.isArray(query)) {
+    throw new OkmError2("OKM1121", "filters parse expects an object of fields.");
+  }
+  for (const field of Object.keys(allow)) {
+    for (const op of allow[field] ?? []) {
+      if (PARSED_OPS.includes(`,${op},`))
+        continue;
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: PARSED_FIX }
+      });
+    }
+  }
+  const nested = relations ?? {};
+  const whereParts = [];
+  let orderBy;
+  for (const key of Object.keys(query)) {
+    const value = query[key];
+    if (key === "sort" && typeof value === "string" && sort.includes(value)) {
+      orderBy = { [value]: "asc" };
+      continue;
+    }
+    if (Object.hasOwn(allow, key)) {
+      whereParts.push(...clauses(key, allow[key] ?? [], value));
+      continue;
+    }
+    if (Object.hasOwn(nested, key)) {
+      whereParts.push(relationClause(key, nested[key] ?? [], value));
+      continue;
+    }
+    throw new OkmError2("OKM1123", `Field ${key} is not in the allow list.`, {
+      fix: { summary: "Remove the field, or add it to filters({ allow }) or relations." }
+    });
+  }
+  const where = combine(whereParts);
+  return orderBy === undefined ? { where } : { where, orderBy };
+}
+function clauses(field, ops, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    if (!ops.includes("eq")) {
+      throw new OkmError2("OKM1120", `filters() cannot apply eq on ${field}.`, {
+        fix: { summary: "Add eq to that field, or send an object of allowed operators." }
+      });
+    }
+    return [{ [field]: value }];
+  }
+  const applied = [];
+  for (const op of Object.keys(value)) {
+    if (!Object.hasOwn(value, op))
+      continue;
+    if (!ops.includes(op) && !(op === "inList" && ops.includes("in"))) {
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Send an operator that field's allow list names." }
+      });
+    }
+    applied.push(one(field, op, value[op]));
+  }
+  if (applied.length === 0) {
+    throw new OkmError2("OKM1120", `filters() cannot apply a value on ${field}.`, {
+      fix: { summary: "Send eq as a scalar, or an object of allowed operators." }
+    });
+  }
+  return applied;
+}
+function one(field, op, value) {
+  switch (op) {
+    case "eq":
+      return {
+        [field]: value !== null && typeof value === "object" ? tag("eq", value) : value
+      };
+    case "in":
+    case "inList":
+      return { [field]: tag("inList", list(value, op)) };
+    case "notIn":
+      return { [field]: tag("notIn", list(value, op)) };
+    case "lt":
+      return { [field]: tag("lt", value) };
+    case "lte":
+      return { [field]: tag("lte", value) };
+    case "gt":
+      return { [field]: tag("gt", value) };
+    case "gte":
+      return { [field]: tag("gte", value) };
+    case "between": {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new OkmError2("OKM1120", `between on ${field} needs two bounds.`, {
+          fix: { summary: "Send between as [from, to]." }
+        });
+      }
+      return { [field]: tag("between", [value[0], value[1]]) };
+    }
+    case "startsWith":
+      return { [field]: tag("startsWith", text(value, op)) };
+    case "endsWith":
+      return { [field]: tag("endsWith", text(value, op)) };
+    case "contains":
+      return { [field]: tag("contains", value) };
+    case "not":
+      if (value !== null && typeof value === "object") {
+        throw new OkmError2("OKM1120", `not on ${field} takes a scalar.`, {
+          fix: { summary: "Send not a scalar or null. Nested operators are not accepted." }
+        });
+      }
+      return { [field]: tag("not", value) };
+    case "containedBy":
+      return { [field]: tag("containedBy", value) };
+    case "overlaps":
+      return { [field]: tag("overlaps", value) };
+    case "hasKey":
+      return { [field]: tag("hasKey", text(value, "hasKey")) };
+    case "hasAnyKey":
+      return { [field]: tag("hasAnyKey", strings(value, field)) };
+    case "like":
+      return { [field]: tag("like", text(value, op)) };
+    case "ilike":
+      return { [field]: tag("ilike", text(value, op)) };
+    default:
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Use an operator parse applies." }
+      });
+  }
+}
+function relationClause(name, fields, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new OkmError2("OKM1120", `filters() cannot apply a value on ${name}.`, {
+      fix: { summary: "Send the relation an object of allowlisted fields." }
+    });
+  }
+  const parts = [];
+  for (const field of Object.keys(value)) {
+    if (!Object.hasOwn(value, field))
+      continue;
+    if (!fields.includes(field)) {
+      throw new OkmError2("OKM1123", `Field ${field} is not in the allow list.`, {
+        fix: { summary: "Remove the field, or add it to filters({ relations })." }
+      });
+    }
+    parts.push(...clauses(field, PARSED, value[field]));
+  }
+  if (parts.length === 0) {
+    throw new OkmError2("OKM1120", `filters() cannot apply a value on ${name}.`, {
+      fix: { summary: "Send the relation an object of allowlisted fields." }
+    });
+  }
+  return { [name]: tag("has", combine(parts)) };
+}
+function combine(parts) {
+  const first = parts[0];
+  if (first === undefined)
+    return {};
+  if (parts.length === 1)
+    return first;
+  return tag("and", parts);
+}
+function list(value, op) {
+  if (!Array.isArray(value)) {
+    throw new OkmError2("OKM1120", `${op} needs an array.`, {
+      fix: { summary: "Send that operator an array of values." }
+    });
+  }
+  return value;
+}
+function strings(value, field) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new OkmError2("OKM1120", `hasAnyKey on ${field} needs an array of strings.`, {
+      fix: { summary: "Send hasAnyKey an array of strings." }
+    });
+  }
+  return value;
+}
+function text(value, op) {
+  if (typeof value !== "string") {
+    throw new OkmError2("OKM1120", `${op} needs a string.`, {
+      fix: { summary: "Send that operator a string." }
+    });
+  }
+  return value;
+}
+export {
+  parseQuery
+};

package/dist/shared/{5vdm4sgp.js → q3j1tq7a.js}

@@ -1,9 +1,9 @@
 import {
   PgSession
-} from "./wqem4jed.js";
+} from "./wkme6tep.js";
 import {
   isConnectionLost
-} from "./tbszx8mz.js";
+} from "./gwn6v667.js";
 import {
   driverErrors,
   rejectClosed,
@@ -11,12 +11,12 @@ import {
   runCall,
   rowsFrom,
   resultFrom
-} from "./rrstp3kb.js";
+} from "./cgbamx3e.js";
 
 // src/adapters/pg/postgres-extra.ts
 var RESET_ALL = "RESET ALL";
 var UNLOCK = "SELECT pg_advisory_unlock_all()";
-async function checkout(pool) {
+async function checkout2(pool) {
   if (pool.isClosed())
     return rejectClosed();
   const reserved = await reserveConnection(pool.sql, pool.acquireMs, pool.counters);
@@ -24,16 +24,17 @@ async function checkout(pool) {
   const local = new Set;
   const session = new PgSession(reserved, pool.counters, "reserved", local, pool.isClosed, pool.poolInflight, pool.notices, pool.named);
   let released = false;
-  let lost = false;
-  const guard = (run) => lost ? rejectClosed("The connection was lost.") : run().catch((error) => {
+  const lost = { on: false };
+  arm(reserved, lost);
+  const guard = (run) => lost.on ? rejectClosed("CONNECTION_CLOSED") : run().catch((error) => {
     if (isConnectionLost(error))
-      lost = true;
+      lost.on = true;
     throw error;
   });
   return {
     execute: (text, params, options) => guard(() => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch))),
     batch: (statements, options) => guard(() => runCall(pool.isClosed(), options, async (watch) => {
-      const { runAtomicBatch } = await import("./b066g80h.js");
+      const { runAtomicBatch } = await import("./ag4c7516.js");
       return runAtomicBatch(session, statements, watch);
     })),
     cancel() {
@@ -44,17 +45,21 @@ async function checkout(pool) {
         return;
       released = true;
       try {
-        if (!lost)
+        if (!lost.on)
           await resetConnection(reserved, session.depth());
       } finally {
         pool.counters.reserved = Math.max(0, pool.counters.reserved - 1);
-        if (!lost)
+        if (lost.on)
+          await pool.sql.unsafe("select 1").catch(() => {
+            return;
+          });
+        else
           reserved.release();
       }
     }
   };
 }
-async function describe(sql, text, params) {
+async function describe2(sql, text, params) {
   const pending = sql.unsafe(text, asParams(params), { prepare: true });
   const described = await pending.describe();
   return {
@@ -62,7 +67,7 @@ async function describe(sql, text, params) {
     parameterCount: described.types.length
   };
 }
-async function* stream(sql, text, params) {
+async function* stream2(sql, text, params) {
   const pending = sql.unsafe(text, asParams(params));
   for await (const chunk of pending.cursor(64)) {
     yield rowsFrom(chunk);
@@ -124,7 +129,21 @@ function asParams(params) {
     return [];
   return params;
 }
-async function holdCheckout(gate, checkout) {
+function watchReserved2(sql, lost) {
+  arm(sql, lost);
+}
+function arm(sql, lost) {
+  const unsafe = sql.unsafe.bind(sql);
+  sql.unsafe = (text, params, options) => unsafe(text, params, {
+    ...options,
+    onexecute(connection) {
+      connection.onclose = () => {
+        lost.on = true;
+      };
+    }
+  });
+}
+async function holdCheckout2(gate, checkout) {
   try {
     const connection = await checkout();
     let released = false;
@@ -143,7 +162,7 @@ async function holdCheckout(gate, checkout) {
     throw error;
   }
 }
-async function holdListener(gate, start) {
+async function holdListener2(gate, start) {
   try {
     const stop = await start();
     let stopped = false;
@@ -162,7 +181,7 @@ async function holdListener(gate, start) {
     throw error;
   }
 }
-function watchQuery(pending, watch, onAbort, ctx) {
+function watchQuery2(pending, watch, onAbort, ctx) {
   return pending.then((result) => {
     finishWatch(pending, watch, onAbort, ctx);
     const why = watch.reason();
@@ -194,11 +213,5 @@ async function classify(error, watch) {
   }
   return Promise.reject(errors.mapDriverError(error));
 }
-export {
-  checkout,
-  describe,
-  holdCheckout,
-  holdListener,
-  stream,
-  watchQuery
-};
+
+export { checkout2, describe2, stream2, watchReserved2, holdCheckout2, holdListener2, watchQuery2 };