okmodel 0.6.0 → 0.8.0

package/dist/shared/jx2m62cs.js

@@ -0,0 +1,96 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  connectClient2,
+  send3
+} from "./agsfb86s.js";
+import {
+  resetSession2
+} from "./7ghwamrf.js";
+import {
+  isConnectionLost
+} from "./cnkky55j.js";
+import {
+  noTimeout
+} from "./q0cqt2sp.js";
+import {
+  WireSession
+} from "./mtw6jz76.js";
+import {
+  rejectClosed,
+  runCall
+} from "./ae4j5f42.js";
+
+// src/adapters/pg/neon-extra.ts
+async function checkout(held) {
+  const { pool, counters, named, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const client = await connectClient2(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 = send3(client, text, params, named);
+    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;
+    });
+    return guarded;
+  }, held.notices, isClosed, false, () => {
+    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) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return guard(() => runCall(isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./b76b8d95.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
+    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));
+}
+export {
+  checkout
+};

package/dist/shared/{r11n8grd.js → k86n8vq3.js}

@@ -3,10 +3,10 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./j60w0dvr.js";
+} from "./bah9nbg3.js";
 import {
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./kgwp4jdd.js";
 import {
   OkmError2,
   throwNamed2
@@ -35,13 +35,16 @@ function plan(session, table, options, mods, view) {
       }
     });
   }
+  if (lock === "skip") {
+    fail2("OKM1120", 'lock: "skip" claims rows on update. A read uses lock: "update" and wait: "skip".', 'Pass lock: "update" and wait: "skip" inside tx(). An update can claim rows on its own.');
+  }
   if (session.tx === undefined) {
     throw new OkmError2("OKM1830", "A row lock needs a transaction. find was called outside tx().", {
       fix: { summary: "Move the find into tx(): the lock lasts until the transaction ends." }
     });
   }
   if (lock === undefined)
-    fail("OKM1121", "wait needs lock: pass lock: update or lock: share.");
+    fail2("OKM1121", "wait needs lock: pass lock: update or lock: share.");
   if (typeof lock !== "string" || !LOCKS.includes(lock)) {
     throwNamed2("OKM1120", shown(lock), LOCKS, `lock must be one of: ${LOCKS.join(", ")}.`);
   }

package/dist/shared/{2z7wv5tj.js → kgwp4jdd.js}

