okmodel 0.1.1 → 0.3.0

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/meck53jv.js

@@ -0,0 +1,99 @@
+import {
+  open2
+} from "./xw1d69vd.js";
+import"./t616ynfn.js";
+import"./n442h54c.js";
+import {
+  assertTargetPolicy,
+  selectTarget,
+  openProject
+} from "./5nmdenb6.js";
+import"./2ssqrv66.js";
+import {
+  isExactVersion,
+  compareExtensionVersions
+} from "./th14ygv2.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/ext.ts
+async function extProject(cwd, command, flags) {
+  const opened = await openProject(cwd);
+  const target = selectTarget(opened.config, flags.target);
+  assertTargetPolicy(target, "check", flags.allowProtected);
+  const pool = open2({ url: target.url, max: 1 });
+  try {
+    if (command === "list")
+      return formatList(await readExtensions(pool));
+    return formatCheck(opened.built.catalog.objects, await readExtensions(pool));
+  } finally {
+    await pool.close();
+  }
+}
+var LIST_SQL = `
+  select a.name, a.default_version, e.extversion, n.nspname
+  from pg_available_extensions a
+  left join pg_extension e on e.extname = a.name
+  left join pg_namespace n on n.oid = e.extnamespace
+  order by a.name
+`;
+async function readExtensions(pool) {
+  const result = await pool.execute(LIST_SQL);
+  return result.rows.map((row) => ({
+    name: cell(row[0]),
+    defaultVersion: cell(row[1]),
+    installedVersion: cell(row[2]),
+    schema: cell(row[3])
+  }));
+}
+function cell(value) {
+  return typeof value === "string" ? value : "";
+}
+function formatList(rows) {
+  const lines = ["name\tdefault\tinstalled\tschema"];
+  for (const row of rows) {
+    lines.push([row.name, row.defaultVersion, row.installedVersion, row.schema].join("\t"));
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function formatCheck(objects, server) {
+  const declared = objects.filter((object) => object.kind === "extension");
+  if (declared.length === 0)
+    return `no extensions
+`;
+  const installed = new Map(server.map((row) => [row.name, row.installedVersion]));
+  const lines = ["name\tdeclared\tinstalled"];
+  for (const object of [...declared].sort((left, right) => left.identity.name < right.identity.name ? -1 : 1)) {
+    const name = object.identity.name;
+    const have = installed.get(name) ?? "";
+    if (have.length === 0) {
+      throw new OkmError2("OKM1811", `Extension ${name} is not installed on the server.`, {
+        fix: { summary: "Install the extension, or remove the declaration." }
+      });
+    }
+    const want = object.definition.version;
+    if (!versionAccepted(want, have)) {
+      throw new OkmError2("OKM1812", `Extension ${name} is ${have} on the server. The schema requires ${want ?? ""}.`, { fix: { summary: "Install a version the declaration accepts, or change the pin." } });
+    }
+    lines.push([name, want ?? "-", have].join("\t"));
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function versionAccepted(declared, installed) {
+  if (declared === undefined)
+    return true;
+  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(declared);
+  const minimum = floor?.[1];
+  if (minimum !== undefined) {
+    return isExactVersion(installed) && compareExtensionVersions(installed, minimum) >= 0;
+  }
+  return declared === installed;
+}
+export {
+  extProject
+};

package/dist/shared/mt5wswjz.js

@@ -0,0 +1,90 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  withHttp,
+  settleCall
+} from "./k34e0xf2.js";
+import {
+  rejectKeys,
+  isRecord,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/batch.ts
+async function batch(session, ops, options, replica) {
+  try {
+    if (replica !== undefined) {
+      throw new OkmError2("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))
+      fail("OKM1121", "batch expects a list of write operations.");
+    const record = options ?? {};
+    if (!isRecord(record))
+      fail("OKM1121", "batch options must be an object.");
+    rejectKeys(record, ["signal", "timeout"], "batch");
+    const prepared = [];
+    for (const op of ops) {
+      const plan = typeof op === "object" && op !== null ? op["~plan"] : undefined;
+      if (plan === undefined) {
+        fail("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
+      }
+      const item = await plan();
+      if (item.checked !== undefined) {
+        fail("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);
+  }
+  return prepared.map((item, index) => {
+    const from = starts[index] ?? 0;
+    return item.finish(results.slice(from, from + item.statements.length));
+  });
+}
+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/shared/n0dgs0pb.js

@@ -0,0 +1,75 @@
+import {
+  definition,
+  unavailable
+} from "./tmbdywx0.js";
+
+// src/dialects/pg/trait.ts
+var TRAIT_KEYS = new Set(["fields", "name", "presets", "sealed", "touch"]);
+function checkTrait(value, where) {
+  if (!isRecord(value))
+    definition(`${where} traits must be a list of traits.`);
+  for (const key of Object.keys(value)) {
+    if (key === "methods" || key === "requires") {
+      unavailable(`Trait option ${key} is not available yet. It arrives in 0.2.`);
+    }
+    if (!TRAIT_KEYS.has(key)) {
+      definition(`${where} trait option ${key} is not supported. Accepted options: fields, name, presets, sealed, touch.`);
+    }
+  }
+  const name = value.name;
+  if (typeof name !== "string" || name.length === 0)
+    definition(`${where} trait needs a name.`);
+  const fields = value.fields;
+  if (!isRecord(fields))
+    definition(`Trait ${name} needs a fields object.`);
+  const known = Object.keys(fields);
+  readNames(value.touch, name, "touch", known);
+  readNames(value.sealed, name, "sealed", known);
+  return value;
+}
+function contributedFields(schemaTraits, options) {
+  const chosen = choose(options?.omitDefaults === undefined ? schemaTraits : undefined, options?.traits);
+  if (chosen === undefined)
+    return [];
+  const pairs = [];
+  const seen = new Set;
+  for (const trait of chosen) {
+    for (const field of Object.keys(trait.fields)) {
+      if (seen.has(field))
+        continue;
+      const builder = trait.fields[field];
+      if (builder === undefined)
+        continue;
+      seen.add(field);
+      pairs.push([field, builder]);
+    }
+  }
+  return pairs;
+}
+function choose(schemaTraits, local) {
+  const shared = schemaTraits ?? [];
+  const own = local ?? [];
+  if (shared.length === 0 && own.length === 0)
+    return;
+  if (own.length === 0)
+    return shared;
+  if (shared.length === 0)
+    return own;
+  return [...shared, ...own];
+}
+function readNames(value, traitName, label, known) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value))
+    definition(`Trait ${traitName} ${label} must be a list of field names.`);
+  for (const field of value) {
+    if (typeof field === "string" && known.includes(field))
+      continue;
+    definition(`Trait ${traitName} ${label} names ${String(field)}, which is not one of its fields. Accepted fields: ${known.join(", ")}.`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export { checkTrait, contributedFields };

package/dist/shared/n442h54c.js

@@ -0,0 +1,14 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/validate/closed.ts
+var VALIDATION_NOT_IMPORTED2 = "Validation is enabled but `okmodel/validate` was not imported.";
+var VALIDATION_NOT_IMPORTED_FIX2 = 'Import "okmodel/validate" before schema().';
+function refuseMissingValidation2() {
+  throw new OkmError2("OKM1201", VALIDATION_NOT_IMPORTED2, {
+    fix: { summary: VALIDATION_NOT_IMPORTED_FIX2 }
+  });
+}
+
+export { VALIDATION_NOT_IMPORTED2, VALIDATION_NOT_IMPORTED_FIX2, refuseMissingValidation2 };