okmodel 0.6.0 → 0.7.0

package/dist/shared/{sbdme3vy.js → vb6qfyve.js}

@@ -3,16 +3,16 @@ import {
 } from "./n4jqhpqz.js";
 import {
   refuseUncancellableTimeout
-} from "./b4v57v3x.js";
+} from "./2d3xq4ps.js";
 import {
   withHttp,
   settleCall
-} from "./j60w0dvr.js";
+} from "./tbrvgw6z.js";
 import {
   rejectKeys,
   isRecord,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -26,29 +26,29 @@ async function batch(session, ops, options, replica) {
       }));
     }
     if (!Array.isArray(ops))
-      fail("OKM1121", "batch expects a list of write operations.");
+      fail2("OKM1121", "batch expects a list of write operations.");
     const record = options ?? {};
     if (!isRecord(record))
-      fail("OKM1121", "batch options must be an object.");
+      fail2("OKM1121", "batch options must be an object.");
     rejectKeys(record, ["signal", "timeout"], "batch");
     await refuseUncancellableTimeout(session.pool, typeof record["timeout"] === "number" ? record["timeout"] : undefined);
     for (const op of ops) {
       if (typeof op === "object" && op !== null && op["~refresh"] === true) {
-        fail("OKM1121", "batch does not take refresh(). Await refresh() on its own. It is one statement and cannot share the batch.");
+        fail2("OKM1121", "batch does not take refresh(). Await refresh() on its own. It is one statement and cannot share the batch.");
       }
     }
     const prepared = [];
     for (const op of ops) {
       const plan = typeof op === "object" && op !== null ? op["~plan"] : undefined;
       if (plan === undefined) {
-        fail("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
+        fail2("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
       }
       const item = await plan();
       if (item.checked === "parent") {
         throw new OkmError2("OKM1705", "batch does not take an update that sets a path column. The parent is checked in the statement, and a batch cannot report that after it commits. Use update({ where, set }) inside tx().", { fix: { summary: "Use update({ where, set }) inside tx()." } });
       }
       if (item.checked !== undefined) {
-        fail("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
+        fail2("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
       }
       prepared.push(item);
     }
@@ -73,11 +73,61 @@ async function run(session, prepared, options) {
   } catch (error) {
     throw at(error, starts);
   }
+  const extra = await recover(session, prepared, results, starts, options);
   return prepared.map((item, index) => {
     const from = starts[index] ?? 0;
-    return item.finish(results.slice(from, from + item.statements.length));
+    const slice = results.slice(from, from + item.statements.length);
+    const more = extra.get(index);
+    return item.finish(more === undefined ? slice : slice.concat(more));
   });
 }
+async function recover(session, prepared, results, starts, options) {
+  const pending = [];
+  for (let index = 0;index < prepared.length; index += 1) {
+    const item = prepared[index];
+    if (item?.follow === undefined)
+      continue;
+    const from = starts[index] ?? 0;
+    const more = item.follow(results.slice(from, from + item.statements.length));
+    if (more.length === 0)
+      continue;
+    pending.push({ index, statements: more });
+  }
+  const found = new Map;
+  if (pending.length === 0)
+    return found;
+  const flat = [];
+  const extraStarts = [];
+  for (const item of pending) {
+    extraStarts.push(flat.length);
+    flat.push(...item.statements);
+  }
+  let ran;
+  try {
+    ran = await runWrite(session, flat, call(options), true);
+  } catch (error) {
+    throw mapExtra(error, pending, extraStarts);
+  }
+  for (let index = 0;index < pending.length; index += 1) {
+    const item = pending[index];
+    if (item === undefined)
+      continue;
+    const from = extraStarts[index] ?? 0;
+    found.set(item.index, ran.slice(from, extraStarts[index + 1] ?? ran.length));
+  }
+  return found;
+}
+function mapExtra(error, pending, extraStarts) {
+  const failed = error?.batchIndex;
+  const move = error?.at;
+  if (typeof failed !== "number" || typeof move !== "function")
+    return error;
+  let slot = 0;
+  while (slot + 1 < extraStarts.length && (extraStarts[slot + 1] ?? Infinity) <= failed)
+    slot += 1;
+  const op = pending[slot]?.index ?? slot;
+  return op === failed ? error : move.call(error, op);
+}
 function call(options) {
   const { signal, timeout } = options;
   if (signal === undefined && timeout === undefined)

package/dist/shared/{5d8t84hg.js → vczs8gd4.js}

@@ -1,19 +1,19 @@
 import {
   refuseUncancellableTimeout
-} from "./b4v57v3x.js";
+} from "./2d3xq4ps.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   openClient,
   withHttp,
   settleCall
-} from "./j60w0dvr.js";
+} from "./tbrvgw6z.js";
 import {
   rejectKeys,
   isRecord,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -96,15 +96,15 @@ class Frame {
 }
 async function tx(session, args) {
   if (typeof args[0] === "function" && args.length > 1) {
-    fail("OKM1120", "options go first: tx(options, fn).");
+    fail2("OKM1120", "options go first: tx(options, fn).");
   }
   const fn = typeof args[0] === "function" ? args[0] : args[1];
   const given = typeof args[0] === "function" ? {} : args[0] ?? {};
   try {
     if (typeof fn !== "function")
-      fail("OKM1121", "tx expects a callback: tx(fn) or tx(options, fn).");
+      fail2("OKM1121", "tx expects a callback: tx(fn) or tx(options, fn).");
     if (!isRecord(given))
-      fail("OKM1121", "tx options must be an object.");
+      fail2("OKM1121", "tx options must be an object.");
     rejectKeys(given, ["isolation", "retry", "signal", "timeout"], "tx");
     const options = given;
     check(options);
@@ -123,14 +123,14 @@ function failWith(session, error) {
 }
 function check(options) {
   if (options.isolation !== undefined && !Object.hasOwn(BEGIN, options.isolation)) {
-    fail("OKM1120", `isolation must be one of: ${Object.keys(BEGIN).join(", ")}.`);
+    fail2("OKM1120", `isolation must be one of: ${Object.keys(BEGIN).join(", ")}.`);
   }
   const { retry, timeout } = options;
   if (retry !== undefined && (!Number.isInteger(retry) || retry < 0)) {
-    fail("OKM1121", "retry must be an integer from 0 up.");
+    fail2("OKM1121", "retry must be an integer from 0 up.");
   }
   if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
-    fail("OKM1121", "timeout must be a number of milliseconds above 0.");
+    fail2("OKM1121", "timeout must be a number of milliseconds above 0.");
   }
 }
 async function outer(session, fn, options) {
@@ -269,7 +269,7 @@ async function run(session, after, hear) {
 }
 async function nested(session, fn, options) {
   if (Object.keys(options).length > 0) {
-    fail("OKM1121", "isolation, retry, timeout, and signal belong to the outermost tx(). A nested tx() is a savepoint on the same transaction.");
+    fail2("OKM1121", "isolation, retry, timeout, and signal belong to the outermost tx(). A nested tx() is a savepoint on the same transaction.");
   }
   const { state: frame, depth } = session.tx;
   frame.check();
@@ -347,7 +347,7 @@ function held(session, frame, after, depth) {
       extras: {
         afterCommit(callback) {
           if (typeof callback !== "function") {
-            fail("OKM1121", "afterCommit expects a function.");
+            fail2("OKM1121", "afterCommit expects a function.");
           }
           frame.check();
           after.push(callback);
@@ -380,7 +380,7 @@ function lockKey(key) {
   }
   const fits = typeof key === "number" ? Number.isSafeInteger(key) : typeof key === "bigint" && key >= -(2n ** 63n) && key < 2n ** 63n;
   if (!fits)
-    fail("OKM1121", "advisoryLock takes a string, a safe integer, or a bigint that fits in 64 bits.");
+    fail2("OKM1121", "advisoryLock takes a string, a safe integer, or a bigint that fits in 64 bits.");
   return ["select pg_advisory_xact_lock($1::bigint)", String(key)];
 }
 function callOf(options) {

package/dist/shared/{5yv4k6a6.js → vqrjpcqn.js}

@@ -1,11 +1,153 @@
 import {
-  required
+  required,
+  openColumn
 } from "./ywr8hmey.js";
 import {
   definition,
   rejected
 } from "./tmbdywx0.js";
 
+// src/dialects/pg/integer.ts
+function smallint2() {
+  return required({
+    baseType: "smallint",
+    encode: (value) => integerToken(value, -32768, 32767, "smallint"),
+    decode: (wire) => decodeBounded(wire, -32768, 32767, "smallint"),
+    sqlForm: "raw"
+  });
+}
+function integer2() {
+  return required({
+    baseType: "integer",
+    encode: (value) => integerToken(value, -2147483648, 2147483647, "integer"),
+    decode: (wire) => decodeBounded(wire, -2147483648, 2147483647, "integer"),
+    sqlForm: "raw"
+  });
+}
+function bigint2(options) {
+  const mode = options?.as ?? "string";
+  if (mode === "number") {
+    return required({
+      baseType: "bigint",
+      encode: encodeBigintNumber,
+      decode: decodeBigintNumber,
+      sqlForm: "raw",
+      typeLabel: "number"
+    });
+  }
+  if (mode === "bigint") {
+    return required({
+      baseType: "bigint",
+      encode: encodeBigintValue,
+      decode: decodeBigintValue,
+      sqlForm: "raw",
+      typeLabel: "bigint"
+    });
+  }
+  if (mode !== "string") {
+    definition(`bigint as ${String(mode)} must be string, number, or bigint.`);
+  }
+  return required({
+    baseType: "bigint",
+    encode: encodeBigintString,
+    decode: decodeBigintString,
+    sqlForm: "raw"
+  });
+}
+function identity2(options) {
+  const mode = options?.as ?? "string";
+  if (mode === "number") {
+    return openColumn({
+      ...identityFlags(),
+      encode: encodeBigintNumber,
+      decode: decodeBigintNumber,
+      typeLabel: "number"
+    });
+  }
+  if (mode === "bigint") {
+    return openColumn({
+      ...identityFlags(),
+      encode: encodeBigintValue,
+      decode: decodeBigintValue,
+      typeLabel: "bigint"
+    });
+  }
+  if (mode !== "string") {
+    definition(`identity as ${String(mode)} must be string, number, or bigint.`);
+  }
+  return openColumn({
+    ...identityFlags(),
+    encode: encodeBigintString,
+    decode: decodeBigintString
+  });
+}
+function encodeBigintString(value) {
+  parseBigint(value);
+  return value;
+}
+function decodeBigintString(wire) {
+  return encodeBigintString(wire);
+}
+function encodeBigintNumber(value) {
+  if (!Number.isSafeInteger(value)) {
+    rejected(`bigint number ${String(value)} must be an integer from ${String(Number.MIN_SAFE_INTEGER)} to ${String(Number.MAX_SAFE_INTEGER)}.`);
+  }
+  return String(value);
+}
+function decodeBigintNumber(wire) {
+  const parsed = parseBigint(wire);
+  const value = Number(parsed);
+  if (!Number.isSafeInteger(value)) {
+    rejected(`bigint ${wire} must be an integer from ${String(Number.MIN_SAFE_INTEGER)} to ${String(Number.MAX_SAFE_INTEGER)} when as is number.`);
+  }
+  return value;
+}
+function encodeBigintValue(value) {
+  return value.toString();
+}
+function decodeBigintValue(wire) {
+  return parseBigint(wire);
+}
+function integerToken(value, min, max, role) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    rejected(`${role} ${String(value)} must be an integer from ${String(min)} to ${String(max)}.`);
+  }
+  return String(value);
+}
+function decodeBounded(wire, min, max, role) {
+  if (!integerText().test(wire)) {
+    rejected(`${role} ${wire} must be an integer, for example 0 or -12.`);
+  }
+  const value = Number(wire);
+  integerToken(value, min, max, role);
+  return value;
+}
+function identityFlags() {
+  return {
+    baseType: "bigint",
+    nullable: false,
+    hasDefault: true,
+    generated: false,
+    guarded: false,
+    hidden: false,
+    omitWrite: true,
+    sqlForm: "raw",
+    identity: { always: true },
+    primaryKey: true
+  };
+}
+function parseBigint(wire) {
+  if (!integerText().test(wire)) {
+    rejected(`bigint ${wire} must be an integer with no leading zeros, for example 0 or -12.`);
+  }
+  return BigInt(wire);
+}
+function integerText() {
+  integerPattern ??= /^-?(?:0|[1-9]\d*)$/;
+  return integerPattern;
+}
+var integerPattern;
+
 // src/dialects/pg/temporal.ts
 var TEMPORAL_MISSING = "Date and time codecs need the Temporal global. okmodel does not ship a polyfill. Use a runtime that provides Temporal, or assign a polyfill to globalThis.Temporal before using these columns.";
 function requireTemporal() {
@@ -222,4 +364,4 @@ function timed(name, precision) {
   return `${name}(${String(precision)})`;
 }
 
-export { encodeInstant, decodeInstant, encodeDate, decodeDate, timestamptz2, timestamp2, date2, time2, timetz2, interval2 };
+export { smallint2, integer2, bigint2, identity2, encodeBigintString, decodeBigintString, integerToken, encodeInstant, decodeInstant, encodeDate, decodeDate, timestamptz2, timestamp2, date2, time2, timetz2, interval2 };

package/dist/shared/{3fqwmr09.js → w72kgg4q.js}

@@ -1,17 +1,17 @@
 import {
   open2
-} from "./wkme6tep.js";
+} from "./14vx95q4.js";
 import"./qq3899ht.js";
 import {
   createdOf,
   testing2
-} from "./8x72s86k.js";
+} from "./7k9grvf6.js";
 import"./n442h54c.js";
 import {
   projectPath,
   loadConfig,
   loadSchema
-} from "./t3g0k88x.js";
+} from "./gs74dbj5.js";
 import {
   sessionFailure,
   finishQuiet,
@@ -19,7 +19,7 @@ import {
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./ttmg09vd.js";
+} from "./tsvww22q.js";
 import"./9s0ypp87.js";
 import {
   OkmError2

package/dist/shared/{1z04fa85.js → w79hsckn.js}

@@ -1,16 +1,14 @@
 import {
-  quoteIdent2,
   noticeBuffer,
-  WireSession,
-  cursorStream
-} from "./4az561fn.js";
+  WireSession
+} from "./1qa0qajz.js";
 import {
   NODE_POSTGRES_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./cgbamx3e.js";
+} from "./kb2sdhfb.js";
 
 // src/adapters/pg/nodepostgres.ts
 import net from "node:net";
@@ -57,7 +55,7 @@ function open4(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   }, inflight);
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./zm0mafk4.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./zp9fmend.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NODE_POSTGRES_CAPABILITIES,
     execute(text, params, options) {
@@ -89,10 +87,15 @@ function open4(config) {
     },
     reserve: () => checkout(),
     stream(text, params) {
-      return stream(text, params);
+      return async function* () {
+        const { streamRows } = await import("./zp9fmend.js");
+        yield* streamRows(checkout, text, params);
+      }();
     },
     listen(channel, onNotify) {
-      return listen(channel, onNotify);
+      if (closed)
+        return rejectClosed();
+      return import("./zp9fmend.js").then((mod) => mod.listen(held, channel, onNotify));
     },
     cancel() {
       for (const pending of inflight)
@@ -104,54 +107,6 @@ function open4(config) {
       await pool.end();
     }
   };
-  function stream(text, params) {
-    return async function* () {
-      const connection = await checkout();
-      try {
-        yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
-      } finally {
-        await connection.release();
-      }
-    }();
-  }
-  async function listen(channel, onNotify) {
-    if (closed)
-      return rejectClosed();
-    const client = await connectClient(pool, acquireMs, counters);
-    counters.reserved += 1;
-    const quoted = quoteIdent2(channel);
-    const onNotification = (message) => {
-      if (message.channel === channel)
-        onNotify(message.payload ?? "");
-    };
-    client.on("notification", onNotification);
-    let released = false;
-    const release = (dead) => {
-      if (released)
-        return;
-      released = true;
-      client.removeListener("notification", onNotification);
-      client.removeListener("error", release);
-      counters.reserved = Math.max(0, counters.reserved - 1);
-      client.release(Boolean(dead));
-    };
-    armDriverError(client, release);
-    try {
-      await client.query(`LISTEN ${quoted}`);
-    } catch (error) {
-      release(false);
-      throw error;
-    }
-    return async () => {
-      if (released)
-        return;
-      try {
-        await client.query(`UNLISTEN ${quoted}`);
-      } finally {
-        release(false);
-      }
-    };
-  }
 }
 function send(runner, text, params, named, client) {
   const query = {
@@ -236,4 +191,4 @@ function statsOf(counters, size) {
   };
 }
 
-export { open4, send, connectClient };
+export { armDriverError, open4, send, connectClient };

package/dist/shared/{09p049xa.js → wa07eas9.js}

@@ -2,31 +2,32 @@ import {
   parseCatalog2
 } from "./qq3899ht.js";
 import"./n442h54c.js";
-import"./wkme6tep.js";
+import"./cm3w0ywp.js";
+import"./14vx95q4.js";
 import {
   watchReserved2
-} from "./q3j1tq7a.js";
+} from "./bz84tkzm.js";
 import {
   ensureMigrationTables2
-} from "./nx9hh281.js";
+} from "./p6qc5gcp.js";
 import {
   sealViews,
   catalogQuery2,
   managedRoleOptions2
-} from "./f0f1n281.js";
+} from "./ax7qv55k.js";
 import {
   assumeRole,
   grantSchema,
   assertSchemaUsageLanded,
   catalogsEqual,
   snapshotDifference
-} from "./p248q79y.js";
+} from "./m6p12kbr.js";
 import {
   roleExists
-} from "./knmes2kh.js";
+} from "./8skf0cam.js";
 import {
   introspectSchema
-} from "./vjpnzwjz.js";
+} from "./b5pftnn2.js";
 import {
   projectPath,
   loadMigrations,
@@ -35,7 +36,7 @@ import {
   hasError,
   lintRefusal,
   openProject
-} from "./t3g0k88x.js";
+} from "./gs74dbj5.js";
 import {
   sqlStatements,
   transactionControl,
@@ -50,10 +51,10 @@ import {
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./ttmg09vd.js";
+} from "./tsvww22q.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   quoteIdent
 } from "./9s0ypp87.js";