@@ -41,6 +41,7 @@ var FIND_OPTIONS = [
   "include",
   "limit",
   "orderBy",
+  "search",
   "select",
   "route",
   "signal",
@@ -56,12 +57,15 @@ var ONE_OPTIONS = [
   "timeout",
   "where"
 ];
+var COUNT_OPTIONS = ["route", "search", "signal", "timeout", "where"];
 var FILTER_OPTIONS = ["route", "signal", "timeout", "where"];
 function readOptionNames(op) {
   if (op === "find")
     return FIND_OPTIONS;
   if (op === "one")
     return ONE_OPTIONS;
+  if (op === "count")
+    return COUNT_OPTIONS;
   return FILTER_OPTIONS;
 }
 var BASE_RULES = [
@@ -78,7 +82,19 @@ function readNeedsOperatorSql(schema, call) {
   if (operatorEmit !== undefined)
     return false;
   const table = indexes(schema).get(call.table);
-  return table !== undefined && needsOperatorSql(table, call.where);
+  if (table === undefined)
+    return false;
+  return needsOperatorSql(table, call.where) || orderHasRelevance(call.orderBy);
+}
+function orderHasRelevance(orderBy) {
+  if (!isRecord(orderBy))
+    return false;
+  for (const key of Object.keys(orderBy)) {
+    const value = orderBy[key];
+    if (isOperator(value) && operatorName(value) === "relevance")
+      return true;
+  }
+  return false;
 }
 function emitRelationFrom(schema, relation, child, sink, parent, alias, depth) {
   if (relation.through !== undefined) {
@@ -122,12 +138,12 @@ function needsOperatorSql(table, value, key) {
 function isTextColumn(dataType) {
   return dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("char(") || dataType.startsWith("character");
 }
-function emitLazy(column, ref, name, value, sink) {
+function emitLazy(table, column, ref, name, value, sink, order) {
   const emit = operatorEmit;
   if (emit === undefined) {
-    fail("OKM1121", `Operator ${name} on ${column.field} is not loaded.`);
+    fail2("OKM1121", `Operator ${name} on ${column.field} is not loaded.`);
   }
-  emit(column, ref, name, value, sink);
+  emit(table, column, ref, name, value, sink, order);
 }
 function verifyRead(schema, call) {
   if (!safetyInstalled())
@@ -208,7 +224,7 @@ function logicalIntent(call) {
     table: call.table,
     where: plain(call.where),
     select: call.select,
-    orderBy: call.orderBy,
+    orderBy: plain(call.orderBy),
     limit: call.limit,
     include: plain(call.include),
     all: call.all
@@ -261,7 +277,7 @@ function emitRead(schema, call, sink, outputs, hooks) {
     throwNamed2("OKM1120", call.table, [...indexes(schema).keys()], `Table ${call.table} is not in the schema. Accepted names: ${list([...indexes(schema).keys()])}.`);
   }
   if (call.build !== undefined) {
-    call.build(schema, table, sink, outputs, call);
+    call.build(schema, table, sink, outputs, call, hooks);
     return;
   }
   rejectOptions(call);
@@ -296,7 +312,7 @@ function emitRead(schema, call, sink, outputs, hooks) {
     column += 1;
   }
   if (call.include !== undefined && hooks === undefined) {
-    fail("OKM1120", "An include needs the include planner.");
+    fail2("OKM1120", "An include needs the include planner.");
   }
   const includes = hooks === undefined || call.include === undefined ? [] : hooks.read(schema, table, call.include, call.all);
   if (selected.length === 0 && includes.length === 0)
@@ -375,7 +391,7 @@ function emitWhere(schema, table, where, sink, alias, depth, appended = false, e
       continue;
     const joined = isOperator(part);
     if (!joined && !isRecord(part))
-      fail("OKM1121", WHERE_FIELDS);
+      fail2("OKM1121", WHERE_FIELDS);
     if (!joined && Object.keys(part).length === 0)
       continue;
     sink.text(started ? " and " : " where ");
@@ -389,7 +405,7 @@ function emitWhere(schema, table, where, sink, alias, depth, appended = false, e
 var WHERE_FIELDS = "where must be an object of fields. Wrap an object value with eq.";
 function emitAnd(schema, table, where, sink, alias, depth) {
   if (!isRecord(where)) {
-    fail("OKM1121", WHERE_FIELDS);
+    fail2("OKM1121", WHERE_FIELDS);
   }
   const keys = Object.keys(where);
   let wrote = false;
@@ -446,7 +462,7 @@ function emitOperator(schema, table, column, ref, name, value, sink, alias, dept
     return;
   }
   if (column === undefined) {
-    fail("OKM1121", "That operator needs a field.");
+    fail2("OKM1121", "That operator needs a field.");
   }
   if (name === "not") {
     emitNot(schema, table, column, ref, value, sink, alias, depth);
@@ -464,7 +480,7 @@ function emitOperator(schema, table, column, ref, name, value, sink, alias, dept
   }
   if (name === "between") {
     if (!Array.isArray(value) || value.length !== 2) {
-      fail("OKM1121", `between on ${column.field} needs two values.`);
+      fail2("OKM1121", `between on ${column.field} needs two values.`);
     }
     sink.text(ref);
     sink.text(" between ");
@@ -479,7 +495,7 @@ function emitOperator(schema, table, column, ref, name, value, sink, alias, dept
   }
   if (TEXT_OPERATORS.includes(`,${name},`) && isTextColumn(column.dataType)) {
     if (typeof value !== "string") {
-      fail("OKM1121", `${name} on ${column.field} needs a string.`);
+      fail2("OKM1121", `${name} on ${column.field} needs a string.`);
     }
     sink.text(ref);
     if (name === "like" || name === "ilike") {
@@ -489,13 +505,13 @@ function emitOperator(schema, table, column, ref, name, value, sink, alias, dept
     }
     sink.text(" like ");
     if (name !== "startsWith" && name !== "endsWith" && name !== "contains") {
-      fail("OKM1121", `${name} on ${column.field} needs a string.`);
+      fail2("OKM1121", `${name} on ${column.field} needs a string.`);
     }
     sink.param(literalPattern(value, name));
     sink.text(" escape E'\\\\'");
     return;
   }
-  emitLazy(column, ref, name, value, sink);
+  emitLazy(table, column, ref, name, value, sink);
 }
 function emitNot(schema, table, column, ref, value, sink, alias, depth) {
   if (value === null) {
@@ -517,7 +533,7 @@ function emitNot(schema, table, column, ref, value, sink, alias, depth) {
 }
 function emitIn(column, ref, name, value, sink) {
   if (!Array.isArray(value)) {
-    fail("OKM1121", `${name} on ${column.field} needs a list.`);
+    fail2("OKM1121", `${name} on ${column.field} needs a list.`);
   }
   sink.mark(`:${String(value.length)}`);
   if (value.length === 0) {
@@ -549,7 +565,7 @@ function emitOr(schema, table, value, sink, alias, depth) {
       sink.text(" or ");
     sink.text("(");
     if (!isRecord(branch)) {
-      fail("OKM1121", "or() branches must be where objects.");
+      fail2("OKM1121", "or() branches must be where objects.");
     }
     let wrote = false;
     for (const key of Object.keys(branch)) {
@@ -569,15 +585,15 @@ function emitOr(schema, table, value, sink, alias, depth) {
 }
 function emitRelationFilter(schema, relation, value, sink, alias, depth) {
   if (!isOperator(value)) {
-    fail("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
+    fail2("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
   }
   const name = operatorName(value);
   if (name !== "has" && name !== "none" && name !== "every") {
-    fail("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
+    fail2("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
   }
   const child = indexes(schema).get(relation.table);
   if (child === undefined) {
-    fail("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
+    fail2("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
   }
   const childAlias = `r${String(depth)}_${relation.name}`;
   sink.mark(`rel:${relation.name}:${name}`);
@@ -601,7 +617,7 @@ function emitOrder(table, orderBy, sink, alias) {
   if (orderBy === undefined)
     return;
   if (!isRecord(orderBy)) {
-    fail("OKM1120", "orderBy must be an object of fields.");
+    fail2("OKM1120", "orderBy must be an object of fields.");
   }
   const keys = Object.keys(orderBy);
   if (keys.length === 0)
@@ -616,9 +632,14 @@ function emitOrder(table, orderBy, sink, alias) {
       throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
     }
     refuseHidden(column);
-    const parsed = parseOrder(key, orderBy[key]);
+    const value = orderBy[key];
     if (index > 0)
       sink.text(", ");
+    if (isOperator(value) && operatorName(value) === "relevance") {
+      emitLazy(table, column, `${alias}.${quote(column.sql)}`, "relevance", operatorValue(value), sink, true);
+      continue;
+    }
+    const parsed = parseOrder(key, value);
     sink.text(alias);
     sink.text(".");
     sink.text(quote(column.sql));
@@ -647,7 +668,7 @@ function emitPrimaryOrder(table, sink, alias) {
 function refuseHidden(column) {
   if (column.hidden !== true)
     return;
-  fail("OKM1120", `Field ${column.field} is hidden.`, "Call hidden({ filterable: true }).");
+  fail2("OKM1120", `Field ${column.field} is hidden.`, "Call hidden({ filterable: true }).");
 }
 function emitLimit(call, sink) {
   if (call.op === "one") {
@@ -660,7 +681,7 @@ function emitLimit(call, sink) {
     return;
   if (call.all !== undefined) {
     if (call.all.length === 0) {
-      fail("OKM1101", "find() .all needs a reason.");
+      fail2("OKM1101", "find() .all needs a reason.");
     }
     sink.mark(`all:${call.all}`);
     if (call.limit !== undefined) {
@@ -672,7 +693,7 @@ function emitLimit(call, sink) {
     return;
   }
   if (call.limit === undefined) {
-    fail("OKM1101", "find() needs a limit, or .all(reason) when the full set is intentional.");
+    fail2("OKM1101", "find() needs a limit, or .all(reason) when the full set is intentional.");
   }
   const limit = readLimit(call.limit);
   sink.text(" limit ");
@@ -689,12 +710,12 @@ function selectedColumns(table, select) {
     return columns;
   }
   if (!Array.isArray(select)) {
-    fail("OKM1120", "select must be a list of field names.");
+    fail2("OKM1120", "select must be a list of field names.");
   }
   const columns = [];
   for (const name of select) {
     if (typeof name !== "string") {
-      fail("OKM1120", "select must be a list of field names.");
+      fail2("OKM1120", "select must be a list of field names.");
     }
     const column = table.columns.get(name);
     if (column === undefined) {
@@ -712,17 +733,17 @@ function parseOrder(field, value) {
   if (isRecord(value)) {
     const dir = value.dir ?? value.direction;
     if (dir !== "asc" && dir !== "desc") {
-      fail("OKM1120", `orderBy ${field} must be asc or desc.`);
+      fail2("OKM1120", `orderBy ${field} must be asc or desc.`);
     }
     const nulls = value.nulls;
     if (nulls === undefined)
       return { dir, nulls: dir === "asc" ? "last" : "first" };
     if (nulls !== "first" && nulls !== "last") {
-      fail("OKM1120", `orderBy ${field} nulls must be first or last.`);
+      fail2("OKM1120", `orderBy ${field} nulls must be first or last.`);
     }
     return { dir, nulls };
   }
-  fail("OKM1120", `orderBy ${field} must be asc or desc.`);
+  fail2("OKM1120", `orderBy ${field} must be asc or desc.`);
 }
 function rejectOptions(call) {
   const accepted = readOptionNames(call.op);
@@ -739,11 +760,11 @@ function rejectOptions(call) {
     present.include = call.include;
   rejectKeys(present, accepted, call.op);
 }
-function rejectKeys(value, accepted, where) {
+function rejectKeys(value, accepted, where, search) {
   for (const key of Object.keys(value)) {
     if (accepted.includes(key))
       continue;
-    throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${where}. Accepted options: ${list(accepted)}.`);
+    throwNamed2("OKM1120", key, accepted, key === "search" && search === true ? `${where}() does not take search. Pass search to find or count.` : `Option ${key} is not accepted by ${where}. Accepted options: ${list(accepted)}.`);
   }
 }
 function readLimit(value) {
@@ -754,7 +775,7 @@ function readLimit(value) {
 }
 function requireValue(column, value) {
   if (value === undefined || value === null) {
-    fail("OKM1121", `Field ${column.field} needs a value.`);
+    fail2("OKM1121", `Field ${column.field} needs a value.`);
   }
   if (typeof value === "object")
     takeObject(column, value);
@@ -762,7 +783,7 @@ function requireValue(column, value) {
 }
 function takeObject(column, value, bare = false) {
   if (bare || !column.accepts?.includes({}.toString.call(value).slice(8, -1))) {
-    fail("OKM1121", `Field ${column.field} rejects that object.`);
+    fail2("OKM1121", `Field ${column.field} rejects that object.`);
   }
 }
 function projectExpr(sql, dataType) {
@@ -867,7 +888,7 @@ var FAIL_FIX = {
 function registerFailFix(code, summary) {
   FAIL_FIX[code] = summary;
 }
-function fail(code, message, fix) {
+function fail2(code, message, fix) {
   const summary = fix ?? FAIL_FIX[code];
   throw new OkmError2(code, message, summary === undefined ? undefined : { fix: { summary } });
 }
@@ -891,4 +912,4 @@ function hasMany(include) {
   return Object.keys(include).length > 0;
 }
 
-export { withRowFilters, installArchiveInspect, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, emitRelationFrom, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, refuseHidden, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, orFail, registerFailFix, fail };
+export { withRowFilters, installArchiveInspect, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, orderHasRelevance, emitRelationFrom, needsOperatorSql, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, refuseHidden, emitLimit, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, orFail, registerFailFix, fail2 };

package/dist/shared/{knmes2kh.js → kj9d8maq.js}

@@ -1,6 +1,6 @@
 import {
   FUNCTION_ARG_TYPES
-} from "./vjpnzwjz.js";
+} from "./p3xbdcvt.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/{g90m9b0g.js → m4xff2a6.js}

@@ -1,15 +1,16 @@
 import {
-  open3
-} from "./5j36z8dn.js";
-import"./8dqhth8c.js";
+  open3,
+  seal2
+} from "./4m6hskg8.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "./cgbamx3e.js";
+} from "./ae4j5f42.js";
 export {
   PGLITE_CAPABILITIES as capabilities,
   hasCapability2 as hasCapability,
   open3 as open,
-  readCapability2 as readCapability
+  readCapability2 as readCapability,
+  seal2 as seal
 };

package/dist/shared/{r6nwkxnt.js → m7n9h2a5.js}

@@ -1,9 +1,9 @@
 import {
-  stack
-} from "./672t5vym.js";
+  stack2
+} from "./mss6ctgv.js";
 import {
   checkPresetNames
-} from "./nsva2a6b.js";
+} from "./znm0bpp5.js";
 import {
   isOperator,
   operatorValue
@@ -60,7 +60,7 @@ function refine(schema, call, uses) {
   const { wheres, rules } = resolve(schema, call.table, uses);
   return {
     ...call,
-    where: stack(call.where, wheres),
+    where: stack2(call.where, wheres),
     ruleLines: [...call.ruleLines ?? [], ...rules]
   };
 }

package/dist/shared/mfedzr74.js

@@ -0,0 +1,145 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  armDriverError,
+  send,
+  connectClient
+} from "./14x60fbf.js";
+import {
+  resetSession2
+} from "./7ghwamrf.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  isConnectionLost
+} from "./cnkky55j.js";
+import {
+  WireSession
+} from "./mtw6jz76.js";
+import {
+  rejectClosed,
+  runCall
+} from "./ae4j5f42.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
+};