okmodel 0.1.1 → 0.2.1

package/dist/shared/{x5x59srr.js → 4jzzghr6.js}

@@ -1,67 +1,168 @@
 import {
+  assertOperatorFits,
+  textArray,
+  arrayElementType
+} from "./zt8y0wzb.js";
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  stack
+} from "./672t5vym.js";
+import {
+  touchFields,
+  fieldSealed,
+  sealingTrait
+} from "./7m88x3e9.js";
+import {
+  writeWouldValidate
+} from "./3a5ne750.js";
+import {
+  encodeJson
+} from "./yw5c610b.js";
+import {
+  withRowFilters,
+  archiveRules,
   emitWhere,
   selectedColumns,
   rejectKeys,
+  takeObject,
   projectExpr,
   decodeRow,
   indexes,
   quote,
   isRecord,
+  registerFailFix,
   fail
-} from "./rgs0st28.js";
+} from "./xrfnq5k8.js";
+import {
+  safetyInstalled,
+  runSafety
+} from "./a5sxz52y.js";
 import {
   isOperator,
   operatorName,
   operatorValue
 } from "./cn0n68ft.js";
 import {
-  OkmError2,
-  throwNamed2
-} from "./ycwz42az.js";
-
-// src/runtime/tx.ts
-async function runWrite(pool, statements, options) {
-  if (statements.length === 0)
-    return [];
-  const first = statements[0];
-  if (statements.length === 1 && first !== undefined) {
-    return [await pool.execute(first.text, first.params, options)];
-  }
-  return pool.batch(statements, options);
-}
+  OkmError2
+} from "./52szzakm.js";
 
 // src/runtime/write.ts
+registerFailFix("OKM1102", "Pass where, or call .all(reason) to match every row.");
+registerFailFix("OKM1190", "Remove the guarded field. Input cannot set it.");
 var WRITE_PARAM_BUDGET = 2048;
