okmodel 0.1.0 → 0.2.1

package/dist/shared/m9tv7xn7.js

@@ -0,0 +1,404 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  stack
+} from "./672t5vym.js";
+import {
+  withRowFilters,
+  archiveRules,
+  emitWhere,
+  rejectKeys,
+  indexes,
+  quote,
+  isRecord,
+  registerFailFix,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  safetyInstalled,
+  runSafety
+} from "./a5sxz52y.js";
+import {
+  isOperator
+} from "./cn0n68ft.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/archive.ts
+registerFailFix("OKM1102", "Pass where, or call .all(reason) to match every row.");
+var OPTIONS = ["allow", "expect", "returning", "signal", "timeout"];
+async function executeArchive(host, op, table, input, options, mods, scope) {
+  const prepared = prepareArchive(host.schema, op, table, input, options, mods, scope);
+  const results = await runWrite(host, prepared.statements, prepared.options);
+  return prepared.finish(results);
+}
+function prepareArchive(schema, op, table, input, options, mods, scope) {
+  const planned = planArchive(schema, op, table, input, options, mods, scope);
+  return {
+    statements: [{ text: planned.text, params: planned.params }],
+    options: planned.call,
+    ...op === "restore" ? { checked: "restore" } : planned.expect !== undefined ? { checked: "expect" } : {},
+    finish: (results) => finish(op, table, results[0], planned)
+  };
+}
+function explainArchive(schema, op, table, input, options, mods, scope) {
+  const planned = planArchive(schema, op, table, input, options, mods, scope);
+  return { statements: [{ text: planned.text, params: planned.params }] };
+}
+function planArchive(schema, op, tableName, input, options, mods, scope) {
+  const table = indexes(schema).get(tableName);
+  if (table === undefined)
+    fail("OKM1120", `Table ${tableName} is not in the schema.`);
+  const archive = table.model.archive;
+  if (archive === undefined) {
+    throw new OkmError2("OKM1052", `Table ${tableName} is not archivable.`, {
+      fix: { summary: "Call archive and restore only on an archivable table." }
+    });
+  }
+  const record = isRecord(options) ? options : {};
+  rejectKeys(record, OPTIONS, op);
+  const expect = expectOf(record.expect ?? mods.expect);
+  const read = readTarget(op, table, input, mods);
+  const target = { ...read, where: stack(read.where, mods.presets) };
+  const view = op === "restore" ? "only" : undefined;
+  noteArchive(table, view);
+  const statement = withRowFilters(scope, view, () => op === "archive" ? archiveSql(schema, table, target.where) : restoreSql(schema, table, target));
+  return {
+    text: statement.text,
+    params: statement.params,
+    expect,
+    archiveId: op === "archive" ? statement.archiveId : undefined,
+    call: callOptions(record)
+  };
+}
+function noteArchive(table, view) {
+  if (!safetyInstalled())
+    return;
+  const rules = archiveRules(table.model, view);
+  if (rules === undefined)
+    return;
+  runSafety(rules, undefined);
+}
+function readTarget(op, table, input, mods) {
+  if (!isRecord(input))
+    fail("OKM1121", `${op} expects { where }.`);
+  const keys = Object.keys(input);
+  if (op === "restore" && input.archiveId !== undefined) {
+    if (input.where !== undefined)
+      fail("OKM1120", "restore takes where or archiveId, not both.");
+    for (const key of keys) {
+      if (key !== "archiveId") {
+        fail("OKM1120", "restore accepts where or archiveId.");
+      }
+    }
+    if (typeof input.archiveId !== "string" || input.archiveId.length === 0) {
+      fail("OKM1121", "restore archiveId must be a uuid.");
+    }
+    const idField = table.model.archive?.idField ?? "archiveId";
+    return { where: { [idField]: input.archiveId }, archiveId: input.archiveId };
+  }
+  for (const key of keys) {
+    if (key !== "where")
+      fail("OKM1120", `${op} accepts where.`);
+  }
+  requireFilter(table, input.where, mods, op);
+  return { where: input.where, archiveId: undefined };
+}
+function archiveSql(schema, table, where) {
+  const archive = table.model.archive;
+  if (archive === undefined) {
+    throw new OkmError2("OKM1052", `Table ${table.model.name} is not archivable.`);
+  }
+  const archiveId = globalThis.crypto.randomUUID();
+  const sql = new Sql;
+  const cascade = archive.cascade;
+  if (cascade.length === 0) {
+    sql.text("update ");
+    sql.text(quote(table.model.sql));
+    sql.text(" as t set ");
+    sql.text(quote(archive.at));
+    sql.text(" = now(), ");
+    sql.text(quote(archive.id));
+    sql.text(" = ");
+    sql.param(archiveId);
+    sql.text("::uuid");
+    emitWhere(schema, table, where, sql, "t", 0);
+    return { text: sql.join(), params: sql.params, archiveId };
+  }
+  const returned = returnedColumns(table, cascade);
+  sql.text("with archived as (update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  sql.text(quote(archive.at));
+  sql.text(" = now(), ");
+  sql.text(quote(archive.id));
+  sql.text(" = ");
+  sql.param(archiveId);
+  sql.text("::uuid");
+  emitWhere(schema, table, where, sql, "t", 0);
+  sql.text(" returning ");
+  sql.text(returned.map((column) => `t.${quote(column)}`).join(", "));
+  sql.text(")");
+  for (let index = 0;index < cascade.length; index += 1) {
+    const child = cascade[index];
+    if (child === undefined)
+      continue;
+    sql.text(", c");
+    sql.text(String(index));
+    sql.text(" as (");
+    childUpdate(schema, sql, child, "archived");
+    sql.text(")");
+  }
+  sql.text(" select count(*)::text from archived");
+  return { text: sql.join(), params: sql.params, archiveId };
+}
+function restoreSql(schema, table, target) {
+  const archive = table.model.archive;
+  if (archive === undefined) {
+    throw new OkmError2("OKM1052", `Table ${table.model.name} is not archivable.`);
+  }
+  const parents = archive.parents;
+  const cascade = archive.cascade;
+  const sql = new Sql;
+  if (parents.length === 0 && cascade.length === 0) {
+    sql.text("update ");
+    sql.text(quote(table.model.sql));
+    sql.text(" as t set ");
+    sql.text(quote(archive.at));
+    sql.text(" = null, ");
+    sql.text(quote(archive.id));
+    sql.text(" = null");
+    emitWhere(schema, table, target.where, sql, "t", 0);
+    return { text: sql.join(), params: sql.params, archiveId: "" };
+  }
+  const pk = primarySql(table);
+  const selected = new Set(pk);
+  for (const parent of parents)
+    for (const column of parent.local)
+      selected.add(column);
+  for (const child of cascade)
+    for (const column of child.remote)
+      selected.add(column);
+  selected.delete(archive.id);
+  sql.text("with target as (select ");
+  sql.text([...selected].map((column) => `t.${quote(column)}`).join(", "));
+  sql.text(", t.");
+  sql.text(quote(archive.id));
+  sql.text(' as "archive_id" from ');
+  sql.text(quote(table.model.sql));
+  sql.text(" t");
+  emitWhere(schema, table, target.where, sql, "t", 0);
+  sql.text(")");
+  if (parents.length > 0) {
+    sql.text(", blocked as (");
+    for (let index = 0;index < parents.length; index += 1) {
+      const parent = parents[index];
+      if (parent === undefined)
+        continue;
+      if (index > 0)
+        sql.text(" union all ");
+      sql.text("select ");
+      sql.text(quoteLiteral(parent.table));
+      sql.text(" as parent from target x join ");
+      sql.text(quote(parent.sql));
+      sql.text(" p on ");
+      sql.text(joinOn("p", parent.remote, "x", parent.local));
+      sql.text(" where p.");
+      sql.text(quote(parent.at));
+      sql.text(" is not null");
+    }
+    sql.text(")");
+  }
+  sql.text(", restored as (update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as u set ");
+  sql.text(quote(archive.at));
+  sql.text(" = null, ");
+  sql.text(quote(archive.id));
+  sql.text(" = null from target x where ");
+  sql.text(joinOn("u", pk, "x", pk));
+  if (parents.length > 0)
+    sql.text(" and not exists (select 1 from blocked)");
+  sql.text(" returning ");
+  sql.text([...new Set([...pk, ...cascade.flatMap((child) => [...child.remote])])].map((column) => `x.${quote(column)}`).join(", "));
+  sql.text(', x."archive_id")');
+  for (let index = 0;index < cascade.length; index += 1) {
+    const child = cascade[index];
+    if (child === undefined)
+      continue;
+    sql.text(", c");
+    sql.text(String(index));
+    sql.text(" as (");
+    childRestore(sql, child, parents.length > 0);
+    sql.text(")");
+  }
+  if (parents.length > 0) {
+    sql.text(" select coalesce((select parent from blocked order by parent limit 1), ''), (select count(*)::text from restored)");
+  } else {
+    sql.text(" select '', count(*)::text from restored");
+  }
+  return { text: sql.join(), params: sql.params, archiveId: "" };
+}
+function childUpdate(schema, sql, child, parent) {
+  const indexed = indexes(schema).get(child.table);
+  sql.text("update ");
+  sql.text(quote(child.sql));
+  sql.text(" as c set ");
+  sql.text(quote(child.at));
+  sql.text(" = now(), ");
+  sql.text(quote(child.id));
+  sql.text(" = $1::uuid from ");
+  sql.text(parent);
+  sql.text(" a where ");
+  sql.text(joinOn("c", child.local, "a", child.remote));
+  if (indexed === undefined) {
+    sql.text(" and c.");
+    sql.text(quote(child.at));
+    sql.text(" is null");
+    return;
+  }
+  emitWhere(schema, indexed, undefined, sql, "c", 0, true);
+}
+function childRestore(sql, child, blocked) {
+  sql.text("update ");
+  sql.text(quote(child.sql));
+  sql.text(" as c set ");
+  sql.text(quote(child.at));
+  sql.text(" = null, ");
+  sql.text(quote(child.id));
+  sql.text(" = null from restored r where ");
+  sql.text(joinOn("c", child.local, "r", child.remote));
+  sql.text(" and c.");
+  sql.text(quote(child.id));
+  sql.text(' = r."archive_id" and c.');
+  sql.text(quote(child.at));
+  sql.text(" is not null");
+  if (blocked)
+    sql.text(" and not exists (select 1 from blocked)");
+}
+function returnedColumns(table, cascade) {
+  const names = [...primarySql(table)];
+  for (const child of cascade) {
+    for (const column of child.remote)
+      if (!names.includes(column))
+        names.push(column);
+  }
+  return names;
+}
+function primarySql(table) {
+  const names = [];
+  for (const field of table.model.primary) {
+    const column = table.columns.get(field);
+    if (column !== undefined)
+      names.push(column.sql);
+  }
+  return names;
+}
+function joinOn(left, leftColumns, right, rightColumns) {
+  const parts = [];
+  for (let index = 0;index < leftColumns.length; index += 1) {
+    const local = leftColumns[index];
+    const remote = rightColumns[index];
+    if (local === undefined || remote === undefined)
+      continue;
+    parts.push(`${left}.${quote(local)} = ${right}.${quote(remote)}`);
+  }
+  return parts.length === 0 ? "true" : parts.join(" and ");
+}
+function finish(op, table, result, planned) {
+  if (op === "restore") {
+    const parent = result.rows[0]?.[0];
+    if (typeof parent === "string" && parent.length > 0) {
+      throw new OkmError2("invalid", `restore on ${table} references archived ${parent}. Restore ${parent} first.`, {
+        kind: "invalid",
+        table,
+        fix: { summary: `Restore ${parent} before this row.` }
+      });
+    }
+  }
+  const count = countOf(op, result, planned);
+  if (planned.expect !== undefined && count !== planned.expect) {
+    throw new OkmError2("not_found", `${op} on ${table} changed ${String(count)} rows. expect was ${String(planned.expect)}.`, {
+      kind: "not_found",
+      table,
+      fix: { summary: "Change the filter, or pass the count this write produced." }
+    });
+  }
+  if (op === "archive")
+    return { count, archiveId: planned.archiveId ?? "" };
+  return { count };
+}
+function countOf(op, result, planned) {
+  if (op === "restore" && result.rows.length > 0) {
+    const cell = result.rows[0]?.[1] ?? result.rows[0]?.[0];
+    if (cell !== undefined && cell !== null && result.rows[0]?.length === 2)
+      return readCount(cell);
+  }
+  if (result.rows.length === 1 && result.rows[0]?.length === 1) {
+    const cell = result.rows[0][0];
+    if (cell !== undefined && cell !== null && planned.text.includes("count(*)"))
+      return readCount(cell);
+  }
+  return result.count;
+}
+function readCount(cell) {
+  const count = Number(cell);
+  return Number.isInteger(count) ? count : 0;
+}
+function expectOf(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new OkmError2("invalid", "expect must be an integer from 0 up.", { kind: "invalid" });
+  }
+  return value;
+}
+function requireFilter(table, where, mods, op) {
+  if (mods.all !== undefined) {
+    if (mods.all.trim().length === 0) {
+      fail("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
+    }
+    return;
+  }
+  if (isOperator(where))
+    return;
+  if (isRecord(where) && Object.keys(where).length > 0)
+    return;
+  fail("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
+}
+function callOptions(input) {
+  const signal = input.signal;
+  const timeout = input.timeout;
+  if (signal === undefined && timeout === undefined)
+    return;
+  return {
+    ...signal !== undefined ? { signal } : {},
+    ...typeof timeout === "number" ? { timeout } : {}
+  };
+}
+function quoteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+
+class Sql {
+  parts = [];
+  params = [];
+  text(value) {
+    this.parts.push(value);
+  }
+  param(encoded) {
+    this.params.push(encoded);
+    this.parts.push(`$${String(this.params.length)}`);
+  }
+  mark() {}
+  join() {
+    return this.parts.join("");
+  }
+}
+export {
+  executeArchive,
+  explainArchive,
+  prepareArchive
+};

package/dist/shared/mrq77sgw.js

@@ -0,0 +1,55 @@
+import {
+  decodeRows,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./mxmcdsh5.js";
+import {
+  fail
+} from "./xrfnq5k8.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.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 OkmError2 ? attachHttp(session.http, error) : error;
+  }
+}
+function plan(session, table, options, mods, view) {
+  const { lock, wait, ...rest } = options;
+  if (session.tx === undefined) {
+    throw new OkmError2("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)
+    fail("OKM1121", "wait needs lock: pass lock: update or lock: share.");
+  if (typeof lock !== "string" || !LOCKS.includes(lock)) {
+    throwNamed2("OKM1120", shown(lock), LOCKS, `lock must be one of: ${LOCKS.join(", ")}.`);
+  }
+  if (wait !== undefined && (typeof wait !== "string" || !WAITS.includes(wait))) {
+    throwNamed2("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
+};