okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/stebqyyd.js

@@ -0,0 +1,401 @@
+import {
+  refuseUncancellableTimeout
+} from "./tcwpjvxe.js";
+import {
+  openClient,
+  withHttp,
+  settleCall
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  isConnectionLost,
+  rejectKeys,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/transaction.ts
+var BEGIN = {
+  "read committed": "BEGIN ISOLATION LEVEL READ COMMITTED",
+  "repeatable read": "BEGIN ISOLATION LEVEL REPEATABLE READ",
+  serializable: "BEGIN ISOLATION LEVEL SERIALIZABLE"
+};
+
+class Frame {
+  done = false;
+  failed = undefined;
+  stopped = undefined;
+  savepoints = 0;
+  signal;
+  abort;
+  active = 0;
+  halt;
+  idle = undefined;
+  cut = () => {
+    return;
+  };
+  conn;
+  idleMs;
+  constructor(conn, idleMs, stoppable) {
+    this.conn = conn;
+    this.idleMs = idleMs;
+    this.abort = stoppable ? new AbortController : undefined;
+    this.signal = this.abort?.signal;
+    this.halt = new Promise((_, reject) => {
+      this.cut = reject;
+    });
+    this.halt.catch(() => {
+      return;
+    });
+  }
+  stop(error) {
+    if (this.done || this.stopped !== undefined)
+      return;
+    this.stopped = error;
+    this.abort?.abort();
+    this.cut(error);
+  }
+  check() {
+    if (this.done) {
+      throw new OkmError("driver", "The transaction has finished. Use the client the callback received only while the callback runs.", { kind: "driver" });
+    }
+    if (this.stopped !== undefined)
+      throw this.stopped;
+  }
+  enter() {
+    this.active += 1;
+    this.rest();
+  }
+  leave() {
+    this.active -= 1;
+    if (this.active === 0)
+      this.arm();
+  }
+  arm() {
+    this.rest();
+    if (this.idleMs === undefined || this.done || this.active > 0)
+      return;
+    this.idle = setTimeout(() => {
+      this.stop(new OkmError("timeout", `The transaction sat idle for ${String(this.idleMs)} ms (timeouts.idleInTransaction).`, { kind: "timeout" }));
+    }, this.idleMs);
+  }
+  rest() {
+    if (this.idle !== undefined)
+      clearTimeout(this.idle);
+    this.idle = undefined;
+  }
+  note(error, whole) {
+    const kind = error?.kind;
+    if (!whole || kind === "cancelled" || kind === "timeout")
+      this.failed ??= error;
+  }
+}
+async function tx(session, args) {
+  if (typeof args[0] === "function" && args.length > 1) {
+    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")
+      fail2("OKM1121", "tx expects a callback: tx(fn) or tx(options, fn).");
+    if (!isRecord(given))
+      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) {
+    return failWith(session, error);
+  }
+}
+function failWith(session, error) {
+  if (error instanceof OkmError || !(error instanceof Error) || error.name !== "DriverError") {
+    return Promise.reject(error);
+  }
+  return settleCall(session, error);
+}
+function check(options) {
+  if (options.isolation !== undefined && !Object.hasOwn(BEGIN, options.isolation)) {
+    fail2("OKM1120", `isolation must be one of: ${Object.keys(BEGIN).join(", ")}.`);
+  }
+  const { retry, timeout } = options;
+  if (retry !== undefined && (!Number.isInteger(retry) || retry < 0)) {
+    fail2("OKM1121", "retry must be an integer from 0 up.");
+  }
+  if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
+    fail2("OKM1121", "timeout must be a number of milliseconds above 0.");
+  }
+}
+async function outer(session, fn, options) {
+  const pool = session.pool;
+  if (pool.reserve === undefined || pool.capabilities.transactions !== "interactive") {
+    throw new OkmError("OKM1111", `tx() needs a driver with transactions: "interactive". This driver has "${pool.capabilities.transactions}".`, withHttp(session.http, {
+      fix: { summary: "Use batch() for an atomic unit on this driver." }
+    }));
+  }
+  await session.connected;
+  const started = Date.now();
+  const limit = options.timeout ?? session.timeouts?.transaction;
+  const deadline = limit === undefined ? undefined : started + limit;
+  const retries = options.retry ?? 0;
+  for (let attempt = 0;; attempt += 1) {
+    try {
+      return await once(session, fn, options, deadline);
+    } catch (error) {
+      const kind = error instanceof OkmError ? error.kind : undefined;
+      if (attempt >= retries || kind !== "serialization" && kind !== "deadlock")
+        throw error;
+      await pause(attempt);
+      if (options.signal?.aborted === true)
+        throw cancelled();
+      if (deadline !== undefined && Date.now() >= deadline)
+        throw timedOut();
+    }
+  }
+}
+function pause(attempt) {
+  const ms = Math.random() * Math.min(100, 4 * 2 ** attempt);
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function cancelled() {
+  return new OkmError("cancelled", "The transaction was cancelled.", { kind: "cancelled" });
+}
+function timedOut() {
+  return new OkmError("timeout", "The transaction timed out.", { kind: "timeout" });
+}
+async function once(session, fn, options, deadline) {
+  const signal = options.signal;
+  if (signal?.aborted === true)
+    throw cancelled();
+  if (deadline !== undefined && Date.now() >= deadline)
+    throw timedOut();
+  const conn = await reserve(session);
+  const frame = new Frame(conn, session.timeouts?.idleInTransaction, signal !== undefined || deadline !== undefined);
+  const after = [];
+  const hear = session.hookm === undefined ? undefined : await import("./96ps4g1z.js");
+  const onAbort = () => frame.stop(cancelled());
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const timer = deadline === undefined ? undefined : setTimeout(() => frame.stop(timedOut()), deadline - Date.now());
+  let began = false;
+  let committing = false;
+  let committed = false;
+  try {
+    await step(session, frame, options.isolation === undefined ? "BEGIN" : BEGIN[options.isolation]);
+    began = true;
+    hear?.phase(session.hookm, "start", 0);
+    frame.arm();
+    const t = openClient(held(session, frame, after, 0));
+    const value = await Promise.race([fn(t), frame.halt]);
+    frame.check();
+    if (frame.failed !== undefined)
+      throw frame.failed;
+    frame.rest();
+    committing = true;
+    await commit(session, frame);
+    committed = true;
+    return value;
+  } catch (error) {
+    if (began && !committed) {
+      if (!committing)
+        await frame.conn.execute("ROLLBACK").catch(() => {
+          return;
+        });
+      if (!(error instanceof OkmError && error.kind === "outcome_unknown")) {
+        hear?.phase(session.hookm, "rollback", 0);
+      }
+    }
+    return await failWith(session, error);
+  } finally {
+    frame.rest();
+    frame.done = true;
+    if (timer !== undefined)
+      clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+    try {
+      await conn.release();
+    } catch (error) {
+      hear?.report(session, error);
+    }
+    if (committed) {
+      hear?.phase(session.hookm, "commit", 0);
+      await run(session, after, hear);
+    }
+  }
+}
+async function reserve(session) {
+  try {
+    return await session.pool.reserve();
+  } catch (error) {
+    return failWith(session, error);
+  }
+}
+function step(session, frame, text) {
+  return frame.conn.execute(text).catch((error) => failWith(session, error));
+}
+async function commit(session, frame) {
+  try {
+    await frame.conn.execute("COMMIT");
+  } catch (error) {
+    if (isConnectionLost(error)) {
+      throw new OkmError("OKM1401", "The commit was sent and its result never arrived. The transaction may or may not have committed.", withHttp(session.http, {
+        kind: "outcome_unknown",
+        cause: error,
+        fix: {
+          summary: "Check whether the write landed, using an idempotency key, before retrying."
+        }
+      }));
+    }
+    throw error;
+  }
+}
+async function run(session, after, hear) {
+  for (const callback of after) {
+    try {
+      await callback();
+    } catch (error) {
+      if (hear !== undefined)
+        hear.report(session, error);
+      else
+        (await import("./96ps4g1z.js")).report(session, error);
+    }
+  }
+}
+async function nested(session, fn, options) {
+  if (Object.keys(options).length > 0) {
+    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();
+  frame.savepoints += 1;
+  const name = `okm_t${String(frame.savepoints)}`;
+  const hear = session.hookm === undefined ? undefined : await import("./96ps4g1z.js");
+  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);
+    const t = openClient(held(session, frame, after, depth + 1));
+    const value = await Promise.race([fn(t), frame.halt]);
+    frame.check();
+    if (frame.failed !== saved)
+      throw frame.failed;
+    await step(session, frame, `RELEASE SAVEPOINT ${name}`);
+    released = true;
+    hear?.phase(session.hookm, "commit", depth + 1);
+    session.tx.after.push(...after);
+    return value;
+  } catch (error) {
+    if (!released && frame.stopped === undefined) {
+      await frame.conn.execute(`ROLLBACK TO SAVEPOINT ${name}`).catch(() => {
+        return;
+      });
+      hooks.okmForgetScope?.();
+      frame.failed = saved;
+      hear?.phase(session.hookm, "rollback", depth + 1);
+    }
+    return await failWith(session, error);
+  }
+}
+function held(session, frame, after, depth) {
+  const base = session.pool;
+  const guarded = async (run, whole) => {
+    frame.check();
+    frame.enter();
+    try {
+      return await run();
+    } catch (error) {
+      frame.note(error, whole);
+      throw error;
+    } finally {
+      frame.leave();
+    }
+  };
+  const pool = depth === 0 ? {
+    capabilities: base.capabilities,
+    execute: (text, params, options) => {
+      if (options?.route === "replica")
+        replicaInside();
+      return guarded(() => frame.conn.execute(text, params, stoppable(frame, options)), false);
+    },
+    batch: (statements, options) => {
+      if (options?.route === "replica")
+        replicaInside();
+      return guarded(() => frame.conn.batch(statements, stoppable(frame, options)), true);
+    },
+    stats: () => base.stats(),
+    close: () => Promise.resolve()
+  } : base;
+  const next = {
+    ...session,
+    pool,
+    tx: {
+      depth,
+      state: frame,
+      after,
+      extras: {
+        afterCommit(callback) {
+          if (typeof callback !== "function") {
+            fail2("OKM1121", "afterCommit expects a function.");
+          }
+          frame.check();
+          after.push(callback);
+        },
+        async advisoryLock(key, options) {
+          const [text, wire] = lockKey(key);
+          try {
+            await pool.execute(text, [wire], callOf(options));
+          } catch (error) {
+            await failWith(next, error);
+          }
+        }
+      }
+    }
+  };
+  return next;
+}
+function stoppable(frame, options) {
+  const own = frame.signal;
+  if (own === undefined)
+    return options;
+  return {
+    ...options,
+    signal: options?.signal === undefined ? own : AbortSignal.any([options.signal, own])
+  };
+}
+function lockKey(key) {
+  if (typeof key === "string") {
+    return ["select pg_advisory_xact_lock(hashtextextended($1, 0))", key];
+  }
+  const fits = typeof key === "number" ? Number.isSafeInteger(key) : typeof key === "bigint" && key >= -(2n ** 63n) && key < 2n ** 63n;
+  if (!fits)
+    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) {
+  if (options?.signal === undefined && options?.timeout === undefined && options?.route === undefined) {
+    return;
+  }
+  return {
+    ...options?.signal !== undefined ? { signal: options.signal } : {},
+    ...options?.timeout !== undefined ? { timeout: options.timeout } : {},
+    ...options?.route !== undefined ? { route: options.route } : {}
+  };
+}
+function replicaInside() {
+  throw new OkmError("OKM1840", "This operation needs the primary.", {
+    fix: {
+      summary: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
+    }
+  });
+}
+export {
+  tx
+};