-var INSERT_OPTIONS = ["expect", "onConflict", "returning", "signal", "timeout"];
-var FILTER_OPTIONS = ["expect", "returning", "signal", "timeout"];
-async function executeWrite(host, op, table, input, options, mods) {
-  const planned = await planWrite(host.schema, op, table, input, options, mods);
-  if (planned.statements.length === 0)
-    return finish([], planned, table);
-  const results = await runWrite(host.pool, planned.statements, callOptions(options));
-  return finish(results, planned, table);
-}
-async function explainWrite(schema, op, table, input, options, mods) {
-  const planned = await planWrite(schema, op, table, input, options, mods);
-  return { statements: planned.statements };
-}
-async function planWrite(schema, op, tableName, input, options, mods) {
+var REDACTED = "[redacted]";
+function encodeColumn(column, value) {
+  if (!column.hidden && !column.sensitive)
+    return column.encode(value);
+  try {
+    return column.encode(value);
+  } catch (error) {
+    if (error instanceof OkmError2) {
+      throw new OkmError2(error.code, `Field ${column.field} was rejected.`, {
+        kind: error.kind,
+        fix: error.fix
+      });
+    }
+    throw error;
+  }
+}
+async function requireValidationImport(schema, op, tableName, options) {
+  if (op === "delete" || validationRegistered(schema))
+    return;
+  const stored = schema;
+  const source = stored.tables?.find((item) => item.name === tableName);
+  if (source === undefined || !writeWouldValidate(stored.validation, source, options))
+    return;
+  const { refuseMissingValidation } = await import("./83eaefwr.js");
+  refuseMissingValidation();
+}
+function validationRegistered(schema) {
+  const hooks = schema.hooks;
+  if (hooks === undefined)
+    return false;
+  for (const hook of hooks) {
+    if (hook["~v"] === 1)
+      return true;
+  }
+  return false;
+}
+var INSERT_OPTIONS = [
+  "allow",
+  "expect",
+  "onConflict",
+  "returning",
+  "signal",
+  "timeout",
+  "validate"
+];
+var FILTER_OPTIONS = ["allow", "expect", "returning", "signal", "timeout", "validate"];
+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);
+  if (plan !== undefined)
+    return prepared;
+  if (prepared.statements.length === 0)
+    return prepared.finish([]);
+  const results = await runWrite(host, prepared.statements, prepared.options);
+  return prepared.finish(results);
+}
+async function prepareWrite(host, op, table, input, options, mods, scope) {
+  try {
+    const planned = await planWrite(host.schema, host.generators, op, table, input, options, mods, scope);
+    return {
+      statements: planned.statements,
+      options: callOptions(options),
+      ...planned.expect !== undefined ? { checked: "expect" } : {},
+      finish: (results) => finish(results, planned, table)
+    };
+  } catch (error) {
+    throw scrubWrite(host.schema, table, input, error);
+  }
+}
+async function explainWrite(schema, op, table, input, options, mods, generators, scope) {
+  try {
+    const planned = await planWrite(schema, generators, op, table, input, options, mods, scope);
+    return { statements: planned.statements };
+  } catch (error) {
+    throw scrubWrite(schema, table, input, error);
+  }
+}
+async function planWrite(schema, generators, op, tableName, input, options, mods, scope) {
+  await requireValidationImport(schema, op, tableName, options);
   const table = indexes(schema).get(tableName);
   if (table === undefined) {
     fail("OKM1120", `Table ${tableName} is not in the schema.`);
   }
+  if (mods.uses !== undefined && op !== "insert") {
+    const { resolve } = await import("./r6nwkxnt.js");
+    mods = { ...mods, presets: resolve(schema, tableName, mods.uses).wheres };
+  }
   const record = isRecord(options) ? options : {};
   rejectKeys(record, op === "insert" ? INSERT_OPTIONS : FILTER_OPTIONS, op);
-  if (op === "insert")
-    return planInsert(table, input, record, mods);
-  if (op === "update")
-    return planUpdate(schema, table, input, record, mods);
-  return planDelete(schema, table, input, record, mods);
+  if (op === "insert") {
+    return planInsert(table, input, record, mods, generators, scope, schema.tenancy);
+  }
+  if (op === "update") {
+    return withRowFilters(scope, mods.archive, () => {
+      noteArchive(table, mods.archive);
+      return planUpdate(schema, table, input, record, mods);
+    });
+  }
+  return withRowFilters(scope, mods.archive, () => {
+    noteArchive(table, mods.archive);
+    return planDelete(schema, table, input, record, mods);
+  });
 }
