okmodel 0.1.0 → 0.2.1

package/dist/shared/{mtkwv8wx.js → 7p2wbz7f.js}

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

package/dist/shared/83eaefwr.js

@@ -0,0 +1,10 @@
+import {
+  VALIDATION_NOT_IMPORTED2,
+  VALIDATION_NOT_IMPORTED_FIX2,
+  refuseMissingValidation2
+} from "./n442h54c.js";
+export {
+  VALIDATION_NOT_IMPORTED2 as VALIDATION_NOT_IMPORTED,
+  VALIDATION_NOT_IMPORTED_FIX2 as VALIDATION_NOT_IMPORTED_FIX,
+  refuseMissingValidation2 as refuseMissingValidation
+};

package/dist/shared/96ps4g1z.js

@@ -0,0 +1,32 @@
+// src/runtime/hookm.ts
+function notices(hookm, notices) {
+  if (hookm === undefined)
+    return;
+  for (const notice of notices) {
+    for (const hook of hookm)
+      call(() => hook.onNotice?.(notice));
+  }
+}
+function phase(hookm, phase, depth) {
+  if (hookm === undefined)
+    return;
+  const event = { phase, depth };
+  for (const hook of hookm)
+    call(() => hook.onTransaction?.(event));
+}
+function report(session, error) {
+  for (const hook of session.hookm ?? [])
+    call(() => hook.onError?.(error));
+  const entry = error instanceof Error ? { code: "code" in error ? String(error.code) : error.name, summary: error.message } : { code: "error", summary: String(error) };
+  call(() => session.logger?.error?.(entry));
+}
+function call(fn) {
+  try {
+    fn();
+  } catch {}
+}
+export {
+  notices,
+  phase,
+  report
+};

package/dist/shared/97g2jnrw.js

@@ -0,0 +1,76 @@
+import {
+  send2,
+  reserve,
+  park
+} from "./ytg3xf9p.js";
+import {
+  isConnectionLost
+} from "./tbszx8mz.js";
+import {
+  WireSession
+} from "./cstgkzdx.js";
+import {
+  rejectClosed,
+  runCall
+} from "./9k6vetvf.js";
+
+// src/adapters/pg/bunsql-extra.ts
+async function checkout(held) {
+  const { counters, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const reserved = held.parked.pop() ?? await reserve(held.sql, held.acquireMs, counters);
+  counters.reserved += 1;
+  const session = new WireSession((text, params) => send2(reserved, text, params), held.notices, isClosed, false, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  });
+  let lost = false;
+  const guard = (run) => lost ? rejectClosed("The connection was lost.") : run().catch((error) => {
+    if (isConnectionLost(error))
+      lost = true;
+    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");
+      return runAtomicBatch(session, statements, watch);
+    })),
+    async release() {
+      if (released)
+        return;
+      released = true;
+      try {
+        if (!lost)
+          await reset(session, reserved);
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        if (!lost)
+          await park(held.parked, reserved);
+      }
+    }
+  };
+}
+async function reset(session, sql) {
+  const run = (text) => sql.unsafe(text);
+  if (session.depth() > 0)
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await run("RESET ALL");
+    await run("SELECT pg_advisory_unlock_all()");
+  } catch {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+    await run("RESET ALL");
+    await run("SELECT pg_advisory_unlock_all()");
+  }
+}
+export {
+  checkout
+};

package/dist/shared/{xy79j5hq.js → 9k6vetvf.js}

@@ -15,6 +15,22 @@ var PGLITE_CAPABILITIES = {
   prepared: "unnamed",
   describe: true
 };
+var NODE_POSTGRES_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: true,
+  prepared: "unnamed",
+  describe: false
+};
+var BUNSQL_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: false,
+  prepared: "unnamed",
+  describe: false
+};
 function readCapability2(flags, name) {
   return flags[name];
 }
