@lunora/do 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/ensureFunctionMetricsTables-UDNVD7FS.mjs

@@ -0,0 +1,248 @@
+const FUNCTION_METRICS_TABLE = "__lunora_metrics";
+const FUNCTION_METRICS_BUCKETS_TABLE = "__lunora_metrics_buckets";
+const FUNCTION_METRICS_SCANS_TABLE = "__lunora_metrics_scans";
+const FUNCTION_METRICS_INDEX_TABLE = "__lunora_metrics_index";
+const FUNCTION_METRICS_BUCKET_MS = 6e4;
+const FUNCTION_METRICS_BUCKET_RETENTION = 1440;
+const FUNCTION_METRICS_MAX_PATHS = 5e3;
+const FUNCTION_METRICS_READ_LIMIT = 1e3;
+const runSql = (sql, query, ...params) => {
+  const runner = sql.exec;
+  return runner.call(sql, query, ...params);
+};
+const bucketFloor = (ts) => Math.floor(ts / FUNCTION_METRICS_BUCKET_MS) * FUNCTION_METRICS_BUCKET_MS;
+const dedupeIndexHits = (hits) => {
+  const seen = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    seen.set(`${hit.table}\0${hit.index}`, { index: hit.index, table: hit.table });
+  }
+  return [...seen.values()];
+};
+const ensureFunctionMetricsTables = (sql) => {
+  runSql(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_TABLE}" (
+            path TEXT PRIMARY KEY,
+            calls INTEGER NOT NULL DEFAULT 0,
+            errors INTEGER NOT NULL DEFAULT 0,
+            conflicts INTEGER NOT NULL DEFAULT 0,
+            scans INTEGER NOT NULL DEFAULT 0,
+            total_duration_ms REAL NOT NULL DEFAULT 0,
+            min_duration_ms REAL,
+            max_duration_ms REAL NOT NULL DEFAULT 0,
+            last_called_at REAL NOT NULL DEFAULT 0,
+            last_error_at REAL,
+            last_error_message TEXT
+        )`
+  );
+  for (const column of ["scans", "conflicts"]) {
+    try {
+      runSql(sql, `ALTER TABLE "${FUNCTION_METRICS_TABLE}" ADD COLUMN ${column} INTEGER NOT NULL DEFAULT 0`);
+    } catch {
+    }
+  }
+  runSql(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_BUCKETS_TABLE}" (
+            path TEXT NOT NULL,
+            bucket_ms INTEGER NOT NULL,
+            calls INTEGER NOT NULL DEFAULT 0,
+            errors INTEGER NOT NULL DEFAULT 0,
+            PRIMARY KEY (path, bucket_ms)
+        )`
+  );
+  runSql(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_SCANS_TABLE}" (
+            path TEXT NOT NULL,
+            table_name TEXT NOT NULL,
+            scans INTEGER NOT NULL DEFAULT 0,
+            PRIMARY KEY (path, table_name)
+        )`
+  );
+  runSql(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_INDEX_TABLE}" (
+            table_name TEXT NOT NULL,
+            index_name TEXT NOT NULL,
+            reads INTEGER NOT NULL DEFAULT 0,
+            PRIMARY KEY (table_name, index_name)
+        )`
+  );
+};
+const recordFunctionMetric = (sql, input) => {
+  ensureFunctionMetricsTables(sql);
+  const pathCountRow = runSql(sql, `SELECT COUNT(*) AS n FROM "${FUNCTION_METRICS_TABLE}"`).one();
+  if (pathCountRow.n >= FUNCTION_METRICS_MAX_PATHS) {
+    const tracked = runSql(sql, `SELECT COUNT(*) AS c FROM "${FUNCTION_METRICS_TABLE}" WHERE path = ?`, input.path).one();
+    if (tracked.c === 0) {
+      return;
+    }
+  }
+  const scannedTables = input.scannedTables ? [...new Set(input.scannedTables)] : [];
+  const scanCount = scannedTables.length;
+  const indexHits = dedupeIndexHits(input.indexHits ?? []);
+  const errorCount = input.errored ? 1 : 0;
+  const conflictCount = input.conflicted ? 1 : 0;
+  const lastErrorAt = input.errored ? input.ts : null;
+  const lastErrorMessage = input.errored ? input.errorMessage ?? null : null;
+  runSql(
+    sql,
+    `INSERT INTO "${FUNCTION_METRICS_TABLE}"
+            (path, calls, errors, conflicts, scans, total_duration_ms, min_duration_ms, max_duration_ms, last_called_at, last_error_at, last_error_message)
+         VALUES (?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+            calls = calls + 1,
+            errors = errors + excluded.errors,
+            conflicts = conflicts + excluded.conflicts,
+            scans = scans + excluded.scans,
+            total_duration_ms = total_duration_ms + excluded.total_duration_ms,
+            min_duration_ms = MIN(COALESCE(min_duration_ms, excluded.min_duration_ms), excluded.min_duration_ms),
+            max_duration_ms = MAX(max_duration_ms, excluded.max_duration_ms),
+            last_called_at = excluded.last_called_at,
+            last_error_at = CASE WHEN excluded.last_error_at IS NULL THEN last_error_at ELSE excluded.last_error_at END,
+            last_error_message = CASE WHEN excluded.last_error_at IS NULL THEN last_error_message ELSE excluded.last_error_message END`,
+    input.path,
+    errorCount,
+    conflictCount,
+    scanCount,
+    input.durationMs,
+    input.durationMs,
+    input.durationMs,
+    input.ts,
+    lastErrorAt,
+    lastErrorMessage
+  );
+  const bucket = bucketFloor(input.ts);
+  runSql(
+    sql,
+    `INSERT INTO "${FUNCTION_METRICS_BUCKETS_TABLE}" (path, bucket_ms, calls, errors)
+         VALUES (?, ?, 1, ?)
+         ON CONFLICT(path, bucket_ms) DO UPDATE SET
+            calls = calls + 1,
+            errors = errors + excluded.errors`,
+    input.path,
+    bucket,
+    errorCount
+  );
+  runSql(
+    sql,
+    `DELETE FROM "${FUNCTION_METRICS_BUCKETS_TABLE}"
+         WHERE path = ?
+           AND bucket_ms <= (
+            SELECT MAX(bucket_ms) - ? FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" WHERE path = ?
+           )`,
+    input.path,
+    FUNCTION_METRICS_BUCKET_RETENTION * FUNCTION_METRICS_BUCKET_MS,
+    input.path
+  );
+  for (const table of scannedTables) {
+    runSql(
+      sql,
+      `INSERT INTO "${FUNCTION_METRICS_SCANS_TABLE}" (path, table_name, scans)
+             VALUES (?, ?, 1)
+             ON CONFLICT(path, table_name) DO UPDATE SET
+                scans = scans + 1`,
+      input.path,
+      table
+    );
+  }
+  for (const hit of indexHits) {
+    runSql(
+      sql,
+      `INSERT INTO "${FUNCTION_METRICS_INDEX_TABLE}" (table_name, index_name, reads)
+             VALUES (?, ?, 1)
+             ON CONFLICT(table_name, index_name) DO UPDATE SET
+                reads = reads + 1`,
+      hit.table,
+      hit.index
+    );
+  }
+};
+const readFunctionMetricScans = (sql) => {
+  ensureFunctionMetricsTables(sql);
+  const rows = runSql(
+    sql,
+    // Bounded read: cap the materialized rows so a bloated attribution table
+    // can't blow up DO memory. Highest-scan rows lead so the dominant
+    // attributions survive the cut.
+    `SELECT path, table_name, scans FROM "${FUNCTION_METRICS_SCANS_TABLE}" ORDER BY scans DESC, path ASC, table_name ASC LIMIT ${String(FUNCTION_METRICS_READ_LIMIT)}`
+  ).toArray();
+  const byPath = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const list = byPath.get(row.path);
+    const entry = { scans: row.scans, table: row.table_name };
+    if (list === void 0) {
+      byPath.set(row.path, [entry]);
+    } else {
+      list.push(entry);
+    }
+  }
+  return byPath;
+};
+const readFunctionMetricIndexHits = (sql) => {
+  ensureFunctionMetricsTables(sql);
+  const rows = runSql(
+    sql,
+    `SELECT table_name, index_name, reads FROM "${FUNCTION_METRICS_INDEX_TABLE}" ORDER BY table_name ASC, index_name ASC`
+  ).toArray();
+  return rows.map((row) => {
+    return { index: row.index_name, reads: row.reads, table: row.table_name };
+  });
+};
+const mergeScanAttribution = (into, scanned) => {
+  for (const table of scanned) {
+    const entry = into.find((attribution) => attribution.table === table);
+    if (entry === void 0) {
+      into.push({ scans: 1, table });
+    } else {
+      entry.scans += 1;
+    }
+  }
+  into.sort((a, b) => b.scans - a.scans || a.table.localeCompare(b.table));
+  return into;
+};
+const readFunctionMetrics = (sql) => {
+  ensureFunctionMetricsTables(sql);
+  const scansByPath = readFunctionMetricScans(sql);
+  const rows = runSql(sql, `SELECT * FROM "${FUNCTION_METRICS_TABLE}" ORDER BY last_called_at DESC LIMIT ${String(FUNCTION_METRICS_READ_LIMIT)}`).toArray();
+  return rows.map((row) => {
+    return {
+      calls: row.calls,
+      conflicts: row.conflicts,
+      errors: row.errors,
+      lastCalledAt: row.last_called_at,
+      lastErrorAt: row.last_error_at,
+      lastErrorMessage: row.last_error_message,
+      maxDurationMs: row.max_duration_ms,
+      path: row.path,
+      scannedTables: scansByPath.get(row.path) ?? [],
+      scans: row.scans,
+      totalDurationMs: row.total_duration_ms
+    };
+  });
+};
+const readFunctionMetricBuckets = (sql, path) => {
+  ensureFunctionMetricsTables(sql);
+  const rows = path === void 0 ? runSql(
+    sql,
+    `SELECT path, bucket_ms, calls, errors FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" ORDER BY bucket_ms ASC, path ASC`
+  ).toArray() : runSql(
+    sql,
+    `SELECT path, bucket_ms, calls, errors FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" WHERE path = ? ORDER BY bucket_ms ASC`,
+    path
+  ).toArray();
+  return rows.map((row) => {
+    return { bucketMs: row.bucket_ms, calls: row.calls, errors: row.errors, path: row.path };
+  });
+};
+const readFunctionMetricsTotals = (sql) => {
+  ensureFunctionMetricsTables(sql);
+  const row = runSql(
+    sql,
+    `SELECT SUM(calls) AS requests, SUM(errors) AS errors FROM "${FUNCTION_METRICS_TABLE}"`
+  ).one();
+  return { errors: row.errors ?? 0, requests: row.requests ?? 0 };
+};
+
+export { FUNCTION_METRICS_BUCKETS_TABLE, FUNCTION_METRICS_BUCKET_MS, FUNCTION_METRICS_BUCKET_RETENTION, FUNCTION_METRICS_INDEX_TABLE, FUNCTION_METRICS_MAX_PATHS, FUNCTION_METRICS_READ_LIMIT, FUNCTION_METRICS_SCANS_TABLE, FUNCTION_METRICS_TABLE, ensureFunctionMetricsTables, mergeScanAttribution, readFunctionMetricBuckets, readFunctionMetricIndexHits, readFunctionMetricScans, readFunctionMetrics, readFunctionMetricsTotals, recordFunctionMetric };

