@lunora/do 0.0.0 → 1.0.0-alpha.1

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/LogBuffer-B_Ezju_N.mjs

@@ -0,0 +1,37 @@
+const DEFAULT_CAPACITY = 500;
+class LogBuffer {
+  /** Backing store, kept in insertion order (oldest first). */
+  buffer = [];
+  capacity;
+  constructor(capacity = DEFAULT_CAPACITY) {
+    this.capacity = capacity > 0 ? Math.trunc(capacity) : DEFAULT_CAPACITY;
+  }
+  /** Number of entries currently buffered. */
+  get size() {
+    return this.buffer.length;
+  }
+  /** Drop every buffered entry. */
+  clear() {
+    this.buffer.length = 0;
+  }
+  /**
+   * Snapshot of the buffered entries, **newest first** so the panel renders
+   * the most recent activity at the top without re-sorting. Returns a fresh
+   * array each call; the caller may mutate it freely.
+   */
+  entries() {
+    return this.buffer.toReversed();
+  }
+  /**
+   * Append an entry, evicting the oldest when at capacity so the buffer never
+   * grows past its bound.
+   */
+  push(entry) {
+    this.buffer.push(entry);
+    if (this.buffer.length > this.capacity) {
+      this.buffer.shift();
+    }
+  }
+}
+
+export { LogBuffer };

package/dist/packem_shared/NotFoundError-CMuMZt81.mjs

@@ -0,0 +1,10 @@
+class NotFoundError extends Error {
+  code = "NOT_FOUND";
+  status = 404;
+  constructor(message = "Document not found") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+
+export { NotFoundError as default };