okmodel 0.5.1 → 0.7.0

package/dist/shared/9y3mmmh1.js

@@ -0,0 +1,436 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  withRowFilters,
+  emitWhere,
+  indexes,
+  quote,
+  isRecord,
+  fail2
+} from "./67txcrcw.js";
+import {
+  OkmError2
+} from "./52szzakm.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 };
+}
+async function move(host, tableName, id, place, view) {
+  await host.connected;
+  const table = indexes(host.schema).get(tableName);
+  if (table === undefined)
+    fail2("OKM1120", `Table ${tableName} is not in the schema.`);
+  const group = groupField(table);
+  if (!sortable(table)) {
+    fail2("OKM1120", `move on ${tableName} needs sortable().`, "Add sortable() from okmodel/traits.");
+  }
+  const anchor = readPlace(place, tableName);
+  const key = moveColumn(host.schema, table);
+  if (sameId(id, anchor.id)) {
+    const current = await readOne(host, table, key, id, group, view);
+    if (current === undefined)
+      missing(tableName, id);
+    return { position: current.position };
+  }
+  const moved = await readOne(host, table, key, id, group, view);
+  if (moved === undefined)
+    missing(tableName, id);
+  const other = await readOne(host, table, key, anchor.id, group, view);
+  if (other === undefined)
+    missing(tableName, anchor.id);
+  if (moved.groupWire !== other.groupWire) {
+    const which = group ?? "group";
+    throw new OkmError2("OKM1120", `move on ${tableName} cannot place ${show(id)} ${anchor.side} ${show(anchor.id)}. ${show(anchor.id)} is in another ${which}.`, { fix: { summary: `Choose an anchor in the same ${which}.` } });
+  }
+  const statements = withRowFilters(host.scope, view, () => moveStatements(host.schema, table, key, id, anchor.id, moved, anchor.side, group));
+  const results = await runWrite(host, statements, callOptions(host));
+  const row = results[1]?.rows[0];
+  if (count(row?.[0]) !== 1)
+    missing(tableName, id);
+  if (count(row?.[1]) !== 1)
+    missing(tableName, anchor.id);
+  return { position: count(row?.[2]) };
+}
+function sortable(table) {
+  const traits = table.model.traits;
+  if (traits === undefined)
+    return false;
+  for (const trait of traits)
+    if (trait.name === "sortable")
+      return true;
+  return false;
+}
+function groupField(table) {
+  const traits = table.model.traits;
+  if (traits === undefined)
+    return;
+  for (const trait of traits) {
+    if (trait.name !== "sortable")
+      continue;
+    const group = trait.group;
+    return typeof group === "string" ? group : undefined;
+  }
+  return;
+}
+function readPlace(place, table) {
+  if (!isRecord(place))
+    fail2("OKM1120", `move on ${table} needs { before } or { after }.`);
+  const before = Object.hasOwn(place, "before");
+  const after = Object.hasOwn(place, "after");
+  if (before === after) {
+    fail2("OKM1120", `move on ${table} needs before or after, not both.`, "Pass one anchor.");
+  }
+  for (const key of Object.keys(place)) {
+    if (key === "before" || key === "after")
+      continue;
+    fail2("OKM1120", `move on ${table} does not accept ${key}. Accepted options: before, after.`);
+  }
+  return { side: before ? "before" : "after", id: before ? place.before : place.after };
+}
+function moveColumn(schema, table) {
+  const tenants = new Set(tenantFieldNames(schema.tenancy, table));
+  const fields = table.model.primary.filter((field) => !tenants.has(field));
+  if (fields.length !== 1) {
+    fail2("OKM1120", `move on ${table.model.name} needs one primary key column besides the tenant key.`);
+  }
+  return requiredColumn(table, fields[0] ?? "");
+}
+function tenantFieldNames(tenancy, table) {
+  if (tenancy === undefined)
+    return [];
+  const keys = tenancy.keys ?? [tenancy.key];
+  return keys.filter((key) => table.columns.has(key));
+}
+async function readOne(host, table, key, id, group, view) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const tenants = tenantColumns(table, tenantFieldNames(host.schema.tenancy, table));
+  const statement = withRowFilters(host.scope, view, () => {
+    const parts = [];
+    const params = [];
+    parts.push("select ");
+    parts.push(quote(position.sql));
+    if (groupColumn !== undefined) {
+      parts.push(", ");
+      parts.push(quote(groupColumn.sql));
+    }
+    for (const column of tenants) {
+      parts.push(", ");
+      parts.push(quote(column.sql));
+    }
+    parts.push(" from ");
+    parts.push(quote(table.model.sql));
+    parts.push(" as t where t.");
+    parts.push(quote(key.sql));
+    parts.push(" = $1::");
+    parts.push(key.dataType);
+    params.push(key.encode(id));
+    emitWhere(host.schema, table, undefined, sink(parts, params), "t", 0, true);
+    return { text: parts.join(""), params };
+  });
+  const result = await host.pool.execute(statement.text, statement.params, callOptions(host));
+  const found = result.rows[0];
+  if (found === undefined)
+    return;
+  let at = 1;
+  const groupWire = groupColumn === undefined ? null : decodeWire(groupColumn, found[at]);
+  if (groupColumn !== undefined)
+    at += 1;
+  const tenantWires = [];
+  for (const column of tenants) {
+    tenantWires.push(decodeWire(column, found[at]));
+    at += 1;
+  }
+  return { position: count(found[0]), groupWire, tenants: tenantWires };
+}
+function moveStatements(schema, table, key, id, anchor, moved, side, group) {
+  const lock = groupLock([lockText(table.model.sql, moved.tenants, moved.groupWire)]);
+  const place = moveStatement(schema, table, key, id, anchor, moved, side, group);
+  const tenants = tenantColumns(table, tenantFieldNames(schema.tenancy, table));
+  return [lock, place, flipStatement(table, moved, group, tenants)];
+}
+function moveStatement(schema, table, key, id, anchor, moved, side, group) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const tenants = tenantColumns(table, tenantFieldNames(schema.tenancy, table));
+  const params = [];
+  const bind = (wire, dataType) => {
+    params.push(wire);
+    return `$${String(params.length)}::${dataType}`;
+  };
+  const groupSlot = groupColumn === undefined ? "" : bind(moved.groupWire, groupColumn.dataType);
+  const tenantSlots = tenants.map((column, index) => bind(moved.tenants[index] ?? null, column.dataType));
+  const movedSlot = bind(key.encode(id), key.dataType);
+  const anchorSlot = bind(key.encode(anchor), key.dataType);
+  const delta = bind(side === "before" ? "-0.5" : "0.5", "numeric");
+  const parts = [];
+  parts.push("with members as (select t.ctid as tid, t.tableoid as toid, t.");
+  parts.push(quote(position.sql));
+  parts.push(" as pos, t.");
+  parts.push(quote(key.sql));
+  parts.push(" as ident from ");
+  parts.push(quote(table.model.sql));
+  parts.push(" as t");
+  let filtered = false;
+  if (groupColumn !== undefined) {
+    parts.push(" where t.");
+    parts.push(quote(groupColumn.sql));
+    parts.push(" is not distinct from ");
+    parts.push(groupSlot);
+    filtered = true;
+  }
+  for (let index = 0;index < tenants.length; index += 1) {
+    const column = tenants[index];
+    if (column === undefined)
+      continue;
+    parts.push(filtered ? " and t." : " where t.");
+    parts.push(quote(column.sql));
+    parts.push(" is not distinct from ");
+    parts.push(tenantSlots[index] ?? "null");
+    filtered = true;
+  }
+  emitWhere(schema, table, undefined, sink(parts, params), "t", 0, filtered);
+  parts.push(" for update of t), numbered as (select ident, pos, tid, toid, row_number() over (order by pos, ident) as ord from members), placed as (select ident, pos, tid, toid, row_number() over (order by case when ident = ");
+  parts.push(movedSlot);
+  parts.push(" then (select ord from numbered where ident = ");
+  parts.push(anchorSlot);
+  parts.push(") + ");
+  parts.push(delta);
+  parts.push(" else ord end, case when ident = ");
+  parts.push(movedSlot);
+  parts.push(" then 0 else 1 end) as new_pos from numbered where (select count(*) from numbered where ident = ");
+  parts.push(movedSlot);
+  parts.push(") = 1 and (select count(*) from numbered where ident = ");
+  parts.push(anchorSlot);
+  parts.push(") = 1), changed as (update ");
+  parts.push(quote(table.model.sql));
+  parts.push(" as t set ");
+  parts.push(quote(position.sql));
+  parts.push(" = (-p.new_pos)::integer from placed as p where t.ctid = p.tid and t.tableoid = p.toid returning t.ctid) select (select count(*)::int from numbered where ident = ");
+  parts.push(movedSlot);
+  parts.push("), (select count(*)::int from numbered where ident = ");
+  parts.push(anchorSlot);
+  parts.push("), coalesce((select new_pos::int from placed where ident = ");
+  parts.push(movedSlot);
+  parts.push("), 0), (select count(*)::int from changed)");
+  return { text: parts.join(""), ...params.length > 0 ? { params } : {} };
+}
+function flipStatement(table, moved, group, tenants) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const params = [];
+  const bind = (wire, dataType) => {
+    params.push(wire);
+    return `$${String(params.length)}::${dataType}`;
+  };
+  const parts = [
+    "update ",
+    quote(table.model.sql),
+    " as t set ",
+    quote(position.sql),
+    " = (-t.",
+    quote(position.sql),
+    ")::integer where t.",
+    quote(position.sql),
+    " < 0"
+  ];
+  if (groupColumn !== undefined) {
+    parts.push(" and t.");
+    parts.push(quote(groupColumn.sql));
+    parts.push(" is not distinct from ");
+    parts.push(bind(moved.groupWire, groupColumn.dataType));
+  }
+  for (let index = 0;index < tenants.length; index += 1) {
+    const column = tenants[index];
+    if (column === undefined)
+      continue;
+    parts.push(" and t.");
+    parts.push(quote(column.sql));
+    parts.push(" is not distinct from ");
+    parts.push(bind(moved.tenants[index] ?? null, column.dataType));
+  }
+  return { text: parts.join(""), ...params.length > 0 ? { 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 decodeWire(column, value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string") {
+    const decode = column.decode;
+    return column.encode(decode === undefined ? value : decode(value));
+  }
+  return column.encode(value);
+}
+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;
+}
+function missing(table, id) {
+  throw new OkmError2("not_found", `move on ${table} could not find ${show(id)}.`, {
+    kind: "not_found",
+    table,
+    fix: { summary: "Pass the id of a row in this table." }
+  });
+}
+function show(id) {
+  if (typeof id === "string" || typeof id === "number")
+    return String(id);
+  return "that id";
+}
+function sameId(left, right) {
+  return left === right;
+}
+function count(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "bigint")
+    return Number(value);
+  if (typeof value === "string" && value.length > 0)
+    return Number(value);
+  return 0;
+}
+function sink(parts, params) {
+  return {
+    text(value) {
+      parts.push(value);
+    },
+    param(encoded) {
+      params.push(encoded);
+      parts.push(`$${String(params.length)}`);
+    },
+    mark() {}
+  };
+}
+function callOptions(host) {
+  const limit = host.timeouts?.statement;
+  return limit === undefined ? undefined : { timeout: limit };
+}
+export {
+  insertAtEnd,
+  move
+};

