okmodel 0.6.0 → 0.7.0

package/dist/shared/{ag4c7516.js → b76b8d95.js}

@@ -2,10 +2,10 @@ import {
   DriverError2,
   outcomeUnknown2,
   mapDriverError2
-} from "./31vm914h.js";
+} from "./cm3w0ywp.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 
 // src/adapters/pg/batch.ts
 var savepointIds = 0;

package/dist/shared/{vmfkhszw.js → bg3rym3g.js}

@@ -1,15 +1,15 @@
 import {
   touchFields,
   fieldSealed
-} from "./7m88x3e9.js";
+} from "./1w508jbr.js";
 import {
   projectExpr,
   quote,
   list,
   isRecord,
   registerFailFix,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   throwNamed2
 } from "./52szzakm.js";
@@ -24,13 +24,13 @@ function readConflict(table, value, allow = NO_ALLOW, tenantKey) {
   if (value === "ignore")
     return { kind: "ignore", columns: [], update: [] };
   if (!isRecord(value)) {
-    fail("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
+    fail2("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
   }
   const keys = Object.keys(value);
   const update = value.update;
   const ret = value.return;
   if (update !== undefined && ret !== undefined) {
-    fail("OKM1120", "onConflict takes update or return, not both.");
+    fail2("OKM1120", "onConflict takes update or return, not both.");
   }
   if (ret === true) {
     rejectConflictKeys(keys, ["on", "return"]);
@@ -44,9 +44,9 @@ function readConflict(table, value, allow = NO_ALLOW, tenantKey) {
       update: updateColumns(table, update, allow)
     };
   }
-  fail("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
+  fail2("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
 }
-function finishInsert(head, returning, params, plan, table, returningColumns, keys) {
+function finishInsert(head, returning, params, plan, table) {
   if (plan.kind === "ignore") {
     return { text: `${head} on conflict do nothing${returning}`, params: [...params] };
   }
@@ -66,10 +66,13 @@ function finishInsert(head, returning, params, plan, table, returningColumns, ke
       params: [...params]
     };
   }
-  return firstOrCreate(head, returning, params, plan.columns, table, returningColumns, keys);
+  return {
+    text: `${head} on conflict (${target})${conflictWhere(table, plan.columns)} do nothing${returning}`,
+    params: [...params]
+  };
 }
-function firstOrCreate(head, returning, params, keys, table, returningColumns, keyRows) {
-  const next = [...params];
+function lookupExisting(table, keys, returningColumns, keyRows) {
+  const params = [];
   const tuples = [];
   for (const row of keyRows) {
     const slots = [];
@@ -77,18 +80,21 @@ function firstOrCreate(head, returning, params, keys, table, returningColumns, k
       const column = keys[index];
       if (column === undefined)
         continue;
-      next.push(row[index] ?? null);
-      slots.push(`$${String(next.length)}::${column.dataType}`);
+      params.push(row[index] ?? null);
+      slots.push(`$${String(params.length)}::${column.dataType}`);
     }
     tuples.push(keys.length === 1 ? slots[0] ?? "null" : `(${slots.join(", ")})`);
   }
-  const keyList = keys.map((column) => quote(column.sql)).join(", ");
   const left = keys.length === 1 ? `t.${quote(keys[0]?.sql ?? "")}` : `(${keys.map((column) => `t.${quote(column.sql)}`).join(", ")})`;
-  const names = returningColumns.map((column) => quote(column.field)).join(", ");
-  const fromTable = returningColumns.map((column) => projectExpr(`t.${quote(column.sql)}`, column.dataType)).join(", ");
-  const match = keys.map((column) => `ins.${quote(column.field)} = t.${quote(column.sql)}`).join(" and ");
-  const text = `with ins(${names}) as (${head} on conflict (${keyList})${conflictWhere(table, keys)} do nothing${returning}) select ${names} from ins union all select ${fromTable} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")}) and not exists (select 1 from ins where ${match})`;
-  return { text, params: next };
+  const projected = returningColumns.map((column) => projectExpr(`t.${quote(column.sql)}`, column.dataType)).join(", ");
+  const text = `select ${projected} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")})${activeAnd(table, keys)}`;
+  return { text, params };
+}
+function activeAnd(table, columns) {
+  const clause = conflictWhere(table, columns);
+  if (clause === "")
+    return "";
+  return ` and t.${clause.replace(/^ where /, "")}`;
 }
 function conflictWhere(table, columns) {
   const archive = table.model.archive;
@@ -121,7 +127,7 @@ function uniqueColumns(table, on, tenantKey) {
     for (const name of fields) {
       const column = table.columns.get(name);
       if (column === undefined) {
-        fail("OKM1104", `onConflict column ${name} is not on ${table.model.name}.`);
+        fail2("OKM1104", `onConflict column ${name} is not on ${table.model.name}.`);
       }
       columns.push(column);
     }
@@ -143,12 +149,12 @@ function acceptedConstraints(model, keys) {
 }
 function updateColumns(table, value, allow) {
   if (!Array.isArray(value) || value.length === 0) {
-    fail("OKM1120", "onConflict update must name at least one column.");
+    fail2("OKM1120", "onConflict update must name at least one column.");
   }
   const columns = [];
   for (const name of value) {
     if (typeof name !== "string")
-      fail("OKM1120", "onConflict update must name columns.");
+      fail2("OKM1120", "onConflict update must name columns.");
     const column = table.columns.get(name);
     if (column === undefined) {
       throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
@@ -166,7 +172,7 @@ function conflictNames(on) {
   if (Array.isArray(on) && on.length > 0 && on.every((name) => typeof name === "string")) {
     return on;
   }
-  fail("OKM1104", "onConflict on must name a unique constraint's columns.");
+  fail2("OKM1104", "onConflict on must name a unique constraint's columns.");
 }
 function fieldsOf(unique, names, tenantKeys) {
   if (tenantKeys.some((key) => unique.includes(key))) {
@@ -210,17 +216,18 @@ function rejectConflictKeys(keys, accepted) {
 }
 function refuseWrite(table, column) {
   if (fieldSealed(table.model, column.field)) {
-    fail("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
   }
   if (column.guardUpdate) {
-    fail("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
   }
   if (column.guarded) {
-    fail("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
   }
-  fail("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
+  fail2("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
 }
 export {
   finishInsert,
+  lookupExisting,
   readConflict
 };

package/dist/shared/{mb2ycs1p.js → bm22fvzr.js}

@@ -1,9 +1,9 @@
 import {
-  effectivePredicate
-} from "./b3awxn7h.js";
+  stack2
+} from "./mss6ctgv.js";
 import {
-  stack
-} from "./672t5vym.js";
+  effectivePredicate
+} from "./n816peh1.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
@@ -16,8 +16,8 @@ import {
   quote,
   isRecord,
   registerFailFix,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   safetyInstalled,
   runSafety
@@ -50,7 +50,7 @@ function explainArchive(schema, op, table, input, options, mods, scope) {
 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.`);
+    fail2("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.`, {
@@ -61,7 +61,7 @@ function planArchive(schema, op, tableName, input, options, mods, scope) {
   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 target = { ...read, where: stack2(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));
@@ -83,25 +83,25 @@ function noteArchive(table, view) {
 }
 function readTarget(op, table, input, mods) {
   if (!isRecord(input))
-    fail("OKM1121", `${op} expects { where }.`);
+    fail2("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.");
+      fail2("OKM1120", "restore takes where or archiveId, not both.");
     for (const key of keys) {
       if (key !== "archiveId") {
-        fail("OKM1120", "restore accepts where or archiveId.");
+        fail2("OKM1120", "restore accepts where or archiveId.");
       }
     }
     if (typeof input.archiveId !== "string" || input.archiveId.length === 0) {
-      fail("OKM1121", "restore archiveId must be a uuid.");
+      fail2("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.`);
+      fail2("OKM1120", `${op} accepts where.`);
   }
   requireFilter(table, input.where, mods, op);
   return { where: input.where, archiveId: undefined };
@@ -358,12 +358,12 @@ function expectOf(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.`);
+      fail2("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
     }
     return;
   }
   if (!effectivePredicate(where)) {
-    fail("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
+    fail2("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
   }
 }
 function callOptions(input) {

package/dist/shared/{q3j1tq7a.js → bz84tkzm.js}

@@ -1,9 +1,13 @@
+import {
+  DriverError2,
+  timedOut2
+} from "./cm3w0ywp.js";
 import {
   PgSession
-} from "./wkme6tep.js";
+} from "./14vx95q4.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   driverErrors,
   rejectClosed,
@@ -11,32 +15,45 @@ import {
   runCall,
   rowsFrom,
   resultFrom
-} from "./cgbamx3e.js";
+} from "./kb2sdhfb.js";
 
 // src/adapters/pg/postgres-extra.ts
 var RESET_ALL = "RESET ALL";
 var UNLOCK = "SELECT pg_advisory_unlock_all()";
-async function checkout2(pool) {
+async function checkout2(pool, timeoutMs) {
   if (pool.isClosed())
     return rejectClosed();
-  const reserved = await reserveConnection(pool.sql, pool.acquireMs, pool.counters);
+  const reserved = await reserveConnection(pool.sql, pool.acquireMs, pool.counters, timeoutMs);
   pool.counters.reserved += 1;
   const local = new Set;
   const session = new PgSession(reserved, pool.counters, "reserved", local, pool.isClosed, pool.poolInflight, pool.notices, pool.named);
   let released = false;
-  const lost = { on: false };
+  const lost = { on: false, stop: () => {
+    return;
+  } };
   arm(reserved, lost);
-  const guard = (run) => lost.on ? rejectClosed("CONNECTION_CLOSED") : run().catch((error) => {
+  let limit = timeoutMs !== undefined && timeoutMs > 0 ? timeoutMs : 0;
+  const remember = (timeout) => {
+    if (timeout !== undefined && timeout > 0)
+      limit = timeout;
+  };
+  const guard = (run) => lost.on ? rejectClosed() : run().catch((error) => {
     if (isConnectionLost(error))
       lost.on = true;
     throw error;
   });
   return {
-    execute: (text, params, options) => guard(() => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch))),
-    batch: (statements, options) => guard(() => runCall(pool.isClosed(), options, async (watch) => {
-      const { runAtomicBatch } = await import("./ag4c7516.js");
-      return runAtomicBatch(session, statements, watch);
-    })),
+    execute: (text, params, options) => {
+      remember(options?.timeout);
+      return guard(() => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      remember(options?.timeout);
+      return guard(() => runCall(pool.isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./b76b8d95.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
     cancel() {
       session.cancel();
     },
@@ -44,13 +61,16 @@ async function checkout2(pool) {
       if (released)
         return;
       released = true;
+      const ms = limit;
       try {
         if (!lost.on)
-          await resetConnection(reserved, session.depth());
+          await deadline(ms, () => resetConnection(reserved, session.depth()), lost);
+      } catch {
+        lost.on = true;
       } finally {
         pool.counters.reserved = Math.max(0, pool.counters.reserved - 1);
         if (lost.on)
-          await pool.sql.unsafe("select 1").catch(() => {
+          await deadline(ms, () => pool.sql.unsafe("select 1"), pool.sql).catch(() => {
             return;
           });
         else
@@ -73,37 +93,141 @@ async function* stream2(sql, text, params) {
     yield rowsFrom(chunk);
   }
 }
-function reserveConnection(sql, acquireMs, counters) {
+function poolWaits(sql) {
+  const options = sql.options;
+  if (options === undefined || options.q !== undefined)
+    return options;
+  const q = new Set;
+  const n = new Set;
+  options.q = q;
+  options.n = n;
+  options.onclose = (id) => {
+    n.add(id);
+    if (n.size < options.max) {
+      queueMicrotask(() => {
+        for (const wait of q)
+          wait.a();
+      });
+      return;
+    }
+    n.clear();
+    for (const wait of q)
+      wait.s();
+    q.clear();
+  };
+  return options;
+}
+function deadline(ms, run, link) {
+  let timer;
+  let off = () => {
+    return;
+  };
+  const slot = link !== undefined && "stop" in link ? link : undefined;
+  const pool = slot === undefined && link !== undefined ? poolWaits(link) : undefined;
+  let ended = false;
+  return new Promise((resolve, reject) => {
+    const fail = (error) => {
+      if (ended)
+        return;
+      ended = true;
+      reject(error);
+    };
+    const stop = () => {
+      fail(new DriverError2("Connection closed", { sqlstate: "08006" }));
+    };
+    if (slot !== undefined)
+      slot.stop = stop;
+    const go = () => {
+      const pending = run();
+      if (ms > 0 && timer === undefined) {
+        timer = setTimeout(() => {
+          pending.cancel?.();
+          fail(timedOut2());
+        }, ms);
+      }
+      pending.then((value) => {
+        if (ended) {
+          value.release?.();
+          return;
+        }
+        ended = true;
+        pool?.n?.clear();
+        resolve(value);
+      }, fail);
+    };
+    if (ms === 0 && pool?.q !== undefined) {
+      let used = false;
+      const wait = {
+        s: stop,
+        a() {
+          if (used || ended)
+            return;
+          used = true;
+          go();
+        }
+      };
+      pool.q.add(wait);
+      off = () => pool.q?.delete(wait);
+    }
+    go();
+  }).finally(() => {
+    clearTimeout(timer);
+    if (slot !== undefined)
+      slot.stop = () => {
+        return;
+      };
+    off();
+  });
+}
+async function runBatch2(pool, statements, options) {
+  const connection = await checkout2(pool, options?.timeout);
+  try {
+    return await connection.batch(statements, options);
+  } finally {
+    await connection.release();
+  }
+}
+function reserveConnection(sql, acquireMs, counters, callMs) {
   counters.waiting += 1;
   let settled = false;
+  const finish = () => {
+    counters.waiting = Math.max(0, counters.waiting - 1);
+  };
   return new Promise((resolve, reject) => {
     let timer;
     if (acquireMs !== undefined) {
       timer = setTimeout(() => {
+        if (settled)
+          return;
         settled = true;
-        counters.waiting = Math.max(0, counters.waiting - 1);
+        finish();
         driverErrors().then((errors) => {
           reject(errors.acquireTimeout());
         });
       }, acquireMs);
     }
-    sql.reserve().then((connection) => {
+    const ms = callMs !== undefined && callMs > 0 ? callMs : 0;
+    deadline(ms, () => sql.reserve(), sql).then((connection) => {
       if (settled) {
-        resetConnection(connection, 0).finally(() => {
+        resetConnection(connection, 0).catch(() => {
+          return;
+        }).finally(() => {
           connection.release();
         });
         return;
       }
+      settled = true;
       if (timer !== undefined)
         clearTimeout(timer);
-      counters.waiting = Math.max(0, counters.waiting - 1);
+      finish();
       resolve(connection);
     }, (error) => {
       if (settled)
         return;
+      settled = true;
       if (timer !== undefined)
         clearTimeout(timer);
-      counters.waiting = Math.max(0, counters.waiting - 1);
+      finish();
       mapFailure(error).then(reject);
     });
   });
@@ -139,6 +263,7 @@ function arm(sql, lost) {
     onexecute(connection) {
       connection.onclose = () => {
         lost.on = true;
+        lost.stop();
       };
     }
   });
@@ -182,13 +307,13 @@ async function holdListener2(gate, start) {
   }
 }
 function watchQuery2(pending, watch, onAbort, ctx) {
-  return pending.then((result) => {
+  return pending.then((value) => {
     finishWatch(pending, watch, onAbort, ctx);
     const why = watch.reason();
     if (why === "timeout" || why === "cancelled")
       return classify(why, watch);
     ctx.note(ctx.text);
-    return resultFrom(result, ctx.notices.since(ctx.start));
+    return resultFrom(value, ctx.notices.since(ctx.start));
   }, (error) => {
     finishWatch(pending, watch, onAbort, ctx);
     return classify(error, watch);
@@ -214,4 +339,4 @@ async function classify(error, watch) {
   return Promise.reject(errors.mapDriverError(error));
 }
 
-export { checkout2, describe2, stream2, watchReserved2, holdCheckout2, holdListener2, watchQuery2 };
+export { checkout2, describe2, stream2, runBatch2, watchReserved2, holdCheckout2, holdListener2, watchQuery2 };

package/dist/shared/{31vm914h.js → cm3w0ywp.js}

@@ -96,22 +96,21 @@ function messageOf(error) {
 }
 function driverFields(input) {
   const fields = {};
-  if (input.sqlstate !== undefined)
-    fields.sqlstate = input.sqlstate;
-  if (input.constraint !== undefined)
-    fields.constraint = input.constraint;
-  if (input.table !== undefined)
-    fields.table = input.table;
-  if (input.column !== undefined)
-    fields.column = input.column;
-  if (input.detail !== undefined)
-    fields.detail = input.detail;
-  if (input.cause !== undefined)
-    fields.cause = input.cause;
-  if (input.batchIndex !== undefined)
-    fields.batchIndex = input.batchIndex;
-  if (input.kind !== undefined)
-    fields.kind = input.kind;
+  const keys = [
+    "sqlstate",
+    "constraint",
+    "table",
+    "column",
+    "detail",
+    "cause",
+    "batchIndex",
+    "kind"
+  ];
+  for (const key of keys) {
+    const value = input[key];
+    if (value !== undefined)
+      fields[key] = value;
+  }
   return fields;
 }