@dbx-tools/falkor-db 0.0.0-stage → 0.9.43

package/lib/src/persistence/manager.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Restore and change-aware durable backup lifecycle for embedded FalkorDB.
+ *
+ * Redis owns dirty detection and RDB creation. This manager only observes
+ * completed saves, stages immutable copies, and advances durable storage after
+ * a successful upload. Reuse it instead of adding application-local backup
+ * timers, manifest ordering, retry, or retention logic.
+ *
+ * @module
+ */
+import { type SnapshotManifest } from "./manifest.ts";
+import { type RedisPersistenceClient } from "./redis-info.ts";
+import type { VolumeStorage } from "./volume.ts";
+/** Configuration for {@link FalkorPersistenceManager}. */
+export interface FalkorPersistenceOptions {
+    dataDir: string;
+    storage?: VolumeStorage;
+    pollIntervalMs?: number;
+    retention?: number;
+    retryDelaysMs?: readonly number[];
+    forceBackupOnShutdown?: boolean;
+    shutdownTimeoutMs?: number;
+    staleBackupWarningMs?: number;
+}
+/** Observable state for health reporting and metrics adapters. */
+export interface FalkorPersistenceStatus {
+    rdbLastSaveTime?: number;
+    rdbChangesSinceLastSave?: number;
+    backupLastSuccessTime?: string;
+    backupLastSequence?: number;
+    backupSizeBytes?: number;
+    backupDurationMs?: number;
+    backupFailures: number;
+    restoreDurationMs?: number;
+    restoreSnapshotSequence?: number;
+}
+/** Coordinates restore, RDB observation, durable upload, retry, and retention. */
+export declare class FalkorPersistenceManager {
+    private readonly options;
+    private readonly dumpPath;
+    private readonly stagingDirectory;
+    private readonly statusValue;
+    private manifest;
+    private redis;
+    private timer;
+    private backupPromise;
+    private checkAgain;
+    private lastUploadedSaveTime;
+    private retryAttempt;
+    private retryAfter;
+    private lastLoggedLocalSaveTime;
+    constructor(options: FalkorPersistenceOptions);
+    get status(): Readonly<FalkorPersistenceStatus>;
+    /** Restore `latest.json` before FalkorDB starts, or keep the local database. */
+    restore(): Promise<SnapshotManifest | undefined>;
+    /** Begin polling Redis persistence metadata for completed new snapshots. */
+    start(redis: RedisPersistenceClient): Promise<void>;
+    /** Stop background polling without forcing a save or upload. */
+    stop(): void;
+    /** Inspect persistence now, coalescing concurrent checks into the newest RDB. */
+    checkNow(): Promise<void>;
+    /** Optionally force one dirty save/upload, bounded so shutdown cannot hang. */
+    prepareShutdown(): Promise<void>;
+    private finishShutdownBackup;
+    private runChecks;
+    private inspectAndBackup;
+    private upload;
+    private forceDirtySnapshot;
+    private observe;
+    private warnIfStale;
+}

package/lib/src/persistence/manager.js

