okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/vwr2y833.js

@@ -0,0 +1,270 @@
+import {
+  readHandle,
+  readCall,
+  attachHttp
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  throwNamed,
+  decodeResult,
+  emitWhere,
+  emitOrder,
+  selectedColumns,
+  rejectKeys,
+  projectExpr,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/tree.ts
+var OPTIONS = [
+  "where",
+  "select",
+  "orderBy",
+  "depth",
+  "self",
+  "relation",
+  "route",
+  "signal",
+  "timeout"
+];
+function build2(session, table, options, mods, view) {
+  try {
+    return open(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError ? attachHttp(session.http, error) : error;
+  }
+}
+function open(session, table, options, mods, view) {
+  const packed = readPacked(options);
+  const user = packed.user;
+  rejectKeys(user, OPTIONS, packed.walk);
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
+  const edge = pickEdge(indexed, user.relation);
+  const identity = identityColumn2(session, indexed);
+  const depth = readDepth(user.depth);
+  const self = readSelf(user.self);
+  const id = userId(identity, packed.id);
+  const shared = {
+    ...user.where !== undefined ? { where: user.where } : {},
+    ...user.select !== undefined ? { select: user.select } : {},
+    ...user.orderBy !== undefined ? { orderBy: user.orderBy } : {},
+    ...user.signal !== undefined ? { signal: user.signal } : {},
+    ...user.timeout !== undefined ? { timeout: user.timeout } : {},
+    ...user.route !== undefined ? { route: user.route } : {}
+  };
+  const base = readCall("find", table, shared, mods.all, session.scope, session.schema.model[table], session.schema, view);
+  const spec = { direction: packed.walk, edge, identity, depth, self, id };
+  const call = {
+    ...base,
+    op: packed.walk,
+    build: (schema, planned, sink, outputs, source) => {
+      emitTree(schema, planned, sink, outputs, source, spec);
+    }
+  };
+  return readHandle(session, table, call, mods, (compiled, rows) => decodeResult(compiled, rows, table));
+}
+function emitTree(schema, table, sink, outputs, call, spec) {
+  const { direction, edge, identity, depth, self, id } = spec;
+  sink.mark(`walk:${direction}|rel:${edge.name}|self:${self ? "1" : "0"}|depth:${depth === undefined ? "all" : String(depth)}|`);
+  const selected = selectedColumns(table, call.select);
+  sink.text("with recursive walk as (select ");
+  emitKeyList(sink, "s", edge.parent, "k");
+  emitKeyList(sink, "s", edge.child, "f");
+  sink.text(", 0 as depth, array[s.");
+  sink.text(quote(identity.sql));
+  sink.text("] as seen from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" s where s.");
+  sink.text(quote(identity.sql));
+  sink.text(" = ");
+  sink.param(identity.encode(id));
+  emitWhere(schema, table, undefined, sink, "s", 0, true);
+  sink.text(" union all select ");
+  let started = emitBare(sink, "c", edge.parent, false);
+  emitBare(sink, "c", edge.child, started);
+  sink.text(", w.depth + 1, w.seen || c.");
+  sink.text(quote(identity.sql));
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" c join walk w on ");
+  if (direction === "descendants")
+    emitStep(sink, "c", edge.child, edge.parent, "k");
+  else
+    emitStep(sink, "c", edge.parent, edge.child, "f");
+  sink.text(" where c.");
+  sink.text(quote(identity.sql));
+  sink.text(" <> all(w.seen)");
+  if (depth !== undefined) {
+    sink.text(" and w.depth < ");
+    sink.text(String(depth));
+  }
+  emitWhere(schema, table, undefined, sink, "c", 0, true);
+  sink.text(") select ");
+  let column = 0;
+  for (let index = 0;index < selected.length; index += 1) {
+    const item = selected[index];
+    if (item === undefined)
+      continue;
+    if (column > 0)
+      sink.text(", ");
+    sink.text(projectExpr(`t.${quote(item.sql)}`, item.dataType));
+    sink.mark(`s:${item.field}`);
+    outputs?.fields.push({ key: item.field, at: column, decode: item.decode });
+    column += 1;
+  }
+  if (column === 0)
+    sink.text("1");
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" t join walk w on ");
+  emitStep(sink, "t", edge.parent, edge.parent, "k");
+  if (self)
+    emitWhere(schema, table, call.where, sink, "t", 0, false);
+  else {
+    sink.text(" where w.depth > 0");
+    emitWhere(schema, table, call.where, sink, "t", 0, true);
+  }
+  if (call.orderBy !== undefined) {
+    emitOrder(table, call.orderBy, sink, "t");
+    return;
+  }
+  sink.text(" order by w.depth asc");
+  sink.mark("order:depth");
+  for (const field of table.model.primary) {
+    const item = table.columns.get(field);
+    if (item === undefined)
+      continue;
+    sink.text(", t.");
+    sink.text(quote(item.sql));
+    sink.text(" asc");
+  }
+}
+function emitKeyList(sink, alias, columns, prefix) {
+  for (let index = 0;index < columns.length; index += 1) {
+    const name = columns[index];
+    if (name === undefined)
+      continue;
+    if (index > 0 || prefix === "f")
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+    sink.text(" as ");
+    sink.text(prefix);
+    sink.text(String(index));
+  }
+}
+function emitBare(sink, alias, columns, lead) {
+  let started = lead;
+  for (const name of columns) {
+    if (started)
+      sink.text(", ");
+    started = true;
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+  }
+  return started;
+}
+function emitStep(sink, alias, columns, against, prefix) {
+  for (let index = 0;index < columns.length; index += 1) {
+    const name = columns[index];
+    if (name === undefined || against[index] === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+    sink.text(" = w.");
+    sink.text(prefix);
+    sink.text(String(index));
+  }
+}
+function readPacked(options) {
+  if (!isRecord(options) || options.walk !== "descendants" && options.walk !== "ancestors") {
+    fail2("OKM1120", "descendants and ancestors are table methods.");
+  }
+  const user = options.options;
+  if (user === undefined)
+    return { id: options.id, walk: options.walk, user: {} };
+  if (!isRecord(user))
+    fail2("OKM1120", `${options.walk} options must be an object.`);
+  return { id: options.id, walk: options.walk, user };
+}
+function pickEdge(table, relation) {
+  const edges = selfEdges(table);
+  if (edges.length === 0) {
+    fail2("OKM1120", `${table.model.name} has no relation to itself.`, `Declare children: many("${table.model.name}") or parent: one("${table.model.name}").`);
+  }
+  const groups = new Set(edges.map((edge) => edge.child.join("\x00")));
+  if (relation === undefined) {
+    if (groups.size !== 1) {
+      fail2("OKM1120", `${table.model.name} has more than one relation to itself. Pass relation.`, `Accepted names: ${edges.map((edge) => edge.name).join(", ")}.`);
+    }
+    const only = edges[0];
+    if (only === undefined)
+      fail2("OKM1120", `${table.model.name} has no relation to itself.`);
+    return only;
+  }
+  if (typeof relation !== "string" || relation.length === 0) {
+    fail2("OKM1120", "relation must be a name.");
+  }
+  const found = edges.find((edge) => edge.name === relation);
+  if (found === undefined) {
+    throwNamed("OKM1120", relation, edges.map((edge) => edge.name), `Relation ${relation} is not a self-relation of ${table.model.name}. Accepted names: ${list(edges.map((edge) => edge.name))}.`);
+  }
+  return found;
+}
+function selfEdges(table) {
+  const edges = [];
+  for (const relation of table.model.relations) {
+    if (relation.table !== table.model.name || relation.through !== undefined)
+      continue;
+    edges.push(relation.kind === "many" ? { name: relation.name, parent: relation.local, child: relation.remote } : { name: relation.name, parent: relation.remote, child: relation.local });
+  }
+  return edges;
+}
+function identityColumn2(session, table) {
+  const tenancy = session.schema.tenancy;
+  const keys = tenancy === undefined ? [] : tenancy.keys ?? [tenancy.key];
+  const fields = table.model.primary.filter((field) => !keys.includes(field));
+  if (fields.length !== 1) {
+    fail2("OKM1120", `${table.model.name} needs one primary key column besides the tenant key.`, "Use a single-column primary key.");
+  }
+  const field = fields[0];
+  const column = field === undefined ? undefined : table.columns.get(field);
+  if (column === undefined) {
+    fail2("OKM1120", `${table.model.name} needs one primary key column besides the tenant key.`);
+  }
+  return column;
+}
+function readDepth(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    fail2("OKM1120", "depth must be an integer from 0 up.");
+  }
+  return value;
+}
+function readSelf(value) {
+  if (value === undefined)
+    return false;
+  if (typeof value !== "boolean")
+    fail2("OKM1120", "self must be true or false.");
+  return value;
+}
+function userId(column, id) {
+  if (id === undefined || id === null) {
+    fail2("OKM1121", `${column.field} needs a value.`);
+  }
+  return id;
+}
+
+export { build2, identityColumn2 };

package/dist/tooling/shared/w17sj05d.js

@@ -0,0 +1,7 @@
+import {
+  build3
+} from "./829fjxyw.js";
+import"./jr2nmr81.js";
+export {
+  build3 as build
+};

package/dist/tooling/shared/w5d89rb4.js

@@ -0,0 +1,131 @@
+import {
+  OkmError,
+  writeArray
+} from "./hfq3n3bd.js";
+
+// src/dialects/pg/operator-fit.ts
+var FAMILIES = {
+  startsWith: ["text"],
+  endsWith: ["text"],
+  like: ["text"],
+  ilike: ["text"],
+  contains: ["text", "array", "jsonb", "range"],
+  containedBy: ["array", "jsonb", "range"],
+  overlaps: ["array", "range"],
+  hasKey: ["jsonb"],
+  hasAnyKey: ["jsonb"],
+  path: ["json", "jsonb"],
+  matches: ["tsvector"],
+  relevance: ["tsvector"],
+  "json.set": ["json", "jsonb"],
+  "arr.append": ["array"],
+  "arr.remove": ["array"]
+};
+var ACCEPTED = {
+  text: [
+    "eq",
+    "not",
+    "lt",
+    "lte",
+    "gt",
+    "gte",
+    "between",
+    "startsWith",
+    "contains",
+    "endsWith",
+    "like",
+    "ilike",
+    "inList",
+    "notIn"
+  ],
+  array: [
+    "eq",
+    "not",
+    "contains",
+    "containedBy",
+    "overlaps",
+    "inList",
+    "notIn",
+    "arr.append",
+    "arr.remove"
+  ],
+  jsonb: ["eq", "not", "contains", "containedBy", "hasKey", "hasAnyKey", "path", "json.set"],
+  json: ["eq", "not", "path", "json.set"],
+  range: ["eq", "not", "lt", "lte", "gt", "gte", "contains", "containedBy", "overlaps"],
+  tsvector: ["eq", "not", "matches", "relevance"],
+  scalar: ["eq", "not", "lt", "lte", "gt", "gte", "between", "inList", "notIn", "inc"]
+};
+var SAFE_TYPE = /^[A-Za-z_][A-Za-z0-9_]*(\(\d+\))?(\[\])*$/;
+var REGCONFIG = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+function columnFamily(dataType) {
+  if (dataType.endsWith("[]"))
+    return "array";
+  if (dataType === "jsonb")
+    return "jsonb";
+  if (dataType === "json")
+    return "json";
+  if (dataType === "tsvector")
+    return "tsvector";
+  if (dataType.endsWith("range"))
+    return "range";
+  if (dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("char(") || dataType.startsWith("character")) {
+    return "text";
+  }
+  return "scalar";
+}
+function assertOperatorFits(column, name) {
+  const families = FAMILIES[name];
+  if (families === undefined)
+    return;
+  if (families.includes(columnFamily(column.dataType)))
+    return;
+  const accepted = ACCEPTED[columnFamily(column.dataType)];
+  const search = (name === "matches" || name === "relevance") && columnFamily(column.dataType) === "text" ? " Search needs a column built for search, not a plain text column." : "";
+  throw new OkmError("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${accepted.join(", ")}.${search}`, { fix: { summary: `Use one of: ${accepted.join(", ")}.` } });
+}
+function sqlType(dataType, column) {
+  if (SAFE_TYPE.test(dataType))
+    return dataType;
+  assertOperatorFits(column, "contains");
+  throw new OkmError("OKM1124", `Operator contains does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${ACCEPTED[columnFamily(column.dataType)].join(", ")}.`, { fix: { summary: "Use a column type this operator accepts." } });
+}
+function assertNoControl(value, role) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) {
+      throw new OkmError("OKM1122", `${role} contains a control character.`, {
+        fix: { summary: "Remove NUL and other control characters. The value is not sent." }
+      });
+    }
+  }
+}
+function assertBoundText(value, role) {
+  if (value.length === 0) {
+    throw new OkmError("OKM1122", `${role} is empty.`, {
+      fix: { summary: "Pass a non-empty key or path segment." }
+    });
+  }
+  assertNoControl(value, role);
+}
+function assertRegconfig(config) {
+  if (!REGCONFIG.test(config)) {
+    throw new OkmError("OKM1122", `Language ${config} is not a text search language. Pass a name such as english.`, { fix: { summary: "Pass a language name such as english." } });
+  }
+}
+function textArray(values, role) {
+  for (const value of values)
+    assertBoundText(value, role);
+  return writeArray(values, 1, (value) => String(value), false);
+}
+function arrayElementType(dataType, column) {
+  if (!dataType.endsWith("[]")) {
+    assertOperatorFits(column, "arr.append");
+  }
+  const element = dataType.slice(0, -2);
+  if (!SAFE_TYPE.test(element)) {
+    throw new OkmError("OKM1124", `Operator arr.append does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${ACCEPTED.array.join(", ")}.`, { fix: { summary: "Use arr.append on an array column." } });
+  }
+  return element;
+}
+
+export { assertOperatorFits, sqlType, assertNoControl, assertBoundText, assertRegconfig, textArray, arrayElementType };

