@lunora/do 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/applyCdcChanges-Ctdmxmrv.mjs

@@ -0,0 +1,103 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { ConflictError } from './ConflictError-C0STs6bU.mjs';
+
+const CDC_LOG_TABLE = "__cdc_log";
+const migrateCdcLog = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CDC_LOG_TABLE)} (
+            seq INTEGER PRIMARY KEY AUTOINCREMENT,
+            ts REAL NOT NULL,
+            ${sql.identifier("table")} TEXT NOT NULL,
+            id TEXT NOT NULL,
+            op TEXT NOT NULL,
+            doc TEXT
+        )`
+  );
+};
+const appendCdcChange = (sql$1, ts, table, id, op, doc) => {
+  const docValue = doc === void 0 ? null : JSON.stringify(doc);
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(CDC_LOG_TABLE)} (ts, ${sql.identifier("table")}, id, op, doc) VALUES (${ts}, ${table}, ${id}, ${op}, ${docValue})`
+  );
+};
+const readCdcChanges = (sql$1, options = {}) => {
+  const sinceSeq = options.sinceSeq ?? 0;
+  const limit = Math.max(1, Math.min(options.limit ?? 1e3, 1e4));
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT seq, ts, ${sql.identifier("table")}, id, op, doc FROM ${sql.identifier(CDC_LOG_TABLE)} WHERE seq > ${sinceSeq} ORDER BY seq ASC LIMIT ${limit}`
+  ).toArray();
+  const changes = rows.map((row) => {
+    const base = { id: row.id, op: row.op, seq: row.seq, table: row.table, ts: row.ts };
+    return row.doc === null ? base : { ...base, doc: JSON.parse(row.doc) };
+  });
+  return { changes, cursor: changes.at(-1)?.seq ?? sinceSeq };
+};
+const trimCdcChanges = (sql$1, throughSeq) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(CDC_LOG_TABLE)} WHERE seq <= ${throughSeq}`);
+};
+const readCdcCursor = (sql$1) => {
+  const seqRow = runDrizzle(sql$1, sql`SELECT seq FROM sqlite_sequence WHERE name = ${CDC_LOG_TABLE}`).toArray();
+  const fromSequence = seqRow[0]?.seq;
+  if (typeof fromSequence === "number") {
+    return fromSequence;
+  }
+  const rows = runDrizzle(sql$1, sql`SELECT MAX(seq) AS seq FROM ${sql.identifier(CDC_LOG_TABLE)}`).toArray();
+  return rows[0]?.seq ?? 0;
+};
+const minCdcSeq = (sql$1) => {
+  const rows = runDrizzle(sql$1, sql`SELECT MIN(seq) AS seq FROM ${sql.identifier(CDC_LOG_TABLE)}`).toArray();
+  return rows[0]?.seq ?? void 0;
+};
+const CDC_META_TABLE = "__cdc_meta";
+const migrateCdcMeta = (sql$1) => {
+  runDrizzle(sql$1, sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CDC_META_TABLE)} (id INTEGER PRIMARY KEY CHECK (id = 1), epoch TEXT NOT NULL)`);
+};
+const readCdcEpoch = (sql$1) => {
+  migrateCdcMeta(sql$1);
+  const rows = runDrizzle(sql$1, sql`SELECT epoch FROM ${sql.identifier(CDC_META_TABLE)} WHERE id = 1`).toArray();
+  const existing = rows[0]?.epoch;
+  if (typeof existing === "string" && existing.length > 0) {
+    return existing;
+  }
+  const minted = crypto.randomUUID();
+  runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(CDC_META_TABLE)} (id, epoch) VALUES (1, ${minted})`);
+  return minted;
+};
+const bumpCdcEpoch = (sql$1) => {
+  migrateCdcMeta(sql$1);
+  const next = crypto.randomUUID();
+  runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(CDC_META_TABLE)} (id, epoch) VALUES (1, ${next}) ON CONFLICT(id) DO UPDATE SET epoch = excluded.epoch`);
+  return next;
+};
+const applyCdcChange = async (writer, change) => {
+  if (change.op === "delete") {
+    await writer.delete(change.id);
+    return;
+  }
+  const document = change.doc ?? {};
+  try {
+    await writer.insert(change.table, document, { allowExplicitId: true });
+  } catch (error) {
+    if (!(error instanceof ConflictError)) {
+      throw error;
+    }
+    const fields = {};
+    for (const [key, value] of Object.entries(document)) {
+      if (key !== "_id") {
+        fields[key] = value;
+      }
+    }
+    await writer.replace(change.id, fields);
+  }
+};
+const applyCdcChanges = async (writer, changes) => {
+  for (const change of changes) {
+    await applyCdcChange(writer, change);
+  }
+};
+
+export { CDC_LOG_TABLE, CDC_META_TABLE, appendCdcChange, applyCdcChanges, bumpCdcEpoch, migrateCdcLog, migrateCdcMeta, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges };

package/dist/packem_shared/applyOnDelete-CMif2RKw.mjs

@@ -0,0 +1,165 @@
+const distinctValues = (rows, field) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const value = row[field];
+    if (value !== null && value !== void 0) {
+      seen.add(value);
+    }
+  }
+  return [...seen];
+};
+const resolveWith = async (options) => {
+  const { counter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
+  if (parents.length === 0) {
+    return;
+  }
+  const parentDefinition = schema.tables[tableName];
+  if (!parentDefinition) {
+    throw new Error(`unknown table: ${tableName}`);
+  }
+  const relationMap = parentDefinition.relationMap ?? {};
+  const requireRelation = (name) => {
+    const relation = relationMap[name];
+    if (!relation) {
+      throw new Error(`unknown relation "${name}" on table "${tableName}"`);
+    }
+    return relation;
+  };
+  const loadOne = async (name, relation, nested) => {
+    const fkValues = distinctValues(parents, relation.field);
+    if (fkValues.length === 0) {
+      for (const parent of parents) {
+        parent[name] = null;
+      }
+      return;
+    }
+    const { page } = await fetcher(relation.table, {
+      baseWhere: relationBaseWhere?.(relation.table),
+      relationBaseWhere,
+      where: { [relation.references]: { in: fkValues } },
+      with: nested.with
+    });
+    const byReference = /* @__PURE__ */ new Map();
+    for (const child of page) {
+      byReference.set(child[relation.references], child);
+    }
+    for (const parent of parents) {
+      parent[name] = byReference.get(parent[relation.field]) ?? null;
+    }
+  };
+  const loadMany = async (name, relation, nested) => {
+    const referenceValues = distinctValues(parents, relation.references);
+    if (referenceValues.length === 0) {
+      for (const parent of parents) {
+        parent[name] = [];
+      }
+      return;
+    }
+    const fkFilter = { [relation.field]: { in: referenceValues } };
+    const where = nested.where ? { AND: [nested.where, fkFilter] } : fkFilter;
+    const { page } = await fetcher(relation.table, {
+      baseWhere: relationBaseWhere?.(relation.table),
+      orderBy: nested.orderBy,
+      relationBaseWhere,
+      where,
+      with: nested.with
+    });
+    const groups = /* @__PURE__ */ new Map();
+    for (const child of page) {
+      const key = child[relation.field];
+      const group = groups.get(key);
+      if (group) {
+        group.push(child);
+      } else {
+        groups.set(key, [child]);
+      }
+    }
+    const cap = typeof nested.limit === "number" ? Math.max(0, Math.floor(nested.limit)) : void 0;
+    for (const parent of parents) {
+      const group = groups.get(parent[relation.references]) ?? [];
+      parent[name] = cap === void 0 ? group : group.slice(0, cap);
+    }
+  };
+  const resolveCounts = async (countInput) => {
+    for (const name of Object.keys(countInput)) {
+      const relation = requireRelation(name);
+      const [whereField, parentField] = relation.kind === "many" ? [relation.field, relation.references] : [relation.references, relation.field];
+      const countByValue = /* @__PURE__ */ new Map();
+      const policyWhere = relationBaseWhere?.(relation.table);
+      for (const value of distinctValues(parents, parentField)) {
+        const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
+        countByValue.set(value, await counter(relation.table, countWhere));
+      }
+      for (const parent of parents) {
+        const counts = parent["_count"] ?? {};
+        const parentValue = parent[parentField];
+        counts[name] = parentValue === null || parentValue === void 0 ? 0 : countByValue.get(parentValue) ?? 0;
+        parent["_count"] = counts;
+      }
+    }
+  };
+  for (const [name, value] of Object.entries(withInput)) {
+    if (value === void 0 || value === false) {
+      continue;
+    }
+    if (name === "_count") {
+      await resolveCounts(value);
+      continue;
+    }
+    const relation = requireRelation(name);
+    const nested = value === true ? {} : value;
+    await (relation.kind === "one" ? loadOne(name, relation, nested) : loadMany(name, relation, nested));
+  }
+};
+const applyRelationOnDelete = async (options, holderTable, relation) => {
+  const { deletedId, deletedReference, findHolders, onCascade, onRestrict, onSetNull, tableName } = options;
+  const referencedValue = relation.references === "_id" ? deletedId : deletedReference(relation.references);
+  if (referencedValue === null || referencedValue === void 0) {
+    return;
+  }
+  const holders = await findHolders(holderTable, relation.field, referencedValue);
+  if (holders.length === 0) {
+    return;
+  }
+  if (relation.onDelete === "restrict") {
+    onRestrict(`cannot delete "${tableName}" row: "${holderTable}.${relation.field}" still references it`);
+  }
+  for (const holder of holders) {
+    const holderId = holder["_id"];
+    if (typeof holderId !== "string") {
+      continue;
+    }
+    await (relation.onDelete === "cascade" ? onCascade(holderTable, holderId) : onSetNull(holderTable, holderId, relation.field));
+  }
+};
+const applyOnDelete = async (options) => {
+  const { schema, tableName } = options;
+  if (!schema.tables[tableName]) {
+    throw new Error(`unknown table: ${tableName}`);
+  }
+  for (const [holderTable, holderDefinition] of Object.entries(schema.tables)) {
+    const relations = holderDefinition.relationMap;
+    if (!relations) {
+      continue;
+    }
+    for (const relation of Object.values(relations)) {
+      if (relation.kind !== "one" || relation.table !== tableName || !relation.onDelete) {
+        continue;
+      }
+      await applyRelationOnDelete(options, holderTable, relation);
+    }
+  }
+};
+const runRowValidators = (definition, document) => {
+  for (const [field, validator] of Object.entries(definition.shape)) {
+    if (!(field in document)) {
+      continue;
+    }
+    if (typeof validator.parse !== "function") {
+      continue;
+    }
+    validator.parse(document[field]);
+  }
+};
+
+export { applyOnDelete, distinctValues, resolveWith, runRowValidators };

package/dist/packem_shared/armRestore-BJk53Ro8.mjs

@@ -0,0 +1,55 @@
+const pitrUnavailable = () => Object.assign(
+  new Error("native PITR is unavailable here (local dev or a non-SQLite Durable Object); use `lunora backup restore` for off-platform recovery"),
+  {
+    code: "PITR_UNAVAILABLE",
+    name: "LunoraError",
+    status: 409
+  }
+);
+const toTime = (time) => {
+  if (typeof time === "number") {
+    return time;
+  }
+  const parsed = Date.parse(time);
+  if (Number.isNaN(parsed)) {
+    throw Object.assign(new Error(`pitr: invalid time "${time}" — expected epoch-ms or an ISO timestamp`), {
+      code: "BAD_REQUEST",
+      name: "LunoraError",
+      status: 400
+    });
+  }
+  return parsed;
+};
+const readBookmark = async (storage, time) => {
+  if (!storage.getCurrentBookmark) {
+    throw pitrUnavailable();
+  }
+  const current = await storage.getCurrentBookmark();
+  if (time === void 0 || !storage.getBookmarkForTime) {
+    return { current };
+  }
+  return { current, forTime: await storage.getBookmarkForTime(toTime(time)) };
+};
+const armRestore = async (storage, args) => {
+  if (!storage.onNextSessionRestoreBookmark) {
+    throw pitrUnavailable();
+  }
+  let target = args.bookmark;
+  if (target === void 0) {
+    if (args.time === void 0) {
+      throw Object.assign(new Error("pitrRestore: provide a `bookmark` or a `time` to restore to"), {
+        code: "BAD_REQUEST",
+        name: "LunoraError",
+        status: 400
+      });
+    }
+    if (!storage.getBookmarkForTime) {
+      throw pitrUnavailable();
+    }
+    target = await storage.getBookmarkForTime(toTime(args.time));
+  }
+  const undoBookmark = await storage.onNextSessionRestoreBookmark(target);
+  return { restoredTo: target, undoBookmark };
+};
+
+export { armRestore, readBookmark };

package/dist/packem_shared/assertFlatPredicate-DyVYReuT.mjs

@@ -0,0 +1,160 @@
+import { distinctValues } from './applyOnDelete-CMif2RKw.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
+  });
+};
+
+export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates };

package/dist/packem_shared/assertReadonly-dDcFE1YZ.mjs

@@ -0,0 +1,29 @@
+const MAX_SQL_ROWS = 1e3;
+const READONLY_LEAD = /^(?:explain\s+(?:query\s+plan\s+)?)?(?:select|with)\b/iu;
+const FORBIDDEN_KEYWORD = /\b(?:alter|attach|create|delete|detach|drop|insert|pragma|reindex|replace|truncate|update|vacuum)\b/iu;
+const LEADING_NOISE = /^(?:\s|--[^\n]*\n?|\/\*[\s\S]*?\*\/)+/u;
+const TRAILING_SEMICOLON = /;\s*$/u;
+const stripLeading = (sql) => sql.replace(LEADING_NOISE, "");
+const sqlError = (message, code) => Object.assign(new Error(message), { code, name: "LunoraError", status: 400 });
+const assertReadonly = (query) => {
+  const trimmed = stripLeading(query).trim();
+  if (trimmed === "") {
+    throw sqlError("the query is empty", "SQL_EMPTY");
+  }
+  const single = trimmed.replace(TRAILING_SEMICOLON, "");
+  if (single.includes(";")) {
+    throw sqlError("only a single statement may be run", "SQL_MULTIPLE_STATEMENTS");
+  }
+  if (!READONLY_LEAD.test(single) || FORBIDDEN_KEYWORD.test(single)) {
+    throw sqlError("the SQL editor is read-only — only SELECT / WITH / EXPLAIN queries are allowed", "SQL_NOT_READONLY");
+  }
+};
+const runReadonlySql = (sql, query) => {
+  assertReadonly(query);
+  const all = sql.exec(query).toArray();
+  const rows = all.length > MAX_SQL_ROWS ? all.slice(0, MAX_SQL_ROWS) : all;
+  const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
+  return { columns, rowCount: all.length, rows, truncated: all.length > MAX_SQL_ROWS };
+};
+
+export { MAX_SQL_ROWS, assertReadonly, runReadonlySql };