okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/7aews1zg.js

@@ -0,0 +1,311 @@
+import {
+  queryHandle,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  throwNamed,
+  emitWhere,
+  emitOrder,
+  refuseHidden,
+  rejectKeys,
+  readLimit,
+  projectExpr,
+  cell,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/aggregate.ts
+var BUCKET = Symbol.for("okmodel.bucket");
+var bucketChunk;
+function loadBucketGroup() {
+  return bucketChunk ??= import("./57btdkgm.js");
+}
+var OPTIONS = [
+  "where",
+  "groupBy",
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "orderBy",
+  "limit",
+  "route",
+  "signal",
+  "timeout"
+];
+var NUMERIC = /^(smallint|integer|bigint|real|double precision|numeric|decimal)\b/;
+var AS_NUMBER = (wire) => Number(wire);
+var AS_TEXT = (wire) => wire;
+var UNORDERED = /^(json|jsonb|bytea|point|line|tsvector)\b|\[\]$/;
+var FUNCTIONS = [
+  { option: "sum", tag: "s", numeric: true },
+  { option: "avg", tag: "a", numeric: true },
+  { option: "min", tag: "n", numeric: false },
+  { option: "max", tag: "x", numeric: false }
+];
+function build(session, table, options, mods, view) {
+  try {
+    if (seesBucket(options))
+      return bucketHandle(session, table, options, mods, view);
+    return plan(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError ? attachHttp(session.http, error) : error;
+  }
+}
+function bucketHandle(session, table, options, mods, view) {
+  const open = () => loadBucketGroup().then((mod) => {
+    try {
+      return { it: plan(session, table, options, mods, view, mod) };
+    } catch (error) {
+      throw error instanceof OkmError ? attachHttp(session.http, error) : error;
+    }
+  });
+  return queryHandle(() => open().then((box) => box.it), {
+    inspect: () => open().then((box) => box.it.inspect()),
+    sql: () => open().then((box) => box.it.sql()),
+    all: (reason) => build(session, table, options, { ...mods, all: reason }, view)
+  });
+}
+function seesBucket(options) {
+  if (!isRecord(options))
+    return false;
+  const groupBy = options.groupBy;
+  if (!Array.isArray(groupBy))
+    return false;
+  for (const item of groupBy) {
+    if (typeof item === "object" && item !== null && BUCKET in item)
+      return true;
+  }
+  return false;
+}
+function plan(session, table, options, mods, view, buckets) {
+  const record = isRecord(options) ? options : {};
+  rejectKeys(record, OPTIONS, "aggregate");
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
+  const spec = parse(indexed, record, buckets);
+  if (spec.groups.length > 0 && record.limit === undefined && mods.all === undefined) {
+    fail2("OKM1101", "aggregate() with groupBy needs a limit, or .all(reason) for every group.");
+  }
+  const names = groupNames(spec.groups);
+  const orderBy = record.orderBy;
+  if (orderBy !== undefined) {
+    if (!isRecord(orderBy))
+      fail2("OKM1120", "orderBy must be an object of fields.");
+    for (const field of Object.keys(orderBy)) {
+      if (!names.includes(field)) {
+        const column = indexed.columns.get(field);
+        if (column !== undefined)
+          refuseHidden(column);
+        throwNamed("OKM1120", field, names, `aggregate() orders by a groupBy field. Accepted names: ${list(names)}.`);
+      }
+    }
+  }
+  if (record.limit !== undefined)
+    readLimit(record.limit);
+  const base = readCall("find", table, {
+    where: record.where,
+    orderBy,
+    limit: record.limit,
+    signal: record.signal,
+    timeout: record.timeout,
+    route: record.route
+  }, mods.all, session.scope, session.schema.model[table], session.schema, view);
+  const call = { ...base, op: "aggregate", build: statement(spec, buckets) };
+  return readHandle(session, table, call, mods, (compiled, rows) => decode(compiled, rows));
+}
+function parse(table, record, buckets) {
+  const grouped = readGroups(table, record.groupBy, buckets);
+  const count = record.count === true;
+  if (record.count !== undefined && typeof record.count !== "boolean") {
+    fail2("OKM1120", "count is true when you want a row count.");
+  }
+  const calls = [];
+  for (const { option, tag, numeric } of FUNCTIONS) {
+    for (const column of columns(table, record[option], option)) {
+      const fits = numeric ? NUMERIC.test(column.dataType) : !UNORDERED.test(column.dataType);
+      if (!fits) {
+        fail2("OKM1124", `${option} does not apply to ${column.dataType} column ${column.field}. ${numeric ? "sum and avg take integer, real, and numeric columns." : "min and max need an ordered type."}`);
+      }
+      calls.push({ option, tag, column, decode: numeric ? sumDecode(column) : column.decode });
+    }
+  }
+  if (!count && calls.length === 0 && grouped.groups.length === 0) {
+    fail2("OKM1120", "aggregate() needs count, sum, avg, min, max, or groupBy.");
+  }
+  return { groups: grouped.groups, bucketed: grouped.bucketed, count, calls };
+}
+function sumDecode(column) {
+  const kind = typeof (column.decode?.("0") ?? "");
+  if (kind === "string")
+    return AS_TEXT;
+  if (kind === "number")
+    return AS_NUMBER;
+  return fail2("OKM1124", `sum and avg need a column whose value is a number or a string. ${column.field} reads as ${kind}.`);
+}
+function columns(table, value, option) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    fail2("OKM1120", `${option} must be a list of field names.`);
+  const out = [];
+  for (const name of value) {
+    const column = typeof name === "string" ? table.columns.get(name) : undefined;
+    if (typeof name !== "string" || column === undefined) {
+      throwNamed("OKM1120", String(name), table.names, `Field ${String(name)} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden, so ${option} cannot read it.`);
+    }
+    out.push(column);
+  }
+  return out;
+}
+function groupNames(groups) {
+  const names = [];
+  for (const group of groups)
+    names.push(group.kind === "field" ? group.column.field : group.as);
+  return names;
+}
+function readGroups(table, value, buckets) {
+  if (value === undefined)
+    return { groups: [], bucketed: false };
+  if (!Array.isArray(value))
+    fail2("OKM1120", "groupBy must be a list of field names.");
+  const fields = new Set;
+  const aliases = new Set;
+  const groups = [];
+  let bucketed = false;
+  for (const item of value) {
+    if (typeof item === "object" && item !== null && BUCKET in item) {
+      if (buckets === undefined)
+        fail2("OKM1120", "bucket group");
+      groups.push(buckets.readBucket(table, item, fields, aliases));
+      bucketed = true;
+      continue;
+    }
+    const column = typeof item === "string" ? table.columns.get(item) : undefined;
+    if (typeof item !== "string" || column === undefined) {
+      throwNamed("OKM1120", String(item), table.names, `Field ${String(item)} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden, so groupBy cannot read it.`);
+    }
+    if (aliases.has(column.field)) {
+      fail2("OKM1120", `group field ${column.field} clashes with a bucket as.`);
+    }
+    fields.add(column.field);
+    groups.push({ kind: "field", column });
+  }
+  return { groups, bucketed };
+}
+function statement(spec, buckets) {
+  return (schema, table, sink, outputs, call) => {
+    sink.mark(`aggregate|${table.model.name}|g:${groupMark(spec.groups)}|c:${String(spec.count)}|${spec.calls.map((item) => `${item.tag}:${item.column.field}`).join(",")}|`);
+    sink.text("select ");
+    const wrote = { at: 0 };
+    for (const group of spec.groups) {
+      if (group.kind === "field") {
+        put(sink, outputs, wrote, projectExpr(`t.${quote(group.column.sql)}`, group.column.dataType), {
+          key: `g:${group.column.field}`,
+          decode: group.column.decode
+        });
+      } else {
+        if (buckets === undefined)
+          fail2("OKM1120", "bucket group");
+        buckets.writeBucket(sink, outputs, wrote, group);
+      }
+    }
+    if (spec.count)
+      put(sink, outputs, wrote, "count(*)::text", { key: "c:", decode: undefined });
+    for (const item of spec.calls) {
+      const ref = `t.${quote(item.column.sql)}`;
+      const expr = item.option === "sum" || item.option === "avg" ? `${item.option}(${ref})::text` : projectExpr(`${item.option}(${ref})`, item.column.dataType);
+      put(sink, outputs, wrote, expr, {
+        key: `${item.tag}:${item.column.field}`,
+        decode: item.decode
+      });
+    }
+    sink.text(" from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    emitWhere(schema, table, call.where, sink, "t", 0);
+    if (spec.groups.length > 0) {
+      sink.text(" group by ");
+      if (spec.bucketed) {
+        if (buckets === undefined)
+          fail2("OKM1120", "bucket group");
+        buckets.writeGrouped(sink, groupNames(spec.groups), call.orderBy);
+      } else {
+        sink.text(spec.groups.map((group) => fieldRef(group)).join(", "));
+        if (isRecord(call.orderBy) && Object.keys(call.orderBy).length > 0) {
+          emitOrder(table, call.orderBy, sink, "t");
+        } else {
+          sink.text(" order by ");
+          sink.text(spec.groups.map((group) => `${fieldRef(group)} asc nulls last`).join(", "));
+        }
+      }
+    }
+    if (call.limit !== undefined) {
+      const limit = String(call.limit);
+      sink.text(" limit ");
+      sink.param(limit);
+      sink.mark(`l:${limit}`);
+    }
+    if (typeof call.all === "string")
+      sink.mark(`all:${call.all}`);
+  };
+}
+function groupMark(groups) {
+  const parts = [];
+  for (const group of groups) {
+    parts.push(group.kind === "field" ? group.column.field : `b:${group.column.field}:${group.as}:${group.unit}:${String(group.shift)}`);
+  }
+  return parts.join(",");
+}
+function fieldRef(group) {
+  if (group.kind !== "field")
+    return fail2("OKM1120", "bucket group");
+  return `t.${quote(group.column.sql)}`;
+}
+function put(sink, outputs, wrote, expr, out) {
+  if (wrote.at > 0)
+    sink.text(", ");
+  sink.text(expr);
+  outputs?.fields.push({ key: out.key, at: wrote.at, decode: out.decode });
+  wrote.at += 1;
+}
+function decode(compiled, rows) {
+  const items = [];
+  for (const row of rows) {
+    const item = {};
+    for (const field of compiled.outputs.fields) {
+      const value = row[field.at];
+      const tag = field.key.slice(0, 2);
+      const name = field.key.slice(2);
+      if (tag === "g:") {
+        item[name] = cell(value, field.decode);
+      } else if (tag === "c:") {
+        item.count = Number(value ?? 0);
+      } else {
+        const group = tag === "s:" ? "sum" : tag === "a:" ? "avg" : tag === "n:" ? "min" : "max";
+        const into = item[group] ??= {};
+        into[name] = cell(value, field.decode);
+      }
+    }
+    items.push(item);
+  }
+  return items;
+}
+export {
+  build
+};

package/dist/tooling/shared/7b3xp9gc.js

@@ -0,0 +1,195 @@
+import {
+  emitSqlValue
+} from "./ybdew6j7.js";
+import {
+  assertOperatorFits,
+  sqlType,
+  assertNoControl,
+  assertBoundText,
+  assertRegconfig,
+  textArray
+} from "./w5d89rb4.js";
+import {
+  isOperator,
+  operatorName,
+  operatorValue,
+  installOperatorSql,
+  quote,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/operator-sql.ts
+function emitStructured(table, column, ref, name, value, sink, order) {
+  if (name === "sql") {
+    emitSqlValue(table, ref, value, sink);
+    return;
+  }
+  if (name === "contains" || name === "containedBy" || name === "overlaps") {
+    emitContainment(column, ref, name, value, sink);
+    return;
+  }
+  if (name === "hasKey" || name === "hasAnyKey") {
+    emitJsonKey(column, ref, name, value, sink);
+    return;
+  }
+  if (name === "path") {
+    emitPath(column, ref, value, sink);
+    return;
+  }
+  if (name === "matches") {
+    emitMatches(column, ref, value, sink);
+    return;
+  }
+  if (name === "relevance") {
+    if (order !== true)
+      fail2("OKM1121", `relevance on ${column.field} belongs in orderBy.`);
+    emitRelevance(column, ref, value, sink);
+    sink.text(" desc");
+    sink.mark(`o:${column.field}:relevance`);
+    return;
+  }
+  if (name === "similar" || name === "wordSimilar") {
+    emitTrigram(column, ref, name, value, sink);
+    return;
+  }
+  assertOperatorFits(column, name);
+  fail2("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
+}
+function emitContainment(column, ref, name, value, sink) {
+  assertOperatorFits(column, name);
+  const op = name === "contains" ? " @> " : name === "containedBy" ? " <@ " : " && ";
+  sink.text(ref);
+  sink.text(op);
+  sink.param(column.encode(value));
+  sink.text("::");
+  sink.text(sqlType(column.dataType, column));
+}
+function emitJsonKey(column, ref, name, value, sink) {
+  assertOperatorFits(column, name);
+  if (name === "hasKey") {
+    if (typeof value !== "string")
+      fail2("OKM1121", `hasKey on ${column.field} needs a key.`);
+    assertBoundText(value, `key on ${column.field}`);
+    sink.text("jsonb_exists(");
+    sink.text(ref);
+    sink.text(", ");
+    sink.param(value);
+    sink.text(")");
+    return;
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    fail2("OKM1121", `hasAnyKey on ${column.field} needs a list of keys.`);
+  }
+  sink.text("jsonb_exists_any(");
+  sink.text(ref);
+  sink.text(", ");
+  sink.param(textArray(value, `key on ${column.field}`));
+  sink.text("::text[])");
+}
+function emitPath(column, ref, value, sink) {
+  assertOperatorFits(column, "path");
+  if (!isRecord(value) || !Array.isArray(value.segments) || !isOperator(value.op)) {
+    fail2("OKM1121", `path on ${column.field} needs segments and a comparison.`);
+  }
+  const segments = value.segments;
+  if (segments.length === 0 || segments.some((item) => typeof item !== "string")) {
+    fail2("OKM1121", `path on ${column.field} needs a list of segments.`);
+  }
+  const opName = operatorName(value.op);
+  if (opName !== "eq" && opName !== "lt" && opName !== "lte" && opName !== "gt" && opName !== "gte") {
+    fail2("OKM1121", `path on ${column.field} compares with eq, lt, lte, gt, or gte.`);
+  }
+  const operand = operatorValue(value.op);
+  const cast = pathCast(column, operand);
+  const sql = opName === "eq" ? " = " : opName === "lt" ? " < " : opName === "lte" ? " <= " : opName === "gt" ? " > " : " >= ";
+  sink.text("(");
+  sink.text(ref);
+  sink.text(" #>> ");
+  sink.param(textArray(segments, `path on ${column.field}`));
+  sink.text("::text[])::");
+  sink.text(cast);
+  sink.text(sql);
+  sink.param(pathParam(operand));
+}
+function pathCast(column, operand) {
+  if (typeof operand === "number")
+    return "numeric";
+  if (typeof operand === "boolean")
+    return "boolean";
+  if (typeof operand === "string")
+    return "text";
+  fail2("OKM1121", `path on ${column.field} compares a string, number, or boolean.`);
+}
+function pathParam(operand) {
+  if (typeof operand === "number")
+    return String(operand);
+  if (typeof operand === "boolean")
+    return operand ? "true" : "false";
+  if (typeof operand === "string")
+    return operand;
+  return "";
+}
+var MATCH_FN = {
+  natural: "websearch_to_tsquery",
+  "all-words": "plainto_tsquery",
+  phrase: "phraseto_tsquery",
+  advanced: "to_tsquery"
+};
+function readMatch(column, value, label) {
+  if (!isRecord(value) || typeof value.query !== "string" || value.query.length === 0) {
+    fail2("OKM1121", `${label} on ${column.field} needs text to look for.`);
+  }
+  assertNoControl(value.query, `${label} on ${column.field}`);
+  const match = value.match ?? "natural";
+  const fn = typeof match === "string" ? MATCH_FN[match] : undefined;
+  if (fn === undefined) {
+    fail2("OKM1121", `${label} on ${column.field} match must be natural, all-words, phrase, or advanced.`);
+  }
+  if (value.language === undefined)
+    return { fn, language: undefined, query: value.query };
+  if (typeof value.language !== "string") {
+    fail2("OKM1121", `${label} on ${column.field} language must be a name such as english.`);
+  }
+  assertRegconfig(value.language);
+  return { fn, language: value.language, query: value.query };
+}
+function emitTsquery(sink, query) {
+  sink.mark(query.language === undefined ? `:${query.fn}` : `:${query.fn}:lang`);
+  sink.text(query.fn);
+  sink.text("(");
+  if (query.language !== undefined) {
+    sink.param(query.language);
+    sink.text("::regconfig, ");
+  }
+  sink.param(query.query);
+  sink.text(")");
+}
+function emitMatches(column, ref, value, sink) {
+  assertOperatorFits(column, "matches");
+  sink.text(ref);
+  sink.text(" @@ ");
+  emitTsquery(sink, readMatch(column, value, "matches"));
+}
+function emitRelevance(column, ref, value, sink) {
+  assertOperatorFits(column, "relevance");
+  sink.text("ts_rank(");
+  sink.text(ref);
+  sink.text(", ");
+  emitTsquery(sink, readMatch(column, value, "relevance"));
+  sink.text(")");
+}
+function emitTrigram(column, ref, name, value, sink) {
+  if (!isRecord(value) || typeof value.query !== "string" || typeof value.schema !== "string") {
+    fail2("OKM1121", `${name} on ${column.field} needs query text.`);
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value.schema)) {
+    fail2("OKM1121", `${name} on ${column.field} needs an extension schema name.`);
+  }
+  sink.text(ref);
+  sink.text(" operator(");
+  sink.text(quote(value.schema));
+  sink.text(name === "similar" ? ".%) " : ".<%) ");
+  sink.param(value.query);
+}
+installOperatorSql(emitStructured);

package/dist/tooling/shared/7kms6fvj.js

@@ -0,0 +1,20 @@
+// src/adapters/pg/cursor.ts
+async function* cursorStream(run, text, params) {
+  const name = "okm_stream";
+  await run("BEGIN");
+  try {
+    await run(`DECLARE ${name} NO SCROLL CURSOR FOR ${text}`, params);
+    for (;; ) {
+      const chunk = await run(`FETCH 64 FROM ${name}`);
+      if (chunk.rows.length === 0)
+        break;
+      yield chunk.rows;
+    }
+  } finally {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  }
+}
+
+export { cursorStream };

package/dist/tooling/shared/7pxncnzs.js

@@ -0,0 +1,40 @@
+import {
+  rejectClosed
+} from "./5x3pf400.js";
+import {
+  isConnectionLost
+} from "./hfq3n3bd.js";
+
+// src/adapters/pg/reserved.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function resetSession2(depth, run) {
+  if (depth > 0)
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  } catch {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  }
+}
+async function resetQueried2(session) {
+  await resetSession2(session.inTransaction() ? 1 : 0, (text) => text === "ROLLBACK" ? session.rollback() : session.query(text, undefined, undefined));
+}
+function refuseWhenLost2(lost, run) {
+  if (lost.on)
+    return rejectClosed();
+  return run().catch((error) => {
+    if (isConnectionLost(error))
+      lost.on = true;
+    throw error;
+  });
+}
+
+export { resetSession2, resetQueried2, refuseWhenLost2 };