okmodel 0.0.0 → 0.1.1

package/dist/shared/w8samvk1.js

@@ -0,0 +1,18 @@
+import {
+  creationOrder2,
+  renameColumn2,
+  renameTable2,
+  serializeCatalog2,
+  catalogHash2,
+  loadTrustedCatalog2,
+  parseCatalog2
+} from "./y9m15dfv.js";
+export {
+  catalogHash2 as catalogHash,
+  creationOrder2 as creationOrder,
+  loadTrustedCatalog2 as loadTrustedCatalog,
+  parseCatalog2 as parseCatalog,
+  renameColumn2 as renameColumn,
+  renameTable2 as renameTable,
+  serializeCatalog2 as serializeCatalog
+};

package/dist/shared/x5x59srr.js

@@ -0,0 +1,566 @@
+import {
+  emitWhere,
+  selectedColumns,
+  rejectKeys,
+  projectExpr,
+  decodeRow,
+  indexes,
+  quote,
+  isRecord,
+  fail
+} from "./rgs0st28.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);
+}
+
+// src/runtime/write.ts
+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) {
+  const table = indexes(schema).get(tableName);
+  if (table === undefined) {
+    fail("OKM1120", `Table ${tableName} is not in the schema.`);
+  }
+  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);
+}
+async function planInsert(table, input, options, mods) {
+  const many = Array.isArray(input);
+  const rows = (many ? input : [input]).map((row) => insertRow(table, row));
+  const columns = writtenColumns(table, rows);
+  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";
+  if (columns.length === 0) {
+    const text = `insert into ${quote(table.model.sql)} default values${clause}`;
+    return {
+      statements: rows.map(() => ({ text })),
+      outputs,
+      shape,
+      expect,
+      keys: undefined,
+      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 statements = [];
+  const keys = [];
+  let offset = 0;
+  for (const chunk of chunks) {
+    const slice = rows.slice(offset, offset + chunk.length);
+    offset += chunk.length;
+    const built = insertHead(table, columns, chunk);
+    if (conflict === undefined || conflictMod === undefined) {
+      statements.push(withParams(`${built.text}${clause}`, built.params));
+      continue;
+    }
+    const keyRows = conflict.kind === "return" ? slice.map((row) => keyWire(conflict.columns, row)) : [];
+    for (const row of keyRows)
+      keys.push([...row]);
+    statements.push(conflictMod.finishInsert(built.text, clause, built.params ?? [], conflict, table, returning, keyRows));
+  }
+  return {
+    statements,
+    outputs,
+    shape,
+    expect,
+    keys: conflict?.kind === "return" ? keys : undefined,
+    keyFields: conflict?.kind === "return" ? conflict.columns.map((column) => column.field) : undefined
+  };
+}
+function planUpdate(schema, table, input, options, mods) {
+  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));
+    return {
+      statements: updateList(schema, table, rows, returning),
+      outputs,
+      shape: returning === undefined ? "count" : "rows",
+      expect,
+      keys: undefined,
+      keyFields: undefined
+    };
+  }
+  if (!isRecord(input))
+    fail("OKM1121", "update expects { where, set } or a list of rows.");
+  const set = writeSet(table, input.set);
+  requireFilter(table, input.where, mods, "update");
+  if (Object.keys(set).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 ");
+  emitSet(sql, table, set, "t");
+  emitFilter(schema, table, input.where, sql, "t");
+  sql.text(returningClause(returning, "t"));
+  return {
+    statements: [sql.statement()],
+    outputs,
+    shape: returning === undefined ? "count" : "rows",
+    expect,
+    keys: undefined,
+    keyFields: undefined
+  };
+}
+function planDelete(schema, table, input, options, mods) {
+  if (!isRecord(input))
+    fail("OKM1121", "delete expects { where }.");
+  rejectKeys(input, ["where"], "delete");
+  requireFilter(table, input.where, mods, "delete");
+  const returning = returningOption(table, options.returning);
+  const sql = new Sql;
+  sql.text("delete from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t");
+  emitFilter(schema, table, input.where, sql, "t");
+  sql.text(returningClause(returning, "t"));
+  return {
+    statements: [sql.statement()],
+    outputs: outputsOf(returning),
+    shape: returning === undefined ? "count" : "rows",
+    expect: expectOf(options, mods),
+    keys: undefined,
+    keyFields: undefined
+  };
+}
+function finish(results, planned, table) {
+  if (planned.shape === "count") {
+    let count = 0;
+    for (const result of results)
+      count += result.count;
+    checkExpect(count, planned.expect, table, "write");
+    return { count };
+  }
+  const decoded = [];
+  for (const result of results) {
+    for (const row of result.rows)
+      decoded.push(decodeRow(planned.outputs, row));
+  }
+  const rows = planned.keys === undefined || planned.keyFields === undefined ? decoded : orderByKeys(decoded, planned.keyFields, planned.keys);
+  checkExpect(rows.length, planned.expect, table, "insert");
+  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);
+  }
+  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 fields = [];
+  const seen = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row.set)) {
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      const column = table.columns.get(key);
+      if (column !== undefined)
+        fields.push(column);
+    }
+  }
+  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 ");
+  for (let field = 0;field < fields.length; field += 1) {
+    const column = fields[field];
+    if (column === undefined)
+      continue;
+    if (field > 0)
+      sql.text(", ");
+    sql.text(quote(column.sql));
+    sql.text(" = case");
+    for (const row of rows) {
+      sql.text(" when ");
+      emitBare(schema, table, row.where, sql, "t");
+      sql.text(" then ");
+      const value = row.set[column.field];
+      if (value === undefined)
+        sql.text(`t.${quote(column.sql)}`);
+      else
+        emitValue(sql, column, value, "t");
+    }
+    sql.text(" else t.");
+    sql.text(quote(column.sql));
+    sql.text(" end");
+  }
+  sql.text(" where ");
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(" or ");
+    sql.text("(");
+    emitBare(schema, table, row.where, sql, "t");
+    sql.text(")");
+  }
+  sql.text(returningClause(returning, "t"));
+  return sql.statement();
+}
+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;
+    const column = table.columns.get(key);
+    if (column === undefined)
+      continue;
+    if (index > 0)
+      sql.text(", ");
+    sql.text(quote(column.sql));
+    sql.text(" = ");
+    emitValue(sql, column, set[key], alias);
+  }
+}
+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 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(column.encode(amount), column.dataType);
+    return;
+  }
+  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.`);
+  }
+  sql.param(column.encode(value), column.dataType);
+}
+function emitFilter(schema, table, where, sql, alias) {
+  emitWhere(schema, table, where, sql.sink(), alias, 0);
+}
+function emitBare(schema, table, where, sql, alias) {
+  let dropped = false;
+  const sink = {
+    text(value) {
+      if (!dropped) {
+        dropped = true;
+        if (value === " where " || value === " and ")
+          return;
+      }
+      sql.text(value);
+    },
+    param(encoded) {
+      sql.param(encoded, "");
+    },
+    mark() {}
+  };
+  emitWhere(schema, table, where, sink, alias, 0);
+  if (!dropped) {
+    fail("OKM1102", `update on ${table.model.name} needs a where for each row.`);
+  }
+}
+
+class Sql {
+  parts = [];
+  params = [];
+  text(value) {
+    this.parts.push(value);
+  }
+  param(wire, dataType) {
+    this.params.push(wire);
+    const slot = `$${String(this.params.length)}`;
+    this.parts.push(dataType.length === 0 ? slot : `${slot}::${dataType}`);
+  }
+  sink() {
+    return {
+      text: (value) => {
+        this.text(value);
+      },
+      param: (encoded) => {
+        this.param(encoded, "");
+      },
+      mark() {}
+    };
+  }
+  statement() {
+    return this.params.length === 0 ? { text: this.parts.join("") } : { text: this.parts.join(""), params: this.params };
+  }
+}
+function insertRow(table, value) {
+  if (!isRecord(value))
+    fail("OKM1121", "insert expects an object or a list of objects.");
+  const row = {};
+  for (const key of Object.keys(value)) {
+    const column = table.columns.get(key);
+    if (column === undefined)
+      continue;
+    if (!column.writable)
+      refuse(table.model.name, column);
+    if (value[key] !== undefined)
+      row[key] = value[key];
+  }
+  return row;
+}
+function cellsFor(table, 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 };
+  });
+}
+function writtenColumns(table, rows) {
+  const present = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row))
+      present.add(key);
+  }
+  const columns = [];
+  for (const column of table.model.columns) {
+    if (column.writable && present.has(column.field))
+      columns.push(column);
+  }
+  return columns;
+}
+function writeSet(table, value) {
+  if (!isRecord(value))
+    fail("OKM1121", "set must be an object of fields.");
+  const set = {};
+  for (const key of Object.keys(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);
+    set[key] = value[key];
+  }
+  return set;
+}
+function updateItem(table, value) {
+  if (!isRecord(value))
+    fail("OKM1121", "update expects { where, set } or a list of rows.");
+  const set = writeSet(table, value.set);
+  if (value.where !== undefined)
+    return { where: value.where, set };
+  if (value.id !== undefined)
+    return { where: { id: value.id }, set };
+  fail("OKM1102", `update on ${table.model.name} needs id or where for each row.`);
+}
+function requireFilter(table, where, mods, op) {
+  if (mods.all !== undefined) {
+    if (mods.all.trim().length === 0) {
+      fail("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
+    }
+    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).`);
+}
+function chunkRows(rows) {
+  const chunks = [];
+  let current = [];
+  let count = 0;
+  for (const row of rows) {
+    let cost = 0;
+    for (const cell of row)
+      if (cell.kind !== "default")
+        cost += 1;
+    if (current.length > 0 && count + cost > WRITE_PARAM_BUDGET) {
+      chunks.push(current);
+      current = [];
+      count = 0;
+    }
+    current.push(row);
+    count += cost;
+  }
+  if (current.length > 0)
+    chunks.push(current);
+  return chunks;
+}
+function withParams(text, params) {
+  if (params === undefined || params.length === 0)
+    return { text };
+  return { text, params };
+}
+function keyWire(columns, row) {
+  return columns.map((column) => {
+    const value = row[column.field];
+    if (value === undefined || value === null)
+      return null;
+    if (typeof value === "object")
+      return null;
+    return column.encode(value);
+  });
+}
+function returningOption(table, value) {
+  if (value === undefined)
+    return;
+  return selectedColumns(table, value);
+}
+function returningClause(columns, alias) {
+  if (columns === undefined || columns.length === 0)
+    return "";
+  const parts = columns.map((column) => {
+    const sql = alias === undefined ? quote(column.sql) : `${alias}.${quote(column.sql)}`;
+    return projectExpr(sql, column.dataType);
+  });
+  return ` returning ${parts.join(", ")}`;
+}
+function outputsOf(columns) {
+  const list = columns ?? [];
+  return {
+    fields: list.map((column, index) => ({
+      key: column.field,
+      at: index,
+      decode: column.decode
+    })),
+    includes: []
+  };
+}
+function expectOf(options, mods) {
+  const value = mods.expect ?? options.expect;
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new OkmError2("invalid", "expect must be an integer from 0 up.", { kind: "invalid" });
+  }
+  return value;
+}
+function checkExpect(count, expected, table, op) {
+  if (expected === undefined || count === expected)
+    return;
+  throw new OkmError2("not_found", `${op} on ${table} changed ${String(count)} rows. expect was ${String(expected)}.`, {
+    kind: "not_found",
+    table,
+    fix: { summary: "Change the filter, or pass the count this write produced." }
+  });
+}
+function callOptions(options) {
+  if (!isRecord(options))
+    return;
+  const signal = options.signal;
+  const timeout = options.timeout;
+  const hasSignal = typeof signal === "object" && signal !== null && "aborted" in signal;
+  const hasTimeout = typeof timeout === "number";
+  if (!hasSignal && !hasTimeout)
+    return;
+  return {
+    ...hasSignal ? { signal } : {},
+    ...hasTimeout ? { timeout } : {}
+  };
+}
+function refuse(table, column) {
+  if (column.guarded) {
+    fail("OKM1190", `Field ${table}.${column.field} is guarded. Input cannot set it.`);
+  }
+  fail("OKM1120", `Field ${table}.${column.field} cannot be written.`);
+}
+export {
+  WRITE_PARAM_BUDGET,
+  executeWrite,
+  explainWrite
+};