package/dist/shared/ab9gmbwy.js

@@ -0,0 +1,213 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  send2,
+  reserve,
+  park
+} from "./x933k9a3.js";
+import {
+  resetSession2,
+  refuseWhenLost2
+} from "./zm0ptry0.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  isConnectionFailure
+} from "./cnkky55j.js";
+import {
+  noTimeout
+} from "./79dt02vc.js";
+import {
+  WireSession
+} from "./1qa0qajz.js";
+import {
+  rejectClosed,
+  runCall
+} from "./kb2sdhfb.js";
+
+// src/adapters/pg/bunsql-extra.ts
+async function recover(sql, error, text, depth, clientRead, closedDuring, again) {
+  if (!lostQuery(error))
+    throw error;
+  await flushClosed(sql);
+  const alreadyDead = closedDuring || socketClosed(error);
+  if (!clientRead && !alreadyDead || depth !== 0 || !readStatement(text))
+    throw error;
+  try {
+    return await again();
+  } catch (next) {
+    if (lostQuery(next))
+      await flushClosed(sql);
+    throw next;
+  }
+}
+function drainClosed(sql) {
+  return flushClosed(sql).then(() => {
+    return;
+  });
+}
+function readStatement(text) {
+  const head = text.trimStart().toLowerCase().replace(/\s+/g, " ");
+  if (head.length === 0 || head.includes("pg_advisory"))
+    return false;
+  if (/\sfor (?:no key update|key share|update|share)\b/.test(head))
+    return false;
+  return !/^(?:insert|update|delete|refresh|with|create|alter|drop|truncate|grant|revoke|comment|vacuum|analyze|reindex|copy|begin|start|commit|rollback|savepoint|release|set|reset)\b/.test(head);
+}
+function lostQuery(error) {
+  return isConnectionFailure(error) || socketClosed(error);
+}
+function socketClosed(error) {
+  if (!(error instanceof Error))
+    return false;
+  if (error.message === "Connection closed")
+    return true;
+  return error.cause instanceof Error && error.cause.message === "Connection closed";
+}
+async function listen(sql, parked, closed, channel, onNotify) {
+  if (closed)
+    return rejectClosed();
+  const pending = parked.splice(0);
+  for (const reserved of pending) {
+    const done = reserved.release();
+    if (done instanceof Promise)
+      await done;
+  }
+  const subscription = await sql.listen(channel, onNotify);
+  return async () => {
+    await subscription.unlisten();
+  };
+}
+async function checkout(held) {
+  const { counters, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const reserved = await takeOpen(held) ?? await reserve(held.sql, held.acquireMs, counters);
+  counters.reserved += 1;
+  const session = new WireSession((text, params) => send2(reserved, text, params), held.notices, isClosed, false, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  });
+  let lost = { on: false };
+  const opened = held.closures();
+  const reconnected = () => {
+    if (held.closures() === opened)
+      return;
+    lost.on = true;
+    return Promise.reject(new DriverError2("Connection closed", { sqlstate: "08006" }));
+  };
+  const guard = (run) => refuseWhenLost2(lost, () => run().catch((error) => {
+    if (error instanceof Error && bunClosed(error.message)) {
+      throw new DriverError2(error.message, { cause: error, sqlstate: "08006" });
+    }
+    throw error;
+  }));
+  let released = false;
+  return {
+    execute: (text, params, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const gone = reconnected();
+      if (gone !== undefined)
+        return gone;
+      return guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const gone = reconnected();
+      if (gone !== undefined)
+        return gone;
+      return guard(() => runCall(isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./b76b8d95.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
+    evict() {
+      lost.on = true;
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      if (!lost.on && reportsClosed(reserved))
+        lost.on = true;
+      try {
+        if (!lost.on)
+          await reset(session, reserved);
+      } catch (error) {
+        if (lostQuery(error) || reportsClosed(reserved))
+          lost.on = true;
+        else
+          throw error;
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        if (lost.on) {
+          try {
+            reserved.release();
+          } catch {}
+          await flushClosed(held.sql);
+        } else
+          await park(held.parked, reserved);
+      }
+    }
+  };
+}
+function reportsClosed(reserved) {
+  return Reflect.get(reserved, "closed") === true;
+}
+async function takeOpen(held) {
+  while (held.parked.length > 0) {
+    const next = held.parked.pop();
+    if (next === undefined)
+      return;
+    if (!reportsClosed(next))
+      return next;
+    try {
+      next.release();
+    } catch {}
+    await flushClosed(held.sql);
+  }
+  return;
+}
+async function flushClosed(sql) {
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    try {
+      await sql.unsafe("select 1");
+      return true;
+    } catch {}
+  }
+  return false;
+}
+function bunClosed(message) {
+  return message === "Connection closed" || message === "connection must be a PostgresSQLConnection";
+}
+async function reset(session, sql) {
+  const run = (text) => sql.unsafe(text);
+  await resetSession2(session.depth(), run);
+}
+function streamRows(checkout, text, params) {
+  return async function* () {
+    const connection = await checkout();
+    try {
+      yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+    } catch (error) {
+      connection.evict?.();
+      throw error;
+    } finally {
+      await connection.release();
+    }
+  }();
+}
+export {
+  checkout,
+  drainClosed,
+  listen,
+  recover,
+  streamRows
+};