Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
400 changes: 358 additions & 42 deletions src/app/App.tsx

Large diffs are not rendered by default.

159 changes: 159 additions & 0 deletions src/app/persistence.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,159 @@
import { describe, expect, it } from "vitest";
import { scenario } from "../board/board";
import {
parseWorkspace,
serializeWorkspace,
type LocalWorkspace,
} from "./workspace";
import {
RECOVERY_KEY,
RECOVERY_PREVIOUS_KEY,
WORKSPACE_KEY,
discardRecovery,
loadStoredWorkspace,
planWorkspaceWrite,
recoveryText,
workspaceContent,
type StorageLike,
} from "./persistence";

function memory(): StorageLike & { map: Map<string, string> } {
const map = new Map<string, string>();
return {
map,
getItem: (key) => map.get(key) ?? null,
setItem: (key, value) => map.set(key, value),
removeItem: (key) => map.delete(key),
};
}
function workspace(patch: Partial<LocalWorkspace> = {}): LocalWorkspace {
return {
board: scenario("cache"),
view: "gallery",
revision: 0,
...patch,
};
}

describe("workspace persistence", () => {
it("does not rewrite an unchanged document or replace a newer tab", () => {
const stored = serializeWorkspace(workspace({ revision: 4 }));
expect(
planWorkspaceWrite({
baseRevision: 4,
storedText: stored,
nextText: serializeWorkspace(workspace({ revision: 4 })),
}),
).toEqual({ action: "adopt", revision: 4 });
const newer = serializeWorkspace(
workspace({
revision: 5,
board: { ...scenario("cache"), title: "Other tab" },
}),
);
const conflict = planWorkspaceWrite({
baseRevision: 4,
storedText: newer,
nextText: serializeWorkspace(
workspace({
revision: 4,
board: { ...scenario("cache"), title: "This tab" },
}),
),
});
expect(conflict).toMatchObject({ action: "conflict", storedRevision: 5 });
const kept = planWorkspaceWrite({
baseRevision: 5,
storedText: newer,
nextText: serializeWorkspace(
workspace({
revision: 5,
board: { ...scenario("cache"), title: "This tab" },
}),
),
});
expect(kept.action).toBe("write");
if (kept.action === "write") {
expect(kept.revision).toBe(6);
expect(parseWorkspace(kept.text).board.title).toBe("This tab");
}
});
it("treats node movement as the same workspace content", () => {
const board = scenario("cache");
const moved = structuredClone(board);
moved.nodes[0].position = { x: 40, y: 80 };
expect(workspaceContent(serializeWorkspace(workspace({ board })))).toBe(
workspaceContent(serializeWorkspace(workspace({ board: moved }))),
);
});
it("adopts the same board saved by another tab without writing over it", () => {
const board = scenario("cache");
const stored = serializeWorkspace(workspace({ board, revision: 7 }));
expect(
planWorkspaceWrite({
baseRevision: 6,
storedText: stored,
nextText: serializeWorkspace(workspace({ board, revision: 6 })),
}),
).toEqual({ action: "adopt", revision: 7 });
});
it("refuses to replace unreadable storage and keeps a recoverable copy", () => {
const store = memory();
store.setItem(WORKSPACE_KEY, "{");
const loaded = loadStoredWorkspace(store, 1000);
expect(loaded).toMatchObject({ status: "unreadable", preserved: true });
expect(store.getItem(WORKSPACE_KEY)).toBe("{");
expect(recoveryText(store.getItem(RECOVERY_KEY))).toBe("{");
const replaced = planWorkspaceWrite({
baseRevision: 0,
storedText: "{",
nextText: serializeWorkspace(workspace()),
});
expect(replaced.action).toBe("write");
if (replaced.action === "write") {
expect(replaced.revision).toBe(1);
expect(parseWorkspace(replaced.text).board.title).toBe("User profile API");
}
const blocked = memory();
blocked.setItem = () => {
throw new Error("quota");
};
blocked.map.set(WORKSPACE_KEY, "{not json");
const blockedLoad = loadStoredWorkspace(blocked);
expect(blockedLoad.status).toBe("unreadable");
if (blockedLoad.status === "unreadable")
expect(blockedLoad.preserved).toBe(false);
expect(
planWorkspaceWrite({
baseRevision: 0,
storedText: null,
nextText: serializeWorkspace(workspace()),
blockWrites: true,
}).action,
).toBe("refuse");
});
it("keeps the previous recovery when a second unreadable document appears", () => {
const store = memory();
store.setItem(WORKSPACE_KEY, "{first");
expect(loadStoredWorkspace(store, 1).status).toBe("unreadable");
store.setItem(WORKSPACE_KEY, "{second");
expect(loadStoredWorkspace(store, 2).status).toBe("unreadable");
expect(recoveryText(store.getItem(RECOVERY_KEY))).toBe("{second");
expect(recoveryText(store.getItem(RECOVERY_PREVIOUS_KEY))).toBe("{first");
discardRecovery(store);
expect(store.getItem(RECOVERY_KEY)).toBeNull();
expect(store.getItem(RECOVERY_PREVIOUS_KEY)).toBeNull();
});
it("still loads a legacy board file stored before workspace revisions", () => {
const store = memory();
const board = scenario("balanced");
store.setItem(
WORKSPACE_KEY,
JSON.stringify(JSON.parse(serializeWorkspace(workspace({ board }))).board),
);
const loaded = loadStoredWorkspace(store);
expect(loaded.status).toBe("ok");
if (loaded.status === "ok")
expect(loaded.workspace.board.title).toBe(board.title);
});
});
182 changes: 182 additions & 0 deletions src/app/persistence.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,182 @@
import { parseWorkspace, type LocalWorkspace } from "./workspace";

