refactor: extract flagged storage entry wrappers

Author: ndycode

lib/storage.ts

@@ -31,6 +31,10 @@ import {
 } from "./storage/backup-paths.js";
 import { restoreAccountsFromBackupPath } from "./storage/backup-restore.js";
 import { looksLikeSyntheticFixtureStorage } from "./storage/fixture-guards.js";
+import {
+	clearFlaggedAccountsEntry,
+	saveFlaggedAccountsEntry,
+} from "./storage/flagged-entry.js";
 import { normalizeFlaggedStorage } from "./storage/flagged-storage.js";
 import {
 	clearFlaggedAccountsOnDisk,

lib/storage/flagged-entry.ts

@@ -0,0 +1,34 @@
+import type { FlaggedAccountStorageV1 } from "../storage.js";
+
+export async function saveFlaggedAccountsEntry(params: {
+	storage: FlaggedAccountStorageV1;
+	withStorageLock: <T>(fn: () => Promise<T>) => Promise<T>;
+	saveUnlocked: (storage: FlaggedAccountStorageV1) => Promise<void>;
+}): Promise<void> {
+	return params.withStorageLock(async () => {
+		await params.saveUnlocked(params.storage);
+	});
+}
+
+export async function clearFlaggedAccountsEntry(params: {
+	path: string;
+	withStorageLock: <T>(fn: () => Promise<T>) => Promise<T>;
+	markerPath: string;
+	getBackupPaths: () => Promise<string[]>;
+	clearFlaggedAccountsOnDisk: (args: {
+		path: string;
+		markerPath: string;
+		backupPaths: string[];
+		logError: (message: string, details: Record<string, unknown>) => void;
+	}) => Promise<void>;
+	logError: (message: string, details: Record<string, unknown>) => void;
+}): Promise<void> {
+	return params.withStorageLock(async () => {
+		await params.clearFlaggedAccountsOnDisk({
+			path: params.path,
+			markerPath: params.markerPath,
+			backupPaths: await params.getBackupPaths(),
+			logError: params.logError,
+		});
+	});
+}

test/flagged-entry.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	clearFlaggedAccountsEntry,
+	saveFlaggedAccountsEntry,
+} from "../lib/storage/flagged-entry.js";
+
+describe("flagged entry helpers", () => {
+	it("delegates save through the storage lock", async () => {
+		const saveUnlocked = vi.fn(async () => undefined);
+		await saveFlaggedAccountsEntry({
+			storage: { version: 1, accounts: [] },
+			withStorageLock: async (fn) => fn(),
+			saveUnlocked,
+		});
+
+		expect(saveUnlocked).toHaveBeenCalledWith({ version: 1, accounts: [] });
+	});
+
+	it("delegates clear through the storage lock and backup resolver", async () => {
+		const clearFlaggedAccountsOnDisk = vi.fn(async () => undefined);
+		await clearFlaggedAccountsEntry({
+			path: "/tmp/flagged.json",
+			withStorageLock: async (fn) => fn(),
+			markerPath: "/tmp/flagged.marker",
+			getBackupPaths: async () => ["/tmp/flagged.json.bak"],
+			clearFlaggedAccountsOnDisk,
+			logError: vi.fn(),
+		});
+
+		expect(clearFlaggedAccountsOnDisk).toHaveBeenCalledWith({
+			path: "/tmp/flagged.json",
+			markerPath: "/tmp/flagged.marker",
+			backupPaths: ["/tmp/flagged.json.bak"],
+			logError: expect.any(Function),
+		});
+	});
+});