okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/04svnxxj.js

@@ -0,0 +1,344 @@
+import {
+  DriverError2,
+  timedOut2,
+  isConnectionLost
+} from "./hfq3n3bd.js";
+import {
+  PgSession2
+} from "./62fxpc1p.js";
+import {
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  rowsFrom,
+  resultFrom
+} from "./5x3pf400.js";
+
+// src/adapters/pg/postgres-extra.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function checkout(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 PgSession2(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("./gqwevek4.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 describe(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* stream(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 runBatch(pool, statements, options) {
+  const connection = await checkout(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 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 holdCheckout(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 holdListener(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 watchQuery(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 {
+  checkout,
+  describe,
+  holdCheckout,
+  holdListener,
+  runBatch,
+  stream,
+  watchQuery
+};

package/dist/tooling/shared/0j0jtse1.js

@@ -0,0 +1,13 @@
+import {
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/result-name.ts
+var PROTOTYPE_KEYS = ",__proto__,constructor,toString,hasOwnProperty,valueOf,isPrototypeOf,propertyIsEnumerable,toLocaleString,__defineGetter__,__defineSetter__,__lookupGetter__,__lookupSetter__,then,";
+function refusePrototypeKey(name, where) {
+  if (!PROTOTYPE_KEYS.includes(`,${name},`))
+    return;
+  fail2("OKM1120", `${where} ${name} is a prototype key. Use another name for the result.`);
+}
+
+export { refusePrototypeKey };