okmodel 0.7.0 → 0.8.0

package/dist/tooling/shared/xhrnjch9.js

@@ -0,0 +1,185 @@
+// src/adapters/capabilities.ts
+var POSTGRESJS_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: true,
+  prepared: "unnamed",
+  describe: true
+};
+var PGLITE_CAPABILITIES = {
+  transactions: "interactive",
+  stream: false,
+  listen: true,
+  cancel: false,
+  prepared: "unnamed",
+  describe: true
+};
+var NODE_POSTGRES_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: true,
+  prepared: "unnamed",
+  describe: false
+};
+var BUNSQL_CAPABILITIES = {
+  transactions: "interactive",
+  stream: true,
+  listen: true,
+  cancel: false,
+  prepared: "unnamed",
+  describe: false
+};
+var NEON_WEBSOCKET_CAPABILITIES = {
+  transactions: "interactive",
+  stream: false,
+  listen: false,
+  cancel: false,
+  prepared: "unnamed",
+  describe: false
+};
+var NEON_HTTP_CAPABILITIES = {
+  transactions: "batch",
+  stream: false,
+  listen: false,
+  cancel: false,
+  prepared: "none",
+  describe: false
+};
+function readCapability2(flags, name) {
+  return flags[name];
+}
+function hasCapability2(flags, name) {
+  return flags[name];
+}
+
+// src/adapters/failure.ts
+var loading;
+function driverErrors() {
+  loading ??= import("./aftb2mwr.js");
+  return loading;
+}
+function rejectClosed() {
+  return import("./345tbc2k.js").then((mod) => mod.closed());
+}
+function rejectUncancellable() {
+  return import("./345tbc2k.js").then((mod) => mod.refused());
+}
+function rejectCancelled() {
+  return driverErrors().then((mod) => Promise.reject(mod.cancelled()));
+}
+function rejectTimedOut() {
+  return driverErrors().then((mod) => Promise.reject(mod.timedOut()));
+}
+async function mapFailure(error) {
+  const mod = await driverErrors();
+  return mod.mapDriverError(error);
+}
+
+// src/adapters/pg/call.ts
+function needsWatch(options) {
+  return options?.signal !== undefined || options?.timeout !== undefined;
+}
+function nextTransactionDepth(depth, text) {
+  const command = text.trim().replace(/;\s*$/, "").trim().toLowerCase();
+  if (/^(?:begin|start transaction)(?:\s|$)/.test(command))
+    return depth + 1;
+  if (command === "commit" || command === "commit work" || command === "end") {
+    return Math.max(0, depth - 1);
+  }
+  if (command === "rollback" || command === "rollback work")
+    return 0;
+  return depth;
+}
+function runCall(closed, options, fn) {
+  if (closed)
+    return rejectClosed();
+  if (options?.signal?.aborted === true)
+    return rejectCancelled();
+  if (options?.timeout !== undefined && options.timeout <= 0)
+    return rejectTimedOut();
+  if (options === undefined || !needsWatch(options))
+    return fn(undefined);
+  const watched = options;
+  return import("./54tqkxja.js").then(({ openWatch }) => {
+    const watch = openWatch(watched);
+    return fn(watch).finally(() => {
+      watch.finish();
+    });
+  });
+}
+
+// src/adapters/pg/result.ts
+var EMPTY_NOTICES = [];
+function cell(value) {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value instanceof Uint8Array)
+    return new TextDecoder().decode(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return null;
+}
+function rowsFrom(value) {
+  const list = rowList(value);
+  const rows = Array.from({ length: list.length });
+  for (let index = 0;index < list.length; index += 1) {
+    rows[index] = rowCells(list[index]);
+  }
+  return rows;
+}
+function resultFrom(value, notices) {
+  const rows = rowsFrom(value);
+  return {
+    rows,
+    count: countFrom(value, rows.length),
+    notices
+  };
+}
+function rowList(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value === "object" && value !== null && "rows" in value) {
+    const rows = Reflect.get(value, "rows");
+    if (Array.isArray(rows))
+      return rows;
+  }
+  return [];
+}
+function rowCells(row) {
+  if (Array.isArray(row)) {
+    const cells = Array.from({ length: row.length });
+    for (let index = 0;index < row.length; index += 1)
+      cells[index] = cell(row[index]);
+    return cells;
+  }
+  if (typeof row === "object" && row !== null) {
+    const values = Object.values(row);
+    const cells = Array.from({ length: values.length });
+    for (let index = 0;index < values.length; index += 1)
+      cells[index] = cell(values[index]);
+    return cells;
+  }
+  return [cell(row)];
+}
+function countFrom(value, rows) {
+  if (typeof value !== "object" || value === null)
+    return rows;
+  const count = Reflect.get(value, "count");
+  if (typeof count === "number" && !Number.isNaN(count))
+    return count;
+  const rowCount = Reflect.get(value, "rowCount");
+  if (typeof rowCount === "number" && !Number.isNaN(rowCount))
+    return rowCount;
+  const affected = Reflect.get(value, "affectedRows");
+  if (typeof affected === "number" && !Number.isNaN(affected))
+    return affected;
+  return rows;
+}
+
+export { POSTGRESJS_CAPABILITIES, PGLITE_CAPABILITIES, NODE_POSTGRES_CAPABILITIES, BUNSQL_CAPABILITIES, NEON_WEBSOCKET_CAPABILITIES, NEON_HTTP_CAPABILITIES, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectUncancellable, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };

package/dist/tooling/shared/xjs6zqtc.js

