okmodel 0.5.1 → 0.6.0

package/dist/shared/{6qd27mx0.js → 1f0xa3cb.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 "./f0f1n281.js";
+import"./vjpnzwjz.js";
+import"./ttmg09vd.js";
+import"./9s0ypp87.js";
+import"./qq3899ht.js";
 export {
   assertAuthorDrift2 as assertAuthorDrift,
   catalogQuery2 as catalogQuery,

package/dist/shared/1nw1f3vs.js

@@ -0,0 +1,23 @@
+import {
+  ensureMigrationTables2,
+  applyTarget2,
+  applyProject2,
+  pushProject2,
+  backfillTiming2
+} from "./nx9hh281.js";
+import"./p248q79y.js";
+import"./knmes2kh.js";
+import"./vjpnzwjz.js";
+import"./t3g0k88x.js";
+import"./ttmg09vd.js";
+import"./n442h54c.js";
+import"./9s0ypp87.js";
+import"./qq3899ht.js";
+import"./wkme6tep.js";
+export {
+  applyProject2 as applyProject,
+  applyTarget2 as applyTarget,
+  backfillTiming2 as backfillTiming,
+  ensureMigrationTables2 as ensureMigrationTables,
+  pushProject2 as pushProject
+};

package/dist/shared/{96qcj21c.js → 1z04fa85.js}

@@ -17,6 +17,9 @@ import net from "node:net";
 import pg from "pg";
 var CANCEL_CODE = 80877102;
 var identity = (value) => value;
+function armDriverError(source, handle = () => {}) {
+  source.on("error", handle);
+}
 var WIRE = {
   getTypeParser() {
     return identity;
@@ -42,6 +45,7 @@ function open4(config) {
     ...config.ssl !== undefined ? { ssl: config.ssl } : {},
     ...config.searchPath !== undefined ? { options: `-c search_path=${config.searchPath}` } : {}
   });
+  armDriverError(pool);
   pool.on("connect", (client) => {
     client.on("notice", (notice) => {
       notices.push(notice);
@@ -53,7 +57,7 @@ function open4(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   }, inflight);
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./r8x5qhd7.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./zm0mafk4.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NODE_POSTGRES_CAPABILITIES,
     execute(text, params, options) {
@@ -121,24 +125,30 @@ function open4(config) {
         onNotify(message.payload ?? "");
     };
     client.on("notification", onNotification);
+    let released = false;
+    const release = (dead) => {
+      if (released)
+        return;
+      released = true;
+      client.removeListener("notification", onNotification);
+      client.removeListener("error", release);
+      counters.reserved = Math.max(0, counters.reserved - 1);
+      client.release(Boolean(dead));
+    };
+    armDriverError(client, release);
     try {
       await client.query(`LISTEN ${quoted}`);
     } catch (error) {
-      counters.reserved = Math.max(0, counters.reserved - 1);
-      client.release();
+      release(false);
       throw error;
     }
-    let stopped = false;
     return async () => {
-      if (stopped)
+      if (released)
         return;
-      stopped = true;
       try {
         await client.query(`UNLISTEN ${quoted}`);
       } finally {
-        client.removeListener("notification", onNotification);
-        counters.reserved = Math.max(0, counters.reserved - 1);
-        client.release();
+        release(false);
       }
     };
   }

package/dist/shared/{qm7cdtvr.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,
@@ -32,10 +35,9 @@ import {
   indexes,
   quote,
   isRecord,
-  effectivePredicate,
   registerFailFix,
   fail
-} from "./gbtcc2d7.js";
+} from "./2z7wv5tj.js";
 import {
   safetyInstalled,
   runSafety
@@ -118,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) {
@@ -151,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, () => {
@@ -166,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 {
@@ -183,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("./32zqc1dw.js");
-  const conflict = conflictMod?.readConflict(table, options.onConflict, allow, tenancy?.key);
+  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 = [];
@@ -192,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;
@@ -208,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);
@@ -221,8 +228,21 @@ function planUpdate(schema, table, input, options, mods) {
     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,
@@ -239,12 +259,25 @@ function planUpdate(schema, table, input, options, mods) {
   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()],
@@ -277,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)
@@ -291,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) {
@@ -362,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 ");
@@ -389,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)
@@ -400,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();
 }
@@ -609,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))
@@ -617,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.");

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