@@ -25,7 +41,7 @@ function hasCapability2(flags, name) {
 // src/adapters/failure.ts
 var loading;
 function driverErrors() {
-  loading ??= import("./mtkwv8wx.js");
+  loading ??= import("./7p2wbz7f.js");
   return loading;
 }
 function rejectClosed(message = "The pool is closed.") {
@@ -48,9 +64,8 @@ function needsWatch(options) {
 }
 function nextTransactionDepth(depth, text) {
   const command = text.trim().replace(/;\s*$/, "").trim().toLowerCase();
-  if (command === "begin" || command === "begin work" || command === "begin transaction") {
+  if (/^(?:begin|start transaction)(?:\s|$)/.test(command))
     return depth + 1;
-  }
   if (command === "commit" || command === "commit work" || command === "end") {
     return Math.max(0, depth - 1);
   }
@@ -58,35 +73,6 @@ function nextTransactionDepth(depth, text) {
     return 0;
   return depth;
 }
-function openWatch(options) {
-  let kind;
-  const controller = new AbortController;
-  const onAbort = () => {
-    if (kind === undefined)
-      kind = "cancelled";
-    controller.abort();
-  };
-  options.signal?.addEventListener("abort", onAbort, { once: true });
-  let timer;
-  if (options.timeout !== undefined) {
-    timer = setTimeout(() => {
-      if (kind === undefined)
-        kind = "timeout";
-      controller.abort();
-    }, options.timeout);
-  }
-  return {
-    signal: controller.signal,
-    finish() {
-      if (timer !== undefined)
-        clearTimeout(timer);
-      options.signal?.removeEventListener("abort", onAbort);
-    },
-    reason() {
-      return kind;
-    }
-  };
-}
 function runCall(closed, options, fn) {
   if (closed)
     return rejectClosed();
@@ -96,9 +82,12 @@ function runCall(closed, options, fn) {
     return rejectTimedOut();
   if (options === undefined || !needsWatch(options))
     return fn(undefined);
-  const watch = openWatch(options);
-  return fn(watch).finally(() => {
-    watch.finish();
+  const watched = options;
+  return import("./k3ted12y.js").then(({ openWatch }) => {
+    const watch = openWatch(watched);
+    return fn(watch).finally(() => {
+      watch.finish();
+    });
   });
 }
 
@@ -174,4 +163,4 @@ function countFrom(value, rows) {
   return rows;
 }
 
-export { POSTGRESJS_CAPABILITIES, PGLITE_CAPABILITIES, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };
+export { POSTGRESJS_CAPABILITIES, PGLITE_CAPABILITIES, NODE_POSTGRES_CAPABILITIES, BUNSQL_CAPABILITIES, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };

package/dist/shared/{w8samvk1.js → a1gdp7j9.js}

@@ -6,7 +6,7 @@ import {
   catalogHash2,
   loadTrustedCatalog2,
   parseCatalog2
-} from "./y9m15dfv.js";
+} from "./d2whjz4k.js";
 export {
   catalogHash2 as catalogHash,
   creationOrder2 as creationOrder,

package/dist/shared/a5sxz52y.js

@@ -0,0 +1,13 @@
+// src/runtime/safety-hook.ts
+var hook;
+function safetyInstalled() {
+  return hook !== undefined;
+}
+function installSafetyHook(next) {
+  hook = next;
+}
+function runSafety(contributions, hatches) {
+  hook?.(contributions, hatches);
+}
+
+export { safetyInstalled, installSafetyHook, runSafety };

package/dist/shared/{dynq16vb.js → b066g80h.js}

@@ -2,10 +2,10 @@ import {
   DriverError2,
   outcomeUnknown2,
   mapDriverError2
-} from "./hd293j9g.js";
+} from "./kyxb62mc.js";
 import {
-  isConnectionFailure
-} from "./ngk8gj61.js";
+  isConnectionLost
+} from "./tbszx8mz.js";
 
 // src/adapters/pg/batch.ts
 var savepointIds = 0;
@@ -21,13 +21,14 @@ async function transaction(session, statements, watch) {
     try {
       await control(session, "COMMIT", watch);
     } catch (error) {
-      if (isConnectionFailure(error))
+      if (isConnectionLost(error))
         throw outcomeUnknown2(error);
       throw stamp(error, null);
     }
     return results;
   } catch (error) {
-    await rollback(session);
+    if (!isConnectionLost(error))
+      await rollback(session);
     throw error;
   }
 }
@@ -40,7 +41,8 @@ async function savepoint(session, statements, watch) {
     await control(session, `RELEASE SAVEPOINT ${name}`, watch);
     return results;
   } catch (error) {
-    await rollback(session, `ROLLBACK TO SAVEPOINT ${name}`);
+    if (!isConnectionLost(error))
+      await rollback(session, `ROLLBACK TO SAVEPOINT ${name}`);
     throw error;
   }
 }

package/dist/shared/cstgkzdx.js

@@ -0,0 +1,154 @@
+import {
+  driverErrors,
+  rejectClosed,
+  nextTransactionDepth,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./9k6vetvf.js";
+
+// src/adapters/pg/session.ts
+function quoteIdent2(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function noticeBuffer() {
+  let notices;
+  return {
+    push(notice) {
+      const severity = notice.severity ?? "";
+      const message = notice.message ?? "";
+      const code = notice.code !== undefined && notice.code.length > 0 ? notice.code : undefined;
+      const entry = code === undefined ? { severity, message } : { severity, message, code };
+      (notices ??= []).push(entry);
+    },
+    start() {
+      return notices?.length ?? 0;
+    },
+    since(start) {
+      if (notices === undefined || notices.length === start)
+        return EMPTY_NOTICES;
+      return notices.slice(start);
+    }
+  };
+}
+
+class WireSession {
+  canCancel;
+  transactionDepth = 0;
+  local = new Set;
+  send;
+  notices;
+  isClosed;
+  onEnter;
+  onLeave;
+  shared;
+  constructor(send, notices, isClosed, canCancel, onEnter, onLeave, shared) {
+    this.send = send;
+    this.notices = notices;
+    this.isClosed = isClosed;
+    this.canCancel = canCancel;
+    this.onEnter = onEnter;
+    this.onLeave = onLeave;
+    this.shared = shared;
+  }
+  query(text, params, watch) {
+    if (this.isClosed())
+      return rejectClosed();
+    const start = this.notices.start();
+    this.onEnter();
+    const pending = this.send(text, params);
+    if (watch === undefined) {
+      return pending.then((result) => {
+        this.onLeave();
+        this.note(text);
+        return resultFrom(result, this.notices.since(start));
+      }, (error) => {
+        this.onLeave();
+        return driverErrors().then((errors) => Promise.reject(errors.mapDriverError(error)));
+      });
+    }
+    return this.watched(pending, watch, start, text);
+  }
+  inTransaction() {
+    return this.transactionDepth > 0;
+  }
+  abandon() {
+    this.transactionDepth = 0;
+  }
+  depth() {
+    return this.transactionDepth;
+  }
+  cancel() {
+    for (const pending of this.local)
+      pending.cancel?.();
+  }
+  note(text) {
+    this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
+  }
+  track(pending) {
+    this.local.add(pending);
+    this.shared?.add(pending);
+  }
+  untrack(pending) {
+    this.local.delete(pending);
+    this.shared?.delete(pending);
+  }
+  watched(pending, watch, start, text) {
+    this.track(pending);
+    const onAbort = () => {
+      pending.cancel?.();
+    };
+    if (watch.signal.aborted)
+      onAbort();
+    else
+      watch.signal.addEventListener("abort", onAbort, { once: true });
+    return pending.then((result) => {
+      this.finishWatched(pending, watch, onAbort);
+      const why = watch.reason();
+      if (why === "timeout" || why === "cancelled")
+        return classify(why, watch);
+      this.note(text);
+      return resultFrom(result, this.notices.since(start));
+    }, (error) => {
+      this.finishWatched(pending, watch, onAbort);
+      return classify(error, watch);
+    });
+  }
+  finishWatched(pending, watch, onAbort) {
+    this.onLeave();
+    this.untrack(pending);
+    watch.signal.removeEventListener("abort", onAbort);
+  }
+}
+async function* cursorStream(run, text, params) {
+  const name = "okm_stream";
+  await run("BEGIN");
+  try {
+    await run(`DECLARE ${name} NO SCROLL CURSOR FOR ${text}`, params);
+    for (;; ) {
+      const chunk = await run(`FETCH 64 FROM ${name}`);
+      if (chunk.rows.length === 0)
+        break;
+      yield chunk.rows;
+    }
+  } finally {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  }
+}
+async function classify(error, watch) {
+  const errors = await driverErrors();
+  if (error instanceof errors.DriverError)
+    return Promise.reject(error);
+  const why = typeof error === "string" ? error : watch.reason();
+  if (why === "timeout") {
+    return Promise.reject(errors.timedOut(typeof error === "string" ? undefined : error));
+  }
+  const code = errors.errorField(error, "code") ?? errors.errorField(error, "errno");
+  if (why === "cancelled" || code === "57014") {
+    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
+  }
+  return Promise.reject(errors.mapDriverError(error));
+}
+
+export { quoteIdent2, noticeBuffer, WireSession, cursorStream };

package/dist/shared/{ax16zpvm.js → d04j53v8.js}

@@ -1,18 +1,19 @@
 import {
   open2
-} from "./7ck0dtry.js";
-import"./y9m15dfv.js";
+} from "./ecdzej21.js";
+import"./d2whjz4k.js";
+import"./n442h54c.js";
 import {
   loadMigrations
-} from "./4j72449d.js";
+} from "./rtnaqre0.js";
 import {
   assertTargetPolicy,
   listTargets,
   loadConfig
-} from "./kynx7vbm.js";
+} from "./5z4q2zda.js";
 import {
   OkmError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/tooling/migrate/status.ts
 import { join } from "node:path";

package/dist/shared/{y9m15dfv.js → d2whjz4k.js}

@@ -2,12 +2,8 @@ import {
   dependencyOrder,
   catalog,
   enumType
-} from "./g5fhqmwe.js";
+} from "./qxa0yb9j.js";
 import {
-  OWNERS2,
-  BUILT_KINDS2,
-  referentialAction,
-  CATALOG_VERSION2,
   canonicalJson,
   staticNamespace2,
   templateNamespace2,
@@ -23,13 +19,19 @@ import {
   constraint2,
   sequence2,
   compareText
-} from "./j5cn2963.js";
+} from "./t4tbsy9h.js";
+import {
+  OWNERS2,
+  BUILT_KINDS2,
+  referentialAction,
+  CATALOG_VERSION2
+} from "./4e4c6vq2.js";
 import {
   sha2562
-} from "./mkjmqjv4.js";
+} from "./nfzc5z0w.js";
 import {
   catalogError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/contracts/catalog/rewrite.ts
 function replaceIdentifier(text, from, to) {
@@ -251,6 +253,7 @@ function rewriteColumn(object, change, dependencies) {
     provenance: object.provenance,
     dependencies,
     ...definition.defaultExpression !== undefined ? { defaultExpression: rewriteExpr(definition.defaultExpression, change, local) } : {},
+    ...definition.collation !== undefined ? { collation: definition.collation } : {},
     ...definition.identity !== undefined ? { identity: definition.identity } : {},
     ...definition.generated !== undefined ? {
       generated: {
@@ -335,6 +338,7 @@ function rewriteTableName(object, change, fromKey, toIdentity) {
         ...object.definition.defaultExpression !== undefined ? {
           defaultExpression: rewriteExpr(object.definition.defaultExpression, { from: change.from, to: change.to }, local)
         } : {},
+        ...object.definition.collation !== undefined ? { collation: object.definition.collation } : {},
         ...object.definition.identity !== undefined ? { identity: object.definition.identity } : {},
         ...object.definition.generated !== undefined ? { generated: object.definition.generated } : {}
       });
@@ -457,6 +461,7 @@ function definitionToJson(object) {
         dataType: definition.dataType,
         nullable: definition.nullable,
         ...definition.defaultExpression !== undefined ? { defaultExpression: definition.defaultExpression } : {},
+        ...definition.collation !== undefined ? { collation: definition.collation } : {},
         ...definition.identity !== undefined ? { identity: { always: definition.identity.always } } : {},
         ...definition.generated !== undefined ? {
           generated: {
@@ -564,7 +569,7 @@ function parseColumn(identity, definition, owner, provenance, dependencies) {
   if (identity.kind !== "column") {
     catalogError2("OKM1020", `Column object identity is ${identity.kind}, not a column.`);
   }
-  rejectUnknown(definition, ["dataType", "defaultExpression", "generated", "identity", "nullable"], "column definition");
+  rejectUnknown(definition, ["collation", "dataType", "defaultExpression", "generated", "identity", "nullable"], "column definition");
   const generated = definition.generated;
   const columnIdentity = definition.identity;
   return column2({
@@ -576,6 +581,7 @@ function parseColumn(identity, definition, owner, provenance, dependencies) {
     provenance,
     dependencies,
     ...definition.defaultExpression === undefined ? {} : { defaultExpression: requireString(definition.defaultExpression, "default") },
+    ...definition.collation === undefined ? {} : { collation: requireString(definition.collation, "collation") },
     ...columnIdentity === undefined ? {} : { identity: parseAlways(columnIdentity) },
     ...generated === undefined ? {} : { generated: parseGenerated(generated) }
   });