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

package/dist/packem_shared/CDC_LOG_TABLE-uwOJxJJZ.mjs

@@ -1,107 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-import { ConflictError } from './ConflictError-CLoq37xH.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 tableFilter = options.tables && options.tables.size > 0 ? sql` AND ${sql.identifier("table")} IN (${sql.join(
-    [...options.tables].map((table) => sql`${table}`),
-    sql`, `
-  )})` : sql``;
-  const rows = runDrizzle(
-    sql$1,
-    sql`SELECT seq, ts, ${sql.identifier("table")}, id, op, doc FROM ${sql.identifier(CDC_LOG_TABLE)} WHERE seq > ${sinceSeq}${tableFilter} 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, change.table);
-    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, void 0, { allowExplicitId: true });
-  }
-};
-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/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 };