okmodel 0.6.0 → 0.8.0

package/dist/shared/1d9q9cv2.js

@@ -0,0 +1,312 @@
+import {
+  emitSqlSelect,
+  decodeSqlNumber
+} from "./3bb7wsqt.js";
+import {
+  refusePrototypeKey
+} from "./a62rb2da.js";
+import {
+  isWindow
+} from "./9a4ae4p8.js";
+import {
+  readSelectFragment
+} from "./bsek72fg.js";
+import {
+  emitWhere,
+  emitOrder,
+  refuseHidden,
+  emitLimit,
+  parseOrder,
+  projectExpr,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./kgwp4jdd.js";
+import {
+  throwNamed2
+} from "./52szzakm.js";
+
+// 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) {
+        throwNamed2("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) {
+    throwNamed2("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
+};

package/dist/shared/2c13q96h.js

@@ -0,0 +1,18 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/adapters/lazy-errors.ts
+function refused() {
+  return Promise.reject(new OkmError2("OKM1120", "timeout"));
+}
+function closed() {
+  return Promise.reject(new DriverError2("The pool is closed.", { sqlstate: "08006" }));
+}
+export {
+  closed,
+  refused
+};

package/dist/shared/{b4v57v3x.js → 2d3xq4ps.js}

@@ -2,8 +2,8 @@
 async function refuseUncancellableTimeout(pool, timeout) {
   if (pool.capabilities.cancel === true || timeout === undefined || !(timeout > 0))
     return;
-  const { noTimeout } = await import("./wxr8cwns.js");
-  noTimeout({ timeout });
+  const { refused } = await import("./2c13q96h.js");
+  await refused();
 }
 
 export { refuseUncancellableTimeout };

package/dist/shared/{1f0xa3cb.js → 3449rcae.js}

@@ -2,11 +2,11 @@ import {
   assertAuthorDrift2,
   catalogQuery2,
   managedRoleOptions2
-} from "./f0f1n281.js";
-import"./vjpnzwjz.js";
-import"./ttmg09vd.js";
-import"./9s0ypp87.js";
-import"./qq3899ht.js";
+} from "./mkrn359n.js";
+import"./p3xbdcvt.js";
+import"./dpc2r7rb.js";
+import"./sjk86yrx.js";
+import"./12z7aznj.js";
 export {
   assertAuthorDrift2 as assertAuthorDrift,
   catalogQuery2 as catalogQuery,

package/dist/shared/{wkme6tep.js → 35q0n9tz.js}

@@ -6,7 +6,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./cgbamx3e.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/postgresjs.ts
 import net from "node:net";
@@ -117,26 +117,18 @@ function open2(config) {
     execute(text, params, options) {
       return sockets.occupy(() => runCall(closed, options, (watch) => root.query(text, params, watch)));
     },
-    async batch(statements, options) {
-      return sockets.occupy(async () => {
-        const { checkout } = await import("./r1fdd0f6.js");
-        const connection = await checkout(held);
-        try {
-          return await connection.batch(statements, options);
-        } finally {
-          await connection.release();
-        }
-      });
+    batch(statements, options) {
+      return sockets.occupy(() => import("./z581d7ny.js").then((mod) => mod.runBatch(held, statements, options)));
     },
     reserve() {
       const gate = sockets.busyGate();
       gate.enter();
-      return import("./r1fdd0f6.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+      return import("./z581d7ny.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
         gate.leave();
         throw error;
       });
     },
-    describe: (text, params) => sockets.occupy(() => import("./r1fdd0f6.js").then((mod) => mod.describe(sql, text, params))),
+    describe: (text, params) => sockets.occupy(() => import("./z581d7ny.js").then((mod) => mod.describe(sql, text, params))),
     stream(text, params) {
       const gate = sockets.busyGate();
       return async function* () {
@@ -151,7 +143,7 @@ function open2(config) {
     listen(channel, onNotify) {
       const gate = sockets.listenerGate();
       gate.enter();
-      return import("./r1fdd0f6.js").then((mod) => mod.holdListener(gate, async () => {
+      return import("./z581d7ny.js").then((mod) => mod.holdListener(gate, async () => {
         const listening = await sql.listen(channel, onNotify);
         return async () => {
           await listening.unlisten();
@@ -221,7 +213,7 @@ class PgSession {
       onAbort();
     else
       watch.signal.addEventListener("abort", onAbort, { once: true });
-    return import("./r1fdd0f6.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+    return import("./z581d7ny.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
       start,
       text,
       notices: this.notices,
@@ -273,7 +265,7 @@ class PgSession {
   }
 }
 async function* loadStream(sql, text, params) {
-  const { stream } = await import("./r1fdd0f6.js");
+  const { stream } = await import("./z581d7ny.js");
   yield* stream(sql, text, params);
 }
 function send(sql, text, params, named) {

package/dist/shared/3bb7wsqt.js

@@ -0,0 +1,99 @@
+import {
+  isFragmentParts
+} from "./bsek72fg.js";
+import {
+  refuseHidden,
+  quote,
+  list,
+  fail2
+} from "./kgwp4jdd.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/sql-fragment.ts
+function emitSqlValue(table, ref, value, sink) {
+  const dot = ref.indexOf(".");
+  const alias = dot < 0 ? ref : ref.slice(0, dot);
+  writeFragment(requireParts(value), sink, alias, ref, table, "where");
+}
+function emitSqlSelect(table, parts, sink, alias) {
+  writeFragment(parts, sink, alias, undefined, table, "select");
+}
+function decodeSqlNumber(wire) {
+  const parsed = Number(wire);
+  if (!Number.isFinite(parsed)) {
+    throw new OkmError2("OKM1125", "A select fragment must be a number.", {
+      fix: { summary: "Use a numeric expression, such as length(title). Text stays in where." }
+    });
+  }
+  return parsed;
+}
+function requireParts(value) {
+  if (!isFragmentParts(value)) {
+    throw new OkmError2("OKM1125", "A fragment was not created by fragment``.", {
+      fix: { summary: "Call fragment`...`." }
+    });
+  }
+  return value;
+}
+function writeFragment(parts, sink, alias, ref, table, place) {
+  sink.mark(":g");
+  sink.text("(");
+  for (const part of parts)
+    writePart(part, sink, alias, ref, table, place);
+  sink.mark(":g");
+  sink.text(")");
+}
+function writePart(part, sink, alias, ref, table, place) {
+  if (part.k === "t") {
+    sink.mark(`:t:${String(part.s.length)}:${part.s}`);
+    sink.text(part.s);
+    return;
+  }
+  if (part.k === "p") {
+    sink.mark(":p");
+    sink.param(part.v);
+    return;
+  }
+  if (part.k === "n") {
+    sink.mark(":n");
+    sink.text("null");
+    return;
+  }
+  if (part.k === "i") {
+    writeIdent(part.n, table, sink, alias, place);
+    return;
+  }
+  if (part.k === "c") {
+    if (ref === undefined) {
+      throw new OkmError2("OKM1125", "fragment.column belongs on a where field.", {
+        fix: { summary: "Use ident(name) in select, or put fragment.column on a where field." }
+      });
+    }
+    sink.mark(":c");
+    sink.text(ref);
+    return;
+  }
+  writeFragment(part.parts, sink, alias, ref, table, place);
+}
+function writeIdent(name, table, sink, alias, place) {
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+  }
+  if (place === "select") {
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden.`, "A select fragment cannot name a hidden field.");
+    }
+  } else {
+    refuseHidden(column);
+  }
+  sink.mark(`:i:${String(column.field.length)}:${column.field}`);
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(column.sql));
+}
+
+export { emitSqlValue, emitSqlSelect, decodeSqlNumber };