okmodel 0.6.0 → 0.8.0

package/dist/tooling/shared/nf7jmhfa.js

@@ -0,0 +1,20 @@
+import {
+  armDriverError2,
+  open4,
+  send3,
+  connectClient2
+} from "./417zdsk7.js";
+import {
+  NODE_POSTGRES_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./xhrnjch9.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/p7f08ktn.js

@@ -0,0 +1,332 @@
+import {
+  POSTGRESJS_CAPABILITIES,
+  rejectClosed,
+  mapFailure,
+  nextTransactionDepth,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/postgresjs.ts
+import net from "node:net";
+import postgres from "postgres";
+class PoolSockets {
+  held = [];
+  busy = 0;
+  listeners = 0;
+  hostCursor = 0;
+  connect(target) {
+    const path = typeof target.path === "string" ? target.path : undefined;
+    const hosts = target.host;
+    const ports = target.port;
+    const index = hosts.length === 0 ? 0 : this.hostCursor % hosts.length;
+    this.hostCursor += 1;
+    const host = hosts[index] ?? "localhost";
+    const port = ports[index] ?? ports[0] ?? 5432;
+    const socket = path !== undefined ? net.connect(path) : net.connect(port, host);
+    this.held.push(socket);
+    return socket;
+  }
+  occupy(run) {
+    this.busy += 1;
+    this.wake();
+    return run().finally(() => {
+      this.busy -= 1;
+      this.park();
+    });
+  }
+  busyGate() {
+    return {
+      enter: () => {
+        this.busy += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.busy -= 1;
+        this.park();
+      }
+    };
+  }
+  listenerGate() {
+    return {
+      enter: () => {
+        this.listeners += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.listeners -= 1;
+        this.park();
+      }
+    };
+  }
+  wake() {
+    for (const socket of this.held)
+      if (socket.writable)
+        socket.ref();
+  }
+  park() {
+    if (this.busy > 0 || this.listeners > 0)
+      return;
+    for (const socket of this.held)
+      if (socket.writable)
+        socket.unref();
+  }
+}
+function driverOptions(config, state) {
+  return {
+    max: state.max,
+    prepare: state.named,
+    idle_timeout: state.plain ? 0 : 30,
+    ...state.plain ? { max_lifetime: null } : {},
+    connect_timeout: 5,
+    types: WIRE_TYPES,
+    ...state.plain ? { socket: (options) => state.sockets.connect(options) } : {},
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    connection: {
+      application_name: "okmodel",
+      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
+    },
+    onnotice(notice) {
+      state.notices.push(notice);
+    }
+  };
+}
+function open3(config) {
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const poolInflight = new Set;
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const plain = config.ssl === undefined;
+  const sockets = new PoolSockets;
+  const sql = postgres(config.url, driverOptions(config, {
+    max,
+    named,
+    plain,
+    notices,
+    sockets
+  }));
+  const root = new PgSession2(sql, counters, "pool", poolInflight, isClosed, undefined, notices, named);
+  const held = { sql, acquireMs, counters, isClosed, notices, named, poolInflight };
+  return {
+    capabilities: POSTGRESJS_CAPABILITIES,
+    execute(text, params, options) {
+      return sockets.occupy(() => runCall(closed, options, (watch) => root.query(text, params, watch)));
+    },
+    batch(statements, options) {
+      return sockets.occupy(() => import("./3m1hkg7z.js").then((mod) => mod.runBatch(held, statements, options)));
+    },
+    reserve() {
+      const gate = sockets.busyGate();
+      gate.enter();
+      return import("./3m1hkg7z.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+        gate.leave();
+        throw error;
+      });
+    },
+    describe: (text, params) => sockets.occupy(() => import("./3m1hkg7z.js").then((mod) => mod.describe(sql, text, params))),
+    stream(text, params) {
+      const gate = sockets.busyGate();
+      return async function* () {
+        gate.enter();
+        try {
+          yield* loadStream(sql, text, params);
+        } finally {
+          gate.leave();
+        }
+      }();
+    },
+    listen(channel, onNotify) {
+      const gate = sockets.listenerGate();
+      gate.enter();
+      return import("./3m1hkg7z.js").then((mod) => mod.holdListener(gate, async () => {
+        const listening = await sql.listen(channel, onNotify);
+        return async () => {
+          await listening.unlisten();
+        };
+      }), (error) => {
+        gate.leave();
+        throw error;
+      });
+    },
+    cancel() {
+      for (const pending of poolInflight)
+        pending.cancel();
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await sql.end({ timeout: 5 });
+    }
+  };
+}
+
+class PgSession2 {
+  canCancel = true;
+  transactionDepth = 0;
+  sql;
+  counters;
+  scope;
+  local;
+  isClosed;
+  shared;
+  notices;
+  named;
+  constructor(sql, counters, scope, local, isClosed, shared, notices, named) {
+    this.sql = sql;
+    this.counters = counters;
+    this.scope = scope;
+    this.local = local;
+    this.isClosed = isClosed;
+    this.shared = shared;
+    this.notices = notices;
+    this.named = named;
+  }
+  query(text, params, watch) {
+    if (this.isClosed())
+      return rejectClosed();
+    const start = this.notices.start();
+    this.enter();
+    const pending = send(this.sql, text, params, this.named);
+    if (watch === undefined) {
+      return pending.then((result) => {
+        this.leave();
+        this.note(text);
+        return resultFrom(result, this.notices.since(start));
+      }, (error) => {
+        this.leave();
+        return mapFailure(error).then((mapped) => {
+          throw mapped;
+        });
+      });
+    }
+    this.local.add(pending);
+    this.shared?.add(pending);
+    const onAbort = () => {
+      pending.cancel();
+    };
+    if (watch.signal.aborted)
+      onAbort();
+    else
+      watch.signal.addEventListener("abort", onAbort, { once: true });
+    return import("./3m1hkg7z.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+      start,
+      text,
+      notices: this.notices,
+      leave: () => {
+        this.leave();
+      },
+      note: (sqlText) => {
+        this.note(sqlText);
+      },
+      untrack: (item) => {
+        this.local.delete(item);
+        this.shared?.delete(item);
+      }
+    }), (error) => {
+      this.leave();
+      this.local.delete(pending);
+      this.shared?.delete(pending);
+      watch.signal.removeEventListener("abort", onAbort);
+      throw error;
+    });
+  }
+  inTransaction() {
+    return this.transactionDepth > 0;
+  }
+  abandon() {
+    this.transactionDepth = 0;
+  }
+  depth() {
+    return this.transactionDepth;
+  }
+  cancel() {
+    for (const pending of this.local)
+      pending.cancel();
+  }
+  note(text) {
+    this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
+  }
+  enter() {
+    if (this.scope === "pool")
+      this.counters.busy += 1;
+    else
+      this.counters.reservedBusy += 1;
+  }
+  leave() {
+    if (this.scope === "pool")
+      this.counters.busy = Math.max(0, this.counters.busy - 1);
+    else
+      this.counters.reservedBusy = Math.max(0, this.counters.reservedBusy - 1);
+  }
+}
+async function* loadStream(sql, text, params) {
+  const { stream } = await import("./3m1hkg7z.js");
+  yield* stream(sql, text, params);
+}
+function send(sql, text, params, named) {
+  if (!named && (params === undefined || params.length === 0))
+    return sql.unsafe(text).raw();
+  return sql.unsafe(text, asParams(params), { prepare: named }).raw();
+}
+function asParams(params) {
+  if (params === undefined)
+    return [];
+  return params;
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+function noticeBuffer() {
+  let notices;
+  return {
+    push(notice) {
+      const severity = typeof notice.severity === "string" ? notice.severity : "";
+      const message = typeof notice.message === "string" ? notice.message : "";
+      const code = typeof notice.code === "string" && notice.code.length > 0 ? notice.code : undefined;
+      const entry = code === undefined ? { severity, message } : { severity, message, code };
+      (notices ??= []).push(entry);
+    },
+    start() {
+      return notices?.length ?? 0;
+    },
+    since(start) {
+      if (notices === undefined || notices.length === start)
+        return EMPTY_NOTICES;
+      return notices.slice(start);
+    }
+  };
+}
+function wire(to, from) {
+  return {
+    to,
+    from: [...from],
+    serialize: (value) => value,
+    parse: (value) => value
+  };
+}
+var WIRE_TYPES = {
+  number: wire(0, [21, 23, 26, 700, 701]),
+  boolean: wire(16, [16]),
+  bytea: wire(17, [17]),
+  json: wire(114, [114, 3802]),
+  date: wire(1184, [1082, 1114, 1184]),
+  boolArray: wire(1000, [1000]),
+  int2Array: wire(1005, [1005]),
+  int4Array: wire(1007, [1007]),
+  textArray: wire(1009, [1009]),
+  int8Array: wire(1016, [1016]),
+  numericArray: wire(1231, [1231]),
+  jsonbArray: wire(3807, [3807])
+};
+
+export { open3, PgSession2 };

package/dist/tooling/shared/ppnnnvj8.js

@@ -0,0 +1,13 @@
+import {
+  fail2
+} from "./f9mphxej.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 };

package/dist/tooling/shared/pqy21k24.js

@@ -0,0 +1,312 @@
+import {
+  readSelectFragment,
+  emitSqlSelect,
+  decodeSqlNumber
+} from "./gmcf9cxf.js";
+import"./3tq8pnb8.js";
+import {
+  refusePrototypeKey
+} from "./ppnnnvj8.js";
+import {
+  throwNamed,
+  emitWhere,
+  emitOrder,
+  refuseHidden,
+  emitLimit,
+  parseOrder,
+  projectExpr,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./f9mphxej.js";
+
+// src/dialects/pg/ops/window.ts
+var RUNTIME = Symbol.for("okmodel.window");
+function isWindow(value) {
+  return typeof value === "object" && value !== null && RUNTIME in value;
+}
+
+// src/runtime/window.ts
+var AS_NUMBER = (wire) => Number(wire);
+var AS_TEXT = (wire) => wire;
+var NUMERIC = /^(smallint|integer|bigint|real|double precision|numeric|decimal)\b/;
+var OPTION_KEYS = ["as", "orderBy", "partitionBy"];
+function attach(schema, call) {
+  const table = indexesOf(schema, call.table);
+  return { ...call, build: statement(readSpec(table, call.select)) };
+}
+function statement(spec) {
+  return (schema, table, sink, outputs, call, hooks) => {
+    sink.mark(`${call.op}|${table.model.name}|`);
+    if (call.include !== undefined && hooks === undefined) {
+      fail2("OKM1120", "An include needs the include planner.");
+    }
+    const includes = hooks === undefined || call.include === undefined ? [] : hooks.read(schema, table, call.include, call.all);
+    sink.text("select ");
+    let column = 0;
+    for (const item of spec.items) {
+      if (column > 0)
+        sink.text(", ");
+      if (item.kind === "column") {
+        sink.text(projectExpr(`t.${quote(item.column.sql)}`, item.column.dataType));
+        sink.mark(`s:${item.column.field}`);
+        outputs?.fields.push({ key: item.column.field, at: column, decode: item.column.decode });
+      } else if (item.kind === "sql") {
+        emitSqlSelect(table, item.parts, sink, "t");
+        sink.text("::text");
+        sink.mark(`s:${item.as}`);
+        outputs?.fields.push({
+          key: item.as,
+          at: column,
+          decode: item.textual === true ? AS_TEXT : decodeSqlNumber
+        });
+      } else {
+        emitWindow(table, item.window, sink);
+        sink.text("::text");
+        outputs?.fields.push({ key: item.window.as, at: column, decode: item.window.decode });
+      }
+      column += 1;
+    }
+    if (spec.items.length === 0 && includes.length === 0)
+      sink.text("1");
+    for (let index = 0;index < includes.length; index += 1) {
+      const include = includes[index];
+      if (include === undefined || hooks === undefined)
+        continue;
+      column = hooks.select(include, `i${String(index)}`, sink, outputs, column);
+    }
+    sink.text(" from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    for (let index = 0;index < includes.length; index += 1) {
+      const include = includes[index];
+      if (include === undefined || hooks === undefined)
+        continue;
+      hooks.join(schema, include, sink, "t", `i${String(index)}`, 0);
+    }
+    emitWhere(schema, table, call.where, sink, "t", 0, false, call.after);
+    emitResultOrder(table, call.orderBy, sink, spec.ordinals);
+    emitLimit(call, sink);
+    call.tail?.(sink);
+  };
+}
+function emitResultOrder(table, orderBy, sink, ordinals) {
+  if (!isRecord(orderBy) || !mentionsOrdinal(orderBy, ordinals)) {
+    emitOrder(table, orderBy, sink, "t");
+    return;
+  }
+  const keys = Object.keys(orderBy);
+  sink.text(" order by ");
+  for (let index = 0;index < keys.length; index += 1) {
+    const key = keys[index];
+    if (key === undefined)
+      continue;
+    const parsed = parseOrder(key, orderBy[key]);
+    if (index > 0)
+      sink.text(", ");
+    const ordinal = ordinals.get(key);
+    if (ordinal !== undefined) {
+      sink.text(ordinal);
+    } else {
+      const column = table.columns.get(key);
+      if (column === undefined) {
+        throwNamed("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+      }
+      refuseHidden(column);
+      sink.text("t.");
+      sink.text(quote(column.sql));
+    }
+    sink.text(parsed.dir === "asc" ? " asc" : " desc");
+    sink.text(parsed.nulls === "first" ? " nulls first" : " nulls last");
+    sink.mark(`o:${key}:${parsed.dir}:${parsed.nulls}`);
+  }
+}
+function mentionsOrdinal(orderBy, ordinals) {
+  if (ordinals.size === 0)
+    return false;
+  for (const key of Object.keys(orderBy)) {
+    if (ordinals.has(key))
+      return true;
+  }
+  return false;
+}
+function emitWindow(table, win, sink) {
+  sink.mark(`w:${win.fn}:${win.as}:p:${win.partition.map((column) => column.field).join("+")}`);
+  if (win.fn === "sum") {
+    const column = win.column;
+    if (column === undefined)
+      fail2("OKM1120", "runningTotal needs a column.");
+    sink.text("sum(t.");
+    sink.text(quote(column.sql));
+    sink.text(")");
+  } else {
+    sink.text(win.fn);
+    sink.text("()");
+  }
+  sink.text(" over (");
+  if (win.partition.length > 0) {
+    sink.text("partition by ");
+    for (let index = 0;index < win.partition.length; index += 1) {
+      const column = win.partition[index];
+      if (column === undefined)
+        continue;
+      if (index > 0)
+        sink.text(", ");
+      sink.text("t.");
+      sink.text(quote(column.sql));
+    }
+  }
+  emitOrder(table, win.orderBy, sink, "t");
+  if (win.tieBreak) {
+    const named = isRecord(win.orderBy) ? Object.keys(win.orderBy) : [];
+    for (const field of table.model.primary) {
+      if (named.includes(field))
+        continue;
+      const column = table.columns.get(field);
+      if (column === undefined)
+        continue;
+      sink.text(", t.");
+      sink.text(quote(column.sql));
+      sink.text(" asc");
+    }
+  }
+  sink.text(")");
+}
+function readSpec(table, select) {
+  if (!Array.isArray(select))
+    fail2("OKM1120", "select must be a list of field names.");
+  const items = [];
+  const ordinals = new Map;
+  const names = new Set;
+  for (const entry of select) {
+    if (typeof entry === "string") {
+      const column = columnOn(table, entry, "select");
+      names.add(column.field);
+      items.push({ kind: "column", column });
+      continue;
+    }
+    const sql = readSelectFragment(entry);
+    if (sql !== undefined) {
+      const as = readAs(sql.as, "fragment");
+      if (names.has(as) || table.columns.has(as)) {
+        fail2("OKM1120", `fragment as ${as} clashes with a column of ${table.model.name}.`, "Pick an as name that is not a column.");
+      }
+      names.add(as);
+      ordinals.set(as, String(items.length + 1));
+      items.push(sql.textual === true ? { kind: "sql", as, parts: sql.parts, textual: true } : { kind: "sql", as, parts: sql.parts });
+      continue;
+    }
+    if (!isWindow(entry)) {
+      fail2("OKM1120", "select takes field names or a window helper. A plain object is not a window.", "Pass rowNumber, rank, denseRank, or runningTotal.");
+    }
+    const win = readWindow(table, entry, names);
+    names.add(win.as);
+    ordinals.set(win.as, String(items.length + 1));
+    items.push({ kind: "window", window: win });
+  }
+  return { items, ordinals };
+}
+function readWindow(table, call, taken) {
+  if (!isRecord(call))
+    fail2("OKM1120", "A window helper was not created by its function.");
+  for (const key of Object.keys(call)) {
+    if (key === "label" || key === "fn" || key === "column")
+      continue;
+    if (OPTION_KEYS.includes(key))
+      continue;
+    fail2("OKM1120", `${call.label} does not take ${key}. Accepted: partitionBy, orderBy, as.`, "Pass partitionBy, orderBy, and as.");
+  }
+  const as = readAs(call.as, call.label);
+  if (taken.has(as) || table.columns.has(as)) {
+    fail2("OKM1120", `${call.label} as ${as} clashes with a column of ${table.model.name}.`, "Pick an as name that is not a column.");
+  }
+  const partition = readPartition(table, call.partitionBy, call.label);
+  if (!isRecord(call.orderBy) || Object.keys(call.orderBy).length === 0) {
+    fail2("OKM1120", `${call.label} needs orderBy, the order inside the group.`, 'Pass orderBy: { field: "desc" }.');
+  }
+  for (const field of Object.keys(call.orderBy))
+    columnOn(table, field, `${call.label} orderBy`);
+  let column;
+  let decode = AS_NUMBER;
+  if (call.fn === "sum") {
+    if (typeof call.column !== "string") {
+      fail2("OKM1120", "runningTotal needs the column to total.");
+    }
+    column = columnOn(table, call.column, "runningTotal");
+    if (!NUMERIC.test(column.dataType)) {
+      fail2("OKM1124", `runningTotal does not apply to ${column.dataType} column ${column.field}. It takes integer, real, and numeric columns.`);
+    }
+    decode = totalDecode(column);
+  }
+  return {
+    fn: call.fn,
+    label: call.label,
+    column,
+    partition,
+    orderBy: call.orderBy,
+    as,
+    decode,
+    tieBreak: call.fn === "row_number" || call.fn === "sum"
+  };
+}
+function readPartition(table, value, label) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || value.length === 0) {
+    fail2("OKM1120", `${label} partitionBy needs the fields that form the group.`, 'Pass partitionBy: ["status"], or leave it out to use the whole result.');
+  }
+  const columns = [];
+  const seen = new Set;
+  for (const name of value) {
+    if (typeof name !== "string") {
+      fail2("OKM1120", `${label} partitionBy takes field names.`);
+    }
+    const column = columnOn(table, name, `${label} partitionBy`);
+    if (seen.has(column.field)) {
+      fail2("OKM1120", `${label} partitionBy lists ${column.field} twice.`);
+    }
+    seen.add(column.field);
+    columns.push(column);
+  }
+  return columns;
+}
+function readAs(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    fail2("OKM1120", `${label} needs as, the name of the result key.`, "Set as to a name, such as n.");
+  }
+  for (let index = 0;index < value.length; index += 1) {
+    if ((value.charCodeAt(index) ?? 0) < 32) {
+      fail2("OKM1120", `${label} as has a control character.`);
+    }
+  }
+  refusePrototypeKey(value, `${label} as`);
+  return value;
+}
+function totalDecode(column) {
+  const kind = typeof (column.decode?.("0") ?? "");
+  if (kind === "string")
+    return AS_TEXT;
+  if (kind === "number")
+    return AS_NUMBER;
+  return fail2("OKM1124", `runningTotal needs a column whose value is a number or a string. ${column.field} reads as ${kind}.`);
+}
+function columnOn(table, name, where) {
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. ${where} accepts: ${list(table.names)}.`);
+  }
+  if (where !== "select")
+    refuseHidden(column);
+  return column;
+}
+function indexesOf(schema, name) {
+  const table = indexes(schema).get(name);
+  if (table === undefined)
+    fail2("OKM1120", `Table ${name} is not in the schema.`);
+  return table;
+}
+export {
+  attach
+};