package/dist/tooling/shared/wbwq1jsa.js

@@ -0,0 +1,157 @@
+import {
+  assertNoControl
+} from "./w5d89rb4.js";
+import {
+  throwNamed,
+  isOperator,
+  operatorName,
+  operatorValue,
+  tag,
+  refuseHidden,
+  indexes,
+  list,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/dialects/pg/ops/search-query.ts
+function searchValue(query, options) {
+  return {
+    query,
+    match: options?.match ?? "natural",
+    language: options?.language
+  };
+}
+
+// src/runtime/text-search.ts
+var MATCHES = ["natural", "all-words", "phrase", "advanced"];
+var SEARCH_KEYS = ["for", "in", "match", "language"];
+function applyTextSearch(schema, call) {
+  const table = indexes(schema).get(call.table);
+  if (table === undefined)
+    fail2("OKM1120", `Table ${call.table} is not in the schema.`);
+  const spec = parseSearch(table, call.search);
+  const options = { match: spec.match, language: spec.language };
+  const where = withMatch(call.where, spec.column.field, spec.text, options);
+  const orderBy = call.op === "find" && call.orderBy === undefined ? ranked(table, spec.column.field, spec.text, options) : call.orderBy;
+  const { search: dropped, ...rest } = call;
+  return {
+    ...rest,
+    where,
+    ...orderBy !== undefined ? { orderBy } : {}
+  };
+}
+function parseSearch(table, search) {
+  if (typeof search === "string") {
+    return { text: textOf(search), column: columnFor(table, undefined), ...natural() };
+  }
+  if (!isRecord(search)) {
+    fail2("OKM1120", "search needs the text to look for, or { for, in, match, language }.", "Pass a string, or search: { for, in }.");
+  }
+  for (const key of Object.keys(search)) {
+    if (SEARCH_KEYS.includes(key))
+      continue;
+    fail2("OKM1120", `search does not take ${key}. Accepted: for, in, match, language.`, "Pass for, in, match, and language.");
+  }
+  if (typeof search.for !== "string") {
+    fail2("OKM1120", "search.for needs text to look for.", "Set for to the text you want to find.");
+  }
+  const named = search.in;
+  if (named !== undefined && typeof named !== "string") {
+    fail2("OKM1120", "search.in names the column to search.", "Set in to a column name.");
+  }
+  return {
+    text: textOf(search.for),
+    column: columnFor(table, named),
+    match: matchOf(search.match),
+    language: languageOf(search.language)
+  };
+}
+function natural() {
+  return { match: "natural", language: undefined };
+}
+function textOf(text) {
+  if (text.length === 0) {
+    fail2("OKM1120", "search needs text to look for.", "Pass the words you want to find.");
+  }
+  assertNoControl(text, "search");
+  return text;
+}
+function matchOf(value) {
+  if (value === undefined)
+    return "natural";
+  if (typeof value === "string" && isMatch(value))
+    return value;
+  fail2("OKM1120", "search.match must be natural, all-words, phrase, or advanced.", "Use natural, all-words, phrase, or advanced.");
+}
+function isMatch(value) {
+  return MATCHES.includes(value);
+}
+function languageOf(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string") {
+    fail2("OKM1120", "search.language must be a text search language such as english.", "Pass a language name such as english, or leave it out.");
+  }
+  return value;
+}
+function columnFor(table, name) {
+  const columns = searchable(table);
+  const names = columns.map((column) => column.field);
+  if (name === undefined) {
+    const only = columns[0];
+    if (columns.length === 1 && only !== undefined)
+      return only;
+    if (columns.length === 0) {
+      fail2("OKM1120", `Table ${table.model.name} has no column you can search.`, "Add a column built for search.");
+    }
+    fail2("OKM1120", `Table ${table.model.name} has more than one column you can search. Name one with search: { for, in }. Columns: ${list(names)}.`, `Set in to one of: ${list(names)}.`);
+  }
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed("OKM1120", name, names, `Column ${name} is not on ${table.model.name}. Columns you can search: ${list(names)}.`);
+  }
+  if (column.dataType !== "tsvector") {
+    fail2("OKM1120", `Column ${name} cannot be searched. Columns you can search: ${list(names)}.`, names.length === 0 ? "This table has no column you can search." : `Search one of: ${list(names)}.`);
+  }
+  if (column.hidden === true)
+    refuseHidden(column);
+  return column;
+}
+function searchable(table) {
+  const found = [];
+  for (const column of table.model.columns) {
+    if (column.dataType === "tsvector" && column.hidden !== true)
+      found.push(column);
+  }
+  return found;
+}
+function withMatch(where, field, text, options) {
+  const filter = { [field]: tag("matches", searchValue(text, passed(options))) };
+  if (where === undefined)
+    return filter;
+  if (isOperator(where) && operatorName(where) === "and") {
+    const branches = operatorValue(where);
+    if (Array.isArray(branches))
+      return tag("and", [...branches, filter]);
+  }
+  return tag("and", [where, filter]);
+}
+function ranked(table, field, text, options) {
+  const order = {
+    [field]: tag("relevance", searchValue(text, passed(options)))
+  };
+  for (const key of table.model.primary) {
+    if (!Object.hasOwn(order, key))
+      order[key] = "asc";
+  }
+  return order;
+}
+function passed(options) {
+  if (options.language === undefined)
+    return { match: options.match };
+  return { match: options.match, language: options.language };
+}
+export {
+  applyTextSearch
+};

package/dist/tooling/shared/wezxf3h8.js

@@ -0,0 +1,17 @@
+import {
+  primaryUrl
+} from "./hfq3n3bd.js";
+
+// packages/harness/src/postgres.ts
+import postgres from "postgres";
+function openPostgres(url = primaryUrl()) {
+  return postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+}
+export {
+  openPostgres
+};

package/dist/tooling/shared/yb4kd19s.js

@@ -0,0 +1,12 @@
+import {
+  creationOrder2,
+  catalogHash2,
+  loadTrustedCatalog2,
+  catalogFileText2
+} from "./hfq3n3bd.js";
+export {
+  catalogFileText2 as catalogFileText,
+  catalogHash2 as catalogHash,
+  creationOrder2 as creationOrder,
+  loadTrustedCatalog2 as loadTrustedCatalog
+};