@@ -0,0 +1,286 @@
+/**
+ * Restore and change-aware durable backup lifecycle for embedded FalkorDB.
+ *
+ * Redis owns dirty detection and RDB creation. This manager only observes
+ * completed saves, stages immutable copies, and advances durable storage after
+ * a successful upload. Reuse it instead of adding application-local backup
+ * timers, manifest ordering, retry, or retention logic.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { mkdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { asyncUtils, log } from "@dbx-tools/shared-core";
+import { enforceRetention, LATEST_MANIFEST_PATH, nextSnapshotSequence, parseSnapshotManifest, snapshotPath, } from "./manifest.js";
+import { getPersistenceInfo, waitForBackgroundSave, } from "./redis-info.js";
+import { stageSnapshot, verifySnapshot } from "./snapshot.js";
+const logger = log.logger("falkor-db:persistence");
+const DEFAULT_RETRY_DELAYS_MS = [5_000, 15_000, 30_000, 60_000, 300_000];
+/** Coordinates restore, RDB observation, durable upload, retry, and retention. */
+export class FalkorPersistenceManager {
+    options;
+    dumpPath;
+    stagingDirectory;
+    statusValue = { backupFailures: 0 };
+    manifest;
+    redis;
+    timer;
+    backupPromise;
+    checkAgain = false;
+    lastUploadedSaveTime = 0;
+    retryAttempt = 0;
+    retryAfter = 0;
+    lastLoggedLocalSaveTime = 0;
+    constructor(options) {
+        this.options = options;
+        this.dumpPath = join(options.dataDir, "dump.rdb");
+        this.stagingDirectory = join(options.dataDir, ".dbx-tools-backups");
+    }
+    get status() {
+        return { ...this.statusValue };
+    }
+    /** Restore `latest.json` before FalkorDB starts, or keep the local database. */
+    async restore() {
+        await mkdir(this.options.dataDir, { recursive: true });
+        if (!this.options.storage) {
+            logger.info("durable storage is not configured; using local RDB persistence", {
+                dataDir: this.options.dataDir,
+            });
+            return undefined;
+        }
+        const raw = await this.options.storage.readJson(LATEST_MANIFEST_PATH);
+        if (raw === null) {
+            logger.info("no durable FalkorDB snapshot found; using local database", {
+                dataDir: this.options.dataDir,
+            });
+            return undefined;
+        }
+        const started = Date.now();
+        const manifest = parseSnapshotManifest(raw);
+        const temporary = `${this.dumpPath}.restore`;
+        await rm(temporary, { force: true });
+        try {
+            await this.options.storage.download(manifest.snapshot, temporary);
+            await verifySnapshot(temporary, manifest.sha256);
+            await rename(temporary, this.dumpPath);
+        }
+        catch (error) {
+            await rm(temporary, { force: true });
+            throw error;
+        }
+        this.manifest = manifest;
+        this.lastUploadedSaveTime = manifest.redisSaveTime ?? 0;
+        this.statusValue.restoreDurationMs = Date.now() - started;
+        this.statusValue.restoreSnapshotSequence = manifest.sequence;
+        logger.info("restored FalkorDB snapshot", {
+            sequence: manifest.sequence,
+            size: manifest.size,
+            durationMs: this.statusValue.restoreDurationMs,
+        });
+        return manifest;
+    }
+    /** Begin polling Redis persistence metadata for completed new snapshots. */
+    async start(redis) {
+        if (this.timer)
+            return;
+        this.redis = redis;
+        const initial = await this.observe(redis);
+        if (this.manifest) {
+            this.lastUploadedSaveTime = initial.rdbLastSaveTime;
+        }
+        await this.checkNow();
+        this.timer = setInterval(() => {
+            void this.checkNow().catch((error) => {
+                logger.error("FalkorDB persistence check failed; retrying later", { error });
+            });
+        }, this.options.pollIntervalMs ?? 10_000);
+        this.timer.unref?.();
+    }
+    /** Stop background polling without forcing a save or upload. */
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    /** Inspect persistence now, coalescing concurrent checks into the newest RDB. */
+    async checkNow() {
+        if (!this.redis)
+            return;
+        if (this.backupPromise) {
+            this.checkAgain = true;
+            return this.backupPromise;
+        }
+        this.backupPromise = this.runChecks();
+        try {
+            await this.backupPromise;
+        }
+        finally {
+            this.backupPromise = undefined;
+        }
+    }
+    /** Optionally force one dirty save/upload, bounded so shutdown cannot hang. */
+    async prepareShutdown() {
+        this.stop();
+        if (!this.options.forceBackupOnShutdown || !this.redis)
+            return;
+        const timeoutMs = this.options.shutdownTimeoutMs ?? 30_000;
+        const work = this.finishShutdownBackup(this.redis);
+        const timeout = new AbortController();
+        try {
+            await Promise.race([
+                work,
+                asyncUtils.sleep(timeoutMs, timeout.signal).then(() => {
+                    throw new Error(`FalkorDB shutdown backup exceeded ${timeoutMs}ms`);
+                }),
+            ]);
+        }
+        catch (error) {
+            logger.error("shutdown backup failed; continuing shutdown", { error });
+        }
+        finally {
+            timeout.abort();
+        }
+    }
+    async finishShutdownBackup(redis) {
+        if (this.backupPromise) {
+            try {
+                await this.backupPromise;
+            }
+            catch (error) {
+                logger.warn("in-flight FalkorDB backup failed; retrying during shutdown", { error });
+            }
+        }
+        await this.forceDirtySnapshot(redis);
+    }
+    async runChecks() {
+        do {
+            this.checkAgain = false;
+            await this.inspectAndBackup();
+        } while (this.checkAgain);
+    }
+    async inspectAndBackup() {
+        const redis = this.redis;
+        if (!redis)
+            return;
+        const info = await this.observe(redis);
+        if (info.rdbBgSaveInProgress)
+            return;
+        if (info.rdbLastBgSaveStatus !== "ok") {
+            logger.error("Redis reported an unsuccessful background save", {
+                status: info.rdbLastBgSaveStatus,
+            });
+            return;
+        }
+        this.warnIfStale(info);
+        if (!this.options.storage) {
+            if (info.rdbLastSaveTime > this.lastLoggedLocalSaveTime) {
+                this.lastLoggedLocalSaveTime = info.rdbLastSaveTime;
+                logger.info("local FalkorDB RDB snapshot completed", {
+                    lastSaveTime: info.rdbLastSaveTime,
+                    changesSinceSave: info.rdbChangesSinceLastSave,
+                    path: this.dumpPath,
+                });
+            }
+            return;
+        }
+        if (info.rdbLastSaveTime <= this.lastUploadedSaveTime || !existsSync(this.dumpPath))
+            return;
+        if (Date.now() < this.retryAfter)
+            return;
+        try {
+            await this.upload(info);
+            this.retryAttempt = 0;
+            this.retryAfter = 0;
+            const newest = await this.observe(redis);
+            if (newest.rdbLastSaveTime > this.lastUploadedSaveTime)
+                this.checkAgain = true;
+        }
+        catch (error) {
+            this.statusValue.backupFailures += 1;
+            const delays = this.options.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+            const delay = asyncUtils.boundedRetryDelay(this.retryAttempt++, delays);
+            this.retryAfter = Date.now() + delay;
+            logger.error("durable FalkorDB backup failed; local database remains available", {
+                error,
+                retryInMs: delay,
+            });
+        }
+    }
+    async upload(info) {
+        const storage = this.options.storage;
+        if (!storage)
+            return;
+        const started = Date.now();
+        const sequence = await nextSnapshotSequence(storage, this.manifest);
+        const remote = snapshotPath(sequence);
+        const stagedPath = join(this.stagingDirectory, `snapshot-${sequence}.rdb`);
+        const staged = await stageSnapshot(this.dumpPath, stagedPath);
+        try {
+            await storage.upload(staged.path, remote, { overwrite: false });
+            const manifest = {
+                snapshot: remote,
+                createdAt: new Date().toISOString(),
+                size: staged.size,
+                sha256: staged.sha256,
+                sequence,
+                redisSaveTime: info.rdbLastSaveTime,
+            };
+            await storage.writeJson(LATEST_MANIFEST_PATH, manifest);
+            this.manifest = manifest;
+            this.lastUploadedSaveTime = info.rdbLastSaveTime;
+            this.statusValue.backupLastSuccessTime = manifest.createdAt;
+            this.statusValue.backupLastSequence = sequence;
+            this.statusValue.backupSizeBytes = staged.size;
+            this.statusValue.backupDurationMs = Date.now() - started;
+            logger.info("uploaded durable FalkorDB snapshot", {
+                sequence,
+                size: staged.size,
+                durationMs: this.statusValue.backupDurationMs,
+            });
+            await enforceRetention(storage, manifest, this.options.retention ?? 5).catch((error) => {
+                logger.warn("FalkorDB snapshot retention cleanup failed", { error });
+            });
+        }
+        finally {
+            await rm(stagedPath, { force: true });
+        }
+    }
+    async forceDirtySnapshot(redis) {
+        let info = await this.observe(redis);
+        if (info.rdbChangesSinceLastSave > 0) {
+            const previous = info.rdbLastSaveTime;
+            await redis.bgSave();
+            info = await waitForBackgroundSave(redis, previous, {
+                timeoutMs: this.options.shutdownTimeoutMs ?? 30_000,
+            });
+        }
+        if (this.options.storage && info.rdbLastSaveTime > this.lastUploadedSaveTime) {
+            this.retryAfter = 0;
+            await this.upload(info);
+        }
+    }
+    async observe(redis) {
+        const info = await getPersistenceInfo(redis);
+        this.statusValue.rdbLastSaveTime = info.rdbLastSaveTime;
+        this.statusValue.rdbChangesSinceLastSave = info.rdbChangesSinceLastSave;
+        return info;
+    }
+    warnIfStale(info) {
+        if (!this.options.storage)
+            return;
+        const threshold = this.options.staleBackupWarningMs;
+        if (!threshold || info.rdbChangesSinceLastSave === 0)
+            return;
+        const last = this.statusValue.backupLastSuccessTime
+            ? Date.parse(this.statusValue.backupLastSuccessTime)
+            : 0;
+        if (Date.now() - last > threshold) {
+            logger.warn("FalkorDB has changes without a recent durable backup", {
+                changesSinceSave: info.rdbChangesSinceLastSave,
+                lastSuccessTime: this.statusValue.backupLastSuccessTime,
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../src/persistence/manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Restore and change-aware durable backup lifecycle for embedded FalkorDB.\n *\n * Redis owns dirty detection and RDB creation. This manager only observes\n * completed saves, stages immutable copies, and advances durable storage after\n * a successful upload. Reuse it instead of adding application-local backup\n * timers, manifest ordering, retry, or retention logic.\n *\n * @module\n */\n\nimport { existsSync } from \"node:fs\";\nimport { mkdir, rename, rm } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { asyncUtils, log } from \"@dbx-tools/shared-core\";\nimport {\n  enforceRetention,\n  LATEST_MANIFEST_PATH,\n  nextSnapshotSequence,\n  parseSnapshotManifest,\n  snapshotPath,\n  type SnapshotManifest,\n} from \"./manifest.ts\";\nimport {\n  getPersistenceInfo,\n  waitForBackgroundSave,\n  type RedisPersistenceClient,\n  type RedisPersistenceInfo,\n} from \"./redis-info.ts\";\nimport { stageSnapshot, verifySnapshot } from \"./snapshot.ts\";\nimport type { VolumeStorage } from \"./volume.ts\";\n\nconst logger = log.logger(\"falkor-db:persistence\");\nconst DEFAULT_RETRY_DELAYS_MS = [5_000, 15_000, 30_000, 60_000, 300_000] as const;\n\n/** Configuration for {@link FalkorPersistenceManager}. */\nexport interface FalkorPersistenceOptions {\n  dataDir: string;\n  storage?: VolumeStorage;\n  pollIntervalMs?: number;\n  retention?: number;\n  retryDelaysMs?: readonly number[];\n  forceBackupOnShutdown?: boolean;\n  shutdownTimeoutMs?: number;\n  staleBackupWarningMs?: number;\n}\n\n/** Observable state for health reporting and metrics adapters. */\nexport interface FalkorPersistenceStatus {\n  rdbLastSaveTime?: number;\n  rdbChangesSinceLastSave?: number;\n  backupLastSuccessTime?: string;\n  backupLastSequence?: number;\n  backupSizeBytes?: number;\n  backupDurationMs?: number;\n  backupFailures: number;\n  restoreDurationMs?: number;\n  restoreSnapshotSequence?: number;\n}\n\n/** Coordinates restore, RDB observation, durable upload, retry, and retention. */\nexport class FalkorPersistenceManager {\n  private readonly dumpPath: string;\n  private readonly stagingDirectory: string;\n  private readonly statusValue: FalkorPersistenceStatus = { backupFailures: 0 };\n  private manifest: SnapshotManifest | undefined;\n  private redis: RedisPersistenceClient | undefined;\n  private timer: ReturnType<typeof setInterval> | undefined;\n  private backupPromise: Promise<void> | undefined;\n  private checkAgain = false;\n  private lastUploadedSaveTime = 0;\n  private retryAttempt = 0;\n  private retryAfter = 0;\n  private lastLoggedLocalSaveTime = 0;\n\n  constructor(private readonly options: FalkorPersistenceOptions) {\n    this.dumpPath = join(options.dataDir, \"dump.rdb\");\n    this.stagingDirectory = join(options.dataDir, \".dbx-tools-backups\");\n  }\n\n  get status(): Readonly<FalkorPersistenceStatus> {\n    return { ...this.statusValue };\n  }\n\n  /** Restore `latest.json` before FalkorDB starts, or keep the local database. */\n  async restore(): Promise<SnapshotManifest | undefined> {\n    await mkdir(this.options.dataDir, { recursive: true });\n    if (!this.options.storage) {\n      logger.info(\"durable storage is not configured; using local RDB persistence\", {\n        dataDir: this.options.dataDir,\n      });\n      return undefined;\n    }\n\n    const raw = await this.options.storage.readJson<unknown>(LATEST_MANIFEST_PATH);\n    if (raw === null) {\n      logger.info(\"no durable FalkorDB snapshot found; using local database\", {\n        dataDir: this.options.dataDir,\n      });\n      return undefined;\n    }\n\n    const started = Date.now();\n    const manifest = parseSnapshotManifest(raw);\n    const temporary = `${this.dumpPath}.restore`;\n    await rm(temporary, { force: true });\n    try {\n      await this.options.storage.download(manifest.snapshot, temporary);\n      await verifySnapshot(temporary, manifest.sha256);\n      await rename(temporary, this.dumpPath);\n    } catch (error) {\n      await rm(temporary, { force: true });\n      throw error;\n    }\n    this.manifest = manifest;\n    this.lastUploadedSaveTime = manifest.redisSaveTime ?? 0;\n    this.statusValue.restoreDurationMs = Date.now() - started;\n    this.statusValue.restoreSnapshotSequence = manifest.sequence;\n    logger.info(\"restored FalkorDB snapshot\", {\n      sequence: manifest.sequence,\n      size: manifest.size,\n      durationMs: this.statusValue.restoreDurationMs,\n    });\n    return manifest;\n  }\n\n  /** Begin polling Redis persistence metadata for completed new snapshots. */\n  async start(redis: RedisPersistenceClient): Promise<void> {\n    if (this.timer) return;\n    this.redis = redis;\n    const initial = await this.observe(redis);\n    if (this.manifest) {\n      this.lastUploadedSaveTime = initial.rdbLastSaveTime;\n    }\n    await this.checkNow();\n    this.timer = setInterval(() => {\n      void this.checkNow().catch((error) => {\n        logger.error(\"FalkorDB persistence check failed; retrying later\", { error });\n      });\n    }, this.options.pollIntervalMs ?? 10_000);\n    this.timer.unref?.();\n  }\n\n  /** Stop background polling without forcing a save or upload. */\n  stop(): void {\n    if (this.timer) clearInterval(this.timer);\n    this.timer = undefined;\n  }\n\n  /** Inspect persistence now, coalescing concurrent checks into the newest RDB. */\n  async checkNow(): Promise<void> {\n    if (!this.redis) return;\n    if (this.backupPromise) {\n      this.checkAgain = true;\n      return this.backupPromise;\n    }\n    this.backupPromise = this.runChecks();\n    try {\n      await this.backupPromise;\n    } finally {\n      this.backupPromise = undefined;\n    }\n  }\n\n  /** Optionally force one dirty save/upload, bounded so shutdown cannot hang. */\n  async prepareShutdown(): Promise<void> {\n    this.stop();\n    if (!this.options.forceBackupOnShutdown || !this.redis) return;\n    const timeoutMs = this.options.shutdownTimeoutMs ?? 30_000;\n    const work = this.finishShutdownBackup(this.redis);\n    const timeout = new AbortController();\n    try {\n      await Promise.race([\n        work,\n        asyncUtils.sleep(timeoutMs, timeout.signal).then(() => {\n          throw new Error(`FalkorDB shutdown backup exceeded ${timeoutMs}ms`);\n        }),\n      ]);\n    } catch (error) {\n      logger.error(\"shutdown backup failed; continuing shutdown\", { error });\n    } finally {\n      timeout.abort();\n    }\n  }\n\n  private async finishShutdownBackup(redis: RedisPersistenceClient): Promise<void> {\n    if (this.backupPromise) {\n      try {\n        await this.backupPromise;\n      } catch (error) {\n        logger.warn(\"in-flight FalkorDB backup failed; retrying during shutdown\", { error });\n      }\n    }\n    await this.forceDirtySnapshot(redis);\n  }\n\n  private async runChecks(): Promise<void> {\n    do {\n      this.checkAgain = false;\n      await this.inspectAndBackup();\n    } while (this.checkAgain);\n  }\n\n  private async inspectAndBackup(): Promise<void> {\n    const redis = this.redis;\n    if (!redis) return;\n    const info = await this.observe(redis);\n    if (info.rdbBgSaveInProgress) return;\n    if (info.rdbLastBgSaveStatus !== \"ok\") {\n      logger.error(\"Redis reported an unsuccessful background save\", {\n        status: info.rdbLastBgSaveStatus,\n      });\n      return;\n    }\n    this.warnIfStale(info);\n    if (!this.options.storage) {\n      if (info.rdbLastSaveTime > this.lastLoggedLocalSaveTime) {\n        this.lastLoggedLocalSaveTime = info.rdbLastSaveTime;\n        logger.info(\"local FalkorDB RDB snapshot completed\", {\n          lastSaveTime: info.rdbLastSaveTime,\n          changesSinceSave: info.rdbChangesSinceLastSave,\n          path: this.dumpPath,\n        });\n      }\n      return;\n    }\n    if (info.rdbLastSaveTime <= this.lastUploadedSaveTime || !existsSync(this.dumpPath)) return;\n    if (Date.now() < this.retryAfter) return;\n\n    try {\n      await this.upload(info);\n      this.retryAttempt = 0;\n      this.retryAfter = 0;\n      const newest = await this.observe(redis);\n      if (newest.rdbLastSaveTime > this.lastUploadedSaveTime) this.checkAgain = true;\n    } catch (error) {\n      this.statusValue.backupFailures += 1;\n      const delays = this.options.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;\n      const delay = asyncUtils.boundedRetryDelay(this.retryAttempt++, delays);\n      this.retryAfter = Date.now() + delay;\n      logger.error(\"durable FalkorDB backup failed; local database remains available\", {\n        error,\n        retryInMs: delay,\n      });\n    }\n  }\n\n  private async upload(info: RedisPersistenceInfo): Promise<void> {\n    const storage = this.options.storage;\n    if (!storage) return;\n    const started = Date.now();\n    const sequence = await nextSnapshotSequence(storage, this.manifest);\n    const remote = snapshotPath(sequence);\n    const stagedPath = join(this.stagingDirectory, `snapshot-${sequence}.rdb`);\n    const staged = await stageSnapshot(this.dumpPath, stagedPath);\n    try {\n      await storage.upload(staged.path, remote, { overwrite: false });\n      const manifest: SnapshotManifest = {\n        snapshot: remote,\n        createdAt: new Date().toISOString(),\n        size: staged.size,\n        sha256: staged.sha256,\n        sequence,\n        redisSaveTime: info.rdbLastSaveTime,\n      };\n      await storage.writeJson(LATEST_MANIFEST_PATH, manifest);\n      this.manifest = manifest;\n      this.lastUploadedSaveTime = info.rdbLastSaveTime;\n      this.statusValue.backupLastSuccessTime = manifest.createdAt;\n      this.statusValue.backupLastSequence = sequence;\n      this.statusValue.backupSizeBytes = staged.size;\n      this.statusValue.backupDurationMs = Date.now() - started;\n      logger.info(\"uploaded durable FalkorDB snapshot\", {\n        sequence,\n        size: staged.size,\n        durationMs: this.statusValue.backupDurationMs,\n      });\n      await enforceRetention(storage, manifest, this.options.retention ?? 5).catch((error) => {\n        logger.warn(\"FalkorDB snapshot retention cleanup failed\", { error });\n      });\n    } finally {\n      await rm(stagedPath, { force: true });\n    }\n  }\n\n  private async forceDirtySnapshot(redis: RedisPersistenceClient): Promise<void> {\n    let info = await this.observe(redis);\n    if (info.rdbChangesSinceLastSave > 0) {\n      const previous = info.rdbLastSaveTime;\n      await redis.bgSave();\n      info = await waitForBackgroundSave(redis, previous, {\n        timeoutMs: this.options.shutdownTimeoutMs ?? 30_000,\n      });\n    }\n    if (this.options.storage && info.rdbLastSaveTime > this.lastUploadedSaveTime) {\n      this.retryAfter = 0;\n      await this.upload(info);\n    }\n  }\n\n  private async observe(redis: RedisPersistenceClient): Promise<RedisPersistenceInfo> {\n    const info = await getPersistenceInfo(redis);\n    this.statusValue.rdbLastSaveTime = info.rdbLastSaveTime;\n    this.statusValue.rdbChangesSinceLastSave = info.rdbChangesSinceLastSave;\n    return info;\n  }\n\n  private warnIfStale(info: RedisPersistenceInfo): void {\n    if (!this.options.storage) return;\n    const threshold = this.options.staleBackupWarningMs;\n    if (!threshold || info.rdbChangesSinceLastSave === 0) return;\n    const last = this.statusValue.backupLastSuccessTime\n      ? Date.parse(this.statusValue.backupLastSuccessTime)\n      : 0;\n    if (Date.now() - last > threshold) {\n      logger.warn(\"FalkorDB has changes without a recent durable backup\", {\n        changesSinceSave: info.rdbChangesSinceLastSave,\n        lastSuccessTime: this.statusValue.backupLastSuccessTime,\n      });\n    }\n  }\n}\n"]}

package/lib/src/persistence/manifest.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Durable snapshot manifest naming, validation, sequencing, and retention.
+ *
+ * `latest.json` is updated only after its immutable snapshot exists. Reuse this
+ * module for manifest policy so restore and cleanup cannot disagree about the
+ * current good snapshot.
+ *
+ * @module
+ */
+import type { VolumeStorage } from "./volume.ts";
+/** Durable pointer updated only after a complete immutable snapshot upload. */
+export declare const LATEST_MANIFEST_PATH = "latest.json";
+/** Directory containing immutable, monotonically sequenced RDB files. */
+export declare const SNAPSHOT_DIRECTORY = "snapshots";
+/** Durable pointer to one verified immutable RDB snapshot. */
+export interface SnapshotManifest {
+    snapshot: string;
+    createdAt: string;
+    size: number;
+    sha256: string;
+    sequence: number;
+    /** Redis `rdb_last_save_time` represented by this snapshot. */
+    redisSaveTime?: number;
+}
+/** Parse an untrusted manifest read from durable storage. */
+export declare function parseSnapshotManifest(value: unknown): SnapshotManifest;
+/** Remote path for an immutable, monotonically sequenced RDB snapshot. */
+export declare function snapshotPath(sequence: number): string;
+/** Choose a sequence above both the manifest and any orphaned uploads. */
+export declare function nextSnapshotSequence(storage: VolumeStorage, manifest?: SnapshotManifest): Promise<number>;
+/** Delete old immutable snapshots while preserving the manifest target. */
+export declare function enforceRetention(storage: VolumeStorage, manifest: SnapshotManifest, retain: number): Promise<void>;

package/lib/src/persistence/manifest.js

@@ -0,0 +1,89 @@
+/**
+ * Durable snapshot manifest naming, validation, sequencing, and retention.
+ *
+ * `latest.json` is updated only after its immutable snapshot exists. Reuse this
+ * module for manifest policy so restore and cleanup cannot disagree about the
+ * current good snapshot.
+ *
+ * @module
+ */
+import { posix } from "node:path";
+/** Durable pointer updated only after a complete immutable snapshot upload. */
+export const LATEST_MANIFEST_PATH = "latest.json";
+/** Directory containing immutable, monotonically sequenced RDB files. */
+export const SNAPSHOT_DIRECTORY = "snapshots";
+/** Parse an untrusted manifest read from durable storage. */
+export function parseSnapshotManifest(value) {
+    if (!isRecord(value))
+        throw new TypeError("FalkorDB latest.json must be an object");
+    const manifest = {
+        snapshot: requiredString(value.snapshot, "snapshot"),
+        createdAt: requiredString(value.createdAt, "createdAt"),
+        size: nonNegativeInteger(value.size, "size"),
+        sha256: requiredString(value.sha256, "sha256").toLowerCase(),
+        sequence: positiveInteger(value.sequence, "sequence"),
+        ...(value.redisSaveTime === undefined
+            ? {}
+            : { redisSaveTime: nonNegativeInteger(value.redisSaveTime, "redisSaveTime") }),
+    };
+    if (!manifest.snapshot.startsWith(`${SNAPSHOT_DIRECTORY}/`)) {
+        throw new TypeError("FalkorDB manifest snapshot must be under snapshots/");
+    }
+    if (!/^[a-f0-9]{64}$/.test(manifest.sha256)) {
+        throw new TypeError("FalkorDB manifest sha256 must be a 64-character hex digest");
+    }
+    if (!Number.isFinite(Date.parse(manifest.createdAt))) {
+        throw new TypeError("FalkorDB manifest createdAt must be an ISO date");
+    }
+    return manifest;
+}
+/** Remote path for an immutable, monotonically sequenced RDB snapshot. */
+export function snapshotPath(sequence) {
+    return posix.join(SNAPSHOT_DIRECTORY, `${String(sequence).padStart(8, "0")}.rdb`);
+}
+/** Choose a sequence above both the manifest and any orphaned uploads. */
+export async function nextSnapshotSequence(storage, manifest) {
+    const entries = await storage.list(SNAPSHOT_DIRECTORY);
+    let maximum = manifest?.sequence ?? 0;
+    for (const entry of entries) {
+        const match = /^(\d+)\.rdb$/.exec(entry.name);
+        if (match)
+            maximum = Math.max(maximum, Number.parseInt(match[1], 10));
+    }
+    return maximum + 1;
+}
+/** Delete old immutable snapshots while preserving the manifest target. */
+export async function enforceRetention(storage, manifest, retain) {
+    const snapshots = (await storage.list(SNAPSHOT_DIRECTORY))
+        .map((entry) => ({ entry, match: /^(\d+)\.rdb$/.exec(entry.name) }))
+        .filter((item) => item.match !== null)
+        .map(({ entry, match }) => ({ entry, sequence: Number.parseInt(match[1], 10) }))
+        .sort((left, right) => right.sequence - left.sequence);
+    const keep = new Set(snapshots.slice(0, Math.max(1, retain)).map(({ entry }) => entry.path));
+    keep.add(manifest.snapshot);
+    for (const { entry } of snapshots) {
+        if (!keep.has(entry.path))
+            await storage.delete(entry.path);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredString(value, name) {
+    if (typeof value !== "string" || !value.trim())
+        throw new TypeError(`${name} must be a string`);
+    return value;
+}
+function nonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0) {
+        throw new TypeError(`${name} must be a non-negative integer`);
+    }
+    return Number(value);
+}
+function positiveInteger(value, name) {
+    const parsed = nonNegativeInteger(value, name);
+    if (parsed < 1)
+        throw new TypeError(`${name} must be positive`);
+    return parsed;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../../src/persistence/manifest.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Durable snapshot manifest naming, validation, sequencing, and retention.\n *\n * `latest.json` is updated only after its immutable snapshot exists. Reuse this\n * module for manifest policy so restore and cleanup cannot disagree about the\n * current good snapshot.\n *\n * @module\n */\n\nimport { posix } from \"node:path\";\nimport type { VolumeStorage } from \"./volume.ts\";\n\n/** Durable pointer updated only after a complete immutable snapshot upload. */\nexport const LATEST_MANIFEST_PATH = \"latest.json\";\n\n/** Directory containing immutable, monotonically sequenced RDB files. */\nexport const SNAPSHOT_DIRECTORY = \"snapshots\";\n\n/** Durable pointer to one verified immutable RDB snapshot. */\nexport interface SnapshotManifest {\n  snapshot: string;\n  createdAt: string;\n  size: number;\n  sha256: string;\n  sequence: number;\n  /** Redis `rdb_last_save_time` represented by this snapshot. */\n  redisSaveTime?: number;\n}\n\n/** Parse an untrusted manifest read from durable storage. */\nexport function parseSnapshotManifest(value: unknown): SnapshotManifest {\n  if (!isRecord(value)) throw new TypeError(\"FalkorDB latest.json must be an object\");\n  const manifest: SnapshotManifest = {\n    snapshot: requiredString(value.snapshot, \"snapshot\"),\n    createdAt: requiredString(value.createdAt, \"createdAt\"),\n    size: nonNegativeInteger(value.size, \"size\"),\n    sha256: requiredString(value.sha256, \"sha256\").toLowerCase(),\n    sequence: positiveInteger(value.sequence, \"sequence\"),\n    ...(value.redisSaveTime === undefined\n      ? {}\n      : { redisSaveTime: nonNegativeInteger(value.redisSaveTime, \"redisSaveTime\") }),\n  };\n  if (!manifest.snapshot.startsWith(`${SNAPSHOT_DIRECTORY}/`)) {\n    throw new TypeError(\"FalkorDB manifest snapshot must be under snapshots/\");\n  }\n  if (!/^[a-f0-9]{64}$/.test(manifest.sha256)) {\n    throw new TypeError(\"FalkorDB manifest sha256 must be a 64-character hex digest\");\n  }\n  if (!Number.isFinite(Date.parse(manifest.createdAt))) {\n    throw new TypeError(\"FalkorDB manifest createdAt must be an ISO date\");\n  }\n  return manifest;\n}\n\n/** Remote path for an immutable, monotonically sequenced RDB snapshot. */\nexport function snapshotPath(sequence: number): string {\n  return posix.join(SNAPSHOT_DIRECTORY, `${String(sequence).padStart(8, \"0\")}.rdb`);\n}\n\n/** Choose a sequence above both the manifest and any orphaned uploads. */\nexport async function nextSnapshotSequence(\n  storage: VolumeStorage,\n  manifest?: SnapshotManifest,\n): Promise<number> {\n  const entries = await storage.list(SNAPSHOT_DIRECTORY);\n  let maximum = manifest?.sequence ?? 0;\n  for (const entry of entries) {\n    const match = /^(\\d+)\\.rdb$/.exec(entry.name);\n    if (match) maximum = Math.max(maximum, Number.parseInt(match[1]!, 10));\n  }\n  return maximum + 1;\n}\n\n/** Delete old immutable snapshots while preserving the manifest target. */\nexport async function enforceRetention(\n  storage: VolumeStorage,\n  manifest: SnapshotManifest,\n  retain: number,\n): Promise<void> {\n  const snapshots = (await storage.list(SNAPSHOT_DIRECTORY))\n    .map((entry) => ({ entry, match: /^(\\d+)\\.rdb$/.exec(entry.name) }))\n    .filter((item): item is typeof item & { match: RegExpExecArray } => item.match !== null)\n    .map(({ entry, match }) => ({ entry, sequence: Number.parseInt(match[1]!, 10) }))\n    .sort((left, right) => right.sequence - left.sequence);\n  const keep = new Set(snapshots.slice(0, Math.max(1, retain)).map(({ entry }) => entry.path));\n  keep.add(manifest.snapshot);\n  for (const { entry } of snapshots) {\n    if (!keep.has(entry.path)) await storage.delete(entry.path);\n  }\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction requiredString(value: unknown, name: string): string {\n  if (typeof value !== \"string\" || !value.trim()) throw new TypeError(`${name} must be a string`);\n  return value;\n}\n\nfunction nonNegativeInteger(value: unknown, name: string): number {\n  if (!Number.isSafeInteger(value) || Number(value) < 0) {\n    throw new TypeError(`${name} must be a non-negative integer`);\n  }\n  return Number(value);\n}\n\nfunction positiveInteger(value: unknown, name: string): number {\n  const parsed = nonNegativeInteger(value, name);\n  if (parsed < 1) throw new TypeError(`${name} must be positive`);\n  return parsed;\n}\n"]}

package/lib/src/persistence/redis-info.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Redis persistence metadata parsing and completed-RDB detection.
+ *
+ * Reuse this module whenever FalkorDB persistence decisions depend on `INFO
+ * persistence`; do not infer snapshot completion from filesystem timestamps
+ * alone or trigger `BGSAVE` merely to discover whether the graph changed.
+ *
+ * @module
+ */
+/** Redis persistence fields required by durable snapshot orchestration. */
+export interface RedisPersistenceInfo {
+    rdbBgSaveInProgress: boolean;
+    rdbLastSaveTime: number;
+    rdbLastBgSaveStatus: string;
+    rdbChangesSinceLastSave: number;
+}
+/** Minimal Redis client surface used by the persistence manager. */
+export interface RedisPersistenceClient {
+    info(section: "persistence"): Promise<string>;
+    bgSave(): Promise<unknown>;
+}
+/** Parse the fields used by the backup manager from `INFO persistence`. */
+export declare function parsePersistenceInfo(raw: string): RedisPersistenceInfo;
+/** Read and parse the current Redis persistence state. */
+export declare function getPersistenceInfo(redis: RedisPersistenceClient): Promise<RedisPersistenceInfo>;
+/** Wait until a requested background save finishes successfully. */
+export declare function waitForBackgroundSave(redis: RedisPersistenceClient, previousSaveTime: number, options?: {
+    intervalMs?: number;
+    timeoutMs?: number;
+}): Promise<RedisPersistenceInfo>;