okmodel 0.7.0 → 0.8.0

package/dist/tooling/shared/yk9mp7vb.js

@@ -0,0 +1,250 @@
+import {
+  stack2
+} from "./cmptmb4f.js";
+import {
+  updateSliceBody2,
+  rejectDuplicateTargets2,
+  emitSet2,
+  Sql2,
+  writeSet2,
+  rejectMixedSets2,
+  readClaim2,
+  rejectUpdateKeys2,
+  requireFilter2,
+  returningOption2,
+  expectOf2,
+  allowSet2,
+  noteGuarded2
+} from "./spk1jg3r.js";
+import"./3tq8pnb8.js";
+import {
+  emitWhere,
+  projectExpr,
+  quote,
+  isRecord,
+  fail2
+} from "./f9mphxej.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
+};

package/dist/tooling/shared/yw30vnq2.js

@@ -0,0 +1,139 @@
+import {
+  driverErrors,
+  rejectClosed,
+  nextTransactionDepth,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/session.ts
+function noticeBuffer() {
+  let notices;
+  return {
+    push(notice) {
+      const severity = notice.severity ?? "";
+      const message = notice.message ?? "";
+      const code = notice.code !== undefined && notice.code.length > 0 ? notice.code : undefined;
+      const entry = code === undefined ? { severity, message } : { severity, message, code };
+      (notices ??= []).push(entry);
+    },
+    start() {
+      return notices?.length ?? 0;
+    },
+    since(start) {
+      if (notices === undefined || notices.length === start)
+        return EMPTY_NOTICES;
+      return notices.slice(start);
+    }
+  };
+}
+
+class WireSession {
+  canCancel;
+  transactionDepth = 0;
+  local = new Set;
+  send;
+  notices;
+  isClosed;
+  onEnter;
+  onLeave;
+  shared;
+  constructor(send, notices, isClosed, canCancel, onEnter, onLeave, shared) {
+    this.send = send;
+    this.notices = notices;
+    this.isClosed = isClosed;
+    this.canCancel = canCancel;
+    this.onEnter = onEnter;
+    this.onLeave = onLeave;
+    this.shared = shared;
+  }
+  query(text, params, watch) {
+    if (this.isClosed())
+      return rejectClosed();
+    const start = this.notices.start();
+    this.onEnter();
+    const pending = this.send(text, params);
+    if (watch === undefined) {
+      return pending.then((result) => {
+        this.onLeave();
+        this.note(text);
+        return resultFrom(result, this.notices.since(start));
+      }, (error) => {
+        this.onLeave();
+        return driverErrors().then((errors) => Promise.reject(errors.mapDriverError(stampQuery(error, text))));
+      });
+    }
+    return this.watched(pending, watch, start, text);
+  }
+  inTransaction() {
+    return this.transactionDepth > 0;
+  }
+  abandon() {
+    this.transactionDepth = 0;
+  }
+  depth() {
+    return this.transactionDepth;
+  }
+  cancel() {
+    for (const pending of this.local)
+      pending.cancel?.();
+  }
+  note(text) {
+    this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
+  }
+  track(pending) {
+    this.local.add(pending);
+    this.shared?.add(pending);
+  }
+  untrack(pending) {
+    this.local.delete(pending);
+    this.shared?.delete(pending);
+  }
+  watched(pending, watch, start, text) {
+    this.track(pending);
+    const onAbort = () => {
+      pending.cancel?.();
+    };
+    if (watch.signal.aborted)
+      onAbort();
+    else
+      watch.signal.addEventListener("abort", onAbort, { once: true });
+    return pending.then((result) => {
+      this.finishWatched(pending, watch, onAbort);
+      const why = watch.reason();
+      if (why === "timeout" || why === "cancelled")
+        return classify(why, watch);
+      this.note(text);
+      return resultFrom(result, this.notices.since(start));
+    }, (error) => {
+      this.finishWatched(pending, watch, onAbort);
+      return classify(stampQuery(error, text), watch);
+    });
+  }
+  finishWatched(pending, watch, onAbort) {
+    this.onLeave();
+    this.untrack(pending);
+    watch.signal.removeEventListener("abort", onAbort);
+  }
+}
+function stampQuery(error, text) {
+  if (typeof error === "object" && error !== null && !("query" in error))
+    Reflect.set(error, "query", text);
+  return error;
+}
+async function classify(error, watch) {
+  const errors = await driverErrors();
+  if (error instanceof errors.DriverError)
+    return Promise.reject(error);
+  const why = typeof error === "string" ? error : watch.reason();
+  if (why === "timeout") {
+    return Promise.reject(errors.timedOut(typeof error === "string" ? undefined : error));
+  }
+  const code = errors.errorField(error, "code") ?? errors.errorField(error, "errno");
+  if (why === "cancelled" || code === "57014") {
+    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
+  }
+  return Promise.reject(errors.mapDriverError(error));
+}
+
+export { noticeBuffer, WireSession };