okmodel 0.6.0 → 0.8.0

package/dist/tooling/shared/pw8fgahx.js

@@ -0,0 +1,69 @@
+import {
+  withHttp,
+  attachHttp
+} from "./mtrqn2hn.js";
+import {
+  OkmError,
+  POSTGRES_FLOOR,
+  isPostgresMajor,
+  parsePostgresFloor,
+  serverNeedsPostgres
+} from "./f9mphxej.js";
+
+// src/runtime/server-check.ts
+var versionQuery = "select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from okm_meta where id = ''head''', true, false, '')))[1]::text where to_regclass('okm_meta') is not null)";
+async function acceptServer(pool, schema, rows, http, requireMeta, options, source) {
+  for (const name in schema.model) {
+    if (schema.model[name]?.presets !== undefined) {
+      (await import("./ma2340rx.js")).checkSchema(schema);
+      break;
+    }
+  }
+  const version = rows[0]?.[1];
+  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
+    throw new OkmError("OKM1801", "The server is not PostgreSQL. The schema dialect is postgres.", withHttp(http, {
+      fix: { summary: "Open the schema with the Postgres driver that matches it." }
+    }));
+  }
+  const recorded = rows[0]?.[2];
+  if (recorded === null || recorded === undefined || recorded.length === 0) {
+    if (requireMeta) {
+      throw new OkmError("OKM1520", "okm_meta has no catalog hash.", withHttp(http, {
+        fix: {
+          summary: "Apply migrations so okm_meta records the catalog, or omit requireMeta to adopt this database."
+        }
+      }));
+    }
+  } else {
+    const { assertCompatible } = await import("./fb9k2qwd.js");
+    try {
+      await assertCompatible(pool, schema, recorded, source, options);
+    } catch (error) {
+      if (error instanceof OkmError)
+        throw attachHttp(http, error);
+      throw error;
+    }
+  }
+  const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
+  const raw = schema.requires?.postgres;
+  if (raw === undefined) {
+    if (major < POSTGRES_FLOOR) {
+      throw new OkmError("OKM1803", serverNeedsPostgres(major, POSTGRES_FLOOR), withHttp(http, {
+        fix: {
+          summary: `Upgrade to PostgreSQL ${String(POSTGRES_FLOOR)} or higher.`
+        }
+      }));
+    }
+    return;
+  }
+  const need = parsePostgresFloor(raw);
+  if (!isPostgresMajor(need) || major < need) {
+    throw new OkmError("OKM1802", serverNeedsPostgres(major, isPostgresMajor(need) ? need : POSTGRES_FLOOR), withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower minPostgres to a major the server meets." }
+    }));
+  }
+}
+export {
+  acceptServer,
+  versionQuery
+};

package/dist/tooling/shared/pwsytxm5.js

@@ -0,0 +1,17 @@
+import {
+  primaryUrl
+} from "./f9mphxej.js";
+
+// packages/harness/src/postgres.ts
+import postgres from "postgres";
+function openPostgres(url = primaryUrl()) {
+  return postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+}
+export {
+  openPostgres
+};

package/dist/tooling/shared/rf83gr2d.js

@@ -0,0 +1,94 @@
+import {
+  OkmError
+} from "./f9mphxej.js";
+
+// src/runtime/compat-words.ts
+var BEHIND_EXPAND = "behind by expand";
+var BEHIND_CONTRACT = "behind by contract";
+var AHEAD_CONTRACT = "ahead by contract";
+
+// src/runtime/drift-detail.ts
+function driftVerdict(codeHash, recordedHash, migrations) {
+  const codeAt = indexOfHash(migrations, codeHash);
+  const recordedAt = indexOfHash(migrations, recordedHash);
+  if (codeAt >= 0 && recordedAt >= codeAt) {
+    for (let index = codeAt + 1;index <= recordedAt; index += 1) {
+      const migration = migrations[index];
+      if (migration !== undefined && migration.expand !== true) {
+        return { state: "ahead by contract", migrationId: migration.id };
+      }
+    }
+    return { state: "ok" };
+  }
+  if (codeAt >= 0 && recordedAt >= 0 && recordedAt < codeAt) {
+    const next = migrations[recordedAt + 1];
+    if (next !== undefined) {
+      return {
+        state: next.expand ? "behind by expand" : "behind by contract",
+        migrationId: next.id
+      };
+    }
+  }
+  if (recordedAt >= 0) {
+    const at = migrations[recordedAt];
+    if (at !== undefined)
+      return { state: "behind", migrationId: at.id };
+  }
+  const last = migrations.at(-1);
+  return { state: "behind", migrationId: last?.id ?? "" };
+}
+async function assertDrift(pool, codeHash, recordedHash, options) {
+  let rows;
+  try {
+    const result = await pool.execute("select migration_id, class, catalog_hash from okm_history order by migration_id, step_index", undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    throw gapError({ state: "behind", migrationId: "" }, error);
+  }
+  const verdict = driftVerdict(codeHash, recordedHash, groupMigrations(rows));
+  if (verdict.state === "ok")
+    return;
+  throw gapError(verdict);
+}
+function indexOfHash(migrations, hash) {
+  let found = -1;
+  for (let index = 0;index < migrations.length; index += 1) {
+    if (migrations[index]?.catalogHash === hash)
+      found = index;
+  }
+  return found;
+}
+function groupMigrations(rows) {
+  const grouped = [];
+  for (const row of rows) {
+    const id = row[0];
+    const stepClass = row[1];
+    const hash = row[2];
+    if (id == null || stepClass == null || hash == null)
+      continue;
+    const expand = stepClass === "expand";
+    const last = grouped.at(-1);
+    if (last !== undefined && last.id === id) {
+      grouped[grouped.length - 1] = {
+        id,
+        catalogHash: hash,
+        expand: last.expand && expand
+      };
+      continue;
+    }
+    grouped.push({ id, catalogHash: hash, expand });
+  }
+  return grouped;
+}
+function gapError(verdict, cause) {
+  const named = verdict.migrationId;
+  const phrase = verdict.state === "ahead by contract" ? `${AHEAD_CONTRACT} migration ${named}` : verdict.state === "behind by expand" ? `${BEHIND_EXPAND} migration ${named}` : verdict.state === "behind by contract" ? `${BEHIND_CONTRACT} migration ${named}` : named.length > 0 ? `behind the app at migration ${named}` : "behind the app";
+  const fix = named.length > 0 ? `Apply ${named}, or change the deploy order.` : "Apply migrations, or change the deploy order.";
+  return new OkmError("OKM1520", `The database is ${phrase}.`, {
+    ...cause === undefined ? {} : { cause },
+    fix: { summary: fix }
+  });
+}
+export {
+  assertDrift
+};

package/dist/tooling/shared/rq5kk8j6.js

@@ -0,0 +1,401 @@
+import {
+  refuseUncancellableTimeout
+} from "./zhwnfyb2.js";
+import {
+  openClient,
+  withHttp,
+  settleCall
+} from "./mtrqn2hn.js";
+import {
+  OkmError,
+  isConnectionLost,
+  rejectKeys,
+  isRecord,
+  fail2
+} from "./f9mphxej.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/rs1jb051.js

@@ -0,0 +1,12 @@
+import {
+  rejectUncancellable
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/no-inflight-timeout.ts
+function noTimeout(options) {
+  if ((options?.timeout ?? 0) <= 0)
+    return;
+  return rejectUncancellable();
+}
+
+export { noTimeout };