@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/{chunk-H5AB6NIR.mjs → chunk-O7SLN3GI.mjs}

@@ -1,13 +1,6 @@
-import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+import { ReplicationError } from './chunk-5NOIGN5Y.mjs';
 
 // src/replication/errors.ts
-var ReplicationError = class extends SirannonError {
-  constructor(message, code = "REPLICATION_ERROR", details) {
-    super(message, code);
-    this.details = details;
-    this.name = "ReplicationError";
-  }
-};
 var ConflictError = class extends ReplicationError {
   constructor(message, table, rowId) {
     super(message, "CONFLICT_ERROR");
@@ -22,12 +15,6 @@ var TransportError = class extends ReplicationError {
     this.name = "TransportError";
   }
 };
-var BatchValidationError = class extends ReplicationError {
-  constructor(message) {
-    super(message, "BATCH_VALIDATION_ERROR");
-    this.name = "BatchValidationError";
-  }
-};
 var WriteConcernError = class extends ReplicationError {
   constructor(message) {
     super(message, "WRITE_CONCERN_ERROR");
@@ -108,4 +95,4 @@ var SyncError = class extends ReplicationError {
   }
 };
 
-export { AuthorityError, BatchValidationError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, ReplicationError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError };
+export { AuthorityError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError };

package/dist/chunk-OQVZBEBY.mjs

@@ -0,0 +1,283 @@
+import { IDENTIFIER_RE, selectCountTableRows, computeChecksum, canonicaliseForChecksum, selectUserSchemaObjects, validateDdlSafety, selectUserTableNames, referencedTables } from './chunk-NVQS53NT.mjs';
+import { ReplicationError } from './chunk-5NOIGN5Y.mjs';
+import { INTERNAL_TABLE_PREFIX } from './chunk-D7LAYTKN.mjs';
+import { createHash } from 'crypto';
+
+var DumpOps = class {
+  constructor(conn, localNodeId, hlc, pkResolver) {
+    this.conn = conn;
+    this.localNodeId = localNodeId;
+    this.hlc = hlc;
+    this.pkResolver = pkResolver;
+  }
+  async *dumpTable(table, batchSize) {
+    if (!IDENTIFIER_RE.test(table)) {
+      throw new ReplicationError(`Invalid table name: ${table}`);
+    }
+    const total = await selectCountTableRows(this.conn, table);
+    if (total === 0) return;
+    const pkColumns = await this.pkResolver.forTable(table);
+    let offset = 0;
+    let batchNum = 0;
+    const needsRowid = pkColumns.length === 1 && pkColumns[0] === "rowid";
+    while (offset < total) {
+      const selectSql = needsRowid ? `SELECT rowid, * FROM "${table}" LIMIT ? OFFSET ?` : `SELECT * FROM "${table}" LIMIT ? OFFSET ?`;
+      const selectStmt = await this.conn.prepare(selectSql);
+      const rows = await selectStmt.all(batchSize, offset);
+      if (rows.length === 0) break;
+      const changes = [];
+      const hlcValue = this.hlc.now();
+      for (const row of rows) {
+        const primaryKey = {};
+        for (const col of pkColumns) {
+          if (col in row) {
+            primaryKey[col] = row[col];
+          }
+        }
+        const rowId = pkColumns.map((col) => String(row[col] ?? "")).join("-");
+        changes.push({
+          table,
+          operation: "insert",
+          rowId,
+          primaryKey,
+          hlc: hlcValue,
+          txId: `dump-${table}-${batchNum}`,
+          nodeId: this.localNodeId,
+          newData: row,
+          oldData: null
+        });
+      }
+      const checksum = computeChecksum(changes);
+      const dumpEpoch = BigInt(Date.now()) * 1000000n;
+      const fromSeq = dumpEpoch + BigInt(offset);
+      const toSeq = dumpEpoch + BigInt(offset + rows.length - 1);
+      const dumpNodeId = `dump-${this.localNodeId}`;
+      yield {
+        sourceNodeId: dumpNodeId,
+        batchId: `dump-${table}-${batchNum}`,
+        fromSeq,
+        toSeq,
+        hlcRange: { min: hlcValue, max: hlcValue },
+        changes,
+        checksum
+      };
+      offset += rows.length;
+      batchNum += 1;
+    }
+  }
+  dumpTableOnConnection(conn, table, batchSize, startAfter) {
+    return dumpTablePages(conn, this.pkResolver, table, batchSize, startAfter);
+  }
+  async generateManifest(conn, table) {
+    if (!IDENTIFIER_RE.test(table)) {
+      throw new ReplicationError(`Invalid table name: ${table}`);
+    }
+    const rowCount = await selectCountTableRows(conn, table);
+    const hash = createHash("sha256");
+    const pkColumns = await this.pkResolver.forTableOnConnection(conn, table);
+    const needsRowid = pkColumns.length === 1 && pkColumns[0] === "rowid";
+    let lastPkValues = null;
+    const PK_BATCH_SIZE = 1e4;
+    let hasRows = true;
+    while (hasRows) {
+      let selectSql;
+      const params = [];
+      if (needsRowid) {
+        if (lastPkValues === null) {
+          selectSql = `SELECT rowid FROM "${table}" ORDER BY rowid LIMIT ?`;
+        } else {
+          selectSql = `SELECT rowid FROM "${table}" WHERE rowid > ? ORDER BY rowid LIMIT ?`;
+          params.push(lastPkValues[0]);
+        }
+      } else if (pkColumns.length === 1) {
+        const col = pkColumns[0];
+        if (lastPkValues === null) {
+          selectSql = `SELECT "${col}" FROM "${table}" ORDER BY "${col}" LIMIT ?`;
+        } else {
+          selectSql = `SELECT "${col}" FROM "${table}" WHERE "${col}" > ? ORDER BY "${col}" LIMIT ?`;
+          params.push(lastPkValues[0]);
+        }
+      } else {
+        const colList = pkColumns.map((c) => `"${c}"`).join(", ");
+        if (lastPkValues === null) {
+          selectSql = `SELECT ${colList} FROM "${table}" ORDER BY ${colList} LIMIT ?`;
+        } else {
+          const placeholders = pkColumns.map(() => "?").join(", ");
+          selectSql = `SELECT ${colList} FROM "${table}" WHERE (${colList}) > (${placeholders}) ORDER BY ${colList} LIMIT ?`;
+          params.push(...lastPkValues);
+        }
+      }
+      params.push(PK_BATCH_SIZE);
+      const stmt = await conn.prepare(selectSql);
+      const rows = await stmt.all(...params);
+      if (rows.length === 0) {
+        hasRows = false;
+        break;
+      }
+      for (const row of rows) {
+        const pkVal = pkColumns.map((col) => String(row[col] ?? "")).join("-");
+        hash.update(pkVal);
+      }
+      if (rows.length < PK_BATCH_SIZE) {
+        hasRows = false;
+      } else {
+        const lastRow = rows[rows.length - 1];
+        lastPkValues = pkColumns.map((col) => lastRow[col]);
+      }
+    }
+    return { table, rowCount, pkHash: hash.digest("hex") };
+  }
+  async verifyManifest(manifest) {
+    const local = await this.generateManifest(this.conn, manifest.table);
+    return local.rowCount === manifest.rowCount && local.pkHash === manifest.pkHash;
+  }
+};
+async function* dumpTablePages(conn, pkResolver, table, batchSize, startAfter) {
+  if (!IDENTIFIER_RE.test(table)) {
+    throw new ReplicationError(`Invalid table name: ${table}`);
+  }
+  const pkColumns = await pkResolver.forTableOnConnection(conn, table);
+  const needsRowid = pkColumns.length === 1 && pkColumns[0] === "rowid";
+  if (startAfter !== void 0 && startAfter.length !== pkColumns.length) {
+    throw new ReplicationError(
+      `Resume key for table '${table}' must carry ${pkColumns.length} value(s), received ${startAfter.length}`
+    );
+  }
+  let lastPkValues = startAfter ?? null;
+  let done = false;
+  while (!done) {
+    let selectSql;
+    const params = [];
+    if (lastPkValues === null) {
+      selectSql = needsRowid ? `SELECT rowid, * FROM "${table}" ORDER BY rowid LIMIT ?` : `SELECT * FROM "${table}" ORDER BY ${pkColumns.map((c) => `"${c}"`).join(", ")} LIMIT ?`;
+      params.push(batchSize);
+    } else if (needsRowid) {
+      selectSql = `SELECT rowid, * FROM "${table}" WHERE rowid > ? ORDER BY rowid LIMIT ?`;
+      params.push(lastPkValues[0], batchSize);
+    } else if (pkColumns.length === 1) {
+      selectSql = `SELECT * FROM "${table}" WHERE "${pkColumns[0]}" > ? ORDER BY "${pkColumns[0]}" LIMIT ?`;
+      params.push(lastPkValues[0], batchSize);
+    } else {
+      const colList = pkColumns.map((c) => `"${c}"`).join(", ");
+      const placeholders = pkColumns.map(() => "?").join(", ");
+      selectSql = `SELECT * FROM "${table}" WHERE (${colList}) > (${placeholders}) ORDER BY ${colList} LIMIT ?`;
+      params.push(...lastPkValues, batchSize);
+    }
+    const stmt = await conn.prepare(selectSql);
+    const rows = await stmt.all(...params);
+    if (rows.length === 0) {
+      break;
+    }
+    const lastRow = rows[rows.length - 1];
+    lastPkValues = pkColumns.map((col) => lastRow[col]);
+    let isLast = rows.length < batchSize;
+    if (!isLast) {
+      let peekSql;
+      const peekParams = [];
+      if (needsRowid) {
+        peekSql = `SELECT 1 FROM "${table}" WHERE rowid > ? LIMIT 1`;
+        peekParams.push(lastPkValues[0]);
+      } else if (pkColumns.length === 1) {
+        peekSql = `SELECT 1 FROM "${table}" WHERE "${pkColumns[0]}" > ? LIMIT 1`;
+        peekParams.push(lastPkValues[0]);
+      } else {
+        const colList = pkColumns.map((c) => `"${c}"`).join(", ");
+        const placeholders = pkColumns.map(() => "?").join(", ");
+        peekSql = `SELECT 1 FROM "${table}" WHERE (${colList}) > (${placeholders}) LIMIT 1`;
+        peekParams.push(...lastPkValues);
+      }
+      const peekStmt = await conn.prepare(peekSql);
+      const peekRow = await peekStmt.get(...peekParams);
+      if (!peekRow) {
+        isLast = true;
+      }
+    }
+    done = isLast;
+    const checksum = createHash("sha256").update(canonicaliseForChecksum(rows)).digest("hex");
+    yield { rows, checksum, isLast };
+  }
+}
+
+// src/core/sync/schema-dump.ts
+async function dumpSchema(conn, excludePrefix = INTERNAL_TABLE_PREFIX) {
+  const rows = await selectUserSchemaObjects(conn, excludePrefix);
+  const filtered = rows.filter((row) => {
+    if (row.name.startsWith(excludePrefix)) return false;
+    if (row.name.startsWith("sqlite_")) return false;
+    if (row.tbl_name.startsWith(excludePrefix)) return false;
+    if (row.tbl_name.startsWith("sqlite_")) return false;
+    return validateDdlSafety(row.sql);
+  });
+  const tables = [];
+  const indexes = [];
+  for (const row of filtered) {
+    if (row.type === "table") {
+      tables.push({ name: row.name, sql: row.sql });
+    } else {
+      indexes.push({ sql: row.sql });
+    }
+  }
+  const tableOrder = await tablesInFkOrder(conn);
+  const orderMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tableOrder.length; i++) {
+    orderMap.set(tableOrder[i], i);
+  }
+  tables.sort((a, b) => (orderMap.get(a.name) ?? 999) - (orderMap.get(b.name) ?? 999));
+  const result = [];
+  for (const t of tables) {
+    result.push(t.sql);
+  }
+  for (const idx of indexes) {
+    result.push(idx.sql);
+  }
+  return result;
+}
+async function tablesInFkOrder(conn) {
+  const tableNames = await selectUserTableNames(conn, INTERNAL_TABLE_PREFIX);
+  const adjacency = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const name of tableNames) {
+    adjacency.set(name, /* @__PURE__ */ new Set());
+    inDegree.set(name, 0);
+  }
+  for (const name of tableNames) {
+    for (const referenced of await referencedTables(conn, name)) {
+      if (tableNames.includes(referenced) && referenced !== name) {
+        const deps = adjacency.get(referenced);
+        if (deps && !deps.has(name)) {
+          deps.add(name);
+          inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  const queue = [];
+  for (const name of tableNames) {
+    if ((inDegree.get(name) ?? 0) === 0) {
+      queue.push(name);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    sorted.push(current);
+    const deps = adjacency.get(current);
+    if (deps) {
+      for (const dep of deps) {
+        const newDeg = (inDegree.get(dep) ?? 1) - 1;
+        inDegree.set(dep, newDeg);
+        if (newDeg === 0) {
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  if (sorted.length < tableNames.length) {
+    const remaining = tableNames.filter((n) => !sorted.includes(n)).sort();
+    sorted.push(...remaining);
+  }
+  return sorted;
+}
+
+export { DumpOps, dumpSchema, dumpTablePages, tablesInFkOrder };

package/dist/{chunk-VLTICJOD.mjs → chunk-PIKHN33N.mjs}

@@ -1,4 +1,4 @@
-import { BackupError } from './chunk-YPYVQJ4C.mjs';
+import { BackupError } from './chunk-UC3SCMIN.mjs';
 import { existsSync, mkdirSync, rmSync, readdirSync, lstatSync } from 'fs';
 import { resolve, dirname, join } from 'path';
 

package/dist/chunk-TJF5GZSV.mjs

@@ -0,0 +1,187 @@
+import { tokenizeSql, readSelectItems, findClauses } from './chunk-JU64Y7HM.mjs';
+import { operationRegistryDigest } from './chunk-TUD5CJ76.mjs';
+import { mkdirSync, writeFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { pathToFileURL } from 'url';
+
+// src/codegen/manifest.ts
+var OPERATION_MANIFEST_VERSION = 1;
+function buildOperationManifest(registry) {
+  const databases = {};
+  for (const databaseId of Object.keys(registry).sort()) {
+    const operations = registry[databaseId] ?? {};
+    const reads = {};
+    const writes = {};
+    for (const name of Object.keys(operations.reads ?? {}).sort()) {
+      const read = operations.reads?.[name];
+      if (read !== void 0) reads[name] = readShape(read);
+    }
+    for (const name of Object.keys(operations.writes ?? {}).sort()) {
+      const write2 = operations.writes?.[name];
+      if (write2 !== void 0) writes[name] = writeShape(write2);
+    }
+    databases[databaseId] = { reads, writes };
+  }
+  return { version: OPERATION_MANIFEST_VERSION, digest: operationRegistryDigest(registry), databases };
+}
+function readShape(operation) {
+  const args = [...operation.args ?? []];
+  const identityArgs = Object.keys(operation.fromIdentity ?? {});
+  return { args, identityArgs, columns: statementColumns(operation, args, identityArgs) };
+}
+function writeShape(operation) {
+  return { args: [...operation.args ?? []], identityArgs: Object.keys(operation.fromIdentity ?? {}), columns: null };
+}
+function statementColumns(operation, args, identityArgs) {
+  if (operation.columns !== void 0) return [...operation.columns];
+  if (args.length > 0 || identityArgs.length > 0) return null;
+  try {
+    return selectColumns(operation.statement({}).sql);
+  } catch {
+    return null;
+  }
+}
+function selectColumns(sql) {
+  const tokens = withoutTrailingSemicolon(tokenizeSql(sql));
+  if (tokens.length === 0 || tokens[0].lower !== "select" || tokens[0].quoted) return null;
+  const items = readSelectItems(sql, tokens, findClauses(sql, tokens));
+  const names = [];
+  for (const item of items) {
+    if (item.star || item.alias === null) return null;
+    names.push(item.alias);
+  }
+  return names.length === 0 ? null : names;
+}
+function withoutTrailingSemicolon(tokens) {
+  const last = tokens[tokens.length - 1];
+  if (last !== void 0 && last.kind === "punct" && last.value === ";") return tokens.slice(0, -1);
+  return tokens;
+}
+
+// src/codegen/render.ts
+var DEFAULT_PACKAGE = "@delali/sirannon-db";
+function renderOperationTypes(manifest, options) {
+  const lines = [
+    `import type { OperationRef } from '${options?.packageName ?? DEFAULT_PACKAGE}'`,
+    "",
+    `export const registryDigest = ${JSON.stringify(manifest.digest ?? null)}`
+  ];
+  const declared = /* @__PURE__ */ new Map();
+  for (const databaseId of Object.keys(manifest.databases).sort()) {
+    const database = manifest.databases[databaseId];
+    lines.push("", ...renderDatabase(databaseId, database, declared));
+  }
+  return `${lines.join("\n")}
+`;
+}
+function claim(declared, generated, source) {
+  const taken = declared.get(generated);
+  if (taken !== void 0 && taken !== source) {
+    throw new Error(
+      `'${source}' and '${taken}' both generate the identifier '${generated}'. Rename one of them so the generated file declares each name once.`
+    );
+  }
+  declared.set(generated, source);
+  return generated;
+}
+function renderDatabase(databaseId, database, declared) {
+  const prefix = pascalCase(databaseId);
+  const rowTypes = /* @__PURE__ */ new Map();
+  const lines = [];
+  for (const [name, shape] of Object.entries(database.reads)) {
+    if (shape.columns === null) continue;
+    const rowType = claim(declared, `${prefix}${pascalCase(name)}Row`, `${databaseId}.reads.${name}`);
+    rowTypes.set(name, rowType);
+    lines.push(`export interface ${rowType} {`);
+    for (const column of shape.columns) lines.push(`  ${propertyKey(column)}: unknown`);
+    lines.push("}", "");
+  }
+  lines.push(`export const ${claim(declared, identifier(databaseId), databaseId)} = {`, "  reads: {");
+  for (const [name, shape] of Object.entries(database.reads)) {
+    const row = rowTypes.get(name) ?? "Record<string, unknown>";
+    lines.push(
+      `    ${propertyKey(name)}: { name: ${JSON.stringify(name)} } as OperationRef<${argsType(shape)}, ${row}>,`
+    );
+  }
+  lines.push("  },", "  writes: {");
+  for (const [name, shape] of Object.entries(database.writes)) {
+    lines.push(
+      `    ${propertyKey(name)}: { name: ${JSON.stringify(name)} } as OperationRef<${argsType(shape)}, never>,`
+    );
+  }
+  lines.push("  },", "}");
+  return lines;
+}
+function argsType(shape) {
+  if (shape.args.length === 0) return "Record<string, never>";
+  return `{ ${shape.args.map((name) => `${propertyKey(name)}: unknown`).join("; ")} }`;
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propertyKey(name) {
+  return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+function identifier(value) {
+  const cleaned = value.replace(/[^A-Za-z0-9_$]/g, "_");
+  return IDENTIFIER.test(cleaned) ? cleaned : `_${cleaned}`;
+}
+function pascalCase(value) {
+  return value.split(/[^A-Za-z0-9]+/).filter((part) => part.length > 0).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+}
+var CODEGEN_USAGE = `sirannon-codegen --registry <module> --out <file> [--manifest <file>] [--export <name>] [--package <name>]
+
+Reads the operation registry a server is built from and writes the typed
+references a client calls it through. The registry module is imported, so run
+it under a loader that reads your source format when it is not JavaScript.`;
+function parseOptions(argv) {
+  const values = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i += 2) {
+    const flag = argv[i];
+    const value = argv[i + 1];
+    if (!flag.startsWith("--") || value === void 0) {
+      throw new Error(`Unrecognised argument '${flag}'
+
+${CODEGEN_USAGE}`);
+    }
+    values.set(flag.slice(2), value);
+  }
+  const registry = values.get("registry");
+  const out = values.get("out");
+  if (registry === void 0 || out === void 0) {
+    throw new Error(`--registry and --out are both required
+
+${CODEGEN_USAGE}`);
+  }
+  return {
+    registry,
+    out,
+    manifest: values.get("manifest"),
+    exportName: values.get("export"),
+    packageName: values.get("package")
+  };
+}
+function readRegistry(module, exportName, path) {
+  const candidate = exportName === void 0 ? module.operations ?? module.default : module[exportName];
+  if (candidate === void 0 || typeof candidate !== "object") {
+    const named = exportName === void 0 ? "'operations' or a default export" : `'${exportName}'`;
+    throw new Error(`Module '${path}' exports no operation registry named ${named}`);
+  }
+  return candidate;
+}
+function write(path, contents) {
+  const target = resolve(path);
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, contents);
+}
+async function runCodegen(argv) {
+  const options = parseOptions(argv);
+  const modulePath = resolve(options.registry);
+  const imported = await import(pathToFileURL(modulePath).href);
+  const manifest = buildOperationManifest(readRegistry(imported, options.exportName, modulePath));
+  write(options.out, renderOperationTypes(manifest, { packageName: options.packageName }));
+  if (options.manifest !== void 0) {
+    write(options.manifest, `${JSON.stringify(manifest, null, 2)}
+`);
+  }
+}
+
+export { CODEGEN_USAGE, OPERATION_MANIFEST_VERSION, buildOperationManifest, renderOperationTypes, runCodegen, selectColumns };

package/dist/chunk-TUD5CJ76.mjs

@@ -0,0 +1,126 @@
+import { sha256Hex } from './chunk-GVCNMPOS.mjs';
+
+// src/server/operation-lookup.ts
+var DIGEST_FIELD_SEPARATOR = "\0";
+function unknownOperation(name, databaseId) {
+  return {
+    status: 404,
+    code: "UNKNOWN_QUERY",
+    message: `No operation named '${name}' is registered for database '${databaseId}'`
+  };
+}
+function ownEntry(group, key) {
+  if (group === void 0 || !Object.hasOwn(group, key)) return void 0;
+  return group[key];
+}
+function findRead(registry, databaseId, name) {
+  const operation = ownEntry(ownEntry(registry, databaseId)?.reads, name);
+  return operation ?? unknownOperation(name, databaseId);
+}
+function findWrite(registry, databaseId, name) {
+  const operation = ownEntry(ownEntry(registry, databaseId)?.writes, name);
+  return operation ?? unknownOperation(name, databaseId);
+}
+function isRefusal(value) {
+  return "status" in value && "code" in value && "message" in value;
+}
+function resolveArguments(operation, supplied, identity) {
+  const declared = operation.args ?? [];
+  const identityFields = operation.fromIdentity ?? {};
+  const resolved = {};
+  for (const name of Object.keys(supplied ?? {})) {
+    if (Object.hasOwn(identityFields, name)) {
+      return {
+        ok: false,
+        refusal: {
+          status: 400,
+          code: "ARGUMENT_NOT_ALLOWED",
+          message: `Argument '${name}' is filled from the authenticated identity and cannot be supplied by the caller`
+        }
+      };
+    }
+    if (!declared.includes(name)) {
+      return {
+        ok: false,
+        refusal: {
+          status: 400,
+          code: "ARGUMENT_NOT_ALLOWED",
+          message: `Argument '${name}' is not declared by this operation`
+        }
+      };
+    }
+  }
+  for (const name of declared) {
+    if (supplied === void 0 || !Object.hasOwn(supplied, name)) {
+      return {
+        ok: false,
+        refusal: { status: 400, code: "MISSING_ARGUMENT", message: `Argument '${name}' is required` }
+      };
+    }
+    resolved[name] = supplied[name];
+  }
+  for (const [name, field] of Object.entries(identityFields)) {
+    const source = identity;
+    const value = source === void 0 || source === null ? void 0 : source[field];
+    if (value === void 0) {
+      return {
+        ok: false,
+        refusal: {
+          status: 401,
+          code: "IDENTITY_REQUIRED",
+          message: `Argument '${name}' is filled from identity field '${String(field)}', which this request does not carry`
+        }
+      };
+    }
+    resolved[name] = value;
+  }
+  return { ok: true, value: resolved };
+}
+function createOperationSource(registry) {
+  return {
+    digest: operationRegistryDigest(registry),
+    resolve: (kind, databaseId, name, supplied, identity) => {
+      const operation = kind === "read" ? findRead(registry, databaseId, name) : findWrite(registry, databaseId, name);
+      if (isRefusal(operation)) return { ok: false, refusal: operation };
+      const args = resolveArguments(operation, supplied, identity);
+      if (!args.ok) return { ok: false, refusal: args.refusal };
+      if (kind === "read") {
+        return { ok: true, statements: [operation.statement(args.value)] };
+      }
+      const produced = operation.statements(args.value);
+      const statements = Array.isArray(produced) ? produced : [produced];
+      if (statements.length === 0) {
+        return {
+          ok: false,
+          refusal: { status: 500, code: "INTERNAL_ERROR", message: `Operation '${name}' produced no statements` }
+        };
+      }
+      return { ok: true, statements };
+    }
+  };
+}
+function operationLine(databaseId, kind, name, operation) {
+  const declared = [...operation.args ?? []].sort();
+  const identityFields = Object.keys(
+    operation.fromIdentity ?? {}
+  ).sort();
+  return [databaseId, kind, name, declared.join(","), identityFields.join(",")].join(DIGEST_FIELD_SEPARATOR);
+}
+function operationRegistryDigest(registry) {
+  if (registry === void 0) return void 0;
+  const lines = [];
+  for (const databaseId of Object.keys(registry).sort()) {
+    const operations = registry[databaseId] ?? {};
+    for (const name of Object.keys(operations.reads ?? {}).sort()) {
+      const read = operations.reads?.[name];
+      if (read) lines.push(operationLine(databaseId, "read", name, read));
+    }
+    for (const name of Object.keys(operations.writes ?? {}).sort()) {
+      const write = operations.writes?.[name];
+      if (write) lines.push(operationLine(databaseId, "write", name, write));
+    }
+  }
+  return sha256Hex(lines.join("\n"));
+}
+
+export { createOperationSource, findRead, findWrite, isRefusal, operationRegistryDigest, resolveArguments };

package/dist/{chunk-YPYVQJ4C.mjs → chunk-UC3SCMIN.mjs}

@@ -53,6 +53,14 @@ var HookDeniedError = class extends SirannonError {
     this.name = "HookDeniedError";
   }
 };
+var RequestDeniedError = class extends SirannonError {
+  status;
+  constructor(status, code, message) {
+    super(message, code);
+    this.name = "RequestDeniedError";
+    this.status = status;
+  }
+};
 var CDCError = class extends SirannonError {
   constructor(message) {
     super(message, "CDC_ERROR");
@@ -101,4 +109,4 @@ var ExtensionError = class extends SirannonError {
   }
 };
 
-export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, ForbiddenSqlError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError, WriteOverloadError };
+export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, ForbiddenSqlError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, RequestDeniedError, SirannonError, TransactionError, WriteOverloadError };