okmodel 0.5.1 → 0.7.0

package/dist/shared/gzaveazc.js

@@ -0,0 +1,285 @@
+import {
+  refusePrototypeKey
+} from "./q5c6ngn3.js";
+import {
+  isWindow
+} from "./9a4ae4p8.js";
+import {
+  emitWhere,
+  emitOrder,
+  refuseHidden,
+  emitLimit,
+  parseOrder,
+  projectExpr,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./67txcrcw.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 {
+        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;
+    }
+    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/{8rsy3hxz.js → h15jx9bc.js}

@@ -1,6 +1,6 @@
 import {
   validationGate
-} from "./9m80mkac.js";
+} from "./ze4hxsmy.js";
 import {
   isOperator
 } from "./cn0n68ft.js";

package/dist/shared/{dyj86cmj.js → hyh73qk6.js}

@@ -1,11 +1,11 @@
 import {
   encodeText,
   decodeText
-} from "./4m9fn52z.js";
+} from "./ed0b8k4s.js";
 import {
   required,
   openColumn
-} from "./c9z5g0fm.js";
+} from "./ywr8hmey.js";
 import {
   definition,
   rejected
@@ -35,7 +35,7 @@ function id2(options) {
     ...client !== undefined ? { clientDefault: client } : {},
     ...okid ? { collation: "C" } : {},
     idSource: chosen === undefined ? "implicit" : "column",
-    ...client === undefined && !supplied ? { defaultSql: chosen === "uuidv4" ? "gen_random_uuid()" : "uuidv7()" } : {},
+    ...client === undefined && !supplied ? { defaultSql: chosen === "uuidv7" ? "uuidv7()" : "gen_random_uuid()" } : {},
     primaryKey: true,
     encode: okid ? encodeText : encodeUuid,
     decode: okid ? decodeText : decodeUuid,

package/dist/shared/je4axnm8.js

@@ -0,0 +1,22 @@
+import {
+  checkout2,
+  describe2,
+  stream2,
+  runBatch2,
+  watchReserved2,
+  holdCheckout2,
+  holdListener2,
+  watchQuery2
+} from "./bz84tkzm.js";
+import"./14vx95q4.js";
+import"./cm3w0ywp.js";
+export {
+  checkout2 as checkout,
+  describe2 as describe,
+  holdCheckout2 as holdCheckout,
+  holdListener2 as holdListener,
+  runBatch2 as runBatch,
+  stream2 as stream,
+  watchQuery2 as watchQuery,
+  watchReserved2 as watchReserved
+};

package/dist/shared/{ycatkxmq.js → jgqj11w4.js}

@@ -1,6 +1,6 @@
 import {
   extensionObject
-} from "./8ktwd3rh.js";
+} from "./r3j8s5y0.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/{6qd27mx0.js → jvd0mqag.js}

@@ -2,11 +2,11 @@ import {
   assertAuthorDrift2,
   catalogQuery2,
   managedRoleOptions2
-} from "./sycnx8gt.js";
-import"./fancm5pt.js";
-import"./ga3sfy93.js";
-import"./8xsbagad.js";
-import"./8bwbwy8h.js";
+} from "./ax7qv55k.js";
+import"./b5pftnn2.js";
+import"./tsvww22q.js";
+import"./9s0ypp87.js";
+import"./qq3899ht.js";
 export {
   assertAuthorDrift2 as assertAuthorDrift,
   catalogQuery2 as catalogQuery,

package/dist/shared/jznfax0y.js

@@ -0,0 +1,155 @@
+import {
+  assertNoControl
+} from "./zchaghkf.js";
+import {
+  searchValue
+} from "./dzj09cye.js";
+import {
+  refuseHidden,
+  indexes,
+  list,
+  isRecord,
+  fail2
+} from "./67txcrcw.js";
+import {
+  isOperator,
+  operatorName,
+  operatorValue,
+  tag
+} from "./cn0n68ft.js";
+import {
+  throwNamed2
+} from "./52szzakm.js";
+
+// 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) {
+    throwNamed2("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/shared/{cgbamx3e.js → kb2sdhfb.js}

@@ -41,11 +41,14 @@ function hasCapability2(flags, name) {
 // src/adapters/failure.ts
 var loading;
 function driverErrors() {
-  loading ??= import("./x72jb7ad.js");
+  loading ??= import("./v8g1vgv8.js");
   return loading;
 }
-function rejectClosed(message = "The pool is closed.") {
-  return driverErrors().then((mod) => Promise.reject(new mod.DriverError(message)));
+function rejectClosed() {
+  return import("./2c13q96h.js").then((mod) => mod.closed());
+}
+function rejectUncancellable() {
+  return import("./2c13q96h.js").then((mod) => mod.refused());
 }
 function rejectCancelled() {
   return driverErrors().then((mod) => Promise.reject(mod.cancelled()));
@@ -163,4 +166,4 @@ function countFrom(value, rows) {
   return rows;
 }
 
-export { POSTGRESJS_CAPABILITIES, PGLITE_CAPABILITIES, NODE_POSTGRES_CAPABILITIES, BUNSQL_CAPABILITIES, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };
+export { POSTGRESJS_CAPABILITIES, PGLITE_CAPABILITIES, NODE_POSTGRES_CAPABILITIES, BUNSQL_CAPABILITIES, readCapability2, hasCapability2, driverErrors, rejectClosed, rejectUncancellable, rejectCancelled, rejectTimedOut, mapFailure, nextTransactionDepth, runCall, EMPTY_NOTICES, rowsFrom, resultFrom };

package/dist/shared/{ps7a6h14.js → kr0jzbw2.js}

@@ -1,22 +1,24 @@
 import {
   open2
-} from "./krxx77g0.js";
-import"./8bwbwy8h.js";
+} from "./14vx95q4.js";
+import"./qq3899ht.js";
 import"./n442h54c.js";
 import {
   assertRoleHealth
-} from "./szm0cksa.js";
-import"./fancm5pt.js";
+} from "./8skf0cam.js";
+import"./b5pftnn2.js";
 import {
   errorDoc,
   openProject
-} from "./qv2ydck9.js";
+} from "./gs74dbj5.js";
 import {
   omitManagedObjects,
+  sessionFailure,
+  finishQuiet,
   assertTargetPolicy,
   selectTarget
-} from "./ga3sfy93.js";
-import"./8xsbagad.js";
+} from "./tsvww22q.js";
+import"./9s0ypp87.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -43,8 +45,10 @@ ${doc.fix}
     const pool = open2({ url: target.url, max: 1 });
     try {
       await assertRoleHealth(pool, opened.config.roles, objects);
+    } catch (error) {
+      throw sessionFailure(error) ?? error;
     } finally {
-      await pool.close();
+      await finishQuiet(() => pool.close());
     }
   }
   return formatTriggers(objects);

