okmodel 0.7.0 → 0.8.0

package/dist/tooling/shared/tn8gay14.js

@@ -0,0 +1,143 @@
+import {
+  DriverError2,
+  isConnectionLost
+} from "./f9mphxej.js";
+import {
+  armDriverError2,
+  send3,
+  connectClient2
+} from "./417zdsk7.js";
+import {
+  resetSession2
+} from "./4d2w25vw.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  WireSession
+} from "./yw30vnq2.js";
+import {
+  rejectClosed,
+  runCall
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/nodepostgres-extra.ts
+async function checkout(held) {
+  const { pool, counters, named, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const client = await connectClient2(pool, held.acquireMs, counters);
+  counters.reserved += 1;
+  let lost = false;
+  const onError = () => {
+    lost = true;
+  };
+  const events = client;
+  events.on("error", onError);
+  const local = new Set;
+  const session = new WireSession((text, params) => {
+    const pending = send3(client, text, params, named, client);
+    const guarded = pending.catch((error) => {
+      if (isConnectionLost(error) || lost) {
+        lost = true;
+        if (isConnectionLost(error))
+          throw error;
+        throw Object.assign(new DriverError2("CONNECTION_CLOSED", { cause: error }), {
+          code: "CONNECTION_CLOSED"
+        });
+      }
+      throw error;
+    });
+    guarded.cancel = () => {
+      pending.cancel?.();
+    };
+    return guarded;
+  }, held.notices, isClosed, true, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  }, local);
+  const guard = (run) => lost ? rejectClosed() : run();
+  let released = false;
+  return {
+    execute: (text, params, options) => guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch))),
+    batch: (statements, options) => guard(() => runCall(isClosed(), options, async (watch) => {
+      const { runAtomicBatch } = await import("./3rrw5w8f.js");
+      return runAtomicBatch(session, statements, watch);
+    })),
+    cancel() {
+      session.cancel();
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      try {
+        if (!lost)
+          await reset(session, client);
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        events.removeListener("error", onError);
+        client.release(lost);
+      }
+    }
+  };
+}
+async function reset(session, client) {
+  await resetSession2(session.depth(), (text) => client.query(text));
+}
+async function listen(held, channel, onNotify) {
+  const { pool, counters } = held;
+  const client = await connectClient2(pool, held.acquireMs, counters);
+  counters.reserved += 1;
+  const quoted = quoteIdent(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));
+  };
+  armDriverError2(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 streamRows(checkout, text, params) {
+  return async function* () {
+    const connection = await checkout();
+    try {
+      yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+    } finally {
+      await connection.release();
+    }
+  }();
+}
+function quoteIdent(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+export {
+  checkout,
+  listen,
+  streamRows
+};

package/dist/tooling/shared/vraj6d74.js

@@ -0,0 +1,42 @@
+import {
+  open3
+} from "./p7f08ktn.js";
+import {
+  createClient
+} from "./mtrqn2hn.js";
+
+// src/runtime/pg/postgresjs.ts
+function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("./2wtvc7rw.js").then((mod) => mod.default(target, options, open3));
+  }
+  const owned = !isPool(target);
+  const pool = isPool(target) ? target : open3({
+    url: target,
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {},
+    ...options.ssl !== undefined ? { ssl: options.ssl } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: owned,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    requireMeta: options.requireMeta,
+    generators: options.generators
+  });
+}
+function isPool(target) {
+  return typeof target === "object" && "execute" in target && "capabilities" in target;
+}
+export {
+  connect
+};

package/dist/tooling/shared/vs0t6qt8.js

