okmodel 0.5.1 → 0.7.0

package/dist/shared/{47x8x9ze.js → ttsqgp4p.js}

@@ -1,7 +1,13 @@
+import {
+  POSTGRES_FLOOR,
+  isPostgresMajor,
+  parsePostgresFloor,
+  serverNeedsPostgres
+} from "./ga9j92qj.js";
 import {
   withHttp,
   attachHttp
-} from "./hf22e0wt.js";
+} from "./tbrvgw6z.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -11,7 +17,7 @@ var versionQuery = "select current_setting('server_version_num'), version(), (se
 async function acceptServer(pool, schema, rows, http, requireMeta, options, source) {
   for (const name in schema.model) {
     if (schema.model[name]?.presets !== undefined) {
-      (await import("./r6nwkxnt.js")).checkSchema(schema);
+      (await import("./m7n9h2a5.js")).checkSchema(schema);
       break;
     }
   }
@@ -31,7 +37,7 @@ async function acceptServer(pool, schema, rows, http, requireMeta, options, sour
       }));
     }
   } else {
-    const { assertCompatible } = await import("./z2rnngj4.js");
+    const { assertCompatible } = await import("./ek2wt2dz.js");
     try {
       await assertCompatible(pool, schema, recorded, source, options);
     } catch (error) {
@@ -41,20 +47,21 @@ async function acceptServer(pool, schema, rows, http, requireMeta, options, sour
     }
   }
   const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
-  const requires = schema.requires?.postgres;
-  if (requires === undefined) {
-    if (major < 15) {
-      throw new OkmError2("OKM1803", `The server is PostgreSQL ${String(major)}. PostgreSQL 15 is the oldest supported.`, withHttp(http, {
-        fix: { summary: "Upgrade to PostgreSQL 15, or set schema({ requires }) to this major." }
+  const raw = schema.requires?.postgres;
+  if (raw === undefined) {
+    if (major < POSTGRES_FLOOR) {
+      throw new OkmError2("OKM1803", serverNeedsPostgres(major, POSTGRES_FLOOR), withHttp(http, {
+        fix: {
+          summary: `Upgrade to PostgreSQL ${String(POSTGRES_FLOOR)} or higher.`
+        }
       }));
     }
     return;
   }
-  const match = /^>=(\d+)$/.exec(requires.trim());
-  const need = match?.[1] === undefined ? undefined : Number(match[1]);
-  if (need === undefined || major < need) {
-    throw new OkmError2("OKM1802", `The server is PostgreSQL ${String(major)}. schema({ requires }) asks for ${requires}.`, withHttp(http, {
-      fix: { summary: "Upgrade the server, or lower requires to a version the server meets." }
+  const need = parsePostgresFloor(raw);
+  if (!isPostgresMajor(need) || major < need) {
+    throw new OkmError2("OKM1802", serverNeedsPostgres(major, isPostgresMajor(need) ? need : POSTGRES_FLOOR), withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower minPostgres to a major the server meets." }
     }));
   }
 }

package/dist/shared/{x72jb7ad.js → v8g1vgv8.js}

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

package/dist/shared/vb6qfyve.js

@@ -0,0 +1,152 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  refuseUncancellableTimeout
+} from "./2d3xq4ps.js";
+import {
+  withHttp,
+  settleCall
+} from "./tbrvgw6z.js";
+import {
+  rejectKeys,
+  isRecord,
+  fail2
+} from "./67txcrcw.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/batch.ts
+async function batch(session, ops, options, replica) {
+  try {
+    if (replica !== undefined) {
+      throw new OkmError2("OKM1840", "batch() needs the primary. .replica() is not allowed on a batch.", withHttp(session.http, {
+        fix: { summary: "Remove .replica(). A batch always runs on the primary." }
+      }));
+    }
+    if (!Array.isArray(ops))
+      fail2("OKM1121", "batch expects a list of write operations.");
+    const record = options ?? {};
+    if (!isRecord(record))
+      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) {
+        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) {
+        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) {
+        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);
+    }
+    return await run(session, prepared, record);
+  } catch (error) {
+    return settleCall(session, error);
+  }
+}
+async function run(session, prepared, options) {
+  await session.connected;
+  const statements = [];
+  const starts = [];
+  for (const item of prepared) {
+    starts.push(statements.length);
+    statements.push(...item.statements);
+  }
+  if (statements.length === 0)
+    return prepared.map((item) => item.finish([]));
+  let results;
+  try {
+    results = await runWrite(session, statements, call(options), true);
+  } 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;
+    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)
+    return;
+  return {
+    ...signal !== undefined ? { signal } : {},
+    ...typeof timeout === "number" ? { timeout } : {}
+  };
+}
+function at(error, starts) {
+  const failed = error?.batchIndex;
+  const move = error?.at;
+  if (typeof failed !== "number" || typeof move !== "function")
+    return error;
+  let index = 0;
+  while (index + 1 < starts.length && (starts[index + 1] ?? Infinity) <= failed)
+    index += 1;
+  return index === failed ? error : move.call(error, index);
+}
+export {
+  batch
+};

package/dist/shared/{r2sp8hrc.js → vczs8gd4.js}

@@ -1,16 +1,19 @@
+import {
+  refuseUncancellableTimeout
+} from "./2d3xq4ps.js";
 import {
   isConnectionLost
-} from "./pf0d8f77.js";
+} from "./cnkky55j.js";
 import {
   openClient,
   withHttp,
   settleCall
-} from "./hf22e0wt.js";
+} from "./tbrvgw6z.js";
 import {
   rejectKeys,
   isRecord,
-  fail
-} from "./gbtcc2d7.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -93,18 +96,19 @@ 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);
+    await refuseUncancellableTimeout(session.pool, options.timeout);
     const call = fn;
     return session.tx === undefined ? await outer(session, call, options) : await nested(session, call, options);
   } catch (error) {
@@ -119,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) {
@@ -265,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();
@@ -275,6 +279,10 @@ async function nested(session, fn, options) {
   const saved = frame.failed;
   const after = [];
   let released = false;
+  const hooks = session.pool;
+  const pending = hooks.okmScopePending?.();
+  if (pending !== undefined)
+    await pending;
   try {
     await step(session, frame, `SAVEPOINT ${name}`);
     hear?.phase(session.hookm, "start", depth + 1);
@@ -293,6 +301,7 @@ async function nested(session, fn, options) {
       await frame.conn.execute(`ROLLBACK TO SAVEPOINT ${name}`).catch(() => {
         return;
       });
+      hooks.okmForgetScope?.();
       frame.failed = saved;
       hear?.phase(session.hookm, "rollback", depth + 1);
     }
@@ -338,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);
@@ -371,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/{1g0drakv.js → vqrjpcqn.js}

@@ -1,11 +1,153 @@
 import {
-  required
-} from "./c9z5g0fm.js";
+  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/{2pqx26h8.js → w72kgg4q.js}

@@ -1,36 +1,38 @@
 import {
   open2
-} from "./krxx77g0.js";
-import"./8bwbwy8h.js";
+} from "./14vx95q4.js";
+import"./qq3899ht.js";
 import {
   createdOf,
   testing2
-} from "./v36c5g6p.js";
+} from "./7k9grvf6.js";
 import"./n442h54c.js";
 import {
+  projectPath,
   loadConfig,
   loadSchema
-} from "./qv2ydck9.js";
+} from "./gs74dbj5.js";
 import {
+  sessionFailure,
+  finishQuiet,
   assertTargetPolicy,
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./ga3sfy93.js";
-import"./8xsbagad.js";
+} from "./tsvww22q.js";
+import"./9s0ypp87.js";
 import {
   OkmError2
 } from "./52szzakm.js";
 
 // src/tooling/migrate/seed.ts
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 async function seedProject(cwd, file, flags) {
   const config = await loadConfig(cwd);
   const target = selectTarget(config, flags.target);
   assertTargetPolicy(target, "seed", flags.allowProtected);
-  const path = join(cwd, file);
+  const path = projectPath(cwd, file);
   if (!existsSync(path)) {
     throw new OkmError2("invalid", `Seed file ${file} was not found.`, {
       fix: { summary: "Pass okm seed <file> a module in this project." }
@@ -40,20 +42,21 @@ async function seedProject(cwd, file, flags) {
   assertDirectConnection(target.url, allowPooler);
   const schema = await loadSchema(cwd, config.schema);
   const pool = open2({ url: target.url, max: 1 });
-  const held = await pool.reserve?.();
-  if (held !== undefined) {
-    try {
-      await assertStableBackend(async () => {
-        const result = await held.execute("select pg_backend_pid()::text");
-        const cell = result.rows[0]?.[0];
-        return cell === null || cell === undefined ? "" : String(cell);
-      }, allowPooler);
-    } finally {
-      await held.release();
-    }
-  }
-  const harness = await testing2(schema, { driver: pool, migrate: false });
+  let harness;
   try {
+    const held = await pool.reserve?.();
+    if (held !== undefined) {
+      try {
+        await assertStableBackend(async () => {
+          const result = await held.execute("select pg_backend_pid()::text");
+          const cell = result.rows[0]?.[0];
+          return cell === null || cell === undefined ? "" : String(cell);
+        }, allowPooler);
+      } finally {
+        await finishQuiet(() => held.release());
+      }
+    }
+    harness = await testing2(schema, { driver: pool, migrate: false });
     const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
     const seed = isRecord(imported) ? imported.default : undefined;
     if (typeof seed !== "function") {
@@ -63,8 +66,14 @@ async function seedProject(cwd, file, flags) {
     }
     await seed(harness);
     return formatCreated(target.name, createdOf(harness));
+  } catch (error) {
+    throw sessionFailure(error) ?? error;
   } finally {
-    await harness.close();
+    const opened = harness;
+    if (opened !== undefined)
+      await finishQuiet(() => opened.close());
+    else
+      await finishQuiet(() => pool.close());
   }
 }
 function formatCreated(target, counts) {