okmodel 0.6.0 → 0.7.0

package/dist/shared/{hazqqecq.js → xnxsed62.js}

@@ -1,3 +1,11 @@
+import {
+  UUIDV7_POSTGRES,
+  isPostgresMajor,
+  parsePostgresFloor,
+  formatPostgresFloor,
+  minPostgresDefinition,
+  uuidv7NeedsPostgres
+} from "./ga9j92qj.js";
 import {
   catalog,
   enumType,
@@ -5,7 +13,7 @@ import {
 } from "./ywspezzx.js";
 import {
   isRelationCall
-} from "./k68eedmy.js";
+} from "./exn3sd90.js";
 import {
   encodeText,
   decodeText
@@ -149,6 +157,7 @@ var SCHEMA_KNOWN = new Set([
   "defaults",
   "extensions",
   "functions",
+  "minPostgres",
   "requires",
   "tables",
   "tenancy",
@@ -178,7 +187,7 @@ function schema2(config) {
   const hooks = collectHooks(tenancy, schemaTraits, config.tables, config.views);
   const types = readTypes(config.types);
   const codecs = readCodecs(config.codecs);
-  const requires = readRequires(config.requires);
+  const requires = readFloor(config.minPostgres, config.requires);
   const idDefault = readIdDefault(config.defaults);
   const namespace = staticNamespace2("public");
   const accepted = acceptTables(config.tables);
@@ -203,8 +212,9 @@ function schema2(config) {
     compileForeignKeys(item, byName, accepted, jobs, edges);
   }
   const model = {};
+  const scopeFields = tenancy === undefined ? undefined : tenancy.keys !== undefined ? tenancy.keys : [tenancy.key];
   for (const item of prepared) {
-    model[item.tsName] = tableModel(item, edges, byName, accepted);
+    model[item.tsName] = tableModel(item, edges, byName, accepted, scopeFields);
   }
   bindViews(config.views, model, tenancy, tables, casing);
   let document;
@@ -502,7 +512,7 @@ function compileTable(item, namespace, casing, codecs, requires, idDefault, jobs
       columnPrimary.push(prepared.sqlName);
     }
     if (column.state.defaultSql === "uuidv7()") {
-      refuseUuidV7(item.name, field, requires);
+      refuseUuidV7(requires);
     }
     const labels = column.state.enumLabels;
     if (labels !== undefined) {
@@ -858,7 +868,7 @@ function readCodecs(codecs) {
   }
   return { bigint, numeric, timestamps };
 }
-function tableModel(item, edges, byName, accepted) {
+function tableModel(item, edges, byName, accepted, scopeFields) {
   const primary = [];
   for (const sqlName of item.primary) {
     const column = item.bySql.get(sqlName);
@@ -891,7 +901,7 @@ function tableModel(item, edges, byName, accepted) {
     primary,
     uniques: item.uniques,
     columns,
-    relations: resolveRelations(item, edges, byName, accepted),
+    relations: resolveRelations(item, edges, byName, accepted, scopeFields),
     ...conceal ? { conceal: true } : {},
     ...item.traits !== undefined ? { traits: item.traits } : {},
     ...item.provenance.source !== undefined ? { source: item.provenance.source } : {},
@@ -899,10 +909,11 @@ function tableModel(item, edges, byName, accepted) {
     ...item.presets !== undefined ? { presets: item.presets } : {}
   };
 }
-function resolveRelations(item, edges, byName, accepted) {
+function resolveRelations(item, edges, byName, accepted, scopeFields) {
   const raw = item.relationOptions;
   if (raw === undefined)
     return [];
+  const describe = (table) => byName.get(table);
   const record = raw;
   const names = Object.keys(record);
   const resolved = [];
@@ -913,11 +924,18 @@ function resolveRelations(item, edges, byName, accepted) {
     seen.add(name);
     const call = record[name];
     if (!isRelationCall(call)) {
-      unavailable(`Table ${item.tsName} relation ${name} is not available yet. one(), many(), and manyThrough() are accepted. morph arrives later.`);
+      unavailable(`Table ${item.tsName} relation ${name} is not a relation. one(), many(), manyThrough(), morph(), and morphMany() are accepted.`);
     }
     const own = call.resolve;
     if (own !== undefined) {
-      resolved.push(own({ owner: item.tsName, name, edges, tables: accepted }));
+      resolved.push(own({
+        owner: item.tsName,
+        name,
+        edges,
+        tables: accepted,
+        describe,
+        ...scopeFields === undefined ? {} : { scopeFields }
+      }));
       continue;
     }
     if (!byName.has(call.table)) {
@@ -1002,21 +1020,32 @@ function readIdDefault(defaults) {
     return { kind: "client", fill };
   definition('schema() defaults.id must be "uuidv7", "uuidv4", or a client generator.');
 }
-function refuseUuidV7(tableName, field, requires) {
-  const declared = Number(/^>=(\d+)$/.exec(requires?.postgres ?? "")?.[1]);
-  if (!(declared > 0) || declared >= 18)
+function refuseUuidV7(requires) {
+  const declared = parsePostgresFloor(requires?.postgres);
+  if (!(declared > 0) || declared >= UUIDV7_POSTGRES)
     return;
-  throw new OkmError2("OKM1812", `Column ${tableName}.${field} uses uuidv7(). Set defaults.id to "uuidv4" or a client generator.`, { fix: { summary: "Set defaults.id." } });
+  const sentence = uuidv7NeedsPostgres();
+  throw new OkmError2("OKM1812", sentence, { fix: { summary: sentence } });
 }
-function readRequires(requires) {
-  if (requires === undefined) {
-    return;
-  }
-  const postgres = requires.postgres;
-  if (postgres !== undefined && postgres.length === 0) {
-    definition("schema() requires.postgres must be a version range such as >=17.");
+function readFloor(minPostgres, requires) {
+  if (minPostgres !== undefined && requires !== undefined) {
+    definition("minPostgres or requires.postgres, not both.");
   }
-  return postgres === undefined ? {} : { postgres };
+  if (minPostgres === undefined && requires === undefined)
+    return;
+  let major = minPostgres;
+  if (minPostgres === undefined) {
+    if (typeof requires !== "object" || requires === null || Array.isArray(requires)) {
+      definition(minPostgresDefinition());
+    }
+    const postgres = requires.postgres;
+    if (postgres === undefined)
+      return {};
+    major = typeof postgres === "string" ? parsePostgresFloor(postgres) : NaN;
+  }
+  if (!isPostgresMajor(major))
+    definition(minPostgresDefinition());
+  return { postgres: formatPostgresFloor(major) };
 }
 function readIndex(tableName, call) {
   if (call.columns.length === 0) {

package/dist/shared/y6njgyda.js

@@ -0,0 +1,249 @@
+import {
+  stack2
+} from "./mss6ctgv.js";
+import {
+  updateSliceBody2,
+  rejectDuplicateTargets2,
+  emitSet2,
+  Sql2,
+  writeSet2,
+  rejectMixedSets2,
+  readClaim2,
+  rejectUpdateKeys2,
+  requireFilter2,
+  returningOption2,
+  expectOf2,
+  allowSet2,
+  noteGuarded2
+} from "./1w508jbr.js";
+import {
+  emitWhere,
+  projectExpr,
+  quote,
+  isRecord,
+  fail2
+} from "./67txcrcw.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/shared/{8etn7d8w.js → z7s6fpxv.js}

@@ -39,7 +39,7 @@ async function refreshView(session, name, concurrently) {
       throw error;
     }
   } catch (error) {
-    const { mapPostgresError } = await import("./d5azex6s.js");
+    const { mapPostgresError } = await import("./63qtkrca.js");
     const mapped = mapPostgresError(error, {
       ...host.http !== undefined ? { http: host.http } : {},
       ...host.includeValues === true ? { includeValues: true } : {},

package/dist/shared/{n7mcc1gk.js → zchaghkf.js}

@@ -18,6 +18,7 @@ var FAMILIES = {
   hasAnyKey: ["jsonb"],
   path: ["json", "jsonb"],
   matches: ["tsvector"],
+  relevance: ["tsvector"],
   "json.set": ["json", "jsonb"],
   "arr.append": ["array"],
   "arr.remove": ["array"]
@@ -53,7 +54,7 @@ var ACCEPTED = {
   jsonb: ["eq", "not", "contains", "containedBy", "hasKey", "hasAnyKey", "path", "json.set"],
   json: ["eq", "not", "path", "json.set"],
   range: ["eq", "not", "lt", "lte", "gt", "gte", "contains", "containedBy", "overlaps"],
-  tsvector: ["eq", "not", "matches"],
+  tsvector: ["eq", "not", "matches", "relevance"],
   scalar: ["eq", "not", "lt", "lte", "gt", "gte", "between", "inList", "notIn", "inc"]
 };
 var SAFE_TYPE = /^[A-Za-z_][A-Za-z0-9_]*(\(\d+\))?(\[\])*$/;
@@ -81,7 +82,7 @@ function assertOperatorFits(column, name) {
   if (families.includes(columnFamily(column.dataType)))
     return;
   const accepted = ACCEPTED[columnFamily(column.dataType)];
-  const search = name === "matches" && columnFamily(column.dataType) === "text" ? " Text search needs a tsvector column." : "";
+  const search = (name === "matches" || name === "relevance") && columnFamily(column.dataType) === "text" ? " Search needs a column built for search, not a plain text column." : "";
   throw new OkmError2("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${accepted.join(", ")}.${search}`, { fix: { summary: `Use one of: ${accepted.join(", ")}.` } });
 }
 function sqlType(dataType, column) {
@@ -110,7 +111,7 @@ function assertBoundText(value, role) {
 }
 function assertRegconfig(config) {
   if (!REGCONFIG.test(config)) {
-    throw new OkmError2("OKM1122", `Text search config ${config} must be a regconfig name such as english or pg_catalog.simple.`, { fix: { summary: "Pass a regconfig name. Quotes and extra clauses are not accepted." } });
+    throw new OkmError2("OKM1122", `Language ${config} is not a text search language. Pass a name such as english.`, { fix: { summary: "Pass a language name such as english." } });
   }
 }
 function textArray(values, role) {

package/dist/shared/zm0ptry0.js

@@ -0,0 +1,40 @@
+import {
+  isConnectionLost
+} from "./cnkky55j.js";
+import {
+  rejectClosed
+} from "./kb2sdhfb.js";
+
+// src/adapters/pg/reserved.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function resetSession2(depth, run) {
+  if (depth > 0)
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  } catch {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  }
+}
+async function resetQueried2(session) {
+  await resetSession2(session.inTransaction() ? 1 : 0, (text) => text === "ROLLBACK" ? session.rollback() : session.query(text, undefined, undefined));
+}
+function refuseWhenLost2(lost, run) {
+  if (lost.on)
+    return rejectClosed();
+  return run().catch((error) => {
+    if (isConnectionLost(error))
+      lost.on = true;
+    throw error;
+  });
+}
+
+export { resetSession2, resetQueried2, refuseWhenLost2 };

package/dist/shared/{nsva2a6b.js → znm0bpp5.js}

@@ -13,6 +13,9 @@ var RESERVED_PRESETS = new Set([
   "insert",
   "update",
   "delete",
+  "descendants",
+  "ancestors",
+  "sync",
   "archive",
   "restore",
   "withArchived",

package/dist/shared/zp9fmend.js

@@ -0,0 +1,145 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  armDriverError,
+  send,
+  connectClient
+} from "./w79hsckn.js";
+import {
+  resetSession2
+} from "./zm0ptry0.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  isConnectionLost
+} from "./cnkky55j.js";
+import {
+  WireSession
+} from "./1qa0qajz.js";
+import {
+  rejectClosed,
+  runCall
+} from "./kb2sdhfb.js";
+
+// src/adapters/pg/nodepostgres-extra.ts
+async function checkout(held) {
+  const { pool, counters, named, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const client = await connectClient(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 = send(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("./b76b8d95.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 connectClient(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));
+  };
+  armDriverError(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
+};