@buoy-gg/time-machine 7.0.28 → 7.0.30

package/src/store/snapshotVault.ts

@@ -1,274 +0,0 @@
-/**
- * Snapshot persistence for Time Machine.
- *
- * Snapshots live ON-DEVICE in persistentStorage (FileSystem → AsyncStorage →
- * localStorage → Memory fallback): no size caps, survives restarts, and never
- * crosses the 2MB external-sync snapshot budget — only metadata does.
- *
- * Layout: ONE storage key per snapshot (persistentStorage's FileSystem
- * backend writes one file per key, and its multiGet is sequential — a single
- * big key beats many small ones), plus one index key holding the metadata
- * list for cheap listing.
- *
- * Keys use the `@react_buoy` family so every tool's isDevToolsStorageKey
- * filter (including our own storage provider) excludes the vault itself from
- * snapshots — a snapshot must never contain snapshots.
- */
-import {
-  persistentStorage,
-  type SuperJSONResult,
-} from "@buoy-gg/shared-ui";
-import type { SnapshotRoute } from "./routeRestore";
-
-const INDEX_KEY = "@react_buoy_time_machine:index";
-const SNAP_PREFIX = "@react_buoy_time_machine:snap:";
-
-export interface SnapshotSourceMeta {
-  warnings: string[];
-}
-
-export interface SnapshotMeta {
-  id: string;
-  name: string;
-  createdAt: number;
-  /** Serialized size of the whole stored snapshot. */
-  sizeBytes: number;
-  /**
-   * A baseline snapshot has NO captured data — restoring it wipes to
-   * fresh-install state (clear + reload).
-   */
-  baseline?: boolean;
-  /**
-   * User-saved restore scope: compound "sourceId::itemKey" strings. When set,
-   * restoring this snapshot touches ONLY these items — "this restore point
-   * means just my cart". Absent = full restore.
-   *
-   * Set through the MCP/adapter `setScope` action. The tool's own UI writes
-   * `excludedKeys` instead — see there for why the two exist.
-   */
-  scope?: string[];
-  /**
-   * Items the user switched OFF in the restore preview and saved: compound
-   * "sourceId::itemKey" strings that every later restore of this snapshot
-   * leaves untouched, including the one-tap RESTORE on the list.
-   *
-   * The inverse of `scope`, and the right default for "I unchecked one of
-   * these ten keys": naming what to SKIP lets everything else through, so a
-   * key that only starts differing tomorrow is still restored. An include
-   * list built from today's diff would silently freeze the restore point to
-   * whatever happened to differ when it was saved.
-   */
-  excludedKeys?: string[];
-  /**
-   * The route the app was on when this snapshot was captured. Absent when the
-   * app has no expo-router (nothing to return to). A restore can navigate back
-   * to it — see routeRestore.ts.
-   */
-  route?: SnapshotRoute;
-  /**
-   * Whether restoring this point should also navigate back to `route`.
-   * Undefined means "yes, if there is a route" — the useful default, and the
-   * reason there is no longer a prompt on every restore.
-   */
-  restoreRoute?: boolean;
-  /** When this point was last restored, for the "restored 4m ago" marker. */
-  lastRestoredAt?: number;
-  /** Source ids captured, with their capture warnings. */
-  sources: Record<string, SnapshotSourceMeta>;
-}
-
-export interface StoredSnapshot {
-  meta: SnapshotMeta;
-  /** Per-source superjson payloads (absent for baseline snapshots). */
-  data: Record<string, SuperJSONResult>;
-}
-
-export async function loadIndex(): Promise<SnapshotMeta[]> {
-  try {
-    const raw = await persistentStorage.getItem(INDEX_KEY);
-    if (!raw) return [];
-    const parsed = JSON.parse(raw) as SnapshotMeta[];
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-
-async function saveIndex(metas: SnapshotMeta[]): Promise<void> {
-  await persistentStorage.setItem(INDEX_KEY, JSON.stringify(metas));
-}
-
-/** Persists the snapshot, stamps meta.sizeBytes, and updates the index. */
-export async function saveSnapshot(
-  snapshot: StoredSnapshot,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  const serialized = JSON.stringify(snapshot);
-  snapshot.meta.sizeBytes = serialized.length;
-  await persistentStorage.setItem(
-    SNAP_PREFIX + snapshot.meta.id,
-    // Re-stringify so the persisted copy carries the final sizeBytes.
-    JSON.stringify(snapshot)
-  );
-  const next = [
-    snapshot.meta,
-    ...metas.filter((m) => m.id !== snapshot.meta.id),
-  ];
-  await saveIndex(next);
-  return next;
-}
-
-export async function loadSnapshot(id: string): Promise<StoredSnapshot | null> {
-  try {
-    const raw = await persistentStorage.getItem(SNAP_PREFIX + id);
-    return raw ? (JSON.parse(raw) as StoredSnapshot) : null;
-  } catch {
-    return null;
-  }
-}
-
-export async function deleteSnapshot(
-  id: string,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  await persistentStorage.removeItem(SNAP_PREFIX + id);
-  const next = metas.filter((m) => m.id !== id);
-  await saveIndex(next);
-  return next;
-}
-
-/**
- * Rewrite one snapshot's metadata in BOTH places it lives — the index and the
- * snapshot's own record — so a reload can't resurrect the old value from
- * whichever one was missed.
- */
-async function patchMeta(
-  id: string,
-  patch: (meta: SnapshotMeta) => SnapshotMeta,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  const apply = (m: SnapshotMeta): SnapshotMeta => (m.id === id ? patch(m) : m);
-  const next = metas.map(apply);
-  await persistentStorage.setItem(INDEX_KEY, JSON.stringify(next));
-  const stored = await loadSnapshot(id);
-  if (stored) {
-    stored.meta = apply(stored.meta);
-    await persistentStorage.setItem(SNAP_PREFIX + id, JSON.stringify(stored));
-  }
-  return next;
-}
-
-/** Set (or clear with null/empty) the "only these items" restore scope. */
-export function setSnapshotScope(
-  id: string,
-  scope: string[] | null,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  return patchMeta(
-    id,
-    (m) => {
-      const next = { ...m };
-      if (scope && scope.length > 0) next.scope = scope;
-      else delete next.scope;
-      return next;
-    },
-    metas
-  );
-}
-
-/**
- * Set (or clear with null/empty) the items a restore of this snapshot must
- * leave alone. Saving exclusions also clears any legacy `scope`: the two
- * answer the same question in opposite directions, and the one the user just
- * chose in the preview wins.
- */
-export function setSnapshotExclusions(
-  id: string,
-  excludedKeys: string[] | null,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  return patchMeta(
-    id,
-    (m) => {
-      const next = { ...m };
-      delete next.scope;
-      if (excludedKeys && excludedKeys.length > 0)
-        next.excludedKeys = excludedKeys;
-      else delete next.excludedKeys;
-      return next;
-    },
-    metas
-  );
-}
-
-/** Turn this point's route restore on or off — the row's route toggle. */
-export function setSnapshotRestoreRoute(
-  id: string,
-  restoreRoute: boolean,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  return patchMeta(id, (m) => ({ ...m, restoreRoute }), metas);
-}
-
-/** Stamp a restore so the list can say which point you are currently in. */
-export function markSnapshotRestored(
-  id: string,
-  at: number,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  return patchMeta(id, (m) => ({ ...m, lastRestoredAt: at }), metas);
-}
-
-/**
- * Copy a stored snapshot under a new id and name. The payload is copied by
- * reference into a fresh record — the vault serializes it on write, so the
- * two never share mutable state.
- */
-export async function duplicateSnapshot(
-  id: string,
-  name: string,
-  metas: SnapshotMeta[]
-): Promise<{ metas: SnapshotMeta[]; meta: SnapshotMeta } | null> {
-  const stored = await loadSnapshot(id);
-  if (!stored) return null;
-  const copy: StoredSnapshot = {
-    meta: {
-      ...stored.meta,
-      id: `${stored.meta.id}_copy_${Date.now().toString(36)}`,
-      name,
-      createdAt: Date.now(),
-      lastRestoredAt: undefined,
-    },
-    data: stored.data,
-  };
-  delete copy.meta.lastRestoredAt;
-  return { metas: await saveSnapshot(copy, metas), meta: copy.meta };
-}
-
-/** Read a whole record so a delete can be held in memory and undone. */
-export async function readSnapshot(id: string): Promise<StoredSnapshot | null> {
-  return loadSnapshot(id);
-}
-
-/** Put a held record back exactly as it was. */
-export async function restoreDeletedSnapshot(
-  stored: StoredSnapshot,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  return saveSnapshot(stored, metas);
-}
-
-export async function renameSnapshot(
-  id: string,
-  name: string,
-  metas: SnapshotMeta[]
-): Promise<SnapshotMeta[]> {
-  const next = metas.map((m) => (m.id === id ? { ...m, name } : m));
-  await saveIndex(next);
-  const stored = await loadSnapshot(id);
-  if (stored) {
-    stored.meta.name = name;
-    await persistentStorage.setItem(SNAP_PREFIX + id, JSON.stringify(stored));
-  }
-  return next;
-}