@@ -0,0 +1,64 @@
+import {
+  decodeRows,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./mtrqn2hn.js";
+import {
+  OkmError,
+  throwNamed,
+  fail2
+} from "./f9mphxej.js";
+
+// src/runtime/lock.ts
+var LOCKS = ["update", "share"];
+var WAITS = ["nowait", "skip"];
+function shown(value) {
+  return typeof value === "string" ? value : JSON.stringify(value) ?? "undefined";
+}
+function build(session, table, options, mods, view) {
+  try {
+    return plan(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError ? attachHttp(session.http, error) : error;
+  }
+}
+function plan(session, table, options, mods, view) {
+  const { lock, wait, ...rest } = options;
+  const forced = session.pool.forcedRoute;
+  if (rest.route === "replica" || forced === "replica") {
+    throw new OkmError("OKM1840", "A locking read needs the primary.", {
+      fix: {
+        summary: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
+      }
+    });
+  }
+  if (lock === "skip") {
+    fail2("OKM1120", 'lock: "skip" claims rows on update. A read uses lock: "update" and wait: "skip".', 'Pass lock: "update" and wait: "skip" inside tx(). An update can claim rows on its own.');
+  }
+  if (session.tx === undefined) {
+    throw new OkmError("OKM1830", "A row lock needs a transaction. find was called outside tx().", {
+      fix: { summary: "Move the find into tx(): the lock lasts until the transaction ends." }
+    });
+  }
+  if (lock === undefined)
+    fail2("OKM1121", "wait needs lock: pass lock: update or lock: share.");
+  if (typeof lock !== "string" || !LOCKS.includes(lock)) {
+    throwNamed("OKM1120", shown(lock), LOCKS, `lock must be one of: ${LOCKS.join(", ")}.`);
+  }
+  if (wait !== undefined && (typeof wait !== "string" || !WAITS.includes(wait))) {
+    throwNamed("OKM1120", shown(wait), WAITS, `wait must be one of: ${WAITS.join(", ")}.`);
+  }
+  const clause = ` for ${lock} of t${wait === undefined ? "" : wait === "skip" ? " skip locked" : " nowait"}`;
+  const call = {
+    ...readCall("find", table, rest, mods.all, session.scope, session.schema.model[table], session.schema, view),
+    tail(sink) {
+      sink.text(clause);
+      sink.mark(`lock:${clause}`);
+    }
+  };
+  return readHandle(session, table, call, mods, (compiled, rows) => decodeRows(compiled, rows, table));
+}
+export {
+  build
+};

package/dist/tooling/shared/vx86qjv8.js

@@ -0,0 +1,150 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  refuseUncancellableTimeout
+} from "./zhwnfyb2.js";
+import {
+  withHttp,
+  settleCall
+} from "./mtrqn2hn.js";
+import {
+  OkmError,
+  rejectKeys,
+  isRecord,
+  fail2
+} from "./f9mphxej.js";
+
+// src/runtime/batch.ts
+async function batch(session, ops, options, replica) {
+  try {
+    if (replica !== undefined) {
+      throw new OkmError("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 OkmError("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/tooling/shared/w7qe8sj1.js

@@ -0,0 +1,140 @@
+import {
+  quote,
+  fail2
+} from "./f9mphxej.js";
+
+// src/runtime/sort.ts
+function insertAtEnd(table, columns, rows, group, tenantFields) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const tenants = tenantColumns(table, tenantFields);
+  const planned = [];
+  const countOf = new Map;
+  const firstOf = new Map;
+  for (const row of rows) {
+    if (groupColumn !== undefined && !Object.hasOwn(row, groupColumn.field)) {
+      fail2("OKM1121", `insert on ${table.model.name} needs ${groupColumn.field} so position has a group.`, "Pass the group on the row. Position is assigned for you.");
+    }
+    const key = lockText(table.model.sql, wires(tenants, row), groupColumn === undefined ? null : cellWire(groupColumn, row[groupColumn.field]));
+    if (!firstOf.has(key))
+      firstOf.set(key, row);
+    const n = (countOf.get(key) ?? 0) + 1;
+    countOf.set(key, n);
+    planned.push({ key, n, row });
+  }
+  const params = [];
+  const bind = (wire, dataType) => {
+    params.push(wire);
+    return `$${String(params.length)}::${dataType}`;
+  };
+  const slotOf = new Map;
+  for (const key of firstOf.keys())
+    slotOf.set(key, bind(key, "text"));
+  const baseRows = [];
+  for (const [key, row] of firstOf) {
+    const parts = [slotOf.get(key) ?? bind(key, "text")];
+    if (groupColumn !== undefined)
+      parts.push(bind(cellWire(groupColumn, row[groupColumn.field]), groupColumn.dataType));
+    for (const column of tenants)
+      parts.push(bind(cellWire(column, row[column.field]), column.dataType));
+    baseRows.push(`(${parts.join(", ")})`);
+  }
+  const baseNames = ["okm_lock"];
+  if (groupColumn !== undefined)
+    baseNames.push("okm_g");
+  for (let index = 0;index < tenants.length; index += 1)
+    baseNames.push(`okm_t${String(index)}`);
+  const lists = planned.map((item) => {
+    const slot = slotOf.get(item.key) ?? bind(item.key, "text");
+    const slots = columns.map((column) => cell(column, item.row[column.field], bind));
+    slots.push(`((select b.pos from base b where b.okm_lock = ${slot}) + ${String(item.n)})::integer`);
+    return `(${slots.join(", ")})`;
+  });
+  const insertColumns = [...columns.map((column) => quote(column.sql)), quote(position.sql)];
+  const text = [
+    "with base as (",
+    "select i.okm_lock, coalesce(max(t.",
+    quote(position.sql),
+    "), 0) as pos from (values ",
+    baseRows.join(", "),
+    ") as i(",
+    baseNames.join(", "),
+    ") left join ",
+    quote(table.model.sql),
+    " as t on ",
+    joinOn(groupColumn, tenants),
+    " group by i.okm_lock",
+    ") insert into ",
+    quote(table.model.sql),
+    " (",
+    insertColumns.join(", "),
+    ") values ",
+    lists.join(", ")
+  ].join("");
+  return { lock: groupLock([...firstOf.keys()]), text, params };
+}
+function joinOn(group, tenants) {
+  const parts = [];
+  if (group !== undefined)
+    parts.push(`t.${quote(group.sql)} is not distinct from i.okm_g`);
+  for (let index = 0;index < tenants.length; index += 1) {
+    const column = tenants[index];
+    if (column === undefined)
+      continue;
+    parts.push(`t.${quote(column.sql)} is not distinct from i.okm_t${String(index)}`);
+  }
+  return parts.length === 0 ? "true" : parts.join(" and ");
+}
+function lockText(sqlName, tenants, group) {
+  return JSON.stringify([sqlName, tenants, group]);
+}
+function groupLock(keys) {
+  const ordered = [...keys].sort(compareText);
+  const values = ordered.map((_, index) => `($${String(index + 1)}::text)`).join(", ");
+  return {
+    text: `select pg_advisory_xact_lock(hashtextextended(k.okm_lock, 0::bigint)) from (select v.okm_lock from (values ${values}) as v(okm_lock) order by v.okm_lock) as k`,
+    params: ordered
+  };
+}
+function compareText(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function wires(columns, row) {
+  return columns.map((column) => cellWire(column, row[column.field]));
+}
+function cellWire(column, value) {
+  if (value === undefined || value === null)
+    return null;
+  return column.encode(value);
+}
+function cell(column, value, bind) {
+  if (value === undefined)
+    return "default";
+  if (value === null)
+    return bind(null, column.dataType);
+  return bind(column.encode(value), column.dataType);
+}
+function tenantColumns(table, fields) {
+  if (fields === undefined)
+    return [];
+  const columns = [];
+  for (const field of fields) {
+    const column = table.columns.get(field);
+    if (column !== undefined)
+      columns.push(column);
+  }
+  return columns;
+}
+function requiredColumn(table, field) {
+  const column = table.columns.get(field);
+  if (column === undefined)
+    fail2("OKM1120", `Table ${table.model.name} has no column ${field}.`);
+  return column;
+}
+export {
+  insertAtEnd
+};

package/dist/tooling/shared/wt7j7nf6.js

@@ -0,0 +1,15 @@
+import {
+  OkmError
+} from "./f9mphxej.js";
+
+// src/runtime/validate/closed.ts
+var VALIDATION_NOT_IMPORTED = "Validation is enabled but `okmodel/validate` was not imported.";
+var VALIDATION_NOT_IMPORTED_FIX = 'Import "okmodel/validate" before schema().';
+function refuseMissingValidation() {
+  throw new OkmError("OKM1201", VALIDATION_NOT_IMPORTED, {
+    fix: { summary: VALIDATION_NOT_IMPORTED_FIX }
+  });
+}
+export {
+  refuseMissingValidation
+};

package/dist/tooling/shared/wwnekq5n.js

@@ -0,0 +1,6 @@
+import {
+  stack2
+} from "./cmptmb4f.js";
+export {
+  stack2 as stack
+};