package/dist/packem_shared/exportShardRows-DZEhUeyI.mjs

@@ -0,0 +1,156 @@
+const DEFAULT_BATCH_SIZE = 200;
+const selectExportTables = (schema, requested) => {
+  const isShardLocal = (table) => {
+    const definition = schema.tables[table];
+    if (!definition) {
+      return false;
+    }
+    return definition.shardMode?.kind !== "global";
+  };
+  if (requested && requested.length > 0) {
+    const filtered = [];
+    for (const name of requested) {
+      if (isShardLocal(name)) {
+        filtered.push(name);
+      }
+    }
+    return filtered;
+  }
+  const result = [];
+  for (const name of Object.keys(schema.tables)) {
+    if (isShardLocal(name)) {
+      result.push(name);
+    }
+  }
+  return result;
+};
+const exportShardTable = async function* (writer, table, batchSize = DEFAULT_BATCH_SIZE) {
+  let cursor = null;
+  let done = false;
+  while (!done) {
+    const page = await writer.findMany(table, { cursor, limit: batchSize });
+    for (const record of page.page) {
+      yield { doc: record, table };
+    }
+    cursor = page.continueCursor;
+    done = page.isDone || cursor === null;
+  }
+};
+const exportShardRows = async function* (writer, schema, args) {
+  const tables = selectExportTables(schema, args.tables);
+  const batchSize = args.batchSize ?? DEFAULT_BATCH_SIZE;
+  for (const table of tables) {
+    yield* exportShardTable(writer, table, batchSize);
+  }
+};
+const FRAMEWORK_FIELDS = /* @__PURE__ */ new Set(["_creationTime", "_id"]);
+const validateAgainstShape = (definition, payload) => {
+  for (const [field, validator] of Object.entries(definition.shape)) {
+    const candidate = payload[field];
+    if (candidate === void 0 && validator.kind === "optional") {
+      continue;
+    }
+    const parser = validator.parse;
+    if (typeof parser !== "function") {
+      continue;
+    }
+    try {
+      parser(candidate);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `field "${field}": ${message}`;
+    }
+  }
+  return void 0;
+};
+const validateImportRow = (schema, table, record) => {
+  const definition = schema.tables[table];
+  if (!definition) {
+    return `unknown table: ${table}`;
+  }
+  if (definition.shardMode?.kind === "global") {
+    return `table "${table}" is a global (.global()) table and is not importable through the shard import path`;
+  }
+  const payload = Object.fromEntries(Object.entries(record).filter(([key]) => !FRAMEWORK_FIELDS.has(key)));
+  for (const key of Object.keys(payload)) {
+    if (!(key in definition.shape)) {
+      return `unexpected field "${key}": not declared in table "${table}"`;
+    }
+  }
+  return validateAgainstShape(definition, payload);
+};
+const idAlreadyExists = async (writer, explicitId) => {
+  try {
+    const existing = await writer.get(explicitId);
+    return existing !== null;
+  } catch {
+    return false;
+  }
+};
+const importOneRow = async (writer, schema, row, line) => {
+  const { doc, table } = row;
+  if (typeof table !== "string" || table.length === 0) {
+    return { error: { code: "BAD_ROW", line, message: "row is missing `table`", table }, kind: "error" };
+  }
+  if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+    return { error: { code: "BAD_ROW", line, message: "row is missing or malformed `doc`", table }, kind: "error" };
+  }
+  const failure = validateImportRow(schema, table, doc);
+  if (failure !== void 0) {
+    return { error: { code: "VALIDATION_ERROR", line, message: failure, table }, kind: "error" };
+  }
+  const explicitId = typeof doc["_id"] === "string" ? doc["_id"] : void 0;
+  if (explicitId !== void 0 && await idAlreadyExists(writer, explicitId)) {
+    return { kind: "conflict" };
+  }
+  try {
+    await writer.insert(table, doc, { allowExplicitId: true });
+    return { kind: "inserted", table };
+  } catch (error) {
+    const code = error.code ?? "INSERT_FAILED";
+    const message = error instanceof Error ? error.message : String(error);
+    return { error: { code, line, message, table }, kind: "error" };
+  }
+};
+const importShardRows = async (writer, schema, args) => {
+  const errors = [];
+  const inserted = {};
+  let conflicts = 0;
+  let line = (args.startLine ?? 1) - 1;
+  for (const row of args.rows) {
+    line += 1;
+    const outcome = await importOneRow(writer, schema, row, line);
+    if (outcome.kind === "error") {
+      errors.push(outcome.error);
+    } else if (outcome.kind === "conflict") {
+      conflicts += 1;
+    } else {
+      inserted[outcome.table] = (inserted[outcome.table] ?? 0) + 1;
+    }
+  }
+  return { conflicts, errors, inserted };
+};
+const parseExportShardArgs = (args) => {
+  const tables = Array.isArray(args["tables"]) ? args["tables"].filter((entry) => typeof entry === "string") : void 0;
+  const batchSize = typeof args["batchSize"] === "number" ? args["batchSize"] : void 0;
+  return { batchSize, tables };
+};
+const parseImportShardArgs = (args) => {
+  const rawRows = Array.isArray(args["rows"]) ? args["rows"] : [];
+  const rows = [];
+  for (const entry of rawRows) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const candidate = entry;
+    if (typeof candidate.table !== "string" || !candidate.doc || typeof candidate.doc !== "object" || Array.isArray(candidate.doc)) {
+      rows.push({ doc: candidate.doc ?? {}, table: typeof candidate.table === "string" ? candidate.table : "" });
+      continue;
+    }
+    rows.push({ doc: candidate.doc, table: candidate.table });
+  }
+  const startLine = typeof args["startLine"] === "number" ? args["startLine"] : void 0;
+  return { rows, startLine };
+};
+
+export { exportShardRows, exportShardTable, importShardRows, parseExportShardArgs, parseImportShardArgs, selectExportTables, validateImportRow };

