okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/f77nnfqy.js

@@ -0,0 +1,231 @@
+import {
+  touchFields,
+  fieldSealed
+} from "./ezqn88nj.js";
+import {
+  throwNamed,
+  projectExpr,
+  quote,
+  list,
+  isRecord,
+  registerFailFix,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/conflict.ts
+registerFailFix("OKM1104", "Set on to the columns of a unique constraint or the primary key.");
+registerFailFix("OKM1190", "Remove the guarded field. Input cannot set it.");
+var NO_ALLOW = new Set;
+function readConflict(table, value, allow = NO_ALLOW, tenantKey) {
+  if (value === undefined || value === "error")
+    return;
+  if (value === "ignore")
+    return { kind: "ignore", columns: [], update: [] };
+  if (!isRecord(value)) {
+    fail2("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
+  }
+  const keys = Object.keys(value);
+  const update = value.update;
+  const ret = value.return;
+  if (update !== undefined && ret !== undefined) {
+    fail2("OKM1120", "onConflict takes update or return, not both.");
+  }
+  if (ret === true) {
+    rejectConflictKeys(keys, ["on", "return"]);
+    return { kind: "return", columns: uniqueColumns(table, value.on, tenantKey), update: [] };
+  }
+  if (update !== undefined) {
+    rejectConflictKeys(keys, ["on", "update"]);
+    return {
+      kind: "update",
+      columns: uniqueColumns(table, value.on, tenantKey),
+      update: updateColumns(table, update, allow)
+    };
+  }
+  fail2("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
+}
+function finishInsert(head, returning, params, plan, table) {
+  if (plan.kind === "ignore") {
+    return { text: `${head} on conflict do nothing${returning}`, params: [...params] };
+  }
+  const target = plan.columns.map((column) => quote(column.sql)).join(", ");
+  if (plan.kind === "update") {
+    const assignments = plan.update.map((column) => `${quote(column.sql)} = excluded.${quote(column.sql)}`);
+    const touch = touchFields(table.model);
+    if (touch !== undefined) {
+      for (const field of touch) {
+        const column = table.columns.get(field);
+        if (column !== undefined)
+          assignments.push(`${quote(column.sql)} = now()`);
+      }
+    }
+    return {
+      text: `${head} on conflict (${target})${conflictWhere(table, plan.columns)} do update set ${assignments.join(", ")}${returning}`,
+      params: [...params]
+    };
+  }
+  return {
+    text: `${head} on conflict (${target})${conflictWhere(table, plan.columns)} do nothing${returning}`,
+    params: [...params]
+  };
+}
+function lookupExisting(table, keys, returningColumns, keyRows) {
+  const params = [];
+  const tuples = [];
+  for (const row of keyRows) {
+    const slots = [];
+    for (let index = 0;index < keys.length; index += 1) {
+      const column = keys[index];
+      if (column === undefined)
+        continue;
+      params.push(row[index] ?? null);
+      slots.push(`$${String(params.length)}::${column.dataType}`);
+    }
+    tuples.push(keys.length === 1 ? slots[0] ?? "null" : `(${slots.join(", ")})`);
+  }
+  const left = keys.length === 1 ? `t.${quote(keys[0]?.sql ?? "")}` : `(${keys.map((column) => `t.${quote(column.sql)}`).join(", ")})`;
+  const projected = returningColumns.map((column) => projectExpr(`t.${quote(column.sql)}`, column.dataType)).join(", ");
+  const text = `select ${projected} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")})${activeAnd(table, keys)}`;
+  return { text, params };
+}
+function activeAnd(table, columns) {
+  const clause = conflictWhere(table, columns);
+  if (clause === "")
+    return "";
+  return ` and t.${clause.replace(/^ where /, "")}`;
+}
+function conflictWhere(table, columns) {
+  const archive = table.model.archive;
+  if (archive === undefined || samePrimary(table, columns))
+    return "";
+  return ` where ${quote(archive.at)} is null`;
+}
+function samePrimary(table, columns) {
+  const primary = table.model.primary;
+  if (columns.length !== primary.length)
+    return false;
+  for (const field of primary) {
+    let found = false;
+    for (const column of columns)
+      if (column.field === field)
+        found = true;
+    if (!found)
+      return false;
+  }
+  return true;
+}
+function uniqueColumns(table, on, tenantKey) {
+  const names = conflictNames(on);
+  const keys = keyList(tenantKey);
+  for (const unique of table.model.uniques) {
+    const fields = fieldsOf(unique, names, keys);
+    if (fields === undefined)
+      continue;
+    const columns = [];
+    for (const name of fields) {
+      const column = table.columns.get(name);
+      if (column === undefined) {
+        fail2("OKM1104", `onConflict column ${name} is not on ${table.model.name}.`);
+      }
+      columns.push(column);
+    }
+    return columns;
+  }
+  const accepted = acceptedConstraints(table.model, keys);
+  const implicit = keys.length === 0 ? "" : ` The tenant key ${keys.join(", ")} is part of each one and is not named here.`;
+  throwNamed("OKM1104", names.join(", "), accepted, `onConflict on ${table.model.name} names ${names.join(", ")}, which is not a unique constraint. Accepted: ${list(accepted)}.${implicit}`);
+}
+function acceptedConstraints(model, keys) {
+  const shown = new Set;
+  for (const fields of model.uniques) {
+    const named = keys.length === 0 ? fields : fields.filter((field) => !keys.includes(field));
+    if (named.length === 0)
+      continue;
+    shown.add(named.length > 1 ? `(${named.join(", ")})` : named.join(""));
+  }
+  return [...shown];
+}
+function updateColumns(table, value, allow) {
+  if (!Array.isArray(value) || value.length === 0) {
+    fail2("OKM1120", "onConflict update must name at least one column.");
+  }
+  const columns = [];
+  for (const name of value) {
+    if (typeof name !== "string")
+      fail2("OKM1120", "onConflict update must name columns.");
+    const column = table.columns.get(name);
+    if (column === undefined) {
+      throwNamed("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    if (fieldSealed(table.model, name) || column.guardUpdate || !column.writable && !(column.guarded && allow.has(name))) {
+      refuseWrite(table, column);
+    }
+    columns.push(column);
+  }
+  return columns;
+}
+function conflictNames(on) {
+  if (typeof on === "string")
+    return [on];
+  if (Array.isArray(on) && on.length > 0 && on.every((name) => typeof name === "string")) {
+    return on;
+  }
+  fail2("OKM1104", "onConflict on must name a unique constraint's columns.");
+}
+function fieldsOf(unique, names, tenantKeys) {
+  if (tenantKeys.some((key) => unique.includes(key))) {
+    const rest = [];
+    for (const field of unique) {
+      if (!tenantKeys.includes(field))
+        rest.push(field);
+    }
+    if (!same(rest, names))
+      return;
+    return unique;
+  }
+  if (!same(unique, names))
+    return;
+  return names;
+}
+function keyList(tenantKey) {
+  if (tenantKey === undefined)
+    return [];
+  if (typeof tenantKey === "string")
+    return [tenantKey];
+  return tenantKey;
+}
+function same(unique, names) {
+  if (unique.length !== names.length)
+    return false;
+  const left = [...unique].sort();
+  const right = [...names].sort();
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+function rejectConflictKeys(keys, accepted) {
+  for (const key of keys) {
+    if (!accepted.includes(key)) {
+      throwNamed("OKM1120", key, accepted, `Option ${key} is not accepted by onConflict. Accepted options: ${list(accepted)}.`);
+    }
+  }
+}
+function refuseWrite(table, column) {
+  if (fieldSealed(table.model, column.field)) {
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is set by a trait. Input cannot set it.`);
+  }
+  if (column.guardUpdate) {
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is a primary key. Input cannot change it.`);
+  }
+  if (column.guarded) {
+    fail2("OKM1190", `Field ${table.model.name}.${column.field} is guarded. Input cannot set it.`);
+  }
+  fail2("OKM1120", `Field ${table.model.name}.${column.field} cannot be written.`);
+}
+export {
+  finishInsert,
+  lookupExisting,
+  readConflict
+};

package/dist/tooling/shared/fh07z1dt.js

@@ -0,0 +1,15 @@
+import {
+  OkmError
+} from "./hfq3n3bd.js";
+
+// src/runtime/validate/closed.ts
+var VALIDATION_NOT_IMPORTED = "Validation is enabled but `okmodel/validate` was not imported.";
+var VALIDATION_NOT_IMPORTED_FIX = 'Import "okmodel/validate" before schema().';
+function refuseMissingValidation() {
+  throw new OkmError("OKM1201", VALIDATION_NOT_IMPORTED, {
+    fix: { summary: VALIDATION_NOT_IMPORTED_FIX }
+  });
+}
+export {
+  refuseMissingValidation
+};

package/dist/tooling/shared/gqwevek4.js

@@ -0,0 +1,81 @@
+import {
+  DriverError2,
+  outcomeUnknown2,
+  mapDriverError2,
+  isConnectionLost
+} from "./hfq3n3bd.js";
+
+// src/adapters/pg/batch.ts
+var savepointIds = 0;
+async function runAtomicBatch(session, statements, watch) {
+  if (session.inTransaction())
+    return savepoint(session, statements, watch);
+  return transaction(session, statements, watch);
+}
+async function transaction(session, statements, watch) {
+  try {
+    await control(session, "BEGIN", watch);
+    const results = await statementsOf(session, statements, watch);
+    try {
+      await control(session, "COMMIT", watch);
+    } catch (error) {
+      if (isConnectionLost(error))
+        throw outcomeUnknown2(error);
+      throw stamp(error, null);
+    }
+    return results;
+  } catch (error) {
+    if (!isConnectionLost(error))
+      await rollback(session);
+    throw error;
+  }
+}
+async function savepoint(session, statements, watch) {
+  savepointIds += 1;
+  const name = `okm_b${String(savepointIds)}`;
+  try {
+    await control(session, `SAVEPOINT ${name}`, watch);
+    const results = await statementsOf(session, statements, watch);
+    await control(session, `RELEASE SAVEPOINT ${name}`, watch);
+    return results;
+  } catch (error) {
+    if (!isConnectionLost(error))
+      await rollback(session, `ROLLBACK TO SAVEPOINT ${name}`);
+    throw error;
+  }
+}
+function control(session, text, watch) {
+  return session.query(text, undefined, watch).then(() => {
+    return;
+  });
+}
+async function rollback(session, text = "ROLLBACK") {
+  try {
+    await session.query(text, undefined, undefined);
+  } catch {
+    session.abandon();
+  }
+}
+async function statementsOf(session, statements, watch) {
+  const results = Array.from({ length: statements.length });
+  for (let index = 0;index < statements.length; index += 1) {
+    const statement = statements[index];
+    if (statement === undefined)
+      continue;
+    try {
+      results[index] = await session.query(statement.text, statement.params, watch);
+    } catch (error) {
+      throw stamp(error, index);
+    }
+  }
+  return results;
+}
+function stamp(error, batchIndex) {
+  const mapped = mapDriverError2(error, batchIndex);
+  if (mapped instanceof DriverError2)
+    return mapped;
+  return error;
+}
+export {
+  runAtomicBatch
+};