package/dist/tooling/shared/t4xveemq.js

@@ -0,0 +1,250 @@
+import {
+  stack2
+} from "./35zemrmf.js";
+import {
+  updateSliceBody2,
+  rejectDuplicateTargets2,
+  emitSet2,
+  Sql2,
+  writeSet2,
+  rejectMixedSets2,
+  readClaim2,
+  rejectUpdateKeys2,
+  requireFilter2,
+  returningOption2,
+  expectOf2,
+  allowSet2,
+  noteGuarded2
+} from "./ezqn88nj.js";
+import"./w5d89rb4.js";
+import {
+  emitWhere,
+  projectExpr,
+  quote,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/version.ts
+function planVersioned(schema, table, input, options, mods) {
+  if (mods.all !== undefined) {
+    fail2("OKM1120", `update on ${table.model.name} cannot use .all() with versioned().`, "Pass a per-row list with the version you read for each row.");
+  }
+  const allow = allowSet2(table, options.allow);
+  noteGuarded2(table, allow, "update");
+  const column = versionColumn(table);
+  const returning = returningOption2(table, options.returning);
+  const expect = expectOf2(options, mods);
+  if (Array.isArray(input) && input.length === 0) {
+    return {
+      statements: [],
+      outputs: outputsOf(undefined),
+      shape: "count",
+      expect,
+      versioned: { fields: [], sent: [] }
+    };
+  }
+  const rows = readRows(schema, table, input, allow, mods, column);
+  const fields = writtenFields(rows);
+  const sent = rows.map((row) => row.version);
+  const claim = Array.isArray(input) ? undefined : isRecord(input) ? readClaim2(input) : undefined;
+  const statement = claim !== undefined ? claimStatement(schema, table, rows[0], claim, column, returning) : targetStatement(schema, table, rows, column, returning);
+  const width = statement.params?.length ?? 0;
+  if (width > 30000) {
+    fail2("OKM1120", `update on ${table.model.name} is too large to check version in one statement.`, "Split the list.");
+  }
+  return {
+    statements: [statement],
+    outputs: outputsOf(returning),
+    shape: returning === undefined ? "count" : "rows",
+    expect,
+    versioned: { fields, sent }
+  };
+}
+function versionColumn(table) {
+  const column = table.columns.get("version");
+  if (column === undefined) {
+    fail2("OKM1120", `Table ${table.model.name} is versioned and has no version column.`);
+  }
+  return column;
+}
+function readRows(schema, table, input, allow, mods, column) {
+  if (Array.isArray(input)) {
+    if (input.length === 0)
+      fail2("OKM1120", "update set is empty.");
+    const rows = input.map((item) => readRow(schema, table, item, allow, mods, column, true));
+    rejectDuplicateTargets2(table, rows);
+    rejectMixedSets2(rows);
+    return rows;
+  }
+  return [readRow(schema, table, input, allow, mods, column, false)];
+}
+function readRow(schema, table, input, allow, mods, column, row) {
+  if (!isRecord(input))
+    fail2("OKM1121", "update expects { where, set, version } or a list of rows.");
+  rejectUpdateKeys2(input, row);
+  if (!Object.hasOwn(input, "version")) {
+    fail2("OKM1120", `update on ${table.model.name} needs the version you read.`, "Pass version from the row you read. If this write conflicts, reread and retry.");
+  }
+  const version = readVersion(input.version, table.model.name, column);
+  const set = writeSet2(table, input.set, allow, schema.tenancy);
+  if (Object.keys(set).length === 0)
+    fail2("OKM1120", "update set is empty.");
+  refusePath(schema, table, set);
+  const where = input.where !== undefined ? input.where : input.id !== undefined ? { id: input.id } : undefined;
+  requireFilter2(table, where, mods, "update");
+  return { where: stack2(where, mods.presets), set, version };
+}
+function readVersion(value, table, column) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    fail2("OKM1121", `version on ${table} must be an integer.`, "Pass the version you read.");
+  }
+  column.encode(value);
+  return value;
+}
+function refusePath(schema, table, set) {
+  if (schema.tenancy?.isPath?.(table.model.name) !== true)
+    return;
+  const field = schema.tenancy.pathOf?.(table.model.name)?.[0]?.localField;
+  if (field === undefined || !Object.hasOwn(set, field))
+    return;
+  fail2("OKM1120", `update on ${table.model.name} cannot change ${field} and check version in one write.`, "Point it at a parent in a later update.");
+}
+function writtenFields(rows) {
+  const names = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row.set))
+      if (!names.includes(key))
+        names.push(key);
+  }
+  return names;
+}
+function targetStatement(schema, table, rows, column, returning) {
+  const sql = new Sql2;
+  sql.text("with ");
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(", ");
+    sql.text("m");
+    sql.text(String(index));
+    sql.text(" as (select s.ctid as tid, s.tableoid as toid, s.");
+    sql.text(quote(column.sql));
+    sql.text(" as okm_version from ");
+    sql.text(quote(table.model.sql));
+    sql.text(" as s");
+    emitWhere(schema, table, row.where, sql.sink(), "s", 0);
+    sql.text(" for update of s)");
+  }
+  sql.text(", gate as (select count(*)::int as n from (");
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(" union all ");
+    sql.text("select 1 from m");
+    sql.text(String(index));
+    sql.text(" where okm_version is distinct from ");
+    sql.param(column.encode(row.version), column.dataType);
+  }
+  sql.text(") as okm_diff), updated as (");
+  updateSliceBody2(schema, table, rows, sql, true, {
+    afterWhere(body, index) {
+      const row = rows[index];
+      if (row === undefined)
+        return;
+      body.text(" and t.");
+      body.text(quote(column.sql));
+      body.text(" = ");
+      body.param(column.encode(row.version), column.dataType);
+    },
+    afterSet(body) {
+      bump(body, column);
+    }
+  });
+  sql.text(" and (select n from gate) = 0");
+  closeUpdated(sql, returning, "gate");
+  return sql.statement();
+}
+function claimStatement(schema, table, row, limit, column, returning) {
+  if (row === undefined)
+    fail2("OKM1120", "update set is empty.");
+  const sql = new Sql2;
+  sql.text("with claimed as (select s.tableoid as toid, s.ctid as tid from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as s");
+  emitWhere(schema, table, row.where, sql.sink(), "s", 0);
+  sql.text(" and s.");
+  sql.text(quote(column.sql));
+  sql.text(" = ");
+  sql.param(column.encode(row.version), column.dataType);
+  sql.text(" for update of s skip locked limit ");
+  sql.param(String(limit), "integer");
+  sql.text("), stale_free as (select 1 as hit from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as s");
+  emitWhere(schema, table, row.where, sql.sink(), "s", 0);
+  sql.text(" and s.");
+  sql.text(quote(column.sql));
+  sql.text(" is distinct from ");
+  sql.param(column.encode(row.version), column.dataType);
+  sql.text(" for update of s skip locked limit 1), updated as (update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  emitSet2(sql, table, row.set, "t");
+  bump(sql, column);
+  sql.text(" where (t.tableoid, t.ctid) in (select toid, tid from claimed)");
+  closeUpdated(sql, returning, "claim");
+  return sql.statement();
+}
+function bump(sql, column) {
+  sql.text(", ");
+  sql.text(quote(column.sql));
+  sql.text(" = t.");
+  sql.text(quote(column.sql));
+  sql.text(" + 1");
+}
+function closeUpdated(sql, returning, source) {
+  const stale = source === "gate" ? "(select n from gate)" : "(case when (select count(*) from updated) > 0 then 0 else (select count(*)::int from stale_free) end)";
+  if (returning === undefined || returning.length === 0) {
+    sql.text(" returning 1) select ");
+    sql.text(stale);
+    sql.text(", (select count(*)::int from updated)");
+    return;
+  }
+  sql.text(" returning t.ctid as okm_tid");
+  for (let index = 0;index < returning.length; index += 1) {
+    const column = returning[index];
+    if (column === undefined)
+      continue;
+    sql.text(", ");
+    sql.text(projectExpr(`t.${quote(column.sql)}`, column.dataType));
+    sql.text(" as okm_");
+    sql.text(String(index));
+  }
+  sql.text(") select ");
+  sql.text(stale);
+  sql.text(", case when u.okm_tid is null then 0 else 1 end");
+  for (let index = 0;index < returning.length; index += 1) {
+    sql.text(", u.okm_");
+    sql.text(String(index));
+  }
+  sql.text(" from (select 1) as okm_one left join updated u on true");
+}
+function outputsOf(columns) {
+  const list = columns ?? [];
+  return {
+    fields: list.map((column, index) => ({
+      key: column.field,
+      at: index + 2,
+      decode: column.decode
+    })),
+    includes: []
+  };
+}
+export {
+  planVersioned
+};