okmodel 0.8.0 → 0.9.1

package/dist/tooling/shared/{5bvw2nev.js → 2v4nwnkb.js}

@@ -3,7 +3,7 @@ import {
   catalogHash2,
   loadTrustedCatalog2,
   catalogFileText2
-} from "./f9mphxej.js";
+} from "./2jdn09e2.js";
 export {
   catalogFileText2 as catalogFileText,
   catalogHash2 as catalogHash,

package/dist/tooling/shared/{spk1jg3r.js → 33z39trp.js}

@@ -1,11 +1,14 @@
+import {
+  assertParamCount2
+} from "./rd8h01ta.js";
 import {
   stack2
-} from "./cmptmb4f.js";
+} from "./angjck01.js";
 import {
   assertOperatorFits,
   textArray,
   arrayElementType
-} from "./3tq8pnb8.js";
+} from "./fdsek6pa.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
@@ -30,11 +33,12 @@ import {
   decodeRow,
   indexes,
   quote,
+  list,
   isRecord,
   orFail,
   registerFailFix,
   fail2
-} from "./f9mphxej.js";
+} from "./2jdn09e2.js";
 
 // src/runtime/predicate.ts
 function effectivePredicate(where) {
@@ -199,7 +203,7 @@ async function requireValidationImport(schema, op, tableName, options) {
   const source = stored.tables?.find((item) => item.name === tableName);
   if (source === undefined || !writeWouldValidate(stored.validation, source, options))
     return;
-  const { refuseMissingValidation } = await import("./wt7j7nf6.js");
+  const { refuseMissingValidation } = await import("./ns9207v3.js");
   refuseMissingValidation();
 }
 function validationRegistered(schema) {
@@ -244,7 +248,7 @@ async function prepareWrite(host, op, table, input, options, mods, scope) {
     return {
       statements: planned.statements,
       options: callOptions(options),
-      ...planned.parentGuard === true ? { checked: "parent" } : planned.expect !== undefined ? { checked: "expect" } : {},
+      ...planned.parentGuard === true ? { checked: "parent" } : planned.treeGuard === true ? { checked: "tree" } : planned.expect !== undefined ? { checked: "expect" } : {},
       ...planned.recover === undefined ? {} : {
         follow: (results) => planned.recover?.(decodePlanned(withoutQuiet(results, planned.quiet), planned.outputs)) ?? []
       },
@@ -269,7 +273,7 @@ async function planWrite(schema, generators, op, tableName, input, options, mods
     fail2("OKM1120", `Table ${tableName} is not in the schema.`);
   }
   if (mods.uses !== undefined && op !== "insert") {
-    const { resolve } = await import("./ma2340rx.js");
+    const { resolve } = await import("./bj1kyqc8.js");
     mods = { ...mods, presets: resolve(schema, tableName, mods.uses).wheres };
   }
   const record = isRecord(options) ? options : {};
@@ -279,7 +283,7 @@ async function planWrite(schema, generators, op, tableName, input, options, mods
   }
   if (op === "update") {
     if (traitNamed(table, "versioned")) {
-      const { planVersioned } = await import("./yk9mp7vb.js");
+      const { planVersioned } = await import("./qdrn8ghn.js");
       return withRowFilters(scope, mods.archive, () => {
         noteArchive(table, mods.archive);
         const planned = planVersioned(schema, table, input, record, mods);
@@ -325,12 +329,12 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
       keyColumns: undefined
     };
   }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./6nyfyw70.js");
+  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./f2r5g0fs.js");
   const conflict = conflictMod?.readConflict(table, options.onConflict, allow, tenantKeyList(tenancy));
   if (conflict?.kind === "update" && traitNamed(table, "versioned")) {
     fail2("OKM1120", `onConflict update on ${table.model.name} does not check the version you read.`, "Read the row and update. ignore and return do not change the existing row.");
   }
-  const sortMod = sorting ? await import("./w7qe8sj1.js") : undefined;
+  const sortMod = sorting ? await import("./d3rhb24q.js") : undefined;
   const chunks = chunkRows(rows.map((row) => cellsFor(columns, row)));
   const statements = [];
   const quiet = [];
@@ -389,7 +393,7 @@ function planUpdate(schema, table, input, options, mods, scope) {
     rejectDuplicateTargets2(table, rows);
     rejectMixedSets2(rows);
     for (const row of rows)
-      refuseTreeCycle(table, row.where, row.set, schema.tenancy?.key);
+      refuseTreeCycle(table, row.where, row.set, tenantKeys(schema.tenancy));
     const moves = rows.some((row) => pathField(schema.tenancy, table.model.name, row.set) !== undefined);
     if (moves) {
       return {
@@ -419,7 +423,8 @@ function planUpdate(schema, table, input, options, mods, scope) {
   requireFilter2(table, input.where, mods, "update");
   if (Object.keys(set).length === 0)
     fail2("OKM1120", "update set is empty.");
-  refuseTreeCycle(table, input.where, set, schema.tenancy?.key);
+  const keys = tenantKeys(schema.tenancy);
+  const cycle = refuseTreeCycle(table, input.where, set, keys);
   const where = stack2(input.where, mods.presets);
   const moved = pathAssignment(schema.tenancy, table.model.name, set, scope);
   if (moved !== undefined && claim !== undefined) {
@@ -446,6 +451,17 @@ function planUpdate(schema, table, input, options, mods, scope) {
       keyColumns: undefined
     };
   }
+  if (cycle !== undefined) {
+    return {
+      statements: [treeSetUpdate(schema, table, where, set, cycle, returning)],
+      outputs: parentOutputs(returning),
+      shape: returning === undefined ? "count" : "rows",
+      expect,
+      keys: undefined,
+      keyColumns: undefined,
+      treeGuard: true
+    };
+  }
   const sql = new Sql2;
   sql.text("update ");
   sql.text(quote(table.model.sql));
@@ -492,6 +508,8 @@ function finish(results, planned, table) {
     return finishVersioned(results, planned, table);
   if (planned.parentGuard === true)
     return finishParent(results, planned, table);
+  if (planned.treeGuard === true)
+    return finishTree(results, planned, table);
   if (planned.shape === "count") {
     let count = 0;
     for (const result of results)
@@ -520,6 +538,18 @@ function finishParent(results, planned, table) {
       fix: { summary: "Point the foreign key at a parent in this tenant." }
     });
   }
+  return finishGuarded(results, planned, table, updated);
+}
+function finishTree(results, planned, table) {
+  const row = results[0]?.rows[0];
+  const matched = countCell(row?.[0]);
+  const updated = countCell(row?.[1]);
+  if (updated < matched) {
+    fail2("OKM1120", `update on ${table} cannot point a tree row at itself or its descendant.`, "Set the parent to another row that is not under this one. A filter that is not the primary key is not checked.");
+  }
+  return finishGuarded(results, planned, table, updated);
+}
+function finishGuarded(results, planned, table, updated) {
   if (planned.shape === "count") {
     checkExpect(updated, planned.expect, table, "write");
     return { count: updated };
@@ -1155,6 +1185,7 @@ class Sql2 {
     };
   }
   statement() {
+    assertParamCount2(this.params.length);
     return this.params.length === 0 ? { text: this.parts.join("") } : { text: this.parts.join(""), params: this.params };
   }
 }
@@ -1165,7 +1196,7 @@ function insertRow(table, value, allow, tenancy) {
   for (const key of Object.keys(value)) {
     const column = table.columns.get(key);
     if (column === undefined)
-      continue;
+      refuseUnknownField(table, key);
     tenancy?.guard(table.model.name, key, "insert");
     if (!writable(table, column, allow, "insert"))
       refuse(table, column);
@@ -1175,6 +1206,9 @@ function insertRow(table, value, allow, tenancy) {
   refuseHalfMorph(table, row);
   return row;
 }
+function refuseUnknownField(table, key) {
+  throwNamed("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+}
 function cellsFor(columns, row) {
   return columns.map((column) => {
     if (!Object.hasOwn(row, column.field))
@@ -1281,10 +1315,10 @@ function writeSet2(table, value, allow, tenancy) {
   }
   const set = {};
   for (const key of Object.keys(value)) {
-    if (value[key] === undefined)
-      continue;
     const column = table.columns.get(key);
     if (column === undefined)
+      refuseUnknownField(table, key);
+    if (value[key] === undefined)
       continue;
     tenancy?.guard(table.model.name, key, "update");
     if (column.guardUpdate || !writable(table, column, allow, "update"))
@@ -1294,10 +1328,11 @@ function writeSet2(table, value, allow, tenancy) {
   refuseHalfMorph(table, set);
   return set;
 }
-function refuseTreeCycle(table, where, set, scopeKey) {
-  const own = keyedId(table, where, scopeKey);
-  if (own === undefined)
+function refuseTreeCycle(table, where, set, scopeKeys) {
+  const keyed = keyedId(table, where, scopeKeys);
+  if (keyed === undefined)
     return;
+  let found;
   for (const relation of table.model.relations) {
     if (relation.kind !== "many" || relation.through !== undefined || relation.morph !== undefined) {
       continue;
@@ -1312,17 +1347,20 @@ function refuseTreeCycle(table, where, set, scopeKey) {
       if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") {
         continue;
       }
-      if ((typeof value === "string" ? value : value.toString()) !== own)
-        continue;
-      fail2("OKM1120", `update on ${table.model.name}.${column.field} cannot point a tree row at itself.`, "Set the parent to another row. A filter that is not the primary key is not checked.");
+      const parent = typeof value === "string" ? value : value.toString();
+      if (parent === keyed.own) {
+        fail2("OKM1120", `update on ${table.model.name}.${column.field} cannot point a tree row at itself.`, "Set the parent to another row. A filter that is not the primary key is not checked.");
+      }
+      found = { own: keyed.own, parent, column, identity: keyed.identity };
     }
   }
+  return found;
 }
-function keyedId(table, where, scopeKey) {
+function keyedId(table, where, scopeKeys) {
   if (!isRecord(where))
     return;
   const primary = table.model.primary;
-  const required = primary.filter((field) => field !== scopeKey);
+  const required = primary.filter((field) => !scopeKeys.includes(field));
   const field = required.length === 1 ? required[0] : undefined;
   if (field === undefined || !Object.hasOwn(where, field))
     return;
@@ -1334,7 +1372,51 @@ function keyedId(table, where, scopeKey) {
   if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") {
     return;
   }
-  return String(value);
+  const identity = table.columns.get(field);
+  if (identity === undefined)
+    return;
+  return { own: String(value), identity };
+}
+function tenantKeys(tenancy) {
+  if (tenancy === undefined)
+    return [];
+  if (tenancy.keys !== undefined && tenancy.keys.length > 0)
+    return tenancy.keys;
+  return [tenancy.key];
+}
+function treeSetUpdate(schema, table, where, set, cycle, returning) {
+  const sql = new Sql2;
+  sql.text("with matched as (select ");
+  sql.text(rowId("t"));
+  sql.text(" from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t");
+  emitFilter(schema, table, where, sql, "t");
+  sql.text("), updated as (update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  emitSet2(sql, table, set, "t");
+  sql.text(" where (");
+  sql.text(rowId("t"));
+  sql.text(") in (select tableoid, ctid from matched) and not exists (with recursive d as (select ");
+  sql.text(quote(cycle.identity.sql));
+  sql.text(" as k from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" where ");
+  sql.text(quote(cycle.column.sql));
+  sql.text(" = ");
+  sql.param(cycle.own, cycle.identity.dataType);
+  sql.text(" union all select c.");
+  sql.text(quote(cycle.identity.sql));
+  sql.text(" from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" c join d on c.");
+  sql.text(quote(cycle.column.sql));
+  sql.text(" = d.k) select 1 from d where d.k = ");
+  sql.param(cycle.parent, cycle.identity.dataType);
+  sql.text(")");
+  endParent(sql, returning);
+  return sql.statement();
 }
 function columnBySql(table, sql) {
   for (const column of table.model.columns) {
@@ -1443,6 +1525,7 @@ function chunkRows(rows) {
 function withParams(text, params) {
   if (params === undefined || params.length === 0)
     return { text };
+  assertParamCount2(params.length);
   return { text, params };
 }
 function keyWire(columns, row) {

package/dist/tooling/shared/{z8d7ptht.js → 353vnw9z.js}

@@ -1,13 +1,13 @@
 import {
   identityColumn2
-} from "./ec71zqgt.js";
+} from "./chk2bh4f.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
 import {
   queryHandle,
   settleCall
-} from "./mtrqn2hn.js";
+} from "./gjj71hfh.js";
 import {
   OkmError,
   throwNamed,
@@ -22,7 +22,7 @@ import {
   list,
   isRecord,
   fail2
-} from "./f9mphxej.js";
+} from "./2jdn09e2.js";
 
 // src/runtime/sync.ts
 var OPTIONS = ["expect", "signal", "timeout", "route"];
@@ -539,8 +539,8 @@ function callOf(options) {
 async function presetWhere(schema, table, uses) {
   if (uses === undefined)
     return;
-  const { resolve } = await import("./ma2340rx.js");
-  const { stack } = await import("./wwnekq5n.js");
+  const { resolve } = await import("./bj1kyqc8.js");
+  const { stack } = await import("./4dzvjtpy.js");
   return stack(undefined, resolve(schema, table, uses).wheres);
 }
 function noteSafety(session, table, view) {

package/dist/tooling/shared/{dw08f3m8.js → 390kry9g.js}

@@ -1,8 +1,8 @@
 import {
   build2,
   identityColumn2
-} from "./ec71zqgt.js";
-import"./mtrqn2hn.js";
+} from "./chk2bh4f.js";
+import"./gjj71hfh.js";
 export {
   build2 as build,
   identityColumn2 as identityColumn

package/dist/tooling/shared/{xjs6zqtc.js → 3f6etb9z.js}

@@ -1,20 +1,20 @@
 import {
   DriverError2
-} from "./f9mphxej.js";
+} from "./2jdn09e2.js";
 import {
   noticeBuffer,
   WireSession
-} from "./yw30vnq2.js";
+} from "./asnnc3v5.js";
 import {
   noTimeout
-} from "./rs1jb051.js";
+} from "./1fwfm5m3.js";
 import {
   BUNSQL_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./xhrnjch9.js";
+} from "./ry2f3w8p.js";
 
 // src/adapters/pg/bunsql.ts
 import { SQL as BunSQL } from "bun";
@@ -22,7 +22,7 @@ var clientPools = new WeakSet;
 function markClientPool2(pool) {
   clientPools.add(pool);
 }
-function open2(config) {
+function open3(config) {
   const max = config.max ?? 10;
   const acquireMs = config.timeouts?.acquire;
   const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
@@ -30,7 +30,6 @@ function open2(config) {
   let closed = false;
   const isClosed = () => closed;
   const named = config.prepared === "named";
-  const parked = [];
   let dropped = 0;
   let closures = 0;
   const sql = new BunSQL(config.url, {
@@ -50,14 +49,13 @@ function open2(config) {
       closures += 1;
     }
   });
-  const root = new WireSession((text, params) => send2(sql, text, params), notices, isClosed, false, () => {
+  const root = new WireSession((text, params) => send3(sql, text, params), notices, isClosed, false, () => {
     counters.busy += 1;
   }, () => {
     counters.busy = Math.max(0, counters.busy - 1);
   });
   const held = {
     sql,
-    parked,
     acquireMs,
     counters,
     notices,
@@ -66,26 +64,26 @@ function open2(config) {
   };
   const run = (text, params, watch) => {
     const sent = dropped;
-    return root.query(text, params, watch).catch((error) => import("./g9ad4n80.js").then((mod) => mod.recover(sql, error, text, root.depth(), clientPools.has(pool), dropped > sent, () => root.query(text, params, watch))));
+    return root.query(text, params, watch).catch((error) => import("./efq6p9df.js").then((mod) => mod.recover(sql, error, text, root.depth(), clientPools.has(pool), dropped > sent, () => root.query(text, params, watch))));
   };
   const afterDrop = (text, params, watch) => {
     if (dropped === 0)
       return run(text, params, watch);
     const seen = dropped;
-    return import("./g9ad4n80.js").then((mod) => mod.drainClosed(sql).then(() => {
+    return import("./efq6p9df.js").then((mod) => mod.drainClosed(sql).then(() => {
       if (dropped === seen)
         dropped = 0;
       return run(text, params, watch);
     }));
   };
-  const checkout = () => closed ? rejectClosed() : import("./g9ad4n80.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./efq6p9df.js").then((mod) => mod.checkout(held));
   const pool = {
     capabilities: BUNSQL_CAPABILITIES,
     execute(text, params, options) {
       const refused = noTimeout(options);
       if (refused !== undefined)
         return refused;
-      return runCall(closed, options, (watch) => releaseParked(parked).then(() => afterDrop(text, params, watch)));
+      return runCall(closed, options, (watch) => afterDrop(text, params, watch));
     },
     async batch(statements, options) {
       const refused = noTimeout(options);
@@ -101,23 +99,22 @@ function open2(config) {
     reserve: () => checkout(),
     stream(text, params) {
       return async function* () {
-        const { streamRows } = await import("./g9ad4n80.js");
+        const { streamRows } = await import("./efq6p9df.js");
         yield* streamRows(checkout, text, params);
       }();
     },
     listen(channel, onNotify) {
-      return import("./g9ad4n80.js").then((mod) => mod.listen(sql, parked, closed, channel, onNotify));
+      return import("./efq6p9df.js").then((mod) => mod.listen(sql, closed, channel, onNotify));
     },
     stats: () => statsOf(counters, max),
     async close() {
       closed = true;
-      await releaseParked(parked);
       await sql.close();
     }
   };
   return pool;
 }
-function send2(sql, text, params) {
+function send3(sql, text, params) {
   const refused = refuseInt8(params);
   if (refused !== undefined)
     return refused;
@@ -149,25 +146,15 @@ async function reserve2(sql, acquireMs, counters) {
       const errors = await driverErrors();
       throw errors.acquireTimeout();
     }
+    if (error instanceof Error && (error.message === "Connection closed" || error.message === "connection must be a PostgresSQLConnection")) {
+      throw new DriverError2(error.message, { cause: error, sqlstate: "08006" });
+    }
     throw await mapFailure(error);
   } finally {
     counters.waiting = Math.max(0, counters.waiting - 1);
   }
 }
-async function park2(parked, reserved) {
-  parked.push(reserved);
-  while (parked.length > 1) {
-    const extra = parked.shift();
-    if (extra !== undefined)
-      await releaseReserved(extra);
-  }
-}
-async function releaseParked(parked) {
-  const pending = parked.splice(0);
-  for (const reserved of pending)
-    await releaseReserved(reserved);
-}
-function releaseReserved(reserved) {
+function releaseReserved2(reserved) {
   const done = reserved.release();
   return done instanceof Promise ? done.then(() => {
     return;
@@ -187,4 +174,4 @@ function statsOf(counters, size) {
   };
 }
 
-export { markClientPool2, open2, send2, reserve2, park2 };
+export { markClientPool2, open3, send3, reserve2, releaseReserved2 };

package/dist/{shared/bnby0esn.js → tooling/shared/3t2cqmsx.js}

@@ -2,7 +2,7 @@ import {
   resetSession2,
   resetQueried2,
   refuseWhenLost2
-} from "./7ghwamrf.js";
+} from "./8t22h3h7.js";
 export {
   refuseWhenLost2 as refuseWhenLost,
   resetQueried2 as resetQueried,

package/dist/tooling/shared/{wwnekq5n.js → 4dzvjtpy.js}

@@ -1,6 +1,6 @@
 import {
   stack2
-} from "./cmptmb4f.js";
+} from "./angjck01.js";
 export {
   stack2 as stack
 };

package/dist/tooling/shared/{y5656f0e.js → 4ec0nxvw.js}

@@ -1,13 +1,13 @@
 import {
   outcomeUnknown2
-} from "./f9mphxej.js";
+} from "./2jdn09e2.js";
 import {
   noticeBuffer,
   WireSession
-} from "./yw30vnq2.js";
+} from "./asnnc3v5.js";
 import {
   noTimeout
-} from "./rs1jb051.js";
+} from "./1fwfm5m3.js";
 import {
   NEON_WEBSOCKET_CAPABILITIES,
   NEON_HTTP_CAPABILITIES,
@@ -17,7 +17,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./xhrnjch9.js";
+} from "./ry2f3w8p.js";
 
 // src/adapters/pg/neon.ts
 import {
@@ -32,12 +32,12 @@ var WIRE = {
   }
 };
 var names = new Map;
-async function open5(config) {
+async function open2(config) {
   if (config.mode === "http")
     return openHttp(config);
   return openWebSocket(config);
 }
-function connectClient3(pool, acquireMs, counters) {
+function connectClient2(pool, acquireMs, counters) {
   counters.waiting += 1;
   let settled = false;
   return new Promise((resolve, reject) => {
@@ -70,7 +70,7 @@ function connectClient3(pool, acquireMs, counters) {
     });
   });
 }
-function send4(runner, text, params, named) {
+function send2(runner, text, params, named) {
   const query = {
     text,
     rowMode: "array",
@@ -111,13 +111,13 @@ async function openWebSocket(config) {
     });
     throw await mapFailure(error);
   }
-  const root = new WireSession((text, params) => send4(pool, text, params, named), notices, isClosed, false, () => {
+  const root = new WireSession((text, params) => send2(pool, text, params, named), notices, isClosed, false, () => {
     counters.busy += 1;
   }, () => {
     counters.busy = Math.max(0, counters.busy - 1);
   });
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./gfvtj6d0.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./f8a010fm.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NEON_WEBSOCKET_CAPABILITIES,
     execute(text, params, options) {
@@ -230,4 +230,4 @@ function statsOf(counters, size) {
   };
 }
 
-export { open5, connectClient3, send4 };
+export { open2, connectClient2, send2 };