package/dist/packem_shared/ftsTableName-BLEMawrp.mjs

@@ -0,0 +1,38 @@
+const ftsTableName = (table, indexName) => `${table}__fts_${indexName}`;
+const tokenizeSearch = (query) => query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+const buildFtsMatch = (tokens) => tokens.map((token, index) => index === tokens.length - 1 ? `"${token}"*` : `"${token}"`).join(" AND ");
+const stringifySearchText = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value) ?? "";
+};
+const scoreDocument = (text, tokens) => {
+  const documentTokens = tokenizeSearch(text);
+  if (documentTokens.length === 0) {
+    return 0;
+  }
+  let score = 0;
+  for (const [index, token] of tokens.entries()) {
+    const isLast = index === tokens.length - 1;
+    let occurrences = 0;
+    for (const documentToken of documentTokens) {
+      if (isLast ? documentToken.startsWith(token) : documentToken === token) {
+        occurrences += 1;
+      }
+    }
+    if (occurrences === 0) {
+      return 0;
+    }
+    score += occurrences;
+  }
+  return score;
+};
+
+export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch };

package/dist/packem_shared/guardWriter-u3UlnCH5.mjs

@@ -0,0 +1,128 @@
+const RLS_UNWRAP_SYMBOL = /* @__PURE__ */ Symbol.for("lunora.ctxdb.rls-unwrap");
+class RlsRequiredError extends Error {
+  code = "RLS_REQUIRED";
+  status = 403;
+  table;
+  constructor(table) {
+    super(
+      `ctx.db access to "${table}" is denied: the schema is marked .rls("required"), so this table is protected. Apply RLS with .use(rls(policies)) in the procedure, or mark the table .public() to opt it out.`
+    );
+    this.name = "RlsRequiredError";
+    this.table = table;
+  }
+}
+const guardWriter = (raw, schema, tableOfId) => {
+  if (schema.rlsMode !== "required") {
+    return raw;
+  }
+  const base = raw;
+  const isProtected = (tableName) => {
+    const definition = schema.tables[tableName];
+    return definition !== void 0 && definition.isPublic !== true;
+  };
+  const guardTable = (tableName) => {
+    if (isProtected(tableName)) {
+      throw new RlsRequiredError(tableName);
+    }
+  };
+  const guardById = async (id, expectedTable) => {
+    if (expectedTable !== void 0) {
+      guardTable(expectedTable);
+      return;
+    }
+    const tableName = await tableOfId(id);
+    if (tableName !== void 0) {
+      guardTable(tableName);
+    }
+  };
+  const baseRankBefore = base.rankBefore;
+  const guarded = {
+    ...raw,
+    [RLS_UNWRAP_SYMBOL]: raw,
+    aggregate: (tableName, options) => {
+      guardTable(tableName);
+      return base.aggregate(tableName, options);
+    },
+    count: (tableName, whereOrArgs) => {
+      guardTable(tableName);
+      return base.count(tableName, whereOrArgs);
+    },
+    delete: async (id, expectedTable) => {
+      await guardById(id, expectedTable);
+      return base.delete(id, expectedTable);
+    },
+    deleteMany: async (ids, options, expectedTable) => {
+      for (const id of ids) {
+        await guardById(id, expectedTable);
+      }
+      return base.deleteMany(ids, options, expectedTable);
+    },
+    findFirst: (tableName, args) => {
+      guardTable(tableName);
+      return base.findFirst(tableName, args);
+    },
+    findFirstOrThrow: (tableName, args) => {
+      guardTable(tableName);
+      return base.findFirstOrThrow(tableName, args);
+    },
+    findMany: (tableName, args) => {
+      guardTable(tableName);
+      return base.findMany(tableName, args);
+    },
+    get: async (id, expectedTable) => {
+      await guardById(id, expectedTable);
+      return base.get(id, expectedTable);
+    },
+    groupBy: (tableName, options) => {
+      guardTable(tableName);
+      return base.groupBy(tableName, options);
+    },
+    insert: (tableName, document, options) => {
+      guardTable(tableName);
+      return base.insert(tableName, document, options);
+    },
+    insertMany: (tableName, documents, options) => {
+      guardTable(tableName);
+      return base.insertMany(tableName, documents, options);
+    },
+    insertManyUnsafe: (tableName, documents, options) => {
+      guardTable(tableName);
+      return base.insertManyUnsafe(tableName, documents, options);
+    },
+    patch: async (id, patch, expectedTable) => {
+      await guardById(id, expectedTable);
+      return base.patch(id, patch, expectedTable);
+    },
+    patchMany: async (patches, options, expectedTable) => {
+      for (const entry of patches) {
+        await guardById(entry.id, expectedTable);
+      }
+      return base.patchMany(patches, options, expectedTable);
+    },
+    query: (tableName) => {
+      guardTable(tableName);
+      return base.query(tableName);
+    },
+    rank: (tableName, indexName, options) => {
+      guardTable(tableName);
+      return base.rank(tableName, indexName, options);
+    },
+    rankPage: (tableName, indexName, options) => {
+      guardTable(tableName);
+      return base.rankPage(tableName, indexName, options);
+    },
+    replace: async (id, document, expectedTable) => {
+      await guardById(id, expectedTable);
+      return base.replace(id, document, expectedTable);
+    }
+  };
+  if (baseRankBefore) {
+    guarded["rankBefore"] = (tableName, indexName, options) => {
+      guardTable(tableName);
+      return baseRankBefore(tableName, indexName, options);
+    };
+  }
+  return guarded;
+};
+
+export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter };

package/dist/packem_shared/matchesStaticWhere-CFk6adSu.mjs

@@ -0,0 +1,54 @@
+const COUNT_OPTION_KEYS = /* @__PURE__ */ new Set(["baseWhere", "relationBaseWhere", "restrictsCounts", "where"]);
+const matchesStaticWhere = (document, predicate) => {
+  for (const [field, expected] of Object.entries(predicate)) {
+    const actual = document[field];
+    if (expected !== null && typeof expected === "object" && !Array.isArray(expected)) {
+      const operatorKeys = Object.keys(expected);
+      if (operatorKeys.length === 1 && operatorKeys[0] === "eq") {
+        if (actual !== expected.eq) {
+          return false;
+        }
+        continue;
+      }
+      return false;
+    }
+    if (actual !== expected) {
+      return false;
+    }
+  }
+  return true;
+};
+const normalizeCountArgument = (argument) => {
+  if (argument === void 0) {
+    return {};
+  }
+  if (typeof argument !== "object" || Array.isArray(argument)) {
+    return { where: argument };
+  }
+  const keys = Object.keys(argument);
+  if (keys.length === 0) {
+    return {};
+  }
+  if (keys.every((key) => COUNT_OPTION_KEYS.has(key))) {
+    return argument;
+  }
+  return { where: argument };
+};
+const AGGREGATE_SQL_FUNCTION = { avg: "AVG", count: "COUNT", max: "MAX", min: "MIN", sum: "SUM" };
+const aggregateSqlFunction = (op) => {
+  const sqlFunction = AGGREGATE_SQL_FUNCTION[op];
+  if (sqlFunction === void 0) {
+    throw new Error(`unknown aggregate op "${op}": expected one of ${Object.keys(AGGREGATE_SQL_FUNCTION).join(", ")}`);
+  }
+  return sqlFunction;
+};
+const throwingScheduler = {
+  runAfter: () => {
+    throw new Error("ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
+  },
+  runAt: () => {
+    throw new Error("ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
+  }
+};
+
+export { AGGREGATE_SQL_FUNCTION, aggregateSqlFunction, matchesStaticWhere, normalizeCountArgument, throwingScheduler };