okmodel 0.5.1 → 0.7.0

package/dist/shared/{0t22wwh1.js → bm22fvzr.js}

@@ -1,6 +1,9 @@
 import {
-  stack
-} from "./672t5vym.js";
+  stack2
+} from "./mss6ctgv.js";
+import {
+  effectivePredicate
+} from "./n816peh1.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
@@ -12,10 +15,9 @@ import {
   indexes,
   quote,
   isRecord,
-  effectivePredicate,
   registerFailFix,
-  fail
-} from "./gbtcc2d7.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   safetyInstalled,
   runSafety
@@ -48,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.`, {
@@ -59,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));
@@ -81,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 };
@@ -356,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/bz84tkzm.js

@@ -0,0 +1,342 @@
+import {
+  DriverError2,
+  timedOut2
+} from "./cm3w0ywp.js";
+import {
+  PgSession
+} from "./14vx95q4.js";
+import {
+  isConnectionLost
+} from "./cnkky55j.js";
+import {
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  rowsFrom,
+  resultFrom
+} 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, timeoutMs) {
+  if (pool.isClosed())
+    return rejectClosed();
+  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, stop: () => {
+    return;
+  } };
+  arm(reserved, lost);
+  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) => {
+      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();
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      const ms = limit;
+      try {
+        if (!lost.on)
+          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 deadline(ms, () => pool.sql.unsafe("select 1"), pool.sql).catch(() => {
+            return;
+          });
+        else
+          reserved.release();
+      }
+    }
+  };
+}
+async function describe2(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params), { prepare: true });
+  const described = await pending.describe();
+  return {
+    columns: described.columns.map((column) => column.name),
+    parameterCount: described.types.length
+  };
+}
+async function* stream2(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params));
+  for await (const chunk of pending.cursor(64)) {
+    yield rowsFrom(chunk);
+  }
+}
+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;
+        finish();
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    const ms = callMs !== undefined && callMs > 0 ? callMs : 0;
+    deadline(ms, () => sql.reserve(), sql).then((connection) => {
+      if (settled) {
+        resetConnection(connection, 0).catch(() => {
+          return;
+        }).finally(() => {
+          connection.release();
+        });
+        return;
+      }
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      finish();
+      resolve(connection);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      finish();
+      mapFailure(error).then(reject);
+    });
+  });
+}
+async function resetConnection(sql, depth) {
+  if (depth > 0)
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  } catch {
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  }
+}
+function asParams(params) {
+  if (params === undefined)
+    return [];
+  return params;
+}
+function watchReserved2(sql, lost) {
+  arm(sql, lost);
+}
+function arm(sql, lost) {
+  const unsafe = sql.unsafe.bind(sql);
+  sql.unsafe = (text, params, options) => unsafe(text, params, {
+    ...options,
+    onexecute(connection) {
+      connection.onclose = () => {
+        lost.on = true;
+        lost.stop();
+      };
+    }
+  });
+}
+async function holdCheckout2(gate, checkout) {
+  try {
+    const connection = await checkout();
+    let released = false;
+    const release = connection.release.bind(connection);
+    connection.release = () => {
+      if (released)
+        return Promise.resolve();
+      released = true;
+      return release().finally(() => {
+        gate.leave();
+      });
+    };
+    return connection;
+  } catch (error) {
+    gate.leave();
+    throw error;
+  }
+}
+async function holdListener2(gate, start) {
+  try {
+    const stop = await start();
+    let stopped = false;
+    return async () => {
+      if (stopped)
+        return;
+      stopped = true;
+      try {
+        await stop();
+      } finally {
+        gate.leave();
+      }
+    };
+  } catch (error) {
+    gate.leave();
+    throw error;
+  }
+}
+function watchQuery2(pending, watch, onAbort, ctx) {
+  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(value, ctx.notices.since(ctx.start));
+  }, (error) => {
+    finishWatch(pending, watch, onAbort, ctx);
+    return classify(error, watch);
+  });
+}
+function finishWatch(pending, watch, onAbort, ctx) {
+  ctx.leave();
+  ctx.untrack(pending);
+  watch.signal.removeEventListener("abort", onAbort);
+}
+async function classify(error, watch) {
+  const errors = await driverErrors();
+  if (error instanceof errors.DriverError)
+    return Promise.reject(error);
+  const why = typeof error === "string" ? error : watch.reason();
+  if (why === "timeout") {
+    return Promise.reject(errors.timedOut(typeof error === "string" ? undefined : error));
+  }
+  const code = errors.errorField(error, "code");
+  if (why === "cancelled" || code === "57014") {
+    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
+  }
+  return Promise.reject(errors.mapDriverError(error));
+}
+
+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;
 }
 

package/dist/shared/cn957f8d.js

@@ -0,0 +1,179 @@
+import {
+  build3
+} from "./pbp1ss85.js";
+import {
+  attachHttp
+} from "./tbrvgw6z.js";
+import {
+  rejectKeys,
+  readLimit,
+  indexes,
+  isRecord,
+  fail2
+} from "./67txcrcw.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/read-stream.ts
+var DEFAULT_BATCH = 1000;
+var MAX_BATCH = 2147483647;
+async function* streamRows(session, call, mods, view, batchOptions, log) {
+  const stop = (error) => {
+    throw log(attachHttp(session.http, error));
+  };
+  let batch;
+  let total;
+  let signal;
+  let deadline;
+  try {
+    if (call.op !== "find") {
+      fail2("OKM1120", `stream() reads rows from find(). ${call.op}() returns one value.`);
+    }
+    if (call.search !== undefined) {
+      fail2("OKM1120", "stream() does not take search in this version. Use find({ search, limit }) for a ranked list.", "Ranked pages are later. find({ search, limit }) returns one ranked list.");
+    }
+    if (Array.isArray(call.select) && call.select.some((item) => typeof item !== "string")) {
+      fail2("OKM1120", "stream() does not take a window. The keyset cursor has no window value to encode.");
+    }
+    const indexed = indexes(session.schema).get(call.table);
+    if (indexed === undefined)
+      fail2("OKM1120", `Table ${call.table} is not in the schema.`);
+    if (indexed.model.primary.length === 0) {
+      fail2("OKM1120", `stream() needs a primary key on ${indexed.model.name}. A keyset batch orders by that key.`, "Give the table a primary key. stream() orders by it.");
+    }
+    batch = readBatch(batchOptions);
+    if (mods.all !== undefined && mods.all.length === 0) {
+      fail2("OKM1101", "find() .all needs a reason.");
+    }
+    if (call.limit !== undefined)
+      total = readLimit(call.limit);
+    else if (mods.all === undefined) {
+      fail2("OKM1101", "find() needs a limit, or .all(reason) when the full set is intentional.");
+    }
+    const timeout = call.timeout;
+    if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
+      fail2("OKM1121", "timeout must be a number of milliseconds above 0.");
+    }
+    signal = signalOf(call.signal);
+    deadline = timeout === undefined ? undefined : Date.now() + timeout;
+  } catch (error) {
+    if (error instanceof OkmError2)
+      stop(error);
+    throw error;
+  }
+  if (total === 0)
+    return;
+  const cancel = session.pool.capabilities.cancel === true;
+  const statement = session.timeouts?.statement;
+  const pin = {};
+  let after;
+  let left = total;
+  let pending;
+  try {
+    while (left === undefined || left > 0) {
+      if (signal?.aborted === true) {
+        stop(new OkmError2("cancelled", "The stream was cancelled.", { kind: "cancelled" }));
+      }
+      const remaining = timeLeft(deadline);
+      const size = left === undefined ? batch : Math.min(batch, left);
+      const handle = build3(session, call.table, pageFields(call, size, after, signal, batchTimeout(remaining, cancel, statement)), mods, view, pin);
+      pending = handle;
+      const value = asPage(await handle);
+      pending = undefined;
+      for (const row of value.items) {
+        yield row;
+        if (left !== undefined) {
+          left -= 1;
+          if (left === 0)
+            return;
+        }
+      }
+      if (value.next === null || value.items.length < size)
+        return;
+      after = value.next;
+    }
+  } catch (error) {
+    if (error instanceof OkmError2 && error.kind === "timeout" && error.message === "The stream timed out.") {
+      stop(error);
+    }
+    throw error;
+  } finally {
+    if (pending !== undefined) {
+      pending.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    }
+  }
+}
+function readBatch(options) {
+  if (options === undefined)
+    return DEFAULT_BATCH;
+  if (!isRecord(options))
+    fail2("OKM1120", "stream() takes an object. Pass { batch }.");
+  rejectKeys(options, ["batch"], "stream");
+  const batch = options.batch;
+  if (batch === undefined)
+    return DEFAULT_BATCH;
+  if (typeof batch !== "number" || !Number.isInteger(batch) || batch < 1 || batch > MAX_BATCH) {
+    fail2("OKM1121", "stream() batch must be an integer from 1 to 2147483647.");
+  }
+  return batch;
+}
+function pageFields(call, size, after, signal, timeout) {
+  const out = { limit: size };
+  if (call.where !== undefined)
+    out.where = call.where;
+  if (call.select !== undefined)
+    out.select = call.select;
+  if (call.orderBy !== undefined)
+    out.orderBy = call.orderBy;
+  if (call.include !== undefined)
+    out.include = call.include;
+  if (call.route !== undefined)
+    out.route = call.route;
+  if (after !== undefined)
+    out.after = after;
+  if (signal !== undefined)
+    out.signal = signal;
+  if (timeout !== undefined)
+    out.timeout = timeout;
+  return out;
+}
+function timeLeft(deadline) {
+  if (deadline === undefined)
+    return;
+  const left = deadline - Date.now();
+  if (left <= 0)
+    throw new OkmError2("timeout", "The stream timed out.", { kind: "timeout" });
+  return left;
+}
+function batchTimeout(remaining, cancel, statement) {
+  if (!cancel || remaining === undefined)
+    return;
+  if (statement !== undefined && statement > 0 && statement < remaining)
+    return statement;
+  return remaining;
+}
+function signalOf(value) {
+  if (typeof value === "object" && value !== null && "aborted" in value) {
+    return value;
+  }
+  return;
+}
+function asPage(value) {
+  if (typeof value !== "object" || value === null || !("items" in value) || !("next" in value)) {
+    throw new OkmError2("OKM1120", "stream() did not get a page of rows.");
+  }
+  const items = value.items;
+  const next = value.next;
+  if (!Array.isArray(items) || next !== null && typeof next !== "string") {
+    throw new OkmError2("OKM1120", "stream() did not get a page of rows.");
+  }
+  return { items, next };
+}
+export {
+  streamRows
+};