@@ -0,0 +1,190 @@
+import {
+  DriverError2
+} from "./f9mphxej.js";
+import {
+  noticeBuffer,
+  WireSession
+} from "./yw30vnq2.js";
+import {
+  noTimeout
+} from "./rs1jb051.js";
+import {
+  BUNSQL_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/bunsql.ts
+import { SQL as BunSQL } from "bun";
+var clientPools = new WeakSet;
+function markClientPool2(pool) {
+  clientPools.add(pool);
+}
+function open2(config) {
+  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 parked = [];
+  let dropped = 0;
+  let closures = 0;
+  const sql = new BunSQL(config.url, {
+    max,
+    idleTimeout: 0,
+    maxLifetime: 0,
+    prepare: named,
+    bigint: false,
+    connectionTimeout: 5,
+    connection: {
+      application_name: "okmodel",
+      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
+    },
+    ...config.ssl !== undefined ? { tls: config.ssl } : {},
+    onclose() {
+      dropped += 1;
+      closures += 1;
+    }
+  });
+  const root = new WireSession((text, params) => send2(sql, text, params), notices, isClosed, false, () => {
+    counters.busy += 1;
+  }, () => {
+    counters.busy = Math.max(0, counters.busy - 1);
+  });
+  const held = {
+    sql,
+    parked,
+    acquireMs,
+    counters,
+    notices,
+    isClosed,
+    closures: () => closures
+  };
+  const run = (text, params, watch) => {
+    const sent = dropped;
+    return root.query(text, params, watch).catch((error) => import("./g9ad4n80.js").then((mod) => mod.recover(sql, error, text, root.depth(), clientPools.has(pool), dropped > sent, () => root.query(text, params, watch))));
+  };
+  const afterDrop = (text, params, watch) => {
+    if (dropped === 0)
+      return run(text, params, watch);
+    const seen = dropped;
+    return import("./g9ad4n80.js").then((mod) => mod.drainClosed(sql).then(() => {
+      if (dropped === seen)
+        dropped = 0;
+      return run(text, params, watch);
+    }));
+  };
+  const checkout = () => closed ? rejectClosed() : import("./g9ad4n80.js").then((mod) => mod.checkout(held));
+  const pool = {
+    capabilities: BUNSQL_CAPABILITIES,
+    execute(text, params, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return runCall(closed, options, (watch) => releaseParked(parked).then(() => afterDrop(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(),
+    stream(text, params) {
+      return async function* () {
+        const { streamRows } = await import("./g9ad4n80.js");
+        yield* streamRows(checkout, text, params);
+      }();
+    },
+    listen(channel, onNotify) {
+      return import("./g9ad4n80.js").then((mod) => mod.listen(sql, parked, closed, channel, onNotify));
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await releaseParked(parked);
+      await sql.close();
+    }
+  };
+  return pool;
+}
+function send2(sql, text, params) {
+  const refused = refuseInt8(params);
+  if (refused !== undefined)
+    return refused;
+  if (params === undefined || params.length === 0)
+    return sql.unsafe(text).raw();
+  return sql.unsafe(text, [...params]).raw();
+}
+function refuseInt8(params) {
+  if (params === undefined)
+    return;
+  for (const value of params) {
+    if (value === null || value.length < 19 || !/^-?(?:0|[1-9]\d*)$/.test(value))
+      continue;
+    const parsed = BigInt(value);
+    if (parsed > 9223372036854775807n || parsed < -9223372036854775808n) {
+      return Promise.reject(new DriverError2("bigint out of range", { sqlstate: "22003" }));
+    }
+  }
+  return;
+}
+async function reserve2(sql, acquireMs, counters) {
+  counters.waiting += 1;
+  try {
+    if (acquireMs === undefined)
+      return await sql.reserve();
+    return await sql.reserve({ signal: AbortSignal.timeout(acquireMs) });
+  } catch (error) {
+    if (isAbort(error)) {
+      const errors = await driverErrors();
+      throw errors.acquireTimeout();
+    }
+    throw await mapFailure(error);
+  } finally {
+    counters.waiting = Math.max(0, counters.waiting - 1);
+  }
+}
+async function park2(parked, reserved) {
+  parked.push(reserved);
+  while (parked.length > 1) {
+    const extra = parked.shift();
+    if (extra !== undefined)
+      await releaseReserved(extra);
+  }
+}
+async function releaseParked(parked) {
+  const pending = parked.splice(0);
+  for (const reserved of pending)
+    await releaseReserved(reserved);
+}
+function releaseReserved(reserved) {
+  const done = reserved.release();
+  return done instanceof Promise ? done.then(() => {
+    return;
+  }) : Promise.resolve();
+}
+function isAbort(error) {
+  if (!(error instanceof Error))
+    return false;
+  return error.name === "AbortError" || error.name === "TimeoutError";
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { markClientPool2, open2, send2, reserve2, park2 };

package/dist/tooling/shared/y031jct9.js

@@ -0,0 +1,16 @@
+import {
+  open3,
+  PgSession2
+} from "./p7f08ktn.js";
+import {
+  POSTGRESJS_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./xhrnjch9.js";
+export {
+  PgSession2 as PgSession,
+  POSTGRESJS_CAPABILITIES as capabilities,
+  hasCapability2 as hasCapability,
+  open3 as open,
+  readCapability2 as readCapability
+};

package/dist/tooling/shared/y5656f0e.js

@@ -0,0 +1,233 @@
+import {
+  outcomeUnknown2
+} from "./f9mphxej.js";
+import {
+  noticeBuffer,
+  WireSession
+} from "./yw30vnq2.js";
+import {
+  noTimeout
+} from "./rs1jb051.js";
+import {
+  NEON_WEBSOCKET_CAPABILITIES,
+  NEON_HTTP_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./xhrnjch9.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("./gfvtj6d0.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 };