okmodel 0.6.0 → 0.8.0

package/dist/shared/3t6kw83m.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 "./bxas03mq.js";
+import {
+  emitWhere,
+  projectExpr,
+  quote,
+  isRecord,
+  fail2
+} from "./kgwp4jdd.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/{5j36z8dn.js → 4m6hskg8.js}

@@ -1,28 +1,26 @@
 import {
-  noTimeout2
-} from "./8dqhth8c.js";
+  noTimeout
+} from "./q0cqt2sp.js";
 import {
   PGLITE_CAPABILITIES,
   driverErrors,
   rejectClosed,
   rejectCancelled,
   rejectTimedOut,
-  mapFailure,
   nextTransactionDepth,
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./cgbamx3e.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/pglite.ts
 import { PGlite } from "@electric-sql/pglite";
-var RESET_ALL = "RESET ALL";
-var UNLOCK = "SELECT pg_advisory_unlock_all()";
 async function open3(config = {}) {
+  const wire = await import("./needfe47.js");
   const db = new PGlite({
     dataDir: config.dataDir ?? "memory://",
-    parsers: WIRE,
-    serializers: WIRE
+    parsers: wire.parsers,
+    serializers: wire.serializers
   });
   await db.waitReady;
   const acquireMs = config.timeouts?.acquire;
@@ -30,8 +28,8 @@ async function open3(config = {}) {
   const notices = noticeBuffer();
   const queryOptions = {
     rowMode: "array",
-    parsers: WIRE,
-    serializers: WIRE,
+    parsers: wire.parsers,
+    serializers: wire.serializers,
     onNotice(notice) {
       notices.push(notice);
     }
@@ -42,7 +40,7 @@ async function open3(config = {}) {
     inflight += 1;
   }, () => {
     inflight = Math.max(0, inflight - 1);
-  });
+  }, (error) => wire.fail(error));
   async function lease() {
     if (closed)
       return rejectClosed();
@@ -50,13 +48,17 @@ async function open3(config = {}) {
     let released = false;
     return {
       execute: (text, params, options) => {
-        noTimeout2(options);
+        const refused = noTimeout(options);
+        if (refused !== undefined)
+          return refused;
         return runCall(closed, options, (watch) => session.query(text, params, watch));
       },
       batch: (statements, options) => {
-        noTimeout2(options);
+        const refused = noTimeout(options);
+        if (refused !== undefined)
+          return refused;
         return runCall(closed, options, async (watch) => {
-          const { runAtomicBatch } = await import("./ag4c7516.js");
+          const { runAtomicBatch } = await import("./b76b8d95.js");
           return runAtomicBatch(session, statements, watch);
         });
       },
@@ -65,7 +67,8 @@ async function open3(config = {}) {
           return;
         released = true;
         try {
-          await reset(session);
+          const { resetQueried } = await import("./bnby0esn.js");
+          await resetQueried(session);
         } finally {
           slot.release();
         }
@@ -75,7 +78,9 @@ async function open3(config = {}) {
   return {
     capabilities: PGLITE_CAPABILITIES,
     execute(text, params, options) {
-      noTimeout2(options);
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
       return runCall(closed, options, async (watch) => {
         await slot.acquire(acquireMs);
         try {
@@ -86,7 +91,9 @@ async function open3(config = {}) {
       });
     },
     async batch(statements, options) {
-      noTimeout2(options);
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
       const connection = await lease();
       try {
         return await connection.batch(statements, options);
@@ -122,6 +129,12 @@ async function open3(config = {}) {
     }
   };
 }
+function seal2(pool) {
+  let closed = 0;
+  return new Proxy(pool, {
+    get: (inner, key) => key === "close" ? () => Promise.resolve(closed = 1) : (inner = inner[key], closed && inner?.call ? () => rejectClosed() : inner)
+  });
+}
 
 class PgliteSession {
   canCancel = false;
@@ -131,12 +144,14 @@ class PgliteSession {
   notices;
   enter;
   leave;
-  constructor(db, options, notices, enter, leave) {
+  fail;
+  constructor(db, options, notices, enter, leave, fail) {
     this.db = db;
     this.options = options;
     this.notices = notices;
     this.enter = enter;
     this.leave = leave;
+    this.fail = fail;
   }
   query(text, params, watch) {
     const why = watch?.reason();
@@ -153,7 +168,7 @@ class PgliteSession {
     }, (error) => {
       this.leave();
       this.notices.take();
-      return mapFailure(error).then((mapped) => {
+      return this.fail(stampQuery(error, text)).then((mapped) => {
         throw mapped;
       });
     });
@@ -237,56 +252,10 @@ class Slot {
     return this.waiters.length;
   }
 }
-async function reset(session) {
-  if (session.inTransaction())
-    await session.rollback().catch(() => {
-      return;
-    });
-  try {
-    await session.query(RESET_ALL, undefined, undefined);
-    await session.query(UNLOCK, undefined, undefined);
-  } catch {
-    await session.rollback().catch(() => {
-      return;
-    });
-    await session.query(RESET_ALL, undefined, undefined);
-    await session.query(UNLOCK, undefined, undefined);
-  }
-}
-function wireMap(oids) {
-  const parsers = {};
-  for (const oid of oids)
-    parsers[oid] = (value) => value;
-  return parsers;
+function stampQuery(error, text) {
+  if (typeof error === "object" && error !== null && !("query" in error))
+    Reflect.set(error, "query", text);
+  return error;
 }
-var WIRE = wireMap([
-  16,
-  17,
-  20,
-  21,
-  23,
-  25,
-  114,
-  700,
-  701,
-  1043,
-  1082,
-  1114,
-  1184,
-  1700,
-  2950,
-  3802,
-  1000,
-  1005,
-  1007,
-  1009,
-  1016,
-  1115,
-  1182,
-  1185,
-  1231,
-  199,
-  3807
-]);
 
-export { open3 };
+export { open3, seal2 };

package/dist/shared/{n076ydsc.js → 4vbf83xx.js}

@@ -1,3 +1,6 @@
+import {
+  emitSqlValue
+} from "./3bb7wsqt.js";
 import {
   assertOperatorFits,
   sqlType,
@@ -5,13 +8,13 @@ import {
   assertBoundText,
   assertRegconfig,
   textArray
-} from "./n7mcc1gk.js";
+} from "./zchaghkf.js";
 import {
   installOperatorSql,
   quote,
   isRecord,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./kgwp4jdd.js";
 import {
   isOperator,
   operatorName,
@@ -19,7 +22,11 @@ import {
 } from "./cn0n68ft.js";
 
 // src/runtime/operator-sql.ts
-function emitStructured(column, ref, name, value, sink) {
+function emitStructured(table, column, ref, name, value, sink, order) {
+  if (name === "sql") {
+    emitSqlValue(table, ref, value, sink);
+    return;
+  }
   if (name === "contains" || name === "containedBy" || name === "overlaps") {
     emitContainment(column, ref, name, value, sink);
     return;
@@ -36,12 +43,20 @@ function emitStructured(column, ref, name, value, sink) {
     emitMatches(column, ref, value, sink);
     return;
   }
+  if (name === "relevance") {
+    if (order !== true)
+      fail2("OKM1121", `relevance on ${column.field} belongs in orderBy.`);
+    emitRelevance(column, ref, value, sink);
+    sink.text(" desc");
+    sink.mark(`o:${column.field}:relevance`);
+    return;
+  }
   if (name === "similar" || name === "wordSimilar") {
     emitTrigram(column, ref, name, value, sink);
     return;
   }
   assertOperatorFits(column, name);
-  fail("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
+  fail2("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
 }
 function emitContainment(column, ref, name, value, sink) {
   assertOperatorFits(column, name);
@@ -56,7 +71,7 @@ function emitJsonKey(column, ref, name, value, sink) {
   assertOperatorFits(column, name);
   if (name === "hasKey") {
     if (typeof value !== "string")
-      fail("OKM1121", `hasKey on ${column.field} needs a key.`);
+      fail2("OKM1121", `hasKey on ${column.field} needs a key.`);
     assertBoundText(value, `key on ${column.field}`);
     sink.text("jsonb_exists(");
     sink.text(ref);
@@ -66,7 +81,7 @@ function emitJsonKey(column, ref, name, value, sink) {
     return;
   }
   if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    fail("OKM1121", `hasAnyKey on ${column.field} needs a list of keys.`);
+    fail2("OKM1121", `hasAnyKey on ${column.field} needs a list of keys.`);
   }
   sink.text("jsonb_exists_any(");
   sink.text(ref);
@@ -77,15 +92,15 @@ function emitJsonKey(column, ref, name, value, sink) {
 function emitPath(column, ref, value, sink) {
   assertOperatorFits(column, "path");
   if (!isRecord(value) || !Array.isArray(value.segments) || !isOperator(value.op)) {
-    fail("OKM1121", `path on ${column.field} needs segments and a comparison.`);
+    fail2("OKM1121", `path on ${column.field} needs segments and a comparison.`);
   }
   const segments = value.segments;
   if (segments.length === 0 || segments.some((item) => typeof item !== "string")) {
-    fail("OKM1121", `path on ${column.field} needs a list of segments.`);
+    fail2("OKM1121", `path on ${column.field} needs a list of segments.`);
   }
   const opName = operatorName(value.op);
   if (opName !== "eq" && opName !== "lt" && opName !== "lte" && opName !== "gt" && opName !== "gte") {
-    fail("OKM1121", `path on ${column.field} compares with eq, lt, lte, gt, or gte.`);
+    fail2("OKM1121", `path on ${column.field} compares with eq, lt, lte, gt, or gte.`);
   }
   const operand = operatorValue(value.op);
   const cast = pathCast(column, operand);
@@ -106,7 +121,7 @@ function pathCast(column, operand) {
     return "boolean";
   if (typeof operand === "string")
     return "text";
-  fail("OKM1121", `path on ${column.field} compares a string, number, or boolean.`);
+  fail2("OKM1121", `path on ${column.field} compares a string, number, or boolean.`);
 }
 function pathParam(operand) {
   if (typeof operand === "number")
@@ -117,35 +132,61 @@ function pathParam(operand) {
     return operand;
   return "";
 }
-function emitMatches(column, ref, value, sink) {
-  assertOperatorFits(column, "matches");
-  if (!isRecord(value) || typeof value.query !== "string") {
-    fail("OKM1121", `matches on ${column.field} needs search text.`);
+var MATCH_FN = {
+  natural: "websearch_to_tsquery",
+  "all-words": "plainto_tsquery",
+  phrase: "phraseto_tsquery",
+  advanced: "to_tsquery"
+};
+function readMatch(column, value, label) {
+  if (!isRecord(value) || typeof value.query !== "string" || value.query.length === 0) {
+    fail2("OKM1121", `${label} on ${column.field} needs text to look for.`);
   }
-  assertNoControl(value.query, `matches on ${column.field}`);
-  const mode = value.mode ?? "websearch";
-  const fn = mode === "websearch" ? "websearch_to_tsquery" : mode === "plain" ? "plainto_tsquery" : mode === "phrase" ? "phraseto_tsquery" : undefined;
+  assertNoControl(value.query, `${label} on ${column.field}`);
+  const match = value.match ?? "natural";
+  const fn = typeof match === "string" ? MATCH_FN[match] : undefined;
   if (fn === undefined) {
-    fail("OKM1121", `matches on ${column.field} mode must be websearch, plain, or phrase.`);
+    fail2("OKM1121", `${label} on ${column.field} match must be natural, all-words, phrase, or advanced.`);
   }
-  sink.text(ref);
-  sink.text(" @@ ");
-  sink.text(fn);
+  if (value.language === undefined)
+    return { fn, language: undefined, query: value.query };
+  if (typeof value.language !== "string") {
+    fail2("OKM1121", `${label} on ${column.field} language must be a name such as english.`);
+  }
+  assertRegconfig(value.language);
+  return { fn, language: value.language, query: value.query };
+}
+function emitTsquery(sink, query) {
+  sink.mark(query.language === undefined ? `:${query.fn}` : `:${query.fn}:lang`);
+  sink.text(query.fn);
   sink.text("(");
-  if (typeof value.config === "string") {
-    assertRegconfig(value.config);
-    sink.param(value.config);
+  if (query.language !== undefined) {
+    sink.param(query.language);
     sink.text("::regconfig, ");
   }
-  sink.param(value.query);
+  sink.param(query.query);
+  sink.text(")");
+}
+function emitMatches(column, ref, value, sink) {
+  assertOperatorFits(column, "matches");
+  sink.text(ref);
+  sink.text(" @@ ");
+  emitTsquery(sink, readMatch(column, value, "matches"));
+}
+function emitRelevance(column, ref, value, sink) {
+  assertOperatorFits(column, "relevance");
+  sink.text("ts_rank(");
+  sink.text(ref);
+  sink.text(", ");
+  emitTsquery(sink, readMatch(column, value, "relevance"));
   sink.text(")");
 }
 function emitTrigram(column, ref, name, value, sink) {
   if (!isRecord(value) || typeof value.query !== "string" || typeof value.schema !== "string") {
-    fail("OKM1121", `${name} on ${column.field} needs query text.`);
+    fail2("OKM1121", `${name} on ${column.field} needs query text.`);
   }
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value.schema)) {
-    fail("OKM1121", `${name} on ${column.field} needs an extension schema name.`);
+    fail2("OKM1121", `${name} on ${column.field} needs an extension schema name.`);
   }
   sink.text(ref);
   sink.text(" operator(");