refactor: extract account snapshot helpers

Author: ndycode

lib/storage.ts

@@ -11,6 +11,10 @@ import {
 } from "./named-backup-export.js";
 import { MODEL_FAMILIES, type ModelFamily } from "./prompts/codex.js";
 import { AnyAccountStorageSchema, getValidationErrors } from "./schemas.js";
+import {
+	describeAccountSnapshot,
+	statSnapshot,
+} from "./storage/account-snapshot.js";
 import {
 	type BackupMetadataSection,
 	type BackupSnapshotMetadata,
@@ -115,17 +119,6 @@ type AccountStorageWithMetadata = AccountStorageV3 & {
 	restoreReason?: RestoreReason;
 };
 
-type BackupSnapshotKind =
-	| "accounts-primary"
-	| "accounts-wal"
-	| "accounts-backup"
-	| "accounts-backup-history"
-	| "accounts-discovered-backup"
-	| "flagged-primary"
-	| "flagged-backup"
-	| "flagged-backup-history"
-	| "flagged-discovered-backup";
-
 export type BackupMetadata = {
 	accounts: BackupMetadataSection;
 	flaggedAccounts: BackupMetadataSection;
@@ -511,70 +504,6 @@ function isCacheLikeBackupArtifactName(entryName: string): boolean {
 	return entryName.toLowerCase().includes(".cache");
 }
 
-async function statSnapshot(path: string): Promise<{
-	exists: boolean;
-	bytes?: number;
-	mtimeMs?: number;
-}> {
-	try {
-		const stats = await fs.stat(path);
-		return { exists: true, bytes: stats.size, mtimeMs: stats.mtimeMs };
-	} catch (error) {
-		const code = (error as NodeJS.ErrnoException).code;
-		if (code !== "ENOENT") {
-			log.warn("Failed to stat backup candidate", {
-				path,
-				error: String(error),
-			});
-		}
-		return { exists: false };
-	}
-}
-
-async function describeAccountSnapshot(
-	path: string,
-	kind: BackupSnapshotKind,
-	index?: number,
-): Promise<BackupSnapshotMetadata> {
-	const stats = await statSnapshot(path);
-	if (!stats.exists) {
-		return { kind, path, index, exists: false, valid: false };
-	}
-	try {
-		const { normalized, schemaErrors, storedVersion } =
-			await loadAccountsFromPath(path);
-		return {
-			kind,
-			path,
-			index,
-			exists: true,
-			valid: !!normalized,
-			bytes: stats.bytes,
-			mtimeMs: stats.mtimeMs,
-			version: typeof storedVersion === "number" ? storedVersion : undefined,
-			accountCount: normalized?.accounts.length,
-			schemaErrors: schemaErrors.length > 0 ? schemaErrors : undefined,
-		};
-	} catch (error) {
-		const code = (error as NodeJS.ErrnoException).code;
-		if (code !== "ENOENT") {
-			log.warn("Failed to inspect account snapshot", {
-				path,
-				error: String(error),
-			});
-		}
-		return {
-			kind,
-			path,
-			index,
-			exists: true,
-			valid: false,
-			bytes: stats.bytes,
-			mtimeMs: stats.mtimeMs,
-		};
-	}
-}
-
 async function loadFlaggedAccountsFromPath(
 	path: string,
 ): Promise<FlaggedAccountStorageV1> {
@@ -1241,10 +1170,24 @@ export async function getBackupMetadata(): Promise<BackupMetadata> {
 		flaggedPath,
 		getAccountsWalPath,
 		getAccountsBackupRecoveryCandidatesWithDiscovery,
-		describeAccountSnapshot,
+		describeAccountSnapshot: (path, kind, index) =>
+			describeAccountSnapshot(path, kind, {
+				index,
+				statSnapshot: (targetPath) =>
+					statSnapshot(targetPath, {
+						stat: fs.stat,
+						logWarn: (message, meta) => log.warn(message, meta),
+					}),
+				loadAccountsFromPath,
+				logWarn: (message, meta) => log.warn(message, meta),
+			}),
 		describeAccountsWalSnapshot: (path) =>
 			describeAccountsWalSnapshot(path, {
-				statSnapshot,
+				statSnapshot: (targetPath) =>
+					statSnapshot(targetPath, {
+						stat: fs.stat,
+						logWarn: (message, meta) => log.warn(message, meta),
+					}),
 				readFile: fs.readFile,
 				isRecord,
 				computeSha256,
@@ -1253,7 +1196,11 @@ export async function getBackupMetadata(): Promise<BackupMetadata> {
 		describeFlaggedSnapshot: (path, kind, index) =>
 			describeFlaggedSnapshot(path, kind, {
 				index,
-				statSnapshot,
+				statSnapshot: (targetPath) =>
+					statSnapshot(targetPath, {
+						stat: fs.stat,
+						logWarn: (message, meta) => log.warn(message, meta),
+					}),
 				loadFlaggedAccountsFromPath,
 				logWarn: (message, meta) => log.warn(message, meta),
 			}),

lib/storage/account-snapshot.ts

@@ -0,0 +1,82 @@
+import type { BackupSnapshotMetadata } from "./backup-metadata.js";
+
+type SnapshotStats = {
+	exists: boolean;
+	bytes?: number;
+	mtimeMs?: number;
+};
+
+export async function statSnapshot(
+	path: string,
+	deps: {
+		stat: typeof import("node:fs").promises.stat;
+		logWarn?: (message: string, meta: Record<string, unknown>) => void;
+	},
+): Promise<SnapshotStats> {
+	try {
+		const stats = await deps.stat(path);
+		return { exists: true, bytes: stats.size, mtimeMs: stats.mtimeMs };
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code !== "ENOENT") {
+			deps.logWarn?.("Failed to stat backup candidate", {
+				path,
+				error: String(error),
+			});
+		}
+		return { exists: false };
+	}
+}
+
+export async function describeAccountSnapshot(
+	path: string,
+	kind: BackupSnapshotMetadata["kind"],
+	deps: {
+		index?: number;
+		statSnapshot: (path: string) => Promise<SnapshotStats>;
+		loadAccountsFromPath: (path: string) => Promise<{
+			normalized: { accounts: unknown[] } | null;
+			schemaErrors: string[];
+			storedVersion?: unknown;
+		}>;
+		logWarn?: (message: string, meta: Record<string, unknown>) => void;
+	},
+): Promise<BackupSnapshotMetadata> {
+	const stats = await deps.statSnapshot(path);
+	if (!stats.exists) {
+		return { kind, path, index: deps.index, exists: false, valid: false };
+	}
+	try {
+		const { normalized, schemaErrors, storedVersion } =
+			await deps.loadAccountsFromPath(path);
+		return {
+			kind,
+			path,
+			index: deps.index,
+			exists: true,
+			valid: !!normalized,
+			bytes: stats.bytes,
+			mtimeMs: stats.mtimeMs,
+			version: typeof storedVersion === "number" ? storedVersion : undefined,
+			accountCount: normalized?.accounts.length,
+			schemaErrors: schemaErrors.length > 0 ? schemaErrors : undefined,
+		};
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code !== "ENOENT") {
+			deps.logWarn?.("Failed to inspect account snapshot", {
+				path,
+				error: String(error),
+			});
+		}
+		return {
+			kind,
+			path,
+			index: deps.index,
+			exists: true,
+			valid: false,
+			bytes: stats.bytes,
+			mtimeMs: stats.mtimeMs,
+		};
+	}
+}