okmodel 0.5.1 → 0.7.0

package/dist/shared/{gde73es6.js → m6p12kbr.js}

@@ -1,12 +1,9 @@
 import {
-  serializeCatalog2,
-  catalogHash2,
-  startupCatalog2,
-  parseCatalog2
-} from "./8bwbwy8h.js";
+  serializeCatalog2
+} from "./qq3899ht.js";
 import {
   roleExists
-} from "./szm0cksa.js";
+} from "./8skf0cam.js";
 import {
   canonicalTypeName,
   createdRoleName,
@@ -17,30 +14,30 @@ import {
   checkedCast,
   omitManagedObjects,
   planMigration,
-  parsePlan,
+  sessionFailure,
   assertTargetPolicy
-} from "./ga3sfy93.js";
+} from "./tsvww22q.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 "./ntneex2a.js";
+} from "./rpycarcr.js";
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
 import {
   identityKey2,
   identityLabel2
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -76,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)}`);
 }
@@ -98,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) {
@@ -303,7 +311,35 @@ 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.";
@@ -360,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 = [];
@@ -588,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;
@@ -611,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();
@@ -753,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/{r6nwkxnt.js → m7n9h2a5.js}

@@ -1,9 +1,9 @@
 import {
-  stack
-} from "./672t5vym.js";
+  stack2
+} from "./mss6ctgv.js";
 import {
   checkPresetNames
-} from "./nsva2a6b.js";
+} from "./znm0bpp5.js";
 import {
   isOperator,
   operatorValue
@@ -60,7 +60,7 @@ function refine(schema, call, uses) {
   const { wheres, rules } = resolve(schema, call.table, uses);
   return {
     ...call,
-    where: stack(call.where, wheres),
+    where: stack2(call.where, wheres),
     ruleLines: [...call.ruleLines ?? [], ...rules]
   };
 }

package/dist/shared/{672t5vym.js → mss6ctgv.js}

@@ -3,10 +3,10 @@ import {
 } from "./cn0n68ft.js";
 
 // src/runtime/preset-stack.ts
-function stack(where, presets) {
+function stack2(where, presets) {
   if (presets === undefined || presets.length === 0)
     return where;
   return tag("and", where === undefined ? presets : [where, ...presets]);
 }
 
-export { stack };
+export { stack2 };

package/dist/shared/{nxdp2ze3.js → mtaszv5a.js}

@@ -1,10 +1,10 @@
 import {
   isConnectionSqlstate,
   isConnectionErrno
-} from "./pf0d8f77.js";
+} from "./cnkky55j.js";
 import {
   createClient
-} from "./hf22e0wt.js";
+} from "./tbrvgw6z.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -331,7 +331,8 @@ async function openEndpoint(open, url, max, defaults, name, role, weight, probeM
     timer: undefined,
     current: 0,
     inflight: 0,
-    latencyMs: null
+    latencyMs: null,
+    generation: 0
   };
 }
 async function detectPosition(endpoint) {
@@ -345,8 +346,11 @@ async function detectPosition(endpoint) {
 async function sample(handle, endpoint) {
   try {
     const sampled = await readPosition(handle, endpoint);
+    const reopened = endpoint.circuit === "open";
     endpoint.failures = 0;
     endpoint.circuit = "closed";
+    if (reopened)
+      endpoint.generation += 1;
     applySample(endpoint, sampled);
   } catch {
     endpoint.failures += 1;
@@ -502,7 +506,7 @@ function routePool(handle) {
     execute: async (text, params, options) => {
       if (handle.closed)
         closed();
-      const choice = await choose(handle, text, options?.route);
+      const choice = await resolve(handle, text, options);
       const result = await attempt(handle, choice, (endpoint) => endpoint.pool.execute(text, params, strip(options)));
       if (choice.op === "write")
         await noteWrite(handle, primary.pool);
@@ -515,6 +519,7 @@ function routePool(handle) {
         replicaRefused();
       const reason = options?.route === "primary" ? "constraint:primary" : "primary-required";
       tell(handle, { op: "write", endpoint: primary.name, reason });
+      await callGuard(primary);
       const result = await primary.pool.batch(statements, strip(options));
       await noteWrite(handle, primary.pool);
       return result;
@@ -555,6 +560,14 @@ function routePool(handle) {
         endpoint.pool.cancel?.();
     };
   }
+  const routed = pool;
+  routed.okmReadOnlyUnit = (text, params, prelude, options) => readOnlyUnit(handle, text, params, prelude, options);
+  routed.okmReadOnlyStream = (text, params, prelude, options) => readOnlyStream(handle, text, params, prelude, options);
+  routed.okmEndpoints = () => handle.endpoints.map((endpoint) => ({
+    name: endpoint.name,
+    generation: endpoint.generation,
+    pool: endpoint.pool
+  }));
   return pool;
 }
 function derive(schema, handle, router, shared, route) {
@@ -601,8 +614,82 @@ function force(handle, router, route) {
   }
   if (router.cancel !== undefined)
     pool.cancel = () => router.cancel();
+  const unit = router.okmReadOnlyUnit;
+  const stream = router.okmReadOnlyStream;
+  const forced = pool;
+  if (unit !== undefined) {
+    forced.okmReadOnlyUnit = (text, params, prelude, options) => unit(text, params, prelude, { ...options, route });
+  }
+  if (stream !== undefined) {
+    forced.okmReadOnlyStream = (text, params, prelude, options) => stream(text, params, prelude, { ...options, route });
+  }
   return pool;
 }
+async function readOnlyUnit(handle, text, params, prelude, options) {
+  if (handle.closed)
+    closed();
+  const choice = await resolve(handle, text, options);
+  return attempt(handle, choice, async (endpoint) => {
+    if (endpoint.pool.reserve === undefined)
+      replicaReserve();
+    const conn = await endpoint.pool.reserve();
+    try {
+      await conn.execute("begin read only");
+      try {
+        await conn.execute(prelude.text, prelude.params);
+        const result = await conn.execute(text, params, strip(options));
+        await conn.execute("commit");
+        return result;
+      } catch (error) {
+        await conn.execute("rollback").catch(() => {
+          return;
+        });
+        throw error;
+      }
+    } finally {
+      await conn.release();
+    }
+  });
+}
+function readOnlyStream(handle, text, params, prelude, options) {
+  return async function* () {
+    if (handle.closed)
+      closed();
+    const choice = await choose(handle, text, options?.route);
+    tell(handle, { op: choice.op, endpoint: choice.endpoint.name, reason: choice.reason });
+    await callGuard(choice.endpoint);
+    if (choice.endpoint.pool.reserve === undefined)
+      replicaReserve();
+    const conn = await choice.endpoint.pool.reserve();
+    try {
+      await conn.execute("begin read only");
+      try {
+        await conn.execute(prelude.text, prelude.params);
+        await conn.execute(`declare okm_rls no scroll cursor for ${text}`, params);
+        for (;; ) {
+          const chunk = await conn.execute("fetch 64 from okm_rls");
+          if (chunk.rows.length === 0)
+            break;
+          yield chunk.rows;
+        }
+        await conn.execute("close okm_rls");
+        await conn.execute("commit");
+      } catch (error) {
+        await conn.execute("rollback").catch(() => {
+          return;
+        });
+        throw error;
+      }
+    } finally {
+      await conn.release();
+    }
+  }();
+}
+function replicaReserve() {
+  throw new OkmError2("OKM1111", "Row-level security needs a driver that can reserve a connection.", {
+    fix: { summary: "Use a Postgres driver that supports interactive transactions." }
+  });
+}
 function classOf(text) {
   const head = text.trimStart().toLowerCase().replace(/\s+/g, " ");
   if (/^(begin|start transaction|commit|rollback|savepoint|release|set|reset)\b/.test(head)) {
@@ -612,7 +699,7 @@ function classOf(text) {
     return "lock";
   if (/\sfor (no key update|key share|update|share)\b/.test(head))
     return "lock";
-  if (/^(insert|update|delete|with|create|alter|drop|truncate|grant|revoke|comment|vacuum|analyze|reindex|copy)\b/.test(head)) {
+  if (/^(insert|update|delete|refresh|with|create|alter|drop|truncate|grant|revoke|comment|vacuum|analyze|reindex|copy)\b/.test(head)) {
     return "write";
   }
   return "read";
@@ -626,7 +713,7 @@ async function choose(handle, text, route) {
   if (primary === undefined)
     throw new OkmError2("OKM1120", "A topology needs one primary URL.");
   if (text.trimStart().toLowerCase().startsWith("select current_setting")) {
-    return { endpoint: primary, op: "read", reason: "primary-required" };
+    return { endpoint: primary, op: "read", reason: "primary-required", skipGuard: true };
   }
   if (route === "replica" && op !== "read")
     replicaRefused();
@@ -673,17 +760,32 @@ async function* readStream(handle, text, route, params, fallback) {
 async function attempt(handle, choice, run) {
   tell(handle, { op: choice.op, endpoint: choice.endpoint.name, reason: choice.reason });
   try {
+    if (choice.skipGuard !== true)
+      await callGuard(choice.endpoint);
     return await tracked(choice.endpoint, choice.op === "read", () => run(choice.endpoint));
   } catch (error) {
-    if (choice.op !== "read" || !isUnreachable(error))
+    if (choice.pinned === true || choice.op !== "read" || !isUnreachable(error))
       throw error;
+    choice.endpoint.generation += 1;
     const next = await retryOf(handle, choice);
     if (next === undefined)
       throw error;
     tell(handle, { op: "read", endpoint: next.endpoint.name, reason: next.reason });
+    if (choice.skipGuard !== true)
+      await callGuard(next.endpoint);
     return tracked(next.endpoint, true, () => run(next.endpoint));
   }
 }
+function callGuard(endpoint) {
+  const guard = endpoint.pool.okmGuard;
+  if (guard === undefined)
+    return Promise.resolve();
+  return guard({
+    name: endpoint.name,
+    generation: endpoint.generation,
+    pool: endpoint.pool
+  });
+}
 var CHAIN_DEPTH = 8;
 function isUnreachable(error) {
   const seen = new Set;
@@ -715,9 +817,7 @@ function unreachableNode(node) {
       return true;
     }
   }
-  if (!(node instanceof Error))
-    return false;
-  return node.message.includes("ECONNREFUSED") || node.message.includes("ECONNRESET") || node.message.includes("CONNECTION_CLOSED") || node.message.includes("terminating connection") || node.message.includes("The pool is closed");
+  return false;
 }
 async function tracked(endpoint, time, run) {
   const replica = endpoint.role === "replica";
@@ -1007,13 +1107,45 @@ function noteFailure(endpoint) {
     endpoint.circuit = "open";
 }
 function strip(options) {
-  if (options === undefined || options.route === undefined)
+  if (options === undefined)
+    return;
+  if (!("route" in options) && !("pin" in options))
     return options;
-  const { route: _route, ...rest } = options;
+  const bag = options;
+  const { route: _route, pin: _pin, ...rest } = bag;
   if (rest.signal === undefined && rest.timeout === undefined)
     return;
   return rest;
 }
+async function resolve(handle, text, options) {
+  const pin = taken(options);
+  if (pin?.name !== undefined)
+    return held(handle, pin.name);
+  const choice = await choose(handle, text, options?.route);
+  if (pin !== undefined && choice.op === "read") {
+    pin.name = choice.endpoint.name;
+    return { ...choice, pinned: true };
+  }
+  return choice;
+}
+function taken(options) {
+  if (options === undefined || !("pin" in options))
+    return;
+  const pin = options.pin;
+  if (typeof pin !== "object" || pin === null)
+    return;
+  return pin;
+}
+function held(handle, name) {
+  for (const endpoint of handle.endpoints) {
+    if (endpoint.name !== name)
+      continue;
+    return { endpoint, op: "read", reason: `stream:${name}`, pinned: true };
+  }
+  throw new OkmError2("OKM1120", `stream() stays on ${name}. That target is not in this topology.`, {
+    fix: { summary: "The first batch chose this target. Later batches do not move." }
+  });
+}
 async function noteWrite(handle, runner) {
   if (!tracks(handle))
     return;

package/dist/shared/n816peh1.js

@@ -0,0 +1,45 @@
+import {
+  isRecord,
+  orFail
+} from "./67txcrcw.js";
+import {
+  isOperator,
+  operatorName,
+  operatorValue
+} from "./cn0n68ft.js";
+
+// src/runtime/predicate.ts
+function effectivePredicate(where) {
+  if (where === undefined)
+    return false;
+  if (isOperator(where)) {
+    const name = operatorName(where);
+    const value = operatorValue(where);
+    if (name === "or") {
+      if (!Array.isArray(value))
+        orFail(false);
+      if (value.length === 0)
+        return true;
+      for (const branch of value) {
+        if (!effectivePredicate(branch))
+          orFail(true);
+      }
+      return true;
+    }
+    if (name === "and") {
+      return Array.isArray(value) && value.some((part) => effectivePredicate(part));
+    }
+    if (name === "not")
+      return effectivePredicate(value);
+    return true;
+  }
+  if (!isRecord(where))
+    return true;
+  for (const key of Object.keys(where)) {
+    if (where[key] !== undefined)
+      return true;
+  }
+  return false;
+}
+
+export { effectivePredicate };

package/dist/shared/nbw1z4yd.js

@@ -0,0 +1,18 @@
+// src/dialects/pg/ops/bucket.ts
+var RUNTIME = Symbol.for("okmodel.bucket");
+function bucket2(column, unit, options) {
+  const spec = options ?? { as: undefined, tz: undefined, weekStart: undefined };
+  return {
+    [RUNTIME]: true,
+    column,
+    unit,
+    as: spec.as,
+    tz: spec.tz,
+    weekStart: spec.weekStart
+  };
+}
+function isBucket(value) {
+  return typeof value === "object" && value !== null && RUNTIME in value;
+}
+
+export { bucket2, isBucket };