@@ -151,12 +152,18 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     onnotice: () => {}
   });
   const reserved = await sql.reserve();
-  const lost = { on: false };
+  const lost = { on: false, stop: () => {
+    return;
+  } };
   watchReserved2(reserved, lost);
   refuseWhenLost(reserved, lost);
   let open = false;
   let failure;
   let value;
+  let created = false;
+  let sawCommit = false;
+  let rolledBack = false;
+  let xid = "";
   try {
     await assertStableBackend(async () => {
       const rows = await reserved.unsafe("select pg_backend_pid()::text as pid");
@@ -165,8 +172,9 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     }, allowPooler);
     await reserved.unsafe("begin");
     open = true;
-    const xid = await readXid(reserved);
+    xid = await readXid(reserved);
     await reserved.unsafe(`create schema ${quoteIdent(scratch)}`);
+    created = true;
     await reserved.unsafe(`set local search_path to ${quoteIdent(scratch)}`);
     await setLocalTimeout(reserved, "lock_timeout", config.timeouts?.lock);
     await setLocalTimeout(reserved, "statement_timeout", config.timeouts?.statement);
@@ -178,21 +186,36 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
         lost.on = true;
       return;
     });
-    if (!lost.on && after !== xid)
+    if (!lost.on && after !== xid) {
+      sawCommit = true;
       throw xidChanged();
-    if (!lost.on)
+    }
+    if (!lost.on) {
       await reserved.unsafe("rollback");
+      rolledBack = true;
+    }
     open = false;
   } catch (error) {
     if (isConnectionLost(error))
       lost.on = true;
     failure = error;
   } finally {
+    if (open && !lost.on && !sawCommit) {
+      const after = await readXid(reserved).catch((error) => {
+        if (isConnectionLost(error))
+          lost.on = true;
+        return;
+      });
+      if (!lost.on && after !== xid)
+        sawCommit = true;
+    }
     if (open && !lost.on) {
       await reserved.unsafe("rollback").catch((error) => {
         if (isConnectionLost(error))
           lost.on = true;
       });
+      if (!lost.on && !sawCommit)
+        rolledBack = true;
     }
     if (!lost.on)
       await reserved.unsafe("reset role").catch(() => {
@@ -207,6 +230,11 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     }
     await finishQuiet(() => sql.end({ timeout: 5 }));
   }
+  if (!created || rolledBack) {
+    if (failure !== undefined)
+      throw sessionFailure(failure) ?? failure;
+    return value;
+  }
   const left = await dropScratch(url, scratch);
   if (left !== undefined) {
     const note = `Scratch schema ${left} is still present.`;