@lunora/do 1.0.0-alpha.44 → 1.0.0-alpha.45

package/dist/packem_shared/ConflictError-CLoq37xH.mjs

@@ -1,12 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-class ConflictError extends LunoraError {
-  /** Why the conflict fired; `occ` is the contention signal the metrics layer counts. */
-  kind;
-  constructor(message = "Optimistic concurrency conflict", kind = "conflict") {
-    super("CONFLICT", message, { name: "ConflictError" });
-    this.kind = kind;
-  }
-}
-
-export { ConflictError };

package/dist/packem_shared/CountRlsUnsupportedError-BGxj0pgS.mjs

@@ -1,133 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-class CountRlsUnsupportedError extends LunoraError {
-  constructor(table) {
-    super(
-      "COUNT_RLS_UNSUPPORTED",
-      table === void 0 ? "count() is not supported in an RLS-restricted context" : `count() is not supported on table "${table}" inside an RLS-restricted context`
-    );
-  }
-}
-const mergeWhere = (left, right) => {
-  if (!left) {
-    return right;
-  }
-  if (!right) {
-    return left;
-  }
-  return { AND: [left, right] };
-};
-const BOOLEAN_COMBINATORS = /* @__PURE__ */ new Set(["AND", "NOT", "OR"]);
-const NOT_EQ = /* @__PURE__ */ Symbol("not-eq");
-const resolveEqValue = (value) => {
-  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-    const operatorKeys = Object.keys(value);
-    if (operatorKeys.length === 1 && operatorKeys[0] === "eq") {
-      return value.eq;
-    }
-    return NOT_EQ;
-  }
-  return value;
-};
-const parseRequestedEqKeys = (requested, accept) => {
-  const resolved = {};
-  for (const [key, raw] of Object.entries(requested)) {
-    if (BOOLEAN_COMBINATORS.has(key) || !accept(key)) {
-      return void 0;
-    }
-    const value = resolveEqValue(raw);
-    if (value === NOT_EQ) {
-      return void 0;
-    }
-    resolved[key] = value;
-  }
-  return resolved;
-};
-const reconcileStaticWhere = (staticWhere, resolved, requested, crossCheckRequested) => {
-  const merged = { ...resolved };
-  if (!staticWhere) {
-    return merged;
-  }
-  for (const [key, value] of Object.entries(staticWhere)) {
-    if (key in merged) {
-      if (merged[key] !== value) {
-        return void 0;
-      }
-    } else if (crossCheckRequested && key in requested) {
-      if (requested[key] !== value) {
-        return void 0;
-      }
-    } else {
-      merged[key] = value;
-    }
-  }
-  return merged;
-};
-const planAggregateLookup = (index, requestedWhere) => {
-  const by = index.by ?? [];
-  const requested = requestedWhere ?? {};
-  const resolved = parseRequestedEqKeys(requested, (key) => by.includes(key));
-  if (resolved === void 0) {
-    return void 0;
-  }
-  for (const key of by) {
-    if (!(key in resolved)) {
-      return void 0;
-    }
-  }
-  return reconcileStaticWhere(index.where, resolved, requested, true);
-};
-const collectPartialKey = (index, requestedWhere, byFields) => {
-  const partial = parseRequestedEqKeys(requestedWhere ?? {}, (key) => byFields.has(key));
-  if (partial === void 0) {
-    return void 0;
-  }
-  return reconcileStaticWhere(index.where, partial, {}, false);
-};
-const selectIndexForReducer = (indexes, op, field, requestedWhere) => {
-  let best;
-  for (const index of indexes) {
-    if (index.op !== op) {
-      continue;
-    }
-    if (op !== "count" && index.field !== field) {
-      continue;
-    }
-    const key = planAggregateLookup(index, requestedWhere);
-    if (!key) {
-      continue;
-    }
-    if (!best || (index.by?.length ?? 0) > (best.index.by?.length ?? 0)) {
-      best = { index, key };
-    }
-  }
-  return best;
-};
-const selectIndexForCount = (indexes, requestedWhere) => selectIndexForReducer(indexes, "count", void 0, requestedWhere);
-const selectIndexForAggregate = (indexes, op, field, requestedWhere) => selectIndexForReducer(indexes, op, field, requestedWhere);
-const selectIndexForGroupBy = (indexes, op, field, by, requestedWhere) => {
-  const requestedFields = new Set(by);
-  for (const index of indexes) {
-    if (index.op !== op) {
-      continue;
-    }
-    if (op !== "count" && index.field !== field) {
-      continue;
-    }
-    const indexBy = index.by ?? [];
-    if (indexBy.length !== requestedFields.size) {
-      continue;
-    }
-    if (!indexBy.every((key) => requestedFields.has(key))) {
-      continue;
-    }
-    const partial = collectPartialKey(index, requestedWhere, requestedFields);
-    if (partial === void 0) {
-      continue;
-    }
-    return { index, partial };
-  }
-  return void 0;
-};
-
-export { CountRlsUnsupportedError, mergeWhere, planAggregateLookup, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy };

