okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/829fjxyw.js

@@ -0,0 +1,198 @@
+import {
+  decodeRows,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  throwNamed,
+  selectedColumns,
+  parseOrder,
+  rejectKeys,
+  readLimit,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  registerFailFix,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/page.ts
+registerFailFix("OKM1130", "Request the next page with the same orderBy and the exact next value the previous page returned. The cursor encodes that order.");
+var OPTIONS = [
+  "where",
+  "select",
+  "orderBy",
+  "limit",
+  "include",
+  "after",
+  "route",
+  "signal",
+  "timeout"
+];
+function build3(session, table, options, mods, view, pin) {
+  try {
+    return plan(session, table, options, mods, view, pin);
+  } catch (error) {
+    throw error instanceof OkmError ? attachHttp(session.http, error) : error;
+  }
+}
+function plan(session, table, options, mods, view, pin) {
+  const record = isRecord(options) ? options : {};
+  if (Object.hasOwn(record, "search")) {
+    fail2("OKM1120", "page() does not take search in this version. Use find({ search, limit }) for a ranked list.", "Ranked pages are later. find({ search, limit }) returns one ranked list.");
+  }
+  rejectKeys(record, OPTIONS, "page");
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
+  if (record.limit === undefined)
+    fail2("OKM1101", "page() needs a limit.");
+  const size = readLimit(record.limit);
+  if (size < 1) {
+    throw new OkmError("invalid", "page() limit must be at least 1.", { kind: "invalid" });
+  }
+  const keys = orderKeys(indexed, record.orderBy);
+  const signature = `${table}:${keys.map((key) => `${key.column.field}.${key.dir}.${key.nulls}`).join(",")}`;
+  const after = record.after === undefined || record.after === null ? undefined : keyset(keys, signature, record.after);
+  const wanted = selectedColumns(indexed, record.select);
+  const extra = keys.filter((key) => !wanted.includes(key.column)).map((key) => key.column.field);
+  const select = extra.length === 0 ? record.select : [...wanted.map((column) => column.field), ...extra];
+  const orderBy = {};
+  for (const key of keys)
+    orderBy[key.column.field] = { dir: key.dir, nulls: key.nulls };
+  const call = {
+    ...readCall("find", table, {
+      where: record.where,
+      select,
+      orderBy,
+      limit: size + 1,
+      include: record.include,
+      signal: record.signal,
+      timeout: record.timeout,
+      route: record.route
+    }, undefined, session.scope, session.schema.model[table], session.schema, view),
+    ...after !== undefined ? { after } : {},
+    ...pin !== undefined ? { pin } : {}
+  };
+  return readHandle(session, table, call, mods, async (compiled, rows) => {
+    const items = await decodeRows(compiled, rows, table);
+    const more = items.length > size;
+    const kept = more ? items.slice(0, size) : items;
+    const last = rows[size - 1];
+    const next = more && last !== undefined ? makeCursor(compiled, last, keys, signature) : null;
+    if (extra.length > 0) {
+      for (const item of kept) {
+        for (const field of extra)
+          delete item[field];
+      }
+    }
+    return { items: kept, next };
+  });
+}
+function orderKeys(table, orderBy) {
+  if (orderBy !== undefined && !isRecord(orderBy)) {
+    fail2("OKM1120", "orderBy must be an object of fields.");
+  }
+  const keys = [];
+  for (const field of Object.keys(orderBy ?? {})) {
+    const column = table.columns.get(field);
+    if (column === undefined) {
+      throwNamed("OKM1120", field, table.names, `Field ${field} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    keys.push({ column, ...parseOrder(field, orderBy?.[field]) });
+  }
+  if (table.model.primary.length === 0) {
+    fail2("OKM1120", `page() needs a primary key on ${table.model.name} to break ties.`);
+  }
+  for (const field of table.model.primary) {
+    const column = table.columns.get(field);
+    if (column === undefined || keys.some((key) => key.column === column))
+      continue;
+    keys.push({ column, dir: "asc", nulls: "last" });
+  }
+  return keys;
+}
+function keyset(keys, signature, token) {
+  const values = readCursor(token, signature, keys.length);
+  return (sink, alias) => {
+    sink.mark(`k:${signature}:${values.map((value) => value === null ? "n" : "v").join("")}`);
+    let wrote = false;
+    for (let index = 0;index < keys.length; index += 1) {
+      const key = keys[index];
+      const value = values[index];
+      if (key === undefined || value === undefined)
+        continue;
+      if (value === null && key.nulls === "last")
+        continue;
+      sink.text(wrote ? " or (" : "(");
+      wrote = true;
+      for (let before = 0;before < index; before += 1) {
+        const prior = keys[before];
+        const held = values[before];
+        if (prior === undefined || held === undefined)
+          continue;
+        const ref = `${alias}.${quote(prior.column.sql)}`;
+        if (held === null) {
+          sink.text(`${ref} is null and `);
+        } else {
+          sink.text(`${ref} = `);
+          sink.param(held);
+          sink.text(" and ");
+        }
+      }
+      const ref = `${alias}.${quote(key.column.sql)}`;
+      if (value === null) {
+        sink.text(`${ref} is not null`);
+      } else {
+        sink.text(key.nulls === "last" ? `(${ref} ${compare(key)} ` : `${ref} ${compare(key)} `);
+        sink.param(value);
+        sink.text(key.nulls === "last" ? ` or ${ref} is null)` : "");
+      }
+      sink.text(")");
+    }
+    if (!wrote)
+      sink.text("false");
+  };
+}
+function compare(key) {
+  return key.dir === "asc" ? ">" : "<";
+}
+function makeCursor(plan, row, keys, signature) {
+  const values = keys.map((key) => {
+    const at = plan.outputs.fields.find((field) => field.key === key.column.field)?.at;
+    return at === undefined ? null : row[at] ?? null;
+  });
+  const bytes = new TextEncoder().encode(JSON.stringify([signature, ...values]));
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function readCursor(token, signature, count) {
+  let parsed;
+  if (typeof token === "string") {
+    try {
+      const binary = atob(token.replaceAll("-", "+").replaceAll("_", "/"));
+      const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+      parsed = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      parsed = undefined;
+    }
+  }
+  if (!Array.isArray(parsed) || typeof parsed[0] !== "string") {
+    fail2("OKM1130", "after is not a cursor that page() returned.");
+  }
+  if (parsed[0] !== signature) {
+    fail2("OKM1130", `The cursor was made for another order: ${parsed[0]}. This page orders by ${signature}.`);
+  }
+  const values = parsed.slice(1);
+  if (values.length !== count || !values.every((value) => value === null || typeof value === "string")) {
+    fail2("OKM1130", "after is not a cursor that page() returned.");
+  }
+  return values;
+}
+
+export { build3 };

package/dist/tooling/shared/8m5znpdt.js

@@ -0,0 +1,66 @@
+import {
+  mapFailure
+} from "./5x3pf400.js";
+
+// src/adapters/pg/pglite-wire.ts
+var OIDS = [
+  16,
+  17,
+  20,
+  21,
+  23,
+  25,
+  114,
+  700,
+  701,
+  1043,
+  1082,
+  1114,
+  1184,
+  1700,
+  2950,
+  3802,
+  1000,
+  1005,
+  1007,
+  1009,
+  1016,
+  1115,
+  1182,
+  1185,
+  1231,
+  199,
+  3807
+];
+function identity(value) {
+  return value;
+}
+function serialize(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "t" : "f";
+  return value;
+}
+var parsers = {};
+var serializers = {};
+for (const oid of OIDS) {
+  parsers[oid] = identity;
+  serializers[oid] = serialize;
+}
+function fail(error) {
+  return mapFailure(protocol(error));
+}
+function protocol(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return error;
+  if (error.code !== "08P01")
+    return error;
+  const message = error instanceof Error ? error.message : "";
+  return new Error(message.length > 0 ? message : "protocol error");
+}
+export {
+  fail,
+  parsers,
+  serializers
+};

package/dist/tooling/shared/8yr7ges1.js

@@ -0,0 +1,211 @@
+import {
+  DriverError2,
+  isConnectionFailure
+} from "./hfq3n3bd.js";
+import {
+  send2,
+  reserve2,
+  park2
+} from "./rcywj2w8.js";
+import {
+  resetSession2,
+  refuseWhenLost2
+} from "./7pxncnzs.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  WireSession
+} from "./jsjjz875.js";
+import {
+  noTimeout
+} from "./3yn79q5m.js";
+import {
+  rejectClosed,
+  runCall
+} from "./5x3pf400.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 reserve2(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("./gqwevek4.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 park2(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/tooling/shared/96ps4g1z.js

@@ -0,0 +1,32 @@
+// src/runtime/hookm.ts
+function notices(hookm, notices) {
+  if (hookm === undefined)
+    return;
+  for (const notice of notices) {
+    for (const hook of hookm)
+      call(() => hook.onNotice?.(notice));
+  }
+}
+function phase(hookm, phase, depth) {
+  if (hookm === undefined)
+    return;
+  const event = { phase, depth };
+  for (const hook of hookm)
+    call(() => hook.onTransaction?.(event));
+}
+function report(session, error) {
+  for (const hook of session.hookm ?? [])
+    call(() => hook.onError?.(error));
+  const entry = error instanceof Error ? { code: "code" in error ? String(error.code) : error.name, summary: error.message } : { code: "error", summary: String(error) };
+  call(() => session.logger?.error?.(entry));
+}
+function call(fn) {
+  try {
+    fn();
+  } catch {}
+}
+export {
+  notices,
+  phase,
+  report
+};

package/dist/tooling/shared/9qr9rkbh.js

@@ -0,0 +1,143 @@
+import {
+  DriverError2,
+  isConnectionLost
+} from "./hfq3n3bd.js";
+import {
+  armDriverError2,
+  send3,
+  connectClient2
+} from "./asgr07mp.js";
+import {
+  resetSession2
+} from "./7pxncnzs.js";
+import {
+  cursorStream
+} from "./7kms6fvj.js";
+import {
+  WireSession
+} from "./jsjjz875.js";
+import {
+  rejectClosed,
+  runCall
+} from "./5x3pf400.js";
+
+// src/adapters/pg/nodepostgres-extra.ts
+async function checkout(held) {
+  const { pool, counters, named, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const client = await connectClient2(pool, held.acquireMs, counters);
+  counters.reserved += 1;
+  let lost = false;
+  const onError = () => {
+    lost = true;
+  };
+  const events = client;
+  events.on("error", onError);
+  const local = new Set;
+  const session = new WireSession((text, params) => {
+    const pending = send3(client, text, params, named, client);
+    const guarded = pending.catch((error) => {
+      if (isConnectionLost(error) || lost) {
+        lost = true;
+        if (isConnectionLost(error))
+          throw error;
+        throw Object.assign(new DriverError2("CONNECTION_CLOSED", { cause: error }), {
+          code: "CONNECTION_CLOSED"
+        });
+      }
+      throw error;
+    });
+    guarded.cancel = () => {
+      pending.cancel?.();
+    };
+    return guarded;
+  }, held.notices, isClosed, true, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  }, local);
+  const guard = (run) => lost ? rejectClosed() : run();
+  let released = false;
+  return {
+    execute: (text, params, options) => guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch))),
+    batch: (statements, options) => guard(() => runCall(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;
+      try {
+        if (!lost)
+          await reset(session, client);
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        events.removeListener("error", onError);
+        client.release(lost);
+      }
+    }
+  };
+}
+async function reset(session, client) {
+  await resetSession2(session.depth(), (text) => client.query(text));
+}
+async function listen(held, channel, onNotify) {
+  const { pool, counters } = held;
+  const client = await connectClient2(pool, held.acquireMs, counters);
+  counters.reserved += 1;
+  const quoted = quoteIdent(channel);
+  const onNotification = (message) => {
+    if (message.channel === channel)
+      onNotify(message.payload ?? "");
+  };
+  client.on("notification", onNotification);
+  let released = false;
+  const release = (dead) => {
+    if (released)
+      return;
+    released = true;
+    client.removeListener("notification", onNotification);
+    client.removeListener("error", release);
+    counters.reserved = Math.max(0, counters.reserved - 1);
+    client.release(Boolean(dead));
+  };
+  armDriverError2(client, release);
+  try {
+    await client.query(`LISTEN ${quoted}`);
+  } catch (error) {
+    release(false);
+    throw error;
+  }
+  return async () => {
+    if (released)
+      return;
+    try {
+      await client.query(`UNLISTEN ${quoted}`);
+    } finally {
+      release(false);
+    }
+  };
+}
+function streamRows(checkout, text, params) {
+  return async function* () {
+    const connection = await checkout();
+    try {
+      yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+    } finally {
+      await connection.release();
+    }
+  }();
+}
+function quoteIdent(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+export {
+  checkout,
+  listen,
+  streamRows
+};

package/dist/tooling/shared/9sfbtwsk.js

@@ -0,0 +1,49 @@
+import {
+  open5
+} from "./am04v8na.js";
+import {
+  createClient
+} from "./jr2nmr81.js";
+
+// src/runtime/pg/neon.ts
+function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("./kbqnrs1x.js").then((mod) => mod.default(target, options, (config) => open5({
+      url: config.url,
+      ...options.mode !== undefined ? { mode: options.mode } : {},
+      ...config.max !== undefined ? { max: config.max } : {},
+      ...config.timeouts !== undefined ? { timeouts: config.timeouts } : {},
+      ...config.prepared !== undefined ? { prepared: config.prepared } : {},
+      ...config.searchPath !== undefined ? { searchPath: config.searchPath } : {}
+    })));
+  }
+  const owned = !isPool(target);
+  const opened = isPool(target) ? Promise.resolve(target) : open5({
+    url: target,
+    ...options.mode !== undefined ? { mode: options.mode } : {},
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {}
+  });
+  return opened.then((pool) => createClient(options.schema, pool, {
+    ownsPool: owned,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    requireMeta: options.requireMeta,
+    generators: options.generators
+  }));
+}
+function isPool(target) {
+  return typeof target === "object" && "execute" in target && "capabilities" in target;
+}
+export {
+  connect
+};

package/dist/tooling/shared/9wsnsvbf.js

@@ -0,0 +1,10 @@
+import {
+  resetSession2,
+  resetQueried2,
+  refuseWhenLost2
+} from "./7pxncnzs.js";
+export {
+  refuseWhenLost2 as refuseWhenLost,
+  resetQueried2 as resetQueried,
+  resetSession2 as resetSession
+};