okmodel 0.6.0 → 0.8.0

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

@@ -1,9 +1,13 @@
+import {
+  DriverError2,
+  timedOut2
+} from "./cm3w0ywp.js";
 import {
   PgSession
-} from "./wkme6tep.js";
+} from "./35q0n9tz.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   driverErrors,
   rejectClosed,
@@ -11,32 +15,45 @@ import {
   runCall,
   rowsFrom,
   resultFrom
-} from "./cgbamx3e.js";
+} from "./ae4j5f42.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/wvdjznah.js

@@ -0,0 +1,213 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  send2,
+  reserve,
+  park
+} from "./zbqbmmrp.js";
+import {
+  resetSession2,
+  refuseWhenLost2
+} from "./7ghwamrf.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  isConnectionFailure
+} from "./cnkky55j.js";
+import {
+  noTimeout
+} from "./q0cqt2sp.js";
+import {
+  WireSession
+} from "./mtw6jz76.js";
+import {
+  rejectClosed,
+  runCall
+} from "./ae4j5f42.js";
+
+// src/adapters/pg/bunsql-extra.ts
+async function recover(sql, error, text, depth, clientRead, closedDuring, again) {
+  if (!lostQuery(error))
+    throw error;
+  await flushClosed(sql);
+  const alreadyDead = closedDuring || socketClosed(error);
+  if (!clientRead && !alreadyDead || depth !== 0 || !readStatement(text))
+    throw error;
+  try {
+    return await again();
+  } catch (next) {
+    if (lostQuery(next))
+      await flushClosed(sql);
+    throw next;
+  }
+}
+function drainClosed(sql) {
+  return flushClosed(sql).then(() => {
+    return;
+  });
+}
+function readStatement(text) {
+  const head = text.trimStart().toLowerCase().replace(/\s+/g, " ");
+  if (head.length === 0 || head.includes("pg_advisory"))
+    return false;
+  if (/\sfor (?:no key update|key share|update|share)\b/.test(head))
+    return false;
+  return !/^(?:insert|update|delete|refresh|with|create|alter|drop|truncate|grant|revoke|comment|vacuum|analyze|reindex|copy|begin|start|commit|rollback|savepoint|release|set|reset)\b/.test(head);
+}
+function lostQuery(error) {
+  return isConnectionFailure(error) || socketClosed(error);
+}
+function socketClosed(error) {
+  if (!(error instanceof Error))
+    return false;
+  if (error.message === "Connection closed")
+    return true;
+  return error.cause instanceof Error && error.cause.message === "Connection closed";
+}
+async function listen(sql, parked, closed, channel, onNotify) {
+  if (closed)
+    return rejectClosed();
+  const pending = parked.splice(0);
+  for (const reserved of pending) {
+    const done = reserved.release();
+    if (done instanceof Promise)
+      await done;
+  }
+  const subscription = await sql.listen(channel, onNotify);
+  return async () => {
+    await subscription.unlisten();
+  };
+}
+async function checkout(held) {
+  const { counters, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const reserved = await takeOpen(held) ?? await reserve(held.sql, held.acquireMs, counters);
+  counters.reserved += 1;
+  const session = new WireSession((text, params) => send2(reserved, text, params), held.notices, isClosed, false, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  });
+  let lost = { on: false };
+  const opened = held.closures();
+  const reconnected = () => {
+    if (held.closures() === opened)
+      return;
+    lost.on = true;
+    return Promise.reject(new DriverError2("Connection closed", { sqlstate: "08006" }));
+  };
+  const guard = (run) => refuseWhenLost2(lost, () => run().catch((error) => {
+    if (error instanceof Error && bunClosed(error.message)) {
+      throw new DriverError2(error.message, { cause: error, sqlstate: "08006" });
+    }
+    throw error;
+  }));
+  let released = false;
+  return {
+    execute: (text, params, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const gone = reconnected();
+      if (gone !== undefined)
+        return gone;
+      return guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const gone = reconnected();
+      if (gone !== undefined)
+        return gone;
+      return guard(() => runCall(isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./b76b8d95.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
+    evict() {
+      lost.on = true;
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      if (!lost.on && reportsClosed(reserved))
+        lost.on = true;
+      try {
+        if (!lost.on)
+          await reset(session, reserved);
+      } catch (error) {
+        if (lostQuery(error) || reportsClosed(reserved))
+          lost.on = true;
+        else
+          throw error;
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        if (lost.on) {
+          try {
+            reserved.release();
+          } catch {}
+          await flushClosed(held.sql);
+        } else
+          await park(held.parked, reserved);
+      }
+    }
+  };
+}
+function reportsClosed(reserved) {
+  return Reflect.get(reserved, "closed") === true;
+}
+async function takeOpen(held) {
+  while (held.parked.length > 0) {
+    const next = held.parked.pop();
+    if (next === undefined)
+      return;
+    if (!reportsClosed(next))
+      return next;
+    try {
+      next.release();
+    } catch {}
+    await flushClosed(held.sql);
+  }
+  return;
+}
+async function flushClosed(sql) {
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    try {
+      await sql.unsafe("select 1");
+      return true;
+    } catch {}
+  }
+  return false;
+}
+function bunClosed(message) {
+  return message === "Connection closed" || message === "connection must be a PostgresSQLConnection";
+}
+async function reset(session, sql) {
+  const run = (text) => sql.unsafe(text);
+  await resetSession2(session.depth(), run);
+}
+function streamRows(checkout, text, params) {
+  return async function* () {
+    const connection = await checkout();
+    try {
+      yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+    } catch (error) {
+      connection.evict?.();
+      throw error;
+    } finally {
+      await connection.release();
+    }
+  }();
+}
+export {
+  checkout,
+  drainClosed,
+  listen,
+  recover,
+  streamRows
+};

package/dist/shared/wz2a78mp.js

@@ -0,0 +1,8 @@
+import {
+  build2,
+  identityColumn2
+} from "./g5yc06ka.js";
+export {
+  build2 as build,
+  identityColumn2 as identityColumn
+};