okmodel 0.1.0 → 0.2.1

package/dist/shared/g9f0zqce.js

@@ -0,0 +1,376 @@
+import {
+  isConnectionLost
+} from "./tbszx8mz.js";
+import {
+  openClient,
+  withHttp,
+  settleCall
+} from "./mxmcdsh5.js";
+import {
+  rejectKeys,
+  isRecord,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  OkmError2
+} from "./52szzakm.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 OkmError2("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 OkmError2("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) {
+  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).");
+    if (!isRecord(given))
+      fail("OKM1121", "tx options must be an object.");
+    rejectKeys(given, ["isolation", "retry", "signal", "timeout"], "tx");
+    const options = given;
+    check(options);
+    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 OkmError2 || !(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)) {
+    fail("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.");
+  }
+  if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
+    fail("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 OkmError2("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 OkmError2 ? 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 OkmError2("cancelled", "The transaction was cancelled.", { kind: "cancelled" });
+}
+function timedOut() {
+  return new OkmError2("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 OkmError2 && 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 OkmError2("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) {
+    fail("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;
+  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;
+      });
+      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) => guarded(() => frame.conn.execute(text, params, stoppable(frame, options)), false),
+    batch: (statements, options) => 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") {
+            fail("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)
+    fail("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)
+    return;
+  return {
+    ...options.signal !== undefined ? { signal: options.signal } : {},
+    ...options.timeout !== undefined ? { timeout: options.timeout } : {}
+  };
+}
+export {
+  tx
+};

package/dist/shared/ge03bfca.js

@@ -0,0 +1,64 @@
+import {
+  withHttp,
+  attachHttp
+} from "./mxmcdsh5.js";
+import {
+  OkmError2
+} from "./52szzakm.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("./r6nwkxnt.js")).checkSchema(schema);
+      break;
+    }
+  }
+  const version = rows[0]?.[1];
+  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
+    throw new OkmError2("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 OkmError2("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("./sfh4pk75.js");
+    try {
+      await assertCompatible(pool, schema, recorded, source, options);
+    } catch (error) {
+      if (error instanceof OkmError2)
+        throw attachHttp(http, error);
+      throw error;
+    }
+  }
+  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." }
+      }));
+    }
+    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." }
+    }));
+  }
+}
+export {
+  acceptServer,
+  versionQuery
+};

package/dist/shared/{79ggp945.js → jns2wx4t.js}

