okmodel 0.0.0 → 0.1.0

package/dist/shared/xy79j5hq.js

@@ -0,0 +1,177 @@
+// 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
+};
+function readCapability2(flags, name) {
+  return flags[name];
+}
+function hasCapability2(flags, name) {
+  return flags[name];
+}
+
+// src/adapters/failure.ts
+var loading;
+function driverErrors() {
+  loading ??= import("./mtkwv8wx.js");
+  return loading;
+}
+function rejectClosed(message = "The pool is closed.") {
+  return driverErrors().then((mod) => Promise.reject(new mod.DriverError(message)));
+}
+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 (command === "begin" || command === "begin work" || command === "begin transaction") {
+    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 openWatch(options) {
+  let kind;
+  const controller = new AbortController;
+  const onAbort = () => {
+    if (kind === undefined)
+      kind = "cancelled";
+    controller.abort();
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  let timer;
+  if (options.timeout !== undefined) {
+    timer = setTimeout(() => {
+      if (kind === undefined)
+        kind = "timeout";
+      controller.abort();
+    }, options.timeout);
+  }
+  return {
+    signal: controller.signal,
+    finish() {
+      if (timer !== undefined)
+        clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+    },
+    reason() {
+      return kind;
+    }
+  };
+}
+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 watch = openWatch(options);
+  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, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };