okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/a2xe04bm.js

@@ -0,0 +1,18 @@
+import {
+  DriverError2,
+  cancelled2,
+  timedOut2,
+  outcomeUnknown2,
+  acquireTimeout2,
+  errorField2,
+  mapDriverError2
+} from "./hfq3n3bd.js";
+export {
+  DriverError2 as DriverError,
+  acquireTimeout2 as acquireTimeout,
+  cancelled2 as cancelled,
+  errorField2 as errorField,
+  mapDriverError2 as mapDriverError,
+  outcomeUnknown2 as outcomeUnknown,
+  timedOut2 as timedOut
+};

package/dist/tooling/shared/a4pzghha.js

@@ -0,0 +1,20 @@
+import {
+  armDriverError2,
+  open4,
+  send3,
+  connectClient2
+} from "./asgr07mp.js";
+import {
+  NODE_POSTGRES_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./5x3pf400.js";
+export {
+  armDriverError2 as armDriverError,
+  NODE_POSTGRES_CAPABILITIES as capabilities,
+  connectClient2 as connectClient,
+  hasCapability2 as hasCapability,
+  open4 as open,
+  readCapability2 as readCapability,
+  send3 as send
+};

package/dist/tooling/shared/am04v8na.js

@@ -0,0 +1,233 @@
+import {
+  outcomeUnknown2
+} from "./hfq3n3bd.js";
+import {
+  noticeBuffer,
+  WireSession
+} from "./jsjjz875.js";
+import {
+  noTimeout
+} from "./3yn79q5m.js";
+import {
+  NEON_WEBSOCKET_CAPABILITIES,
+  NEON_HTTP_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./5x3pf400.js";
+
+// src/adapters/pg/neon.ts
+import {
+  Pool,
+  neon,
+  neonConfig
+} from "@neondatabase/serverless";
+var CONNECT_MS = 30000;
+var WIRE = {
+  getTypeParser() {
+    return (value) => value;
+  }
+};
+var names = new Map;
+async function open5(config) {
+  if (config.mode === "http")
+    return openHttp(config);
+  return openWebSocket(config);
+}
+function connectClient3(pool, acquireMs, counters) {
+  counters.waiting += 1;
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        settled = true;
+        counters.waiting = Math.max(0, counters.waiting - 1);
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    take(pool).then((client) => {
+      if (settled) {
+        client.release();
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(client);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+function send4(runner, text, params, named) {
+  const query = {
+    text,
+    rowMode: "array",
+    types: WIRE,
+    ...params !== undefined && params.length > 0 ? { values: params } : {},
+    ...named ? { name: statementName(text) } : {}
+  };
+  return runner.query(query);
+}
+async function openWebSocket(config) {
+  ensureWebSocket();
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const pool = new Pool({
+    connectionString: config.url,
+    max,
+    idleTimeoutMillis: 0,
+    allowExitOnIdle: true,
+    connectionTimeoutMillis: CONNECT_MS,
+    application_name: "okmodel",
+    types: WIRE,
+    ...config.searchPath !== undefined ? { options: `-c search_path=${config.searchPath}` } : {}
+  });
+  pool.on("error", () => {
+    return;
+  });
+  try {
+    const warmed = await take(pool);
+    warmed.release();
+  } catch (error) {
+    await pool.end().catch(() => {
+      return;
+    });
+    throw await mapFailure(error);
+  }
+  const root = new WireSession((text, params) => send4(pool, text, params, named), notices, isClosed, false, () => {
+    counters.busy += 1;
+  }, () => {
+    counters.busy = Math.max(0, counters.busy - 1);
+  });
+  const held = { pool, acquireMs, counters, notices, named, isClosed };
+  const checkout = () => closed ? rejectClosed() : import("./kz715295.js").then((mod) => mod.checkout(held));
+  return {
+    capabilities: NEON_WEBSOCKET_CAPABILITIES,
+    execute(text, params, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return runCall(closed, options, (watch) => root.query(text, params, watch));
+    },
+    async batch(statements, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const connection = await checkout();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => checkout(),
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await pool.end();
+    }
+  };
+}
+function openHttp(config) {
+  const max = config.max ?? 10;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  let closed = false;
+  const sql = neon(config.url, { arrayMode: true, fullResults: true });
+  const run = async (text, params) => {
+    counters.busy += 1;
+    try {
+      const result = await sql.query(text, params === undefined ? [] : [...params]);
+      return resultFrom(result, EMPTY_NOTICES);
+    } finally {
+      counters.busy = Math.max(0, counters.busy - 1);
+    }
+  };
+  return {
+    capabilities: NEON_HTTP_CAPABILITIES,
+    execute(text, params, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      if (closed)
+        return rejectClosed();
+      return runCall(closed, options, () => run(text, params).catch((error) => mapFailure(error).then((mapped) => Promise.reject(mapped))));
+    },
+    async batch(statements, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      if (closed)
+        return rejectClosed();
+      counters.busy += 1;
+      try {
+        const queries = statements.map((statement) => sql.query(statement.text, statement.params === undefined ? [] : [...statement.params]));
+        const results = await sql.transaction(queries, httpOptions());
+        return results.map((result) => resultFrom(result, EMPTY_NOTICES));
+      } catch (error) {
+        if (!isDatabaseError(error))
+          throw outcomeUnknown2(error);
+        throw await mapFailure(error);
+      } finally {
+        counters.busy = Math.max(0, counters.busy - 1);
+      }
+    },
+    stats: () => statsOf(counters, max),
+    close() {
+      closed = true;
+      return Promise.resolve();
+    }
+  };
+}
+function httpOptions() {
+  return { arrayMode: true, fullResults: true };
+}
+function isDatabaseError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" && /^[0-9A-Z]{5}$/.test(code);
+}
+function take(pool) {
+  const connect = pool.connect.bind(pool);
+  return connect();
+}
+function ensureWebSocket() {
+  if (neonConfig.webSocketConstructor === undefined && typeof WebSocket === "function") {
+    neonConfig.webSocketConstructor = WebSocket;
+  }
+}
+function statementName(text) {
+  const existing = names.get(text);
+  if (existing !== undefined)
+    return existing;
+  const name = `okm_${String(names.size)}`;
+  names.set(text, name);
+  return name;
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { open5, connectClient3, send4 };

package/dist/tooling/shared/asgr07mp.js

@@ -0,0 +1,194 @@
+import {
+  noticeBuffer,
+  WireSession
+} from "./jsjjz875.js";
+import {
+  NODE_POSTGRES_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall
+} from "./5x3pf400.js";
+
+// src/adapters/pg/nodepostgres.ts
+import net from "node:net";
+import pg from "pg";
+var CANCEL_CODE = 80877102;
+var identity = (value) => value;
+function armDriverError2(source, handle = () => {}) {
+  source.on("error", handle);
+}
+var WIRE = {
+  getTypeParser() {
+    return identity;
+  }
+};
+function open4(config) {
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const inflight = new Set;
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const pool = new pg.Pool({
+    connectionString: config.url,
+    max,
+    idleTimeoutMillis: 0,
+    allowExitOnIdle: true,
+    connectionTimeoutMillis: 5000,
+    application_name: "okmodel",
+    types: WIRE,
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    ...config.searchPath !== undefined ? { options: `-c search_path=${config.searchPath}` } : {}
+  });
+  armDriverError2(pool);
+  pool.on("connect", (client) => {
+    client.on("notice", (notice) => {
+      notices.push(notice);
+    });
+  });
+  const root = new WireSession((text, params) => send3(pool, text, params, named, undefined), notices, isClosed, true, () => {
+    counters.busy += 1;
+  }, () => {
+    counters.busy = Math.max(0, counters.busy - 1);
+  }, inflight);
+  const held = { pool, acquireMs, counters, notices, named, isClosed };
+  const checkout = () => closed ? rejectClosed() : import("./9qr9rkbh.js").then((mod) => mod.checkout(held));
+  return {
+    capabilities: NODE_POSTGRES_CAPABILITIES,
+    execute(text, params, options) {
+      return runCall(closed, options, async (watch) => {
+        if (watch === undefined)
+          return root.query(text, params, undefined);
+        const client = await connectClient2(pool, acquireMs, counters);
+        counters.busy += 1;
+        const session = new WireSession((statement, values) => send3(client, statement, values, named, client), notices, isClosed, true, () => {
+          return;
+        }, () => {
+          return;
+        }, inflight);
+        try {
+          return await session.query(text, params, watch);
+        } finally {
+          counters.busy = Math.max(0, counters.busy - 1);
+          client.release();
+        }
+      });
+    },
+    async batch(statements, options) {
+      const connection = await checkout();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => checkout(),
+    stream(text, params) {
+      return async function* () {
+        const { streamRows } = await import("./9qr9rkbh.js");
+        yield* streamRows(checkout, text, params);
+      }();
+    },
+    listen(channel, onNotify) {
+      if (closed)
+        return rejectClosed();
+      return import("./9qr9rkbh.js").then((mod) => mod.listen(held, channel, onNotify));
+    },
+    cancel() {
+      for (const pending of inflight)
+        pending.cancel?.();
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await pool.end();
+    }
+  };
+}
+function send3(runner, text, params, named, client) {
+  const query = {
+    text,
+    rowMode: "array",
+    types: WIRE,
+    ...params !== undefined && params.length > 0 ? { values: params } : {},
+    ...named ? { name: statementName(text) } : {}
+  };
+  const pending = runner.query(query);
+  if (client !== undefined)
+    pending.cancel = () => cancelBackend(client);
+  return pending;
+}
+var names = new Map;
+function statementName(text) {
+  const existing = names.get(text);
+  if (existing !== undefined)
+    return existing;
+  const name = `okm_${String(names.size)}`;
+  names.set(text, name);
+  return name;
+}
+function cancelBackend(client) {
+  const pid = client.processID;
+  const secret = client.secretKey;
+  if (typeof pid !== "number" || typeof secret !== "number")
+    return;
+  const socket = client.host.startsWith("/") === true ? net.connect(client.host) : net.connect(client.port, client.host);
+  socket.unref();
+  socket.once("error", () => {
+    socket.destroy();
+  });
+  socket.once("connect", () => {
+    const bytes = Buffer.alloc(16);
+    bytes.writeInt32BE(16, 0);
+    bytes.writeInt32BE(CANCEL_CODE, 4);
+    bytes.writeInt32BE(pid, 8);
+    bytes.writeInt32BE(secret, 12);
+    socket.end(bytes);
+  });
+}
+function connectClient2(pool, acquireMs, counters) {
+  counters.waiting += 1;
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        settled = true;
+        counters.waiting = Math.max(0, counters.waiting - 1);
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    pool.connect().then((client) => {
+      if (settled) {
+        client.release();
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(client);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { armDriverError2, open4, send3, connectClient2 };