export const WORKSPACE_KEY = "liveboard-v1";
export const RECOVERY_KEY = "liveboard-v1-recovery";
export const RECOVERY_PREVIOUS_KEY = "liveboard-v1-recovery-previous";

export type StorageLike = {
getItem(key: string): string | null;
setItem(key: string, value: string): void;
removeItem(key: string): void;
};

export type LoadResult =
| { status: "empty" }
| { status: "ok"; workspace: LocalWorkspace; text: string }
| { status: "unreadable"; text: string; preserved: boolean };

export type WritePlan =
| { action: "write"; text: string; revision: number }
| { action: "adopt"; revision: number }
| { action: "conflict"; storedText: string; storedRevision: number }
| { action: "refuse"; reason: "unreadable" | "quarantine" };

function canonical(value: unknown): unknown {
if (Array.isArray(value)) return value.map(canonical);
if (value && typeof value === "object")
return Object.fromEntries(
Object.entries(value as Record<string, unknown>)
.sort(([a], [b]) => a.localeCompare(b))
.map(([key, item]) => [key, canonical(item)]),
);
return value;
}
export function workspaceBody(text: string): string {
try {
const raw = JSON.parse(text) as Record<string, unknown> | null;
if (raw && typeof raw === "object" && !Array.isArray(raw))
delete raw.revision;
return JSON.stringify(canonical(raw));
} catch {
return text;
}
}
export function workspaceContent(text: string): string {
try {
const raw = JSON.parse(text) as {
revision?: number;
board?: { nodes?: { position?: unknown }[] };
};
delete raw.revision;
for (const node of raw.board?.nodes ?? []) delete node.position;
return JSON.stringify(canonical(raw));
} catch {
return text;
}
}

export function storedRevision(text: string | null): number | "unreadable" {
if (!text) return 0;
try {
const raw = JSON.parse(text) as Record<string, unknown> | null;
if (!raw || typeof raw !== "object" || Array.isArray(raw))
return "unreadable";
if (raw.format !== "liveboard-workspace-v1") return 0;
if (raw.revision === undefined) return 0;
if (
typeof raw.revision === "number" &&
Number.isInteger(raw.revision) &&
raw.revision >= 0 &&
raw.revision <= Number.MAX_SAFE_INTEGER
)
return raw.revision;
return "unreadable";
} catch {
return "unreadable";
}
}

export function planWorkspaceWrite(input: {
baseRevision: number;
storedText: string | null;
nextText: string;
blockWrites?: boolean;
}): WritePlan {
if (input.blockWrites) return { action: "refuse", reason: "quarantine" };
const revision = storedRevision(input.storedText);
if (revision === "unreadable") {
const raw = JSON.parse(input.nextText) as Record<string, unknown>;
raw.revision = 1;
return { action: "write", text: JSON.stringify(raw), revision: 1 };
}
const nextBody = workspaceBody(input.nextText);
const storedBody = input.storedText ? workspaceBody(input.storedText) : "";
if (input.storedText && revision > input.baseRevision) {
if (storedBody === nextBody) return { action: "adopt", revision };
return {
action: "conflict",
storedText: input.storedText,
storedRevision: revision,
};
}
if (input.storedText && storedBody === nextBody)
return { action: "adopt", revision };
const nextRevision = revision + 1;
const raw = JSON.parse(input.nextText) as Record<string, unknown>;
raw.revision = nextRevision;
return {
action: "write",
text: JSON.stringify(raw),
revision: nextRevision,
};
}

export function recoveryText(record: string | null): string | undefined {
if (!record) return undefined;
try {
const raw = JSON.parse(record) as Record<string, unknown> | null;
if (
raw?.format === "liveboard-recovery-v1" &&
typeof raw.text === "string" &&
raw.text.length > 0
)
return raw.text;
} catch {
return undefined;
}
return undefined;
}

function preserveUnreadable(
storage: StorageLike,
text: string,
now: number,
): boolean {
const record = JSON.stringify({
format: "liveboard-recovery-v1",
savedAt: now,
text,
});
try {
const existing = storage.getItem(RECOVERY_KEY);
if (existing && recoveryText(existing) !== text) {
if (!storage.getItem(RECOVERY_PREVIOUS_KEY))
storage.setItem(RECOVERY_PREVIOUS_KEY, existing);
}
storage.setItem(RECOVERY_KEY, record);
return recoveryText(storage.getItem(RECOVERY_KEY)) === text;
} catch {
return false;
}
}

export function loadStoredWorkspace(
storage: StorageLike,
now = Date.now(),
): LoadResult {
let text: string | null;
try {
text = storage.getItem(WORKSPACE_KEY);
} catch {
return { status: "empty" };
}
if (!text) return { status: "empty" };
try {
return { status: "ok", workspace: parseWorkspace(text), text };
} catch {
return {
status: "unreadable",
text,
preserved: preserveUnreadable(storage, text, now),
};
}
}

export function discardRecovery(storage: StorageLike) {
try {
storage.removeItem(RECOVERY_KEY);
storage.removeItem(RECOVERY_PREVIOUS_KEY);
} catch {
/* The banner can close even when storage is blocked. */
}
}
Loading
Loading