@@ -1,16 +1,24 @@
+import {
+  touchFields,
+  fieldSealed
+} from "./7m88x3e9.js";
 import {
   projectExpr,
   quote,
   list,
   isRecord,
+  registerFailFix,
   fail
-} from "./f5thc1s0.js";
+} from "./xrfnq5k8.js";
 import {
   throwNamed2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/runtime/conflict.ts
-function readConflict(table, value) {
+registerFailFix("OKM1104", "Set on to the columns of a unique constraint or the primary key.");
+registerFailFix("OKM1190", "Remove the guarded field. Input cannot set it.");
+var NO_ALLOW = new Set;
+function readConflict(table, value, allow = NO_ALLOW) {
   if (value === undefined || value === "error")
     return;
   if (value === "ignore")
@@ -33,7 +41,7 @@ function readConflict(table, value) {
     return {
       kind: "update",
       columns: uniqueColumns(table, value.on),
-      update: updateColumns(table, update)
+      update: updateColumns(table, update, allow)
     };
   }
   fail("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
@@ -44,9 +52,17 @@ function finishInsert(head, returning, params, plan, table, returningColumns, ke
   }
   const target = plan.columns.map((column) => quote(column.sql)).join(", ");
   if (plan.kind === "update") {
-    const set = plan.update.map((column) => `${quote(column.sql)} = excluded.${quote(column.sql)}`).join(", ");
+    const assignments = plan.update.map((column) => `${quote(column.sql)} = excluded.${quote(column.sql)}`);
+    const touch = touchFields(table.model);
+    if (touch !== undefined) {
+      for (const field of touch) {
+        const column = table.columns.get(field);
+        if (column !== undefined)
+          assignments.push(`${quote(column.sql)} = now()`);
+      }
+    }
     return {
-      text: `${head} on conflict (${target}) do update set ${set}${returning}`,
+      text: `${head} on conflict (${target})${conflictWhere(table, plan.columns)} do update set ${assignments.join(", ")}${returning}`,
       params: [...params]
     };
   }
@@ -71,9 +87,29 @@ function firstOrCreate(head, returning, params, keys, table, returningColumns, k
   const names = returningColumns.map((column) => quote(column.field)).join(", ");
   const fromTable = returningColumns.map((column) => projectExpr(`t.${quote(column.sql)}`, column.dataType)).join(", ");
   const match = keys.map((column) => `ins.${quote(column.field)} = t.${quote(column.sql)}`).join(" and ");
-  const text = `with ins(${names}) as (${head} on conflict (${keyList}) do nothing${returning}) select ${names} from ins union all select ${fromTable} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")}) and not exists (select 1 from ins where ${match})`;
+  const text = `with ins(${names}) as (${head} on conflict (${keyList})${conflictWhere(table, keys)} do nothing${returning}) select ${names} from ins union all select ${fromTable} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")}) and not exists (select 1 from ins where ${match})`;
   return { text, params: next };
 }
+function conflictWhere(table, columns) {
+  const archive = table.model.archive;
+  if (archive === undefined || samePrimary(table, columns))
+    return "";
+  return ` where ${quote(archive.at)} is null`;
+}
+function samePrimary(table, columns) {
+  const primary = table.model.primary;
+  if (columns.length !== primary.length)
+    return false;
+  for (const field of primary) {
+    let found = false;
+    for (const column of columns)
+      if (column.field === field)
+        found = true;
+    if (!found)
+      return false;
+  }
+  return true;
+}
 function uniqueColumns(table, on) {
   const names = conflictNames(on);
   for (const unique of table.model.uniques) {
@@ -92,7 +128,7 @@ function uniqueColumns(table, on) {
   const accepted = table.model.uniques.map((fields) => fields.join(", "));
   throwNamed2("OKM1104", names.join(", "), accepted, `onConflict on ${table.model.name} names ${names.join(", ")}, which is not a unique constraint. Accepted: ${list(accepted)}.`);
 }
-function updateColumns(table, value) {
+function updateColumns(table, value, allow) {
   if (!Array.isArray(value) || value.length === 0) {
     fail("OKM1120", "onConflict update must name at least one column.");
   }
@@ -104,8 +140,9 @@ function updateColumns(table, value) {
     if (column === undefined) {
       throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
     }
-    if (!column.writable)
-      refuseWrite(table.model.name, column);
+    if (fieldSealed(table.model, name) || column.guardUpdate || !column.writable && !(column.guarded && allow.has(name))) {
+      refuseWrite(table, column);
+    }
     columns.push(column);
   }
   return columns;
@@ -137,10 +174,16 @@ function rejectConflictKeys(keys, accepted) {
   }
 }
 function refuseWrite(table, column) {
+  if (fieldSealed(table.model, column.field)) {
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
+  }
+  if (column.guardUpdate) {
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
+  }
   if (column.guarded) {
-    fail("OKM1190", `Field ${table}.${column.field} is guarded. Input cannot set it.`);
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
   }
-  fail("OKM1120", `Field ${table}.${column.field} cannot be written.`);
+  fail("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
 }
 export {
   finishInsert,

package/dist/shared/k3ted12y.js

@@ -0,0 +1,33 @@
+// src/adapters/pg/watch.ts
+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;
+    }
+  };
+}
+export {
+  openWatch
+};

package/dist/shared/k7dwkhvq.js

@@ -0,0 +1,31 @@
+// src/contracts/location.ts
+function callerLocation(skip) {
+  const lines = new Error().stack?.split(`
+`);
+  if (lines === undefined)
+    return;
+  let left = skip;
+  for (const line of lines) {
+    const slash = line.lastIndexOf("/");
+    if (slash < 0)
+      continue;
+    const tail = line.slice(slash + 1);
+    const colon = tail.indexOf(":");
+    if (colon < 1 || tail.startsWith("location."))
+      continue;
+    if (left > 0) {
+      left -= 1;
+      continue;
+    }
+    const end = tail.indexOf(":", colon + 1);
+    if (end < 0)
+      return;
+    return `${tail.slice(0, colon)}:${tail.slice(colon + 1, end)}`;
+  }
+  return;
+}
+function withLocation(message, source) {
+  return source === undefined ? message : `${message} (${source})`;
+}
+
+export { callerLocation, withLocation };

package/dist/shared/{hd293j9g.js → kyxb62mc.js}

@@ -1,6 +1,6 @@
 import {
   OkmError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/adapters/error.ts
 class DriverError2 extends Error {
@@ -57,6 +57,18 @@ function errorField2(error, key) {
   const value = Reflect.get(error, key);
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+function sqlstateOf(error) {
+  const code = errorField2(error, "code");
+  if (isSqlstate(code))
+    return code;
+  const errno = errorField2(error, "errno");
+  if (isSqlstate(errno))
+    return errno;
+  return errorField2(error, "sqlstate");
+}
+function isSqlstate(value) {
+  return value !== undefined && /^[0-9A-Z]{5}$/.test(value);
+}
 function mapDriverError2(error, batchIndex) {
   if (error instanceof OkmError2)
     return error;
@@ -65,7 +77,7 @@ function mapDriverError2(error, batchIndex) {
   }
   const message = error instanceof Error ? error.message : "driver error";
   return new DriverError2(message, driverFields({
-    sqlstate: errorField2(error, "code") ?? errorField2(error, "sqlstate"),
+    sqlstate: sqlstateOf(error),
     constraint: errorField2(error, "constraint_name") ?? errorField2(error, "constraint"),
     table: errorField2(error, "table_name") ?? errorField2(error, "table"),
     column: errorField2(error, "column_name") ?? errorField2(error, "column"),