package/dist/packem_shared/DATA_MIGRATION_STATE_TABLE-CYwBpyTr.mjs

@@ -1,245 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const DATA_MIGRATION_STATE_TABLE = "__lunora_migrations";
-const DEFAULT_BATCH_SIZE = 100;
-const STALE_CLAIM_TIMEOUT_MS = 3e4;
-const CLAIM_HEARTBEAT_INTERVAL_MS = 1e4;
-const runSql = (sql, query, ...params) => {
-  const runner = sql.exec;
-  return runner.call(sql, query, ...params);
-};
-const ensureStateTable = (sql) => {
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${DATA_MIGRATION_STATE_TABLE}" (
-            id TEXT PRIMARY KEY,
-            direction TEXT NOT NULL,
-            status TEXT NOT NULL,
-            cursor TEXT,
-            processed INTEGER NOT NULL DEFAULT 0,
-            changed INTEGER NOT NULL DEFAULT 0,
-            started_at REAL,
-            updated_at REAL,
-            error TEXT
-        )`
-  );
-};
-const readState = (sql, id) => {
-  const rows = runSql(sql, `SELECT * FROM "${DATA_MIGRATION_STATE_TABLE}" WHERE id = ?`, id).toArray();
-  const row = rows[0];
-  if (!row) {
-    return void 0;
-  }
-  return {
-    changed: row.changed,
-    // eslint-disable-next-line unicorn/no-null -- mirrors the SQLite `cursor` column: a missing cursor is NULL, not undefined
-    cursor: typeof row.cursor === "string" ? row.cursor : null,
-    direction: row.direction === "down" ? "down" : "up",
-    processed: row.processed,
-    startedAt: typeof row.started_at === "number" ? row.started_at : void 0,
-    status: row.status === "completed" || row.status === "failed" ? row.status : "in_progress"
-  };
-};
-const deleteState = (sql, id) => {
-  runSql(sql, `DELETE FROM "${DATA_MIGRATION_STATE_TABLE}" WHERE id = ?`, id);
-};
-const persistState = (sql, state) => {
-  runSql(
-    sql,
-    `INSERT INTO "${DATA_MIGRATION_STATE_TABLE}"
-            (id, direction, status, cursor, processed, changed, started_at, updated_at, error)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(id) DO UPDATE SET
-            direction = excluded.direction,
-            status = excluded.status,
-            cursor = excluded.cursor,
-            processed = excluded.processed,
-            changed = excluded.changed,
-            updated_at = excluded.updated_at,
-            error = excluded.error`,
-    state.id,
-    state.direction,
-    state.status,
-    state.cursor,
-    state.processed,
-    state.changed,
-    state.startedAt,
-    state.updatedAt,
-    state.error
-  );
-};
-const claimMigration = (sql, id, direction, now) => {
-  runSql(
-    sql,
-    `INSERT INTO "${DATA_MIGRATION_STATE_TABLE}"
-            (id, direction, status, cursor, processed, changed, started_at, updated_at, error)
-         VALUES (?, ?, 'in_progress', NULL, 0, 0, ?, ?, NULL)
-         ON CONFLICT(id) DO UPDATE SET
-            status = 'in_progress',
-            updated_at = excluded.updated_at
-         WHERE
-            "${DATA_MIGRATION_STATE_TABLE}".direction <> excluded.direction
-            OR "${DATA_MIGRATION_STATE_TABLE}".status <> 'in_progress'
-            OR "${DATA_MIGRATION_STATE_TABLE}".updated_at IS NULL
-            OR "${DATA_MIGRATION_STATE_TABLE}".updated_at <= excluded.updated_at - ${String(STALE_CLAIM_TIMEOUT_MS)}`,
-    id,
-    direction,
-    now,
-    now
-  );
-  return runSql(sql, `SELECT changes() AS changed`).one().changed > 0;
-};
-const releaseClaim = (sql, id) => {
-  runSql(sql, `UPDATE "${DATA_MIGRATION_STATE_TABLE}" SET updated_at = 0 WHERE id = ? AND status = 'in_progress'`, id);
-};
-const touchClaim = (sql, id, now) => {
-  runSql(sql, `UPDATE "${DATA_MIGRATION_STATE_TABLE}" SET updated_at = ? WHERE id = ? AND status = 'in_progress'`, now, id);
-};
-const readMigrationStatus = (sql, id) => {
-  const exists = runSql(
-    sql,
-    `SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1`,
-    DATA_MIGRATION_STATE_TABLE
-  ).toArray();
-  if (exists.length === 0) {
-    return [];
-  }
-  const filter = id === void 0 ? " ORDER BY id" : " WHERE id = ?";
-  const params = id === void 0 ? [] : [id];
-  const rows = runSql(sql, `SELECT * FROM "${DATA_MIGRATION_STATE_TABLE}"${filter}`, ...params).toArray();
-  return rows.map((row) => {
-    return {
-      changed: row.changed,
-      cursor: typeof row.cursor === "string" ? row.cursor : null,
-      direction: row.direction === "down" ? "down" : "up",
-      error: typeof row.error === "string" ? row.error : null,
-      id: row.id,
-      processed: row.processed,
-      startedAt: typeof row.started_at === "number" ? row.started_at : null,
-      status: row.status === "completed" || row.status === "failed" ? row.status : "in_progress",
-      updatedAt: typeof row.updated_at === "number" ? row.updated_at : null
-    };
-  });
-};
-const runDataMigration = async (options) => {
-  const { migration, sql, writer } = options;
-  const direction = options.direction ?? "up";
-  const dryRun = options.dryRun ?? false;
-  const clock = options.clock ?? (() => Date.now());
-  const maxBatches = options.maxBatches ?? Number.POSITIVE_INFINITY;
-  const batchSize = options.batchSize ?? migration.batchSize ?? DEFAULT_BATCH_SIZE;
-  const transform = direction === "up" ? migration.up : migration.down;
-  if (!transform) {
-    throw new LunoraError("INTERNAL", `data migration "${migration.id}" has no \`${direction}\` transform`);
-  }
-  let cursor = null;
-  let processed = 0;
-  let changed = 0;
-  let startedAt = clock();
-  if (!dryRun) {
-    ensureStateTable(sql);
-    const existing = readState(sql, migration.id);
-    if (existing?.direction === direction && existing.status === "completed") {
-      return { changed: existing.changed, cursor: null, direction, dryRun, id: migration.id, processed: existing.processed, status: "completed" };
-    }
-    if (existing && existing.direction !== direction) {
-      deleteState(sql, migration.id);
-    }
-    const claimed = claimMigration(sql, migration.id, direction, clock());
-    if (!claimed) {
-      const active = readState(sql, migration.id);
-      return {
-        changed: active?.changed ?? 0,
-        cursor: active?.cursor ?? cursor,
-        direction,
-        dryRun,
-        id: migration.id,
-        processed: active?.processed ?? 0,
-        status: active?.status ?? "in_progress"
-      };
-    }
-    const resume = existing?.direction === direction ? existing : void 0;
-    if (resume) {
-      cursor = resume.cursor;
-      processed = resume.processed;
-      changed = resume.changed;
-      startedAt = resume.startedAt ?? startedAt;
-    }
-  }
-  let isDone = false;
-  let batches = 0;
-  let lastHeartbeatAt = startedAt;
-  try {
-    while (!isDone && batches < maxBatches) {
-      const batch = await writer.findMany(migration.table, { cursor, limit: batchSize });
-      for (const document of batch.page) {
-        processed += 1;
-        const next = transform(document);
-        if (next !== void 0) {
-          changed += 1;
-          if (!dryRun) {
-            await writer.replace(String(document["_id"]), { ...next, _creationTime: document["_creationTime"], _id: document["_id"] }, void 0, {
-              allowExplicitId: true
-            });
-          }
-        }
-        if (!dryRun) {
-          const now = clock();
-          if (now - lastHeartbeatAt >= CLAIM_HEARTBEAT_INTERVAL_MS) {
-            touchClaim(sql, migration.id, now);
-            lastHeartbeatAt = now;
-          }
-        }
-      }
-      cursor = batch.continueCursor;
-      isDone = batch.isDone;
-      batches += 1;
-      if (!dryRun) {
-        const batchEndedAt = clock();
-        persistState(sql, {
-          changed,
-          // eslint-disable-next-line unicorn/no-null -- bound to the SQLite cursor column: a finished run stores NULL
-          cursor: isDone ? null : cursor,
-          direction,
-          // eslint-disable-next-line unicorn/no-null -- bound to the SQLite error column: a clean batch stores NULL
-          error: null,
-          id: migration.id,
-          processed,
-          startedAt,
-          status: isDone ? "completed" : "in_progress",
-          updatedAt: batchEndedAt
-        });
-        lastHeartbeatAt = batchEndedAt;
-        try {
-          await options.onBatch?.({ batches, changed, processed });
-        } catch {
-        }
-      }
-    }
-  } catch (error) {
-    if (!dryRun) {
-      persistState(sql, {
-        changed,
-        cursor,
-        direction,
-        error: error instanceof Error ? error.message : String(error),
-        id: migration.id,
-        processed,
-        startedAt,
-        status: "failed",
-        updatedAt: clock()
-      });
-    }
-    throw error;
-  }
-  if (!dryRun && !isDone) {
-    try {
-      releaseClaim(sql, migration.id);
-    } catch (error) {
-      console.warn(`data migration "${migration.id}": releaseClaim failed`, error);
-    }
-  }
-  return { changed, cursor: isDone ? null : cursor, direction, dryRun, id: migration.id, processed, status: isDone ? "completed" : "in_progress" };
-};
-
-export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration };

package/dist/packem_shared/DEFAULT_MAX_RELATION_KEYS-BEan1CRD.mjs

@@ -1,211 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { distinctValues } from './applyOnDelete-BXSq3S70.mjs';
-
-const RELATION_EXISTS_KEY = "__relationExists";
-
-const RELATION_OPERATOR_META = {
-  every: { kind: "many", negateChild: true, negated: true },
-  is: { kind: "one", negated: false },
-  isNot: { kind: "one", negated: true, nullDisjunct: true },
-  none: { kind: "many", negated: true },
-  some: { kind: "many", negated: false }
-};
-const RELATION_OPERATORS = new Set(Object.keys(RELATION_OPERATOR_META));
-const joinColumns = (relation) => relation.kind === "one" ? { clause: relation.field, project: relation.references } : { clause: relation.references, project: relation.field };
-const DEFAULT_MAX_RELATION_KEYS = 5e3;
-const KEY_OVERFLOW = /* @__PURE__ */ Symbol("relation-key-overflow");
-const branchesOf = (value) => Array.isArray(value) ? value.map((branch) => branch ?? {}) : [];
-const combineAnd = (clauses) => {
-  if (clauses.length === 1) {
-    const [only] = clauses;
-    return only ?? {};
-  }
-  return clauses.length === 0 ? {} : { AND: clauses };
-};
-const isRelationPredicate = (value) => {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const keys = Object.keys(value);
-  return keys.length > 0 && keys.every((key) => RELATION_OPERATORS.has(key));
-};
-const containsRelationPredicate = (where, schema, tableName) => {
-  const relationMap = schema.tables[tableName]?.relationMap ?? {};
-  return Object.keys(where).some((key) => {
-    const value = where[key];
-    if (key === "AND" || key === "OR") {
-      return branchesOf(value).some((branch) => containsRelationPredicate(branch, schema, tableName));
-    }
-    if (key === "NOT") {
-      return containsRelationPredicate(value ?? {}, schema, tableName);
-    }
-    return Boolean(relationMap[key]) && isRelationPredicate(value);
-  });
-};
-const assertFlatPredicate = (where, schema, tableName, op) => {
-  if (where && containsRelationPredicate(where, schema, tableName)) {
-    throw new LunoraError("INTERNAL", `relation-crossing predicates are not supported in ${op}() — use them in findMany/findFirst or an RLS read policy`);
-  }
-};
-const projectChildKeys = async (relation, childWhere, projectField, context, escalatable) => {
-  const resolvedChildWhere = await resolveForTable(childWhere, relation.table, context);
-  const { page } = await context.fetcher(relation.table, {
-    baseWhere: context.relationBaseWhere?.(relation.table),
-    relationBaseWhere: context.relationBaseWhere,
-    where: resolvedChildWhere
-  });
-  const keys = distinctValues(page, projectField);
-  if (keys.length > context.maxRelationKeys) {
-    if (escalatable) {
-      return KEY_OVERFLOW;
-    }
-    throw new LunoraError(
-      "INTERNAL",
-      `relation predicate on "${relation.table}" matched ${String(keys.length)} rows, exceeding the ${String(context.maxRelationKeys)}-key limit; narrow the predicate (a same-shard EXISTS push-down lifts this cap)`
-    );
-  }
-  return keys;
-};
-const compileOperator = async (operator, relation, childWhere, context, escalatable) => {
-  const meta = RELATION_OPERATOR_META[operator];
-  if (!meta) {
-    throw new LunoraError("INTERNAL", `unknown relation operator "${operator}"`);
-  }
-  const { clause, project } = joinColumns(relation);
-  const keys = await projectChildKeys(relation, meta.negateChild ? { NOT: childWhere } : childWhere, project, context, escalatable);
-  if (keys === KEY_OVERFLOW) {
-    return KEY_OVERFLOW;
-  }
-  if (!meta.negated) {
-    return { [clause]: { in: keys } };
-  }
-  if (meta.nullDisjunct) {
-    return { OR: [{ [clause]: { notIn: keys } }, { [clause]: { isNull: true } }] };
-  }
-  return { [clause]: { notIn: keys } };
-};
-const buildExistsMarker = async (operator, relation, childWhere, parentTable, context) => {
-  const meta = RELATION_OPERATOR_META[operator];
-  if (!meta) {
-    throw new LunoraError("INTERNAL", `unknown relation operator "${operator}"`);
-  }
-  const base = context.relationBaseWhere?.(relation.table);
-  const predicatePart = meta.negateChild ? { NOT: childWhere } : childWhere;
-  const merged = base ? { AND: [base, predicatePart] } : predicatePart;
-  const resolvedChild = await resolveForTable(merged, relation.table, context);
-  const marker = { childWhere: resolvedChild, negated: meta.negated, parentTable, relation };
-  return { [RELATION_EXISTS_KEY]: marker };
-};
-const assertCardinality = (operator, name, relation) => {
-  const meta = RELATION_OPERATOR_META[operator];
-  if (meta && meta.kind !== relation.kind) {
-    throw new LunoraError("INTERNAL", `relation operator "${operator}" requires a to-${meta.kind} relation, but "${name}" is to-${relation.kind}`);
-  }
-};
-const resolveRelationNode = async (name, relation, predicate, parentTable, context) => {
-  const clauses = [];
-  for (const operator of Object.keys(predicate)) {
-    assertCardinality(operator, name, relation);
-    const childWhere = predicate[operator] ?? {};
-    const pushable = context.canPushExists?.(relation) ?? false;
-    if (pushable && context.existsPushMode === "always") {
-      clauses.push(await buildExistsMarker(operator, relation, childWhere, parentTable, context));
-      continue;
-    }
-    const semijoin = await compileOperator(operator, relation, childWhere, context, pushable);
-    if (semijoin === KEY_OVERFLOW) {
-      clauses.push(await buildExistsMarker(operator, relation, childWhere, parentTable, context));
-    } else {
-      clauses.push(semijoin);
-    }
-  }
-  return combineAnd(clauses);
-};
-const resolveKey = async (key, value, tableName, context) => {
-  if (key === "AND" || key === "OR") {
-    const resolved = [];
-    for (const branch of branchesOf(value)) {
-      resolved.push(await resolveForTable(branch, tableName, context));
-    }
-    return { [key]: resolved };
-  }
-  if (key === "NOT") {
-    return { NOT: await resolveForTable(value ?? {}, tableName, context) };
-  }
-  const relation = context.schema.tables[tableName]?.relationMap?.[key];
-  if (relation && isRelationPredicate(value)) {
-    return resolveRelationNode(key, relation, value, tableName, context);
-  }
-  return { [key]: value };
-};
-const resolveForTable = async (where, tableName, context) => {
-  const clauses = [];
-  for (const key of Object.keys(where)) {
-    clauses.push(await resolveKey(key, where[key], tableName, context));
-  }
-  return combineAnd(clauses);
-};
-const resolveRelationPredicates = async (where, options) => {
-  if (!where || !containsRelationPredicate(where, options.schema, options.tableName)) {
-    return where;
-  }
-  return resolveForTable(where, options.tableName, {
-    canPushExists: options.canPushExists,
-    existsPushMode: options.existsPushMode ?? "auto",
-    fetcher: options.fetcher,
-    maxRelationKeys: options.maxRelationKeys ?? DEFAULT_MAX_RELATION_KEYS,
-    relationBaseWhere: options.relationBaseWhere,
-    schema: options.schema
-  });
-};
-const firstShardedHit = (branches, schema, tableName) => {
-  for (const branch of branches) {
-    const hit = findShardedRelationTarget(branch, schema, tableName);
-    if (hit) {
-      return hit;
-    }
-  }
-  return void 0;
-};
-const inspectKey = (key, value, schema, tableName) => {
-  if (key === "AND" || key === "OR") {
-    return firstShardedHit(branchesOf(value), schema, tableName);
-  }
-  if (key === "NOT") {
-    return firstShardedHit([value ?? {}], schema, tableName);
-  }
-  const relation = schema.tables[tableName]?.relationMap?.[key];
-  if (!relation || !isRelationPredicate(value)) {
-    return void 0;
-  }
-  if (schema.tables[relation.table]?.shardMode?.kind === "shardBy") {
-    return { relation: key, target: relation.table };
-  }
-  return firstShardedHit(Object.values(value), schema, relation.table);
-};
-const findShardedRelationTarget = (where, schema, tableName) => {
-  for (const key of Object.keys(where)) {
-    const hit = inspectKey(key, where[key], schema, tableName);
-    if (hit) {
-      return hit;
-    }
-  }
-  return void 0;
-};
-const assertShapeShardable = (effectiveWhere, schema, table) => {
-  if (!effectiveWhere) {
-    return;
-  }
-  const offending = findShardedRelationTarget(effectiveWhere, schema, table);
-  if (!offending) {
-    return;
-  }
-  throw Object.assign(
-    new Error(
-      `shape on "${table}" joins the sharded table "${offending.target}" via relation "${offending.relation}" — a live shape cannot replicate rows that live in another shard's Durable Object. Fix it by (a) denormalizing the joined columns into "${table}", or (b) moving "${offending.target}" to .global() so it is served through the latency-tiered D1 shape tier.`
-    ),
-    { code: "SHAPE_CROSS_SHARD_JOIN", name: "LunoraError", status: 400 }
-  );
-};
-
-export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates };