okmodel 0.5.0 → 0.6.0

package/dist/shared/{p7pfx624.js → 2cg3wnxc.js}

@@ -1,3 +1,6 @@
+import {
+  effectivePredicate
+} from "./b3awxn7h.js";
 import {
   assertOperatorFits,
   textArray,
@@ -16,10 +19,10 @@ import {
 } from "./n4jqhpqz.js";
 import {
   writeWouldValidate
-} from "./9m80mkac.js";
+} from "./ze4hxsmy.js";
 import {
   encodeJson
-} from "./gjthds9j.js";
+} from "./9628a9xt.js";
 import {
   withRowFilters,
   archiveRules,
@@ -34,7 +37,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./qgvt8nx1.js";
+} from "./2z7wv5tj.js";
 import {
   safetyInstalled,
   runSafety
@@ -45,7 +48,8 @@ import {
   operatorValue
 } from "./cn0n68ft.js";
 import {
-  OkmError2
+  OkmError2,
+  throwNamed2
 } from "./52szzakm.js";
 
 // src/runtime/write.ts
@@ -98,6 +102,8 @@ var INSERT_OPTIONS = [
   "validate"
 ];
 var FILTER_OPTIONS = ["allow", "expect", "returning", "signal", "timeout", "validate"];
+var UPDATE_KEYS = ["set", "where"];
+var UPDATE_ROW_KEYS = ["id", "set", "where"];
 var NO_ALLOW = new Set;
 async function executeWrite(host, op, table, input, options, mods, scope, plan) {
   const prepared = await prepareWrite(host, op, table, input, options, mods, scope);
@@ -114,7 +120,7 @@ async function prepareWrite(host, op, table, input, options, mods, scope) {
     return {
       statements: planned.statements,
       options: callOptions(options),
-      ...planned.expect !== undefined ? { checked: "expect" } : {},
+      ...planned.parentGuard === true ? { checked: "parent" } : planned.expect !== undefined ? { checked: "expect" } : {},
       finish: (results) => finish(results, planned, table)
     };
   } catch (error) {
@@ -147,7 +153,7 @@ async function planWrite(schema, generators, op, tableName, input, options, mods
   if (op === "update") {
     return withRowFilters(scope, mods.archive, () => {
       noteArchive(table, mods.archive);
-      return planUpdate(schema, table, input, record, mods);
+      return planUpdate(schema, table, input, record, mods, scope);
     });
   }
   return withRowFilters(scope, mods.archive, () => {
@@ -162,12 +168,16 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
   const rows = (many ? input : [input]).map((row) => insertRow(table, row, allow, tenancy));
   tenancy?.stamp(table.model.name, rows, scope);
   fillInsert(table, rows, generators);
-  const columns = writtenColumns(table, rows, allow, tenancy?.key);
+  const columns = writtenColumns(table, rows, allow, tenantKeyList(tenancy));
   const returning = selectedColumns(table, options.returning);
   const outputs = outputsOf(returning);
   const clause = returningClause(returning, undefined);
   const expect = expectOf(options, mods);
   const shape = many ? "rows" : "row";
+  const path = tenancy?.isPath?.(table.model.name) === true;
+  if (path && options.onConflict !== undefined && options.onConflict !== "error") {
+    fail("OKM1120", `onConflict on ${table.model.name} is not available. The insert checks the parent.`);
+  }
   if (columns.length === 0) {
     const text = `insert into ${quote(table.model.sql)} default values${clause}`;
     return {
@@ -179,8 +189,8 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
       keyFields: undefined
     };
   }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./9tgmr1gh.js");
-  const conflict = conflictMod?.readConflict(table, options.onConflict, allow);
+  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./vmfkhszw.js");
+  const conflict = conflictMod?.readConflict(table, options.onConflict, allow, tenantKeyList(tenancy));
   const chunks = chunkRows(rows.map((row) => cellsFor(columns, row)));
   const statements = [];
   const keys = [];
@@ -188,7 +198,7 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
   for (const chunk of chunks) {
     const slice = rows.slice(offset, offset + chunk.length);
     offset += chunk.length;
-    const built = insertHead(table, columns, chunk);
+    const built = path ? pathInsert(table, columns, chunk, scope, tenancy) : insertHead(table, columns, chunk);
     if (conflict === undefined || conflictMod === undefined) {
       statements.push(withParams(`${built.text}${clause}`, built.params));
       continue;
@@ -204,10 +214,11 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
     shape,
     expect,
     keys: conflict?.kind === "return" ? keys : undefined,
-    keyFields: conflict?.kind === "return" ? conflict.columns.map((column) => column.field) : undefined
+    keyFields: conflict?.kind === "return" ? conflict.columns.map((column) => column.field) : undefined,
+    ...path ? { parent: rows.length } : {}
   };
 }
-function planUpdate(schema, table, input, options, mods) {
+function planUpdate(schema, table, input, options, mods, scope) {
   const allow = allowSet(table, options.allow);
   noteGuarded(table, allow, "update");
   const returning = returningOption(table, options.returning);
@@ -216,8 +227,22 @@ function planUpdate(schema, table, input, options, mods) {
   if (Array.isArray(input)) {
     const rows = input.map((item) => {
       const row = updateItem(table, item, allow, schema.tenancy);
+      requireFilter(table, row.where, mods, "update");
+      pathAssignment(schema.tenancy, table.model.name, row.set, scope);
       return { ...row, where: stack(row.where, mods.presets) };
     });
+    const moves = rows.some((row) => pathField(schema.tenancy, table.model.name, row.set) !== undefined);
+    if (moves) {
+      return {
+        statements: [pathListUpdate(schema, table, rows, scope, returning)],
+        outputs: parentOutputs(returning),
+        shape: returning === undefined ? "count" : "rows",
+        expect,
+        keys: undefined,
+        keyFields: undefined,
+        parentGuard: true
+      };
+    }
     return {
       statements: updateList(schema, table, rows, returning),
       outputs,
@@ -229,16 +254,30 @@ function planUpdate(schema, table, input, options, mods) {
   }
   if (!isRecord(input))
     fail("OKM1121", "update expects { where, set } or a list of rows.");
+  rejectUpdateKeys(input, false);
   const set = writeSet(table, input.set, allow, schema.tenancy);
   requireFilter(table, input.where, mods, "update");
   if (Object.keys(set).length === 0)
     fail("OKM1120", "update set is empty.");
+  const where = stack(input.where, mods.presets);
+  if (pathAssignment(schema.tenancy, table.model.name, set, scope) !== undefined) {
+    return {
+      statements: [pathSetUpdate(schema, table, where, set, scope, returning)],
+      outputs: parentOutputs(returning),
+      shape: returning === undefined ? "count" : "rows",
+      expect,
+      keys: undefined,
+      keyFields: undefined,
+      parentGuard: true
+    };
+  }
   const sql = new Sql;
   sql.text("update ");
   sql.text(quote(table.model.sql));
   sql.text(" as t set ");
   emitSet(sql, table, set, "t");
-  emitFilter(schema, table, stack(input.where, mods.presets), sql, "t");
+  emitFilter(schema, table, where, sql, "t");
+  schema.tenancy?.noteParent?.(table.model.name, set, sql.sink(), scope, (field) => table.columns.get(field)?.sql);
   sql.text(returningClause(returning, "t"));
   return {
     statements: [sql.statement()],
@@ -271,6 +310,8 @@ function planDelete(schema, table, input, options, mods) {
   };
 }
 function finish(results, planned, table) {
+  if (planned.parentGuard === true)
+    return finishParent(results, planned, table);
   if (planned.shape === "count") {
     let count = 0;
     for (const result of results)
@@ -285,63 +326,164 @@ function finish(results, planned, table) {
   }
   const rows = planned.keys === undefined || planned.keyFields === undefined ? decoded : orderByKeys(decoded, planned.keyFields, planned.keys);
   checkExpect(rows.length, planned.expect, table, "insert");
+  if (planned.parent !== undefined && rows.length < planned.parent) {
+    throw new OkmError2("OKM1705", `Insert on ${table} did not find a parent in this tenant.`, {
+      fix: { summary: "Insert under a parent that belongs to this tenant." }
+    });
+  }
   if (planned.shape === "row")
     return rows[0] ?? null;
   return rows;
 }
-function orderByKeys(rows, fields, keys) {
-  const found = new Map;
-  for (const row of rows)
-    found.set(fields.map((field) => wireKey(row[field])).join("\x00"), row);
-  const ordered = [];
-  for (const key of keys) {
-    const row = found.get(key.map((value) => value ?? "").join("\x00"));
-    if (row !== undefined)
-      ordered.push(row);
+function finishParent(results, planned, table) {
+  const row = results[0]?.rows[0];
+  const matched = countCell(row?.[0]);
+  const updated = countCell(row?.[1]);
+  if (updated < matched) {
+    throw new OkmError2("OKM1705", `Update on ${table} did not find a parent in this tenant.`, {
+      fix: { summary: "Point the foreign key at a parent in this tenant." }
+    });
   }
-  return ordered;
+  if (planned.shape === "count") {
+    checkExpect(updated, planned.expect, table, "write");
+    return { count: updated };
+  }
+  const decoded = [];
+  if (updated > 0) {
+    for (const result of results) {
+      for (const item of result.rows)
+        decoded.push(decodeRow(planned.outputs, item));
+    }
+  }
+  checkExpect(decoded.length, planned.expect, table, "write");
+  if (planned.shape === "row")
+    return decoded[0] ?? null;
+  return decoded;
 }
-function wireKey(value) {
-  if (typeof value === "string")
+function countCell(value) {
+  if (typeof value === "number")
     return value;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  return "";
+  if (typeof value === "bigint")
+    return Number(value);
+  if (typeof value === "string" && value.length > 0)
+    return Number(value);
+  return 0;
 }
-function insertHead(table, columns, rows) {
-  const params = [];
-  const lists = [];
-  for (const row of rows) {
-    const slots = [];
-    for (const cell of row) {
-      if (cell.kind === "default") {
-        slots.push("default");
-        continue;
-      }
-      params.push(cell.kind === "null" ? null : cell.wire);
-      slots.push(`$${String(params.length)}::${cell.dataType}`);
-    }
-    lists.push(`(${slots.join(", ")})`);
+function pathField(tenancy, table, set) {
+  if (tenancy?.isPath?.(table) !== true)
+    return;
+  const field = tenancy.pathOf?.(table)?.[0]?.localField;
+  if (field === undefined || !Object.hasOwn(set, field))
+    return;
+  return field;
+}
+function pathAssignment(tenancy, table, set, scope) {
+  const field = pathField(tenancy, table, set);
+  if (field === undefined)
+    return;
+  const value = set[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new OkmError2("OKM1705", `Update on ${table} cannot verify ${field}. Pass the parent id as a string.`, { fix: { summary: "Pass the parent id as a string so the tenant can be checked." } });
   }
-  const names = columns.map((column) => quote(column.sql)).join(", ");
+  if (scope === undefined || "unscoped" in scope) {
+    throw new OkmError2("OKM1705", `Update on ${table} cannot verify ${field} without a tenant.`, {
+      fix: { summary: `Call for({ ... }) so ${field} can be checked.` }
+    });
+  }
+  return field;
+}
+function parentOutputs(returning) {
+  const outputs = outputsOf(returning);
+  if (returning === undefined)
+    return outputs;
   return {
-    text: `insert into ${quote(table.model.sql)} (${names}) values ${lists.join(", ")}`,
-    params
+    fields: outputs.fields.map((field) => ({ ...field, at: field.at + 2 })),
+    includes: outputs.includes
   };
 }
-function updateList(schema, table, rows, returning) {
-  if (rows.length === 0)
-    return [];
-  const width = Math.max(1, Object.keys(rows[0]?.set ?? {}).length + 2);
-  const size = Math.max(1, Math.floor(WRITE_PARAM_BUDGET / (width * 2)));
-  const statements = [];
-  for (let index = 0;index < rows.length; index += size) {
-    statements.push(updateSlice(schema, table, rows.slice(index, index + size), returning));
+function pathSetUpdate(schema, table, where, set, scope, returning) {
+  const sql = new Sql;
+  sql.text("with matched as (select t.ctid as tid from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t");
+  emitFilter(schema, table, where, sql, "t");
+  sql.text("), updated as (update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  emitSet(sql, table, set, "t");
+  sql.text(" where t.ctid in (select tid from matched)");
+  schema.tenancy?.noteParent?.(table.model.name, set, sql.sink(), scope, (field) => table.columns.get(field)?.sql);
+  endParent(sql, returning);
+  return sql.statement();
+}
+function pathListUpdate(schema, table, rows, scope, returning) {
+  const sql = new Sql;
+  sql.text("with matched as (");
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(" union all ");
+    sql.text("select t.ctid as tid, ");
+    sql.text(String(index));
+    sql.text(" as ord from ");
+    sql.text(quote(table.model.sql));
+    sql.text(" as t where ");
+    emitBare(schema, table, row.where, sql, "t");
   }
-  return statements;
+  sql.text("), rejected as (");
+  let rejected = false;
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (pathField(schema.tenancy, table.model.name, row.set) === undefined)
+      continue;
+    if (rejected)
+      sql.text(" union all ");
+    rejected = true;
+    sql.text("select ");
+    sql.text(String(index));
+    sql.text(" as ord where exists (select 1 from matched where ord = ");
+    sql.text(String(index));
+    sql.text(")");
+    noteParentNot(schema, table, row.set, scope, sql);
+  }
+  if (!rejected)
+    sql.text("select 0 as ord where false");
+  sql.text("), updated as (");
+  updateSliceBody(schema, table, rows, sql, true);
+  sql.text(" and not exists (select 1 from rejected)");
+  endParent(sql, returning);
+  return sql.statement();
 }
-function updateSlice(schema, table, rows, returning) {
+function noteParentNot(schema, table, set, scope, sql) {
+  let first = true;
+  schema.tenancy?.noteParent?.(table.model.name, set, {
+    text(value) {
+      if (first) {
+        first = false;
+        sql.text(" and not ");
+        return;
+      }
+      sql.text(value);
+    },
+    param(encoded) {
+      sql.param(encoded, "");
+    },
+    mark() {}
+  }, scope, (field) => table.columns.get(field)?.sql);
+}
+function endParent(sql, returning) {
+  if (returning === undefined || returning.length === 0) {
+    sql.text(" returning 1) select (select count(*)::int from matched), (select count(*)::int from updated)");
+    return;
+  }
+  sql.text(returningClause(returning, "t"));
+  sql.text(") select c.matched, c.updated, u.* from (select (select count(*)::int from matched) as matched, (select count(*)::int from updated) as updated) c left join updated u on true");
+}
+function updateSliceBody(schema, table, rows, sql, wrapWhere = false) {
   const fields = [];
   const seen = new Set;
   for (const row of rows) {
@@ -356,7 +498,6 @@ function updateSlice(schema, table, rows, returning) {
   }
   if (fields.length === 0)
     fail("OKM1120", "update set is empty.");
-  const sql = new Sql;
   sql.text("update ");
   sql.text(quote(table.model.sql));
   sql.text(" as t set ");
@@ -383,7 +524,7 @@ function updateSlice(schema, table, rows, returning) {
     sql.text(" end");
   }
   emitTouch(sql, table, fields.length > 0);
-  sql.text(" where ");
+  sql.text(wrapWhere ? " where (" : " where ");
   for (let index = 0;index < rows.length; index += 1) {
     const row = rows[index];
     if (row === undefined)
@@ -394,6 +535,64 @@ function updateSlice(schema, table, rows, returning) {
     emitBare(schema, table, row.where, sql, "t");
     sql.text(")");
   }
+  if (wrapWhere)
+    sql.text(")");
+}
+function orderByKeys(rows, fields, keys) {
+  const found = new Map;
+  for (const row of rows)
+    found.set(fields.map((field) => wireKey(row[field])).join("\x00"), row);
+  const ordered = [];
+  for (const key of keys) {
+    const row = found.get(key.map((value) => value ?? "").join("\x00"));
+    if (row !== undefined)
+      ordered.push(row);
+  }
+  return ordered;
+}
+function wireKey(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return "";
+}
+function insertHead(table, columns, rows) {
+  const params = [];
+  const lists = [];
+  for (const row of rows) {
+    const slots = [];
+    for (const cell of row) {
+      if (cell.kind === "default") {
+        slots.push("default");
+        continue;
+      }
+      params.push(cell.kind === "null" ? null : cell.wire);
+      slots.push(`$${String(params.length)}::${cell.dataType}`);
+    }
+    lists.push(`(${slots.join(", ")})`);
+  }
+  const names = columns.map((column) => quote(column.sql)).join(", ");
+  return {
+    text: `insert into ${quote(table.model.sql)} (${names}) values ${lists.join(", ")}`,
+    params
+  };
+}
+function updateList(schema, table, rows, returning) {
+  if (rows.length === 0)
+    return [];
+  const width = Math.max(1, Object.keys(rows[0]?.set ?? {}).length + 2);
+  const size = Math.max(1, Math.floor(WRITE_PARAM_BUDGET / (width * 2)));
+  const statements = [];
+  for (let index = 0;index < rows.length; index += size) {
+    statements.push(updateSlice(schema, table, rows.slice(index, index + size), returning));
+  }
+  return statements;
+}
+function updateSlice(schema, table, rows, returning) {
+  const sql = new Sql;
+  updateSliceBody(schema, table, rows, sql);
   sql.text(returningClause(returning, "t"));
   return sql.statement();
 }
@@ -603,7 +802,7 @@ function nextFill(fill, generators) {
     return generators.okid();
   return fill.call();
 }
-function writtenColumns(table, rows, allow, tenantKey) {
+function writtenColumns(table, rows, allow, tenantKeys) {
   const present = new Set;
   for (const row of rows) {
     for (const key of Object.keys(row))
@@ -611,12 +810,55 @@ function writtenColumns(table, rows, allow, tenantKey) {
   }
   const columns = [];
   for (const column of table.model.columns) {
-    if (present.has(column.field) && (writable(table, column, allow) || column.fill !== undefined || column.field === tenantKey)) {
+    if (present.has(column.field) && (writable(table, column, allow) || column.fill !== undefined || tenantKeys?.includes(column.field) === true)) {
       columns.push(column);
     }
   }
   return columns;
 }
+function tenantKeyList(tenancy) {
+  if (tenancy === undefined)
+    return;
+  if (tenancy.keys !== undefined && tenancy.keys.length > 0)
+    return tenancy.keys;
+  return [tenancy.key];
+}
+function pathInsert(table, columns, rows, scope, tenancy) {
+  const sql = new Sql;
+  const names = columns.map((column) => quote(column.sql)).join(", ");
+  const selected = columns.map((column) => `v.${quote(column.sql)}`).join(", ");
+  sql.text(`insert into ${quote(table.model.sql)} (${names}) select ${selected} from (values `);
+  for (let row = 0;row < rows.length; row += 1) {
+    const cells = rows[row];
+    if (cells === undefined)
+      continue;
+    if (row > 0)
+      sql.text(", ");
+    sql.text("(");
+    for (let index = 0;index < cells.length; index += 1) {
+      const cell = cells[index];
+      if (index > 0)
+        sql.text(", ");
+      if (cell === undefined || cell.kind === "default") {
+        sql.text("default");
+        continue;
+      }
+      sql.param(cell.kind === "null" ? null : cell.wire, cell.dataType);
+    }
+    sql.text(")");
+  }
+  sql.text(`) as v(${names})`);
+  tenancy?.lockPredicate?.({
+    table: table.model.name,
+    fieldSql: (field) => table.columns.get(field)?.sql,
+    encode: table.columns.get(tenancy.key)?.encode,
+    alias: "v",
+    appended: false,
+    scope,
+    sink: sql.sink()
+  });
+  return sql.statement();
+}
 function writeSet(table, value, allow, tenancy) {
   if (!isRecord(value))
     fail("OKM1121", "set must be an object of fields.");
@@ -637,6 +879,7 @@ function writeSet(table, value, allow, tenancy) {
 function updateItem(table, value, allow, tenancy) {
   if (!isRecord(value))
     fail("OKM1121", "update expects { where, set } or a list of rows.");
+  rejectUpdateKeys(value, true);
   const set = writeSet(table, value.set, allow, tenancy);
   if (value.where !== undefined)
     return { where: value.where, set };
@@ -644,6 +887,14 @@ function updateItem(table, value, allow, tenancy) {
     return { where: { id: value.id }, set };
   fail("OKM1102", `update on ${table.model.name} needs id or where for each row.`);
 }
+function rejectUpdateKeys(input, row) {
+  const accepted = row ? UPDATE_ROW_KEYS : UPDATE_KEYS;
+  for (const key of Object.keys(input)) {
+    if (accepted.includes(key))
+      continue;
+    throwNamed2("OKM1120", key, [...accepted, ...FILTER_OPTIONS], `Option ${key} is not accepted by update. Accepted options: ${accepted.join(", ")}. timeout and signal go in the second argument.`);
+  }
+}
 function requireFilter(table, where, mods, op) {
   if (mods.all !== undefined) {
     if (mods.all.trim().length === 0) {
@@ -651,11 +902,9 @@ function requireFilter(table, where, mods, op) {
     }
     return;
   }
-  if (isOperator(where))
-    return;
-  if (isRecord(where) && Object.keys(where).length > 0)
-    return;
-  fail("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
+  if (!effectivePredicate(where)) {
+    fail("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
+  }
 }
 function chunkRows(rows) {
   const chunks = [];

package/dist/shared/{dyj86cmj.js → 2jd1sn0e.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

package/dist/shared/{qgvt8nx1.js → 2z7wv5tj.js}

@@ -416,6 +416,7 @@ function emitPredicate(schema, table, key, value, sink, alias, depth) {
   if (column === undefined) {
     throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
   }
+  refuseHidden(column);
   sink.mark(`w:${key}`);
   emitOperand(schema, table, column, value, sink, alias, depth);
 }
@@ -533,7 +534,9 @@ function emitIn(column, ref, name, value, sink) {
   sink.text(")");
 }
 function emitOr(schema, table, value, sink, alias, depth) {
-  if (!Array.isArray(value) || value.length === 0) {
+  if (!Array.isArray(value))
+    orFail(false);
+  if (value.length === 0) {
     sink.text("false");
     sink.mark(":0");
     return;
@@ -559,7 +562,7 @@ function emitOr(schema, table, value, sink, alias, depth) {
       emitPredicate(schema, table, key, item, sink, alias, depth);
     }
     if (!wrote)
-      sink.text("true");
+      orFail(true);
     sink.text(")");
   }
   sink.text(")");
@@ -612,6 +615,7 @@ function emitOrder(table, orderBy, sink, alias) {
     if (column === undefined) {
       throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
     }
+    refuseHidden(column);
     const parsed = parseOrder(key, orderBy[key]);
     if (index > 0)
       sink.text(", ");
@@ -640,6 +644,11 @@ function emitPrimaryOrder(table, sink, alias) {
     sink.text(" asc");
   }
 }
+function refuseHidden(column) {
+  if (column.hidden !== true)
+    return;
+  fail("OKM1120", `Field ${column.field} is hidden.`, "Call hidden({ filterable: true }).");
+}
 function emitLimit(call, sink) {
   if (call.op === "one") {
     const ordered = call.orderBy !== undefined && isRecord(call.orderBy) && Object.keys(call.orderBy).length > 0;
@@ -844,6 +853,13 @@ function list(names) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !isOperator(value);
 }
+function orFail(empty) {
+  throw new OkmError2("OKM1121", empty ? "or() branch is empty." : "Pass an array: or([a, b]).", {
+    fix: {
+      summary: empty ? "Give every or() branch a predicate. An empty branch matches every row." : "Pass an array: or([a, b])."
+    }
+  });
+}
 var FAIL_FIX = {
   OKM1121: "Use eq for an object value, or has, none, or every for a relation.",
   OKM1101: "Pass limit, or call .all(reason)."
@@ -851,8 +867,8 @@ var FAIL_FIX = {
 function registerFailFix(code, summary) {
   FAIL_FIX[code] = summary;
 }
-function fail(code, message) {
-  const summary = FAIL_FIX[code];
+function fail(code, message, fix) {
+  const summary = fix ?? FAIL_FIX[code];
   throw new OkmError2(code, message, summary === undefined ? undefined : { fix: { summary } });
 }
 function plain(value) {
@@ -875,4 +891,4 @@ function hasMany(include) {
   return Object.keys(include).length > 0;
 }
 
-export { withRowFilters, installArchiveInspect, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, emitRelationFrom, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, registerFailFix, fail };
+export { withRowFilters, installArchiveInspect, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, emitRelationFrom, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, refuseHidden, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, orFail, registerFailFix, fail };

package/dist/shared/{kyxb62mc.js → 31vm914h.js}

@@ -75,7 +75,7 @@ function mapDriverError2(error, batchIndex) {
   if (error instanceof DriverError2) {
     return batchIndex === undefined ? error : error.at(batchIndex);
   }
-  const message = error instanceof Error ? error.message : "driver error";
+  const message = messageOf(error);
   return new DriverError2(message, driverFields({
     sqlstate: sqlstateOf(error),
     constraint: errorField2(error, "constraint_name") ?? errorField2(error, "constraint"),
@@ -86,6 +86,14 @@ function mapDriverError2(error, batchIndex) {
     batchIndex
   }));
 }
+function messageOf(error) {
+  if (!(error instanceof Error))
+    return "driver error";
+  if (error.message.length > 0)
+    return error.message;
+  const first = error.errors?.[0];
+  return first instanceof Error && first.message.length > 0 ? first.message : "driver error";
+}
 function driverFields(input) {
   const fields = {};
   if (input.sqlstate !== undefined)