package/dist/shared/{janx09m5.js → ktz42yez.js}

@@ -1,20 +1,22 @@
 import {
   open2
-} from "./krxx77g0.js";
-import"./8bwbwy8h.js";
+} from "./14vx95q4.js";
+import"./qq3899ht.js";
 import"./n442h54c.js";
 import {
   openProject
-} from "./qv2ydck9.js";
+} from "./gs74dbj5.js";
 import {
+  sessionFailure,
+  finishQuiet,
   assertTargetPolicy,
   selectTarget
-} from "./ga3sfy93.js";
-import"./8xsbagad.js";
+} from "./tsvww22q.js";
+import"./9s0ypp87.js";
 import {
   isExactVersion,
   compareExtensionVersions
-} from "./8ktwd3rh.js";
+} from "./r3j8s5y0.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -29,8 +31,10 @@ async function extProject(cwd, command, flags) {
     if (command === "list")
       return formatList(await readExtensions(pool));
     return formatCheck(opened.built.catalog.objects, await readExtensions(pool));
+  } catch (error) {
+    throw sessionFailure(error) ?? error;
   } finally {
-    await pool.close();
+    await finishQuiet(() => pool.close());
   }
 }
 var LIST_SQL = `
@@ -78,7 +82,9 @@ function formatCheck(objects, server) {
     }
     const want = object.definition.version;
     if (!versionAccepted(want, have)) {
-      throw new OkmError2("OKM1812", `Extension ${name} is ${have} on the server. The schema requires ${want ?? ""}.`, { fix: { summary: "Install a version the declaration accepts, or change the pin." } });
+      throw new OkmError2("OKM1812", extensionNeeds(name, want ?? "", have), {
+        fix: { summary: "Install a version the declaration accepts, or change the pin." }
+      });
     }
     lines.push([name, want ?? "-", have].join("\t"));
   }
@@ -86,6 +92,12 @@ function formatCheck(objects, server) {
 `)}
 `;
 }
+function extensionNeeds(name, want, have) {
+  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(want);
+  const need = floor?.[1] ?? want;
+  const higher = floor === null ? "" : " or higher";
+  return `Extension ${name} needs ${need}${higher}. The server has ${have}. Install a version the declaration accepts, or change the pin.`;
+}
 function versionAccepted(declared, installed) {
   if (declared === undefined)
     return true;