@lunora/do 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/CountRlsUnsupportedError-28ZvvwKS.mjs

@@ -0,0 +1,133 @@
+class CountRlsUnsupportedError extends Error {
+  code = "COUNT_RLS_UNSUPPORTED";
+  name = "LunoraError";
+  status = 422;
+  constructor(table) {
+    super(
+      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-PTtTiQ7U.mjs

@@ -0,0 +1,237 @@
+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 Error(`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"] });
+          }
+        }
+        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) {
+    releaseClaim(sql, migration.id);
+  }
+  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-DU-Y4-LJ.mjs

@@ -0,0 +1,209 @@
+import { distinctValues } from './applyOnDelete-BQ-8ZlZ1.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 Error(`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 Error(
+      `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 Error(`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 Error(`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 Error(`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 };