-async function planInsert(table, input, options, mods) {
+async function planInsert(table, input, options, mods, generators, scope, tenancy) {
+  const allow = allowSet(table, options.allow);
+  noteGuarded(table, allow, "insert");
   const many = Array.isArray(input);
-  const rows = (many ? input : [input]).map((row) => insertRow(table, row));
-  const columns = writtenColumns(table, rows);
+  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 returning = selectedColumns(table, options.returning);
   const outputs = outputsOf(returning);
   const clause = returningClause(returning, undefined);
@@ -78,9 +179,9 @@ async function planInsert(table, input, options, mods) {
       keyFields: undefined
     };
   }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./yd1kzwn2.js");
-  const conflict = conflictMod?.readConflict(table, options.onConflict);
-  const chunks = chunkRows(rows.map((row) => cellsFor(table, columns, row)));
+  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./jns2wx4t.js");
+  const conflict = conflictMod?.readConflict(table, options.onConflict, allow);
+  const chunks = chunkRows(rows.map((row) => cellsFor(columns, row)));
   const statements = [];
   const keys = [];
   let offset = 0;
@@ -107,11 +208,16 @@ async function planInsert(table, input, options, mods) {
   };
 }
 function planUpdate(schema, table, input, options, mods) {
+  const allow = allowSet(table, options.allow);
+  noteGuarded(table, allow, "update");
   const returning = returningOption(table, options.returning);
   const outputs = outputsOf(returning);
   const expect = expectOf(options, mods);
   if (Array.isArray(input)) {
-    const rows = input.map((item) => updateItem(table, item));
+    const rows = input.map((item) => {
+      const row = updateItem(table, item, allow, schema.tenancy);
+      return { ...row, where: stack(row.where, mods.presets) };
+    });
     return {
       statements: updateList(schema, table, rows, returning),
       outputs,
@@ -123,7 +229,7 @@ function planUpdate(schema, table, input, options, mods) {
   }
   if (!isRecord(input))
     fail("OKM1121", "update expects { where, set } or a list of rows.");
-  const set = writeSet(table, input.set);
+  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.");
@@ -132,7 +238,7 @@ function planUpdate(schema, table, input, options, mods) {
   sql.text(quote(table.model.sql));
   sql.text(" as t set ");
   emitSet(sql, table, set, "t");
-  emitFilter(schema, table, input.where, sql, "t");
+  emitFilter(schema, table, stack(input.where, mods.presets), sql, "t");
   sql.text(returningClause(returning, "t"));
   return {
     statements: [sql.statement()],
@@ -153,7 +259,7 @@ function planDelete(schema, table, input, options, mods) {
   sql.text("delete from ");
   sql.text(quote(table.model.sql));
   sql.text(" as t");
-  emitFilter(schema, table, input.where, sql, "t");
+  emitFilter(schema, table, stack(input.where, mods.presets), sql, "t");
   sql.text(returningClause(returning, "t"));
   return {
     statements: [sql.statement()],
@@ -276,6 +382,7 @@ function updateSlice(schema, table, rows, returning) {
     sql.text(quote(column.sql));
     sql.text(" end");
   }
+  emitTouch(sql, table, fields.length > 0);
   sql.text(" where ");
   for (let index = 0;index < rows.length; index += 1) {
     const row = rows[index];
@@ -292,41 +399,102 @@ function updateSlice(schema, table, rows, returning) {
 }
 function emitSet(sql, table, set, alias) {
   const keys = Object.keys(set);
-  for (let index = 0;index < keys.length; index += 1) {
-    const key = keys[index];
-    if (key === undefined)
-      continue;
+  let wrote = false;
+  for (const key of keys) {
     const column = table.columns.get(key);
     if (column === undefined)
       continue;
-    if (index > 0)
+    if (wrote)
       sql.text(", ");
+    wrote = true;
     sql.text(quote(column.sql));
     sql.text(" = ");
     emitValue(sql, column, set[key], alias);
   }
+  wrote = emitTouch(sql, table, wrote);
+}
+function emitTouch(sql, table, wrote) {
+  const touch = touchFields(table.model);
+  if (touch === undefined)
+    return wrote;
+  for (const field of touch) {
+    const column = table.columns.get(field);
+    if (column === undefined)
+      continue;
+    if (wrote)
+      sql.text(", ");
+    wrote = true;
+    sql.text(quote(column.sql));
+    sql.text(" = now()");
+  }
+  return wrote;
 }
 function emitValue(sql, column, value, alias) {
   if (isOperator(value)) {
-    if (operatorName(value) !== "inc") {
-      fail("OKM1121", `Field ${column.field} received an operator. set accepts a value or inc.`);
+    const name = operatorName(value);
+    if (name === "inc") {
+      const amount = operatorValue(value);
+      if (typeof amount === "object" && amount !== null) {
+        fail("OKM1121", `inc on ${column.field} needs a value.`);
+      }
+      sql.text(`${alias}.${quote(column.sql)} + `);
+      sql.param(encodeColumn(column, amount), column.dataType);
+      return;
     }
-    const amount = operatorValue(value);
-    if (typeof amount === "object" && amount !== null) {
-      fail("OKM1121", `inc on ${column.field} needs a value.`);
+    if (name === "json.set") {
+      emitJsonSet(sql, column, value, alias);
+      return;
     }
-    sql.text(`${alias}.${quote(column.sql)} + `);
-    sql.param(column.encode(amount), column.dataType);
-    return;
+    if (name === "arr.append" || name === "arr.remove") {
+      emitArrayWrite(sql, column, name, value, alias);
+      return;
+    }
+    fail("OKM1121", `Field ${column.field} received an operator. set accepts a value, inc, set, or arr.`);
   }
   if (value === null) {
     sql.text(`null::${column.dataType}`);
     return;
   }
-  if (typeof value === "object") {
-    fail("OKM1121", `Field ${column.field} received an object. Pass a value or inc.`);
+  if (typeof value === "object")
+    takeObject(column, value);
+  sql.param(encodeColumn(column, value), column.dataType);
+}
+function emitJsonSet(sql, column, value, alias) {
+  assertOperatorFits(column, "json.set");
+  if (!isOperator(value))
+    fail("OKM1121", `json.set on ${column.field} needs a path and a value.`);
+  const stored = operatorValue(value);
+  if (!isRecord(stored) || !Array.isArray(stored.path)) {
+    fail("OKM1121", `json.set on ${column.field} needs a path and a value.`);
+  }
+  const path = stored.path;
+  if (path.length === 0 || path.some((item) => typeof item !== "string")) {
+    fail("OKM1121", `json.set on ${column.field} needs a list of segments.`);
   }
-  sql.param(column.encode(value), column.dataType);
+  const encoded = encodeJson(stored.value);
+  const ref = `${alias}.${quote(column.sql)}`;
+  const target = column.dataType === "json" ? `${ref}::jsonb` : ref;
+  sql.text(`jsonb_set(${target}, `);
+  sql.param(textArray(path, `path on ${column.field}`), "text[]");
+  sql.text(", ");
+  sql.param(encoded, "jsonb");
+  sql.text(")");
+  if (column.dataType === "json")
+    sql.text("::json");
+}
+function emitArrayWrite(sql, column, name, value, alias) {
+  assertOperatorFits(column, name);
+  const encode = column.elementEncode;
+  if (encode === undefined) {
+    fail("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: eq, not, lt, lte, gt, gte, between, inList, notIn, inc.`);
+  }
+  if (!isOperator(value)) {
+    fail("OKM1121", `${name} on ${column.field} needs an element.`);
+  }
+  const fn = name === "arr.append" ? "array_append" : "array_remove";
+  sql.text(`${fn}(${alias}.${quote(column.sql)}, `);
+  sql.param(encode(operatorValue(value)), arrayElementType(column.dataType, column));
+  sql.text(")");
 }
 function emitFilter(schema, table, where, sql, alias) {
   emitWhere(schema, table, where, sql.sink(), alias, 0);
@@ -379,7 +547,7 @@ class Sql {
     return this.params.length === 0 ? { text: this.parts.join("") } : { text: this.parts.join(""), params: this.params };
   }
 }
-function insertRow(table, value) {
+function insertRow(table, value, allow, tenancy) {
   if (!isRecord(value))
     fail("OKM1121", "insert expects an object or a list of objects.");
   const row = {};
@@ -387,27 +555,55 @@ function insertRow(table, value) {
     const column = table.columns.get(key);
     if (column === undefined)
       continue;
-    if (!column.writable)
-      refuse(table.model.name, column);
+    tenancy?.guard(table.model.name, key, "insert");
+    if (!writable(table, column, allow))
+      refuse(table, column);
     if (value[key] !== undefined)
       row[key] = value[key];
   }
   return row;
 }
-function cellsFor(table, columns, row) {
+function cellsFor(columns, row) {
   return columns.map((column) => {
     if (!Object.hasOwn(row, column.field))
       return { kind: "default" };
     const value = row[column.field];
     if (value === null)
       return { kind: "null", dataType: column.dataType };
-    if (typeof value === "object") {
-      fail("OKM1121", `Field ${table.model.name}.${column.field} received an object.`);
-    }
-    return { kind: "value", wire: column.encode(value), dataType: column.dataType };
+    if (typeof value === "object")
+      takeObject(column, value);
+    return { kind: "value", wire: encodeColumn(column, value), dataType: column.dataType };
   });
 }
-function writtenColumns(table, rows) {
+function fillInsert(table, rows, generators) {
+  const fills = [];
+  for (const column of table.model.columns) {
+    if (column.fill !== undefined)
+      fills.push(column);
+  }
+  if (fills.length === 0)
+    return;
+  for (const row of rows) {
+    for (const column of fills) {
+      if (Object.hasOwn(row, column.field))
+        continue;
+      const fill = column.fill;
+      if (fill === undefined)
+        continue;
+      row[column.field] = nextFill(fill, generators);
+    }
+  }
+}
+function nextFill(fill, generators) {
+  if (fill.name === "uuidv4" && generators?.uuidv4 !== undefined)
+    return generators.uuidv4();
+  if (fill.name === "uuidv7" && generators?.uuidv7 !== undefined)
+    return generators.uuidv7();
+  if (fill.name === "okid" && generators?.okid !== undefined)
+    return generators.okid();
+  return fill.call();
+}
+function writtenColumns(table, rows, allow, tenantKey) {
   const present = new Set;
   for (const row of rows) {
     for (const key of Object.keys(row))
@@ -415,12 +611,13 @@ function writtenColumns(table, rows) {
   }
   const columns = [];
   for (const column of table.model.columns) {
-    if (column.writable && present.has(column.field))
+    if (present.has(column.field) && (writable(table, column, allow) || column.fill !== undefined || column.field === tenantKey)) {
       columns.push(column);
+    }
   }
   return columns;
 }
-function writeSet(table, value) {
+function writeSet(table, value, allow, tenancy) {
   if (!isRecord(value))
     fail("OKM1121", "set must be an object of fields.");
   const set = {};
@@ -428,19 +625,19 @@ function writeSet(table, value) {
     if (value[key] === undefined)
       continue;
     const column = table.columns.get(key);
-    if (column === undefined) {
-      throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${table.names.join(", ")}.`);
-    }
-    if (!column.writable)
-      refuse(table.model.name, column);
+    if (column === undefined)
+      continue;
+    tenancy?.guard(table.model.name, key, "update");
+    if (column.guardUpdate || !writable(table, column, allow))
+      refuse(table, column);
     set[key] = value[key];
   }
   return set;
 }
-function updateItem(table, value) {
+function updateItem(table, value, allow, tenancy) {
   if (!isRecord(value))
     fail("OKM1121", "update expects { where, set } or a list of rows.");
-  const set = writeSet(table, value.set);
+  const set = writeSet(table, value.set, allow, tenancy);
   if (value.where !== undefined)
     return { where: value.where, set };
   if (value.id !== undefined)
@@ -491,9 +688,7 @@ function keyWire(columns, row) {
     const value = row[column.field];
     if (value === undefined || value === null)
       return null;
-    if (typeof value === "object")
-      return null;
-    return column.encode(value);
+    return encodeColumn(column, value);
   });
 }
 function returningOption(table, value) {
@@ -554,10 +749,148 @@ function callOptions(options) {
   };
 }
 function refuse(table, column) {
+  if (fieldSealed(table.model, column.field)) {
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
+  }
+  if (column.guardUpdate) {
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
+  }
   if (column.guarded) {
-    fail("OKM1190", `Field ${table}.${column.field} is guarded. Input cannot set it.`);
+    fail("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
+  }
+  fail("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
+}
+function writable(table, column, allow) {
+  if (fieldSealed(table.model, column.field))
+    return false;
+  if (column.writable)
+    return true;
+  return column.guarded && allow.has(column.field);
+}
+function allowSet(table, value) {
+  if (value === undefined)
+    return NO_ALLOW;
+  if (!Array.isArray(value))
+    fail("OKM1120", "allow must be a list of field names.");
+  const set = new Set;
+  for (const name of value) {
+    if (typeof name !== "string" || !table.columns.has(name)) {
+      fail("OKM1120", "allow must name fields on the table.");
+    }
+    set.add(name);
+  }
+  return set;
+}
+function noteArchive(table, view) {
+  if (!safetyInstalled())
+    return;
+  const rules = archiveRules(table.model, view);
+  if (rules === undefined)
+    return;
+  runSafety(rules, undefined);
+}
+function noteGuarded(table, allow, op) {
+  if (!safetyInstalled())
+    return;
+  const contributions = [];
+  const hatches = [];
+  const touch = touchFields(table.model);
+  const source = table.model.source;
+  for (const column of table.model.columns) {
+    const traitName = sealingTrait(table.model, column.field);
+    if (traitName !== undefined) {
+      const sets = op === "insert" || touch?.includes(column.field) === true;
+      contributions.push({
+        rule: traitName,
+        contribution: sets ? `${traitName} ${table.model.name}.${column.field} set by ${traitName}` : `${traitName} ${table.model.name}.${column.field} kept`,
+        provenance: "planner",
+        ...source !== undefined ? { source } : {}
+      });
+      continue;
+    }
+    if (!column.guarded)
+      continue;
+    const name = `${table.model.name}.${column.field}`;
+    if (allow.has(column.field)) {
+      contributions.push({
+        rule: "guarded",
+        contribution: `guarded ${name} allowed`,
+        provenance: "allow"
+      });
+      hatches.push({ name: "allow", reason: name });
+    } else {
+      contributions.push({
+        rule: "guarded",
+        contribution: `guarded ${name} absent`,
+        provenance: "planner"
+      });
+    }
+  }
+  if (contributions.length === 0)
+    return;
+  runSafety(contributions, hatches.length === 0 ? undefined : hatches);
+}
+function scrubWrite(schema, tableName, input, error) {
+  if (!(error instanceof OkmError2))
+    return error;
+  const table = indexes(schema).get(tableName);
+  if (table === undefined || table.model.conceal !== true)
+    return error;
+  const secrets = [];
+  const names = new Set;
+  for (const column of table.model.columns) {
+    if (column.hidden || column.sensitive)
+      names.add(column.field);
+  }
+  collectSecrets(input, names, secrets);
+  if (secrets.length === 0)
+    return error;
+  let message = error.message;
+  for (const secret of secrets) {
+    if (secret.length < 4 || !message.includes(secret))
+      continue;
+    message = message.replaceAll(secret, REDACTED);
   }
-  fail("OKM1120", `Field ${table}.${column.field} cannot be written.`);
+  const issues = error.issues === undefined ? undefined : redactIssues(error.issues, secrets);
+  if (message === error.message && issues === undefined)
+    return error;
+  return new OkmError2(error.code, message, {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    ...error.issues !== undefined ? { issues: issues ?? error.issues } : {},
+    fix: error.fix
+  });
+}
+function redactIssues(issues, secrets) {
+  let changed = false;
+  const next = issues.map((issue) => {
+    let message = issue.message;
+    for (const secret of secrets) {
+      if (secret.length < 4 || !message.includes(secret))
+        continue;
+      message = message.replaceAll(secret, REDACTED);
+      changed = true;
+    }
+    return message === issue.message ? issue : { path: issue.path, message };
+  });
+  return changed ? next : undefined;
+}
+function collectSecrets(value, names, found, key) {
+  if (typeof value === "string") {
+    if (key !== undefined && names.has(key))
+      found.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      collectSecrets(item, names, found);
+    return;
+  }
+  if (!isRecord(value))
+    return;
+  for (const child of Object.keys(value))
+    collectSecrets(value[child], names, found, child);
 }
 export {
   WRITE_PARAM_BUDGET,