package/dist/shared/xqbhg6cn.js

@@ -0,0 +1,119 @@
+import {
+  PgSession
+} from "./dkn3y60a.js";
+import {
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  rowsFrom
+} from "./xy79j5hq.js";
+
+// src/adapters/pg/postgres-extra.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function checkout(pool) {
+  if (pool.isClosed())
+    return rejectClosed();
+  const reserved = await reserveConnection(pool.sql, pool.acquireMs, pool.counters);
+  pool.counters.reserved += 1;
+  const local = new Set;
+  const session = new PgSession(reserved, pool.counters, "reserved", local, pool.isClosed, pool.poolInflight, pool.notices, pool.named);
+  let released = false;
+  return {
+    execute: (text, params, options) => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch)),
+    batch: (statements, options) => runCall(pool.isClosed(), options, async (watch) => {
+      const { runAtomicBatch } = await import("./dynq16vb.js");
+      return runAtomicBatch(session, statements, watch);
+    }),
+    cancel() {
+      session.cancel();
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      try {
+        await resetConnection(reserved, session.depth());
+      } finally {
+        pool.counters.reserved = Math.max(0, pool.counters.reserved - 1);
+        reserved.release();
+      }
+    }
+  };
+}
+async function describe(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params), { prepare: true });
+  const described = await pending.describe();
+  return {
+    columns: described.columns.map((column) => column.name),
+    parameterCount: described.types.length
+  };
+}
+async function* stream(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params));
+  for await (const chunk of pending.cursor(64)) {
+    yield rowsFrom(chunk);
+  }
+}
+function reserveConnection(sql, 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);
+    }
+    sql.reserve().then((connection) => {
+      if (settled) {
+        resetConnection(connection, 0).finally(() => {
+          connection.release();
+        });
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(connection);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+async function resetConnection(sql, depth) {
+  if (depth > 0)
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  } catch {
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  }
+}
+function asParams(params) {
+  if (params === undefined)
+    return [];
+  return params;
+}
+export {
+  checkout,
+  describe,
+  stream
+};