okmodel 0.7.0 → 0.8.0

package/dist/tooling/shared/417zdsk7.js

@@ -0,0 +1,194 @@
+import {
+  noticeBuffer,
+  WireSession
+} from "./yw30vnq2.js";
+import {
+  NODE_POSTGRES_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/nodepostgres.ts
+import net from "node:net";
+import pg from "pg";
+var CANCEL_CODE = 80877102;
+var identity = (value) => value;
+function armDriverError2(source, handle = () => {}) {
+  source.on("error", handle);
+}
+var WIRE = {
+  getTypeParser() {
+    return identity;
+  }
+};
+function open4(config) {
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const inflight = new Set;
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const pool = new pg.Pool({
+    connectionString: config.url,
+    max,
+    idleTimeoutMillis: 0,
+    allowExitOnIdle: true,
+    connectionTimeoutMillis: 5000,
+    application_name: "okmodel",
+    types: WIRE,
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    ...config.searchPath !== undefined ? { options: `-c search_path=${config.searchPath}` } : {}
+  });
+  armDriverError2(pool);
+  pool.on("connect", (client) => {
+    client.on("notice", (notice) => {
+      notices.push(notice);
+    });
+  });
+  const root = new WireSession((text, params) => send3(pool, text, params, named, undefined), notices, isClosed, true, () => {
+    counters.busy += 1;
+  }, () => {
+    counters.busy = Math.max(0, counters.busy - 1);
+  }, inflight);
+  const held = { pool, acquireMs, counters, notices, named, isClosed };
+  const checkout = () => closed ? rejectClosed() : import("./tn8gay14.js").then((mod) => mod.checkout(held));
+  return {
+    capabilities: NODE_POSTGRES_CAPABILITIES,
+    execute(text, params, options) {
+      return runCall(closed, options, async (watch) => {
+        if (watch === undefined)
+          return root.query(text, params, undefined);
+        const client = await connectClient2(pool, acquireMs, counters);
+        counters.busy += 1;
+        const session = new WireSession((statement, values) => send3(client, statement, values, named, client), notices, isClosed, true, () => {
+          return;
+        }, () => {
+          return;
+        }, inflight);
+        try {
+          return await session.query(text, params, watch);
+        } finally {
+          counters.busy = Math.max(0, counters.busy - 1);
+          client.release();
+        }
+      });
+    },
+    async batch(statements, options) {
+      const connection = await checkout();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => checkout(),
+    stream(text, params) {
+      return async function* () {
+        const { streamRows } = await import("./tn8gay14.js");
+        yield* streamRows(checkout, text, params);
+      }();
+    },
+    listen(channel, onNotify) {
+      if (closed)
+        return rejectClosed();
+      return import("./tn8gay14.js").then((mod) => mod.listen(held, channel, onNotify));
+    },
+    cancel() {
+      for (const pending of inflight)
+        pending.cancel?.();
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await pool.end();
+    }
+  };
+}
+function send3(runner, text, params, named, client) {
+  const query = {
+    text,
+    rowMode: "array",
+    types: WIRE,
+    ...params !== undefined && params.length > 0 ? { values: params } : {},
+    ...named ? { name: statementName(text) } : {}
+  };
+  const pending = runner.query(query);
+  if (client !== undefined)
+    pending.cancel = () => cancelBackend(client);
+  return pending;
+}
+var names = new Map;
+function statementName(text) {
+  const existing = names.get(text);
+  if (existing !== undefined)
+    return existing;
+  const name = `okm_${String(names.size)}`;
+  names.set(text, name);
+  return name;
+}
+function cancelBackend(client) {
+  const pid = client.processID;
+  const secret = client.secretKey;
+  if (typeof pid !== "number" || typeof secret !== "number")
+    return;
+  const socket = client.host.startsWith("/") === true ? net.connect(client.host) : net.connect(client.port, client.host);
+  socket.unref();
+  socket.once("error", () => {
+    socket.destroy();
+  });
+  socket.once("connect", () => {
+    const bytes = Buffer.alloc(16);
+    bytes.writeInt32BE(16, 0);
+    bytes.writeInt32BE(CANCEL_CODE, 4);
+    bytes.writeInt32BE(pid, 8);
+    bytes.writeInt32BE(secret, 12);
+    socket.end(bytes);
+  });
+}
+function connectClient2(pool, acquireMs, counters) {
+  counters.waiting += 1;
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        settled = true;
+        counters.waiting = Math.max(0, counters.waiting - 1);
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    pool.connect().then((client) => {
+      if (settled) {
+        client.release();
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(client);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { armDriverError2, open4, send3, connectClient2 };

package/dist/tooling/shared/4d2w25vw.js

@@ -0,0 +1,40 @@
+import {
+  rejectClosed
+} from "./xhrnjch9.js";
+import {
+  isConnectionLost
+} from "./f9mphxej.js";
+
+// src/adapters/pg/reserved.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function resetSession2(depth, run) {
+  if (depth > 0)
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  } catch {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  }
+}
+async function resetQueried2(session) {
+  await resetSession2(session.inTransaction() ? 1 : 0, (text) => text === "ROLLBACK" ? session.rollback() : session.query(text, undefined, undefined));
+}
+function refuseWhenLost2(lost, run) {
+  if (lost.on)
+    return rejectClosed();
+  return run().catch((error) => {
+    if (isConnectionLost(error))
+      lost.on = true;
+    throw error;
+  });
+}
+
+export { resetSession2, resetQueried2, refuseWhenLost2 };

package/dist/tooling/shared/54tqkxja.js

@@ -0,0 +1,51 @@
+// src/adapters/pg/watch.ts
+var callers = new WeakMap;
+function listenOn(signal, onAbort) {
+  let set = callers.get(signal);
+  if (set === undefined) {
+    const created = new Set;
+    callers.set(signal, created);
+    signal.addEventListener("abort", () => {
+      for (const each of created)
+        each();
+    }, { once: true });
+    set = created;
+  }
+  const registered = set;
+  registered.add(onAbort);
+  return () => {
+    registered.delete(onAbort);
+  };
+}
+function openWatch(options) {
+  let kind;
+  const controller = new AbortController;
+  const onAbort = () => {
+    if (kind === undefined)
+      kind = "cancelled";
+    controller.abort();
+  };
+  const release = options.signal === undefined ? undefined : listenOn(options.signal, onAbort);
+  let timer;
+  if (options.timeout !== undefined) {
+    timer = setTimeout(() => {
+      if (kind === undefined)
+        kind = "timeout";
+      controller.abort();
+    }, options.timeout);
+  }
+  return {
+    signal: controller.signal,
+    finish() {
+      if (timer !== undefined)
+        clearTimeout(timer);
+      release?.();
+    },
+    reason() {
+      return kind;
+    }
+  };
+}
+export {
+  openWatch
+};

package/dist/tooling/shared/5bvw2nev.js

@@ -0,0 +1,12 @@
+import {
+  creationOrder2,
+  catalogHash2,
+  loadTrustedCatalog2,
+  catalogFileText2
+} from "./f9mphxej.js";
+export {
+  catalogFileText2 as catalogFileText,
+  catalogHash2 as catalogHash,
+  creationOrder2 as creationOrder,
+  loadTrustedCatalog2 as loadTrustedCatalog
+};

package/dist/tooling/shared/6nyfyw70.js

@@ -0,0 +1,231 @@
+import {
+  touchFields,
+  fieldSealed
+} from "./spk1jg3r.js";
+import {
+  throwNamed,
+  projectExpr,
+  quote,
+  list,
+  isRecord,
+  registerFailFix,
+  fail2
+} from "./f9mphxej.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/72fyg4zv.js

@@ -0,0 +1,160 @@
+import {
+  OkmError,
+  isOperator,
+  operatorValue,
+  safetyInstalled,
+  runSafety
+} from "./f9mphxej.js";
+
+// src/runtime/exposure.ts
+var REDACTED = "[redacted]";
+var namesOf = new WeakMap;
+function redactView(schema, view, call) {
+  const names = concealedNames(schema);
+  const secrets = new Set;
+  harvest(schema, call.where, names, undefined, secrets);
+  harvest(schema, call.include, names, undefined, secrets);
+  const model = schema.model[call.table];
+  const rules = model === undefined ? view.rules : [...view.rules, ...exposureRules(model, call)];
+  if (safetyInstalled())
+    runSafety(rules, undefined);
+  return {
+    ...view,
+    intent: {
+      ...view.intent,
+      where: walk(view.intent.where, names),
+      include: walk(view.intent.include, names)
+    },
+    rules,
+    sql: {
+      ...view.sql,
+      params: view.sql.params.map((value) => value !== null && secrets.has(value) ? REDACTED : value)
+    }
+  };
+}
+function scrubCall(error, schema, call) {
+  const names = concealedNames(schema);
+  const secrets = new Set;
+  harvest(schema, call.where, names, undefined, secrets);
+  harvest(schema, call.include, names, undefined, secrets);
+  let message = error.message;
+  for (const secret of secrets) {
+    if (secret.length < 4 || !message.includes(secret))
+      continue;
+    message = message.replaceAll(secret, REDACTED);
+  }
+  if (message === error.message)
+    return error;
+  return new OkmError(error.code, message, {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    fix: error.fix
+  });
+}
+function concealedNames(schema) {
+  const cached = namesOf.get(schema);
+  if (cached !== undefined)
+    return cached;
+  const names = new Set;
+  for (const model of Object.values(schema.model)) {
+    if (model.conceal !== true)
+      continue;
+    for (const column of model.columns) {
+      if (column.hidden || column.sensitive)
+        names.add(column.field);
+    }
+  }
+  namesOf.set(schema, names);
+  return names;
+}
+function exposureRules(model, call) {
+  const named = namedSelect(call.select);
+  const source = model.source;
+  const rules = [];
+  for (const column of model.columns) {
+    if (column.hidden && (named === undefined || !named.has(column.field))) {
+      rules.push({
+        rule: "hidden",
+        contribution: `hidden ${model.name}.${column.field} excluded`,
+        provenance: "catalog",
+        ...source !== undefined ? { source } : {}
+      });
+    }
+    if (column.sensitive) {
+      rules.push({
+        rule: "sensitive",
+        contribution: `sensitive ${model.name}.${column.field} redacted`,
+        provenance: "catalog",
+        ...source !== undefined ? { source } : {}
+      });
+    }
+  }
+  return rules;
+}
+function namedSelect(select) {
+  if (!Array.isArray(select))
+    return;
+  const names = new Set;
+  for (const name of select) {
+    if (typeof name === "string")
+      names.add(name);
+  }
+  return names;
+}
+function harvest(schema, value, names, key, into) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      harvest(schema, item, names, key, into);
+    return;
+  }
+  if (isOperator(value)) {
+    harvest(schema, operatorValue(value), names, key, into);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    for (const child of Object.keys(record))
+      harvest(schema, record[child], names, child, into);
+    return;
+  }
+  if (key === undefined || !names.has(key))
+    return;
+  const encode = encodeOf(schema, key);
+  if (encode === undefined)
+    return;
+  try {
+    into.add(encode(value));
+  } catch {}
+}
+function encodeOf(schema, field) {
+  for (const model of Object.values(schema.model)) {
+    for (const column of model.columns) {
+      if (column.field === field && (column.hidden || column.sensitive)) {
+        return column.encode;
+      }
+    }
+  }
+  return;
+}
+function walk(value, names, key) {
+  if (Array.isArray(value))
+    return value.map((item) => walk(item, names, key));
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    if (typeof record.op === "string" && "value" in record) {
+      return { op: record.op, value: walk(record.value, names, key) };
+    }
+    const out = {};
+    for (const child of Object.keys(record))
+      out[child] = walk(record[child], names, child);
+    return out;
+  }
+  if (key !== undefined && names.has(key))
+    return REDACTED;
+  return value;
+}
+export {
+  redactView,
+  scrubCall
+};