refactor(web): remove legacy settings migration (#1704)

* refactor(web): remove legacy settings migration

* fix(web): hydrate portable settings from boot state

* fix(web): preserve sidebar sync contracts

* fix(web): retain portable settings filters

* fix(web): retry sidebar settings writes

* fix(web): retain sidebar boot settings

* fix(websocket): avoid shutdown teardown leaks

* fix(boot): normalize sidebar task preferences

* fix(settings): preserve saved views during hydration

* fix(jira): avoid duplicate saved-view syncs

* fix(jira): preserve saved views on fetch failure

* fix(jira): retry saved-view hydration failures

* refactor(jira): simplify hydration request cleanup

* fix(websocket): close late clients after hub shutdown
This commit is contained in:
Carlos Florêncio
2026-07-16 00:06:41 +01:00
committed by GitHub
parent d763b8c0c9
commit b9eb6ae058
60 changed files with 891 additions and 1808 deletions
@@ -12,7 +12,6 @@ import {
} from "./use-default-query-presets";
const STORAGE_KEY = "kandev:github-default-queries:v1";
const SYNC_FAILED_KEY = "kandev:github-default-queries:sync-failed:v1";
const WORKSPACE_ID = "ws-1";
const SETTINGS_TIMESTAMP = "2026-01-01T00:00:00Z";
@@ -82,88 +81,18 @@ function resetMocks() {
);
}
describe("useDefaultQueryPresets legacy sync", () => {
beforeEach(resetMocks);
it("retries local defaults after a failed backend sync and clears the marker", async () => {
const local = { pr: [preset], issue: [] };
localStorageMock.setItem(STORAGE_KEY, JSON.stringify(local));
localStorageMock.setItem(SYNC_FAILED_KEY, "1");
renderHook(() => useDefaultQueryPresets());
await waitFor(() => {
expect(updateUserSettings).toHaveBeenCalledWith({
github_default_query_presets: local,
});
expect(localStorageMock.getItem(SYNC_FAILED_KEY)).toBeNull();
});
});
it("retries null local defaults after a failed reset sync", async () => {
localStorageMock.setItem(SYNC_FAILED_KEY, "1");
vi.mocked(fetchUserSettings).mockResolvedValue({
settings: { github_default_query_presets: { pr: [preset], issue: [] } },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
renderHook(() => useDefaultQueryPresets());
await waitFor(() => {
expect(updateUserSettings).toHaveBeenCalledWith({
github_default_query_presets: null,
});
expect(localStorageMock.getItem(SYNC_FAILED_KEY)).toBeNull();
});
});
it("does not overwrite cross-tab local changes with a stale hydration response", async () => {
const initial = { pr: [preset], issue: [] };
const crossTab = { pr: [], issue: [preset] };
const server = {
pr: [{ ...preset, value: "server", label: "Server" }],
issue: [],
};
let resolveFetch: (value: Awaited<ReturnType<typeof fetchUserSettings>>) => void = () => {};
vi.mocked(fetchUserSettings).mockReturnValue(
new Promise((resolve) => {
resolveFetch = resolve;
}),
);
localStorageMock.setItem(STORAGE_KEY, JSON.stringify(initial));
renderHook(() => useDefaultQueryPresets());
await waitFor(() => expect(fetchUserSettings).toHaveBeenCalled());
localStorageMock.setItem(STORAGE_KEY, JSON.stringify(crossTab));
const event = new Event("storage");
Object.defineProperty(event, "key", { value: STORAGE_KEY });
window.dispatchEvent(event);
resolveFetch({
settings: { github_default_query_presets: server },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
await Promise.resolve();
await Promise.resolve();
expect(localStorageMock.getItem(STORAGE_KEY)).toBe(JSON.stringify(crossTab));
expect(updateUserSettings).not.toHaveBeenCalled();
});
});
describe("useDefaultQueryPresets workspace sync", () => {
beforeEach(resetMocks);
it("migrates local defaults into a fresh workspace", async () => {
it("ignores stale local defaults when workspace settings are empty", async () => {
const local = { pr: [preset], issue: [] };
localStorageMock.setItem(STORAGE_KEY, JSON.stringify(local));
__resetSnapshotForTests();
const { result } = renderHook(() => useDefaultQueryPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.prPresets[0]?.value).toBe("mine"));
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledWith({
workspace_id: WORKSPACE_ID,
default_query_presets: local,
});
await waitFor(() => expect(result.current.prPresets[0]?.value).not.toBe("mine"));
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
it("does not migrate local defaults over existing workspace defaults", async () => {
@@ -12,12 +12,6 @@ import {
updateGitHubWorkspaceSettings,
} from "@/lib/api/domains/github-api";
import { createQueuedUserSettingsSync } from "@/lib/user-settings-sync";
import { hasUserSettingsSyncFailure } from "@/lib/user-settings-sync-failure";
const STORAGE_KEY = "kandev:github-default-queries:v1";
const MIGRATED_KEY = "kandev:github-default-queries:migrated-to-backend:v1";
const WORKSPACE_MIGRATED_KEY_PREFIX = "kandev:github-default-queries:migrated-to-workspace:v1:";
const SYNC_FAILED_KEY = "kandev:github-default-queries:sync-failed:v1";
export type StoredQueryPreset = {
value: string;
@@ -35,45 +29,13 @@ export function toStored(presets: PresetOption[]): StoredQueryPreset[] {
return presets.map(({ value, label, filter, group }) => ({ value, label, filter, group }));
}
function readStorage(): StoredDefaults | null {
if (typeof window === "undefined") return null;
try {
const raw = window.localStorage.getItem(STORAGE_KEY);
if (!raw) return null;
const parsed = JSON.parse(raw) as unknown;
if (
typeof parsed !== "object" ||
parsed === null ||
!Array.isArray((parsed as StoredDefaults).pr) ||
!Array.isArray((parsed as StoredDefaults).issue)
) {
return null;
}
return parsed as StoredDefaults;
} catch {
return null;
}
}
function writeStorage(defaults: StoredDefaults | null) {
if (typeof window === "undefined") return;
try {
if (defaults === null) {
window.localStorage.removeItem(STORAGE_KEY);
} else {
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(defaults));
}
} catch {
/* ignore quota / access errors */
}
}
let snapshot: StoredDefaults | null | undefined = undefined;
let snapshotVersion = 0;
const listeners = new Set<() => void>();
function publish(next: StoredDefaults | null) {
snapshot = next;
writeStorage(next);
snapshotVersion += 1;
listeners.forEach((fn) => fn());
}
@@ -89,22 +51,9 @@ function readServerDefaults(value: unknown): StoredDefaults | null | undefined {
return value as StoredDefaults;
}
async function readLegacyServerDefaults(): Promise<StoredDefaults | null | undefined> {
try {
const response = await fetchUserSettings({ cache: "no-store" });
const defaults = readServerDefaults(response.settings.github_default_query_presets);
return defaults === undefined ? null : defaults;
} catch {
return undefined;
}
}
const syncServer = createQueuedUserSettingsSync<StoredDefaults | null>(
SYNC_FAILED_KEY,
(defaults) => ({
github_default_query_presets: defaults,
}),
);
const syncServer = createQueuedUserSettingsSync<StoredDefaults | null>((defaults) => ({
github_default_query_presets: defaults,
}));
let workspaceSyncQueue = Promise.resolve();
@@ -123,55 +72,15 @@ function syncWorkspaceDefaultQueryPresets(
return workspaceSyncQueue;
}
function snapshotKey(value: StoredDefaults | null): string {
return JSON.stringify(value);
}
function hasMigratedToBackend(): boolean {
if (typeof window === "undefined") return false;
return window.localStorage.getItem(MIGRATED_KEY) === "1";
}
function markMigratedToBackend(): void {
if (typeof window === "undefined") return;
try {
window.localStorage.setItem(MIGRATED_KEY, "1");
} catch {
/* ignore storage failures */
}
}
function hasMigratedToWorkspace(workspaceId: string): boolean {
if (typeof window === "undefined") return false;
return window.localStorage.getItem(WORKSPACE_MIGRATED_KEY_PREFIX + workspaceId) === "1";
}
function markMigratedToWorkspace(workspaceId: string): void {
if (typeof window === "undefined") return;
try {
window.localStorage.setItem(WORKSPACE_MIGRATED_KEY_PREFIX + workspaceId, "1");
} catch {
/* ignore storage failures */
}
}
function subscribe(cb: () => void) {
listeners.add(cb);
const onStorage = (event: StorageEvent) => {
if (event.key !== STORAGE_KEY) return;
snapshot = readStorage();
listeners.forEach((fn) => fn());
};
window.addEventListener("storage", onStorage);
return () => {
listeners.delete(cb);
window.removeEventListener("storage", onStorage);
};
}
function getSnapshot(): StoredDefaults | null {
if (snapshot === undefined) snapshot = readStorage();
return snapshot;
return snapshot ?? null;
}
function getServerSnapshot(): StoredDefaults | null {
@@ -180,31 +89,20 @@ function getServerSnapshot(): StoredDefaults | null {
export function __resetSnapshotForTests() {
snapshot = undefined;
snapshotVersion = 0;
listeners.forEach((fn) => fn());
}
function useLegacyDefaultQueryPresetSync(enabled: boolean) {
function useUserDefaultQueryPresetSync(enabled: boolean) {
useEffect(() => {
if (!enabled) return;
let cancelled = false;
const initialKey = snapshotKey(getSnapshot());
const initialVersion = snapshotVersion;
fetchUserSettings({ cache: "no-store" })
.then((response) => {
const serverDefaults = readServerDefaults(response.settings.github_default_query_presets);
if (cancelled || serverDefaults === undefined) return;
const local = getSnapshot();
if (snapshotKey(local) !== initialKey) return;
if (hasUserSettingsSyncFailure(SYNC_FAILED_KEY)) {
void syncServer(local);
return;
}
if (serverDefaults === null && local !== null && !hasMigratedToBackend()) {
void syncServer(local);
markMigratedToBackend();
return;
}
if (cancelled || serverDefaults === undefined || snapshotVersion !== initialVersion) return;
publish(serverDefaults);
markMigratedToBackend();
})
.catch(() => {});
return () => {
@@ -227,30 +125,10 @@ function useWorkspaceDefaultQueryPresets(workspaceId: string | null) {
const seq = writeSeq.current;
setWorkspaceDefaults(undefined);
fetchGitHubWorkspaceSettings(workspaceId)
.then(async (settings) => {
.then((settings) => {
if (cancelled || seq !== writeSeq.current) return;
const defaults = readServerDefaults(settings.default_query_presets);
let local: StoredDefaults | null | undefined = getSnapshot();
if (local === null) {
local = await readLegacyServerDefaults();
}
if (cancelled || seq !== writeSeq.current) return;
if (
(defaults === null || defaults === undefined) &&
local !== undefined &&
local !== null &&
!hasMigratedToWorkspace(workspaceId)
) {
setWorkspaceDefaults(local);
void syncWorkspaceDefaultQueryPresets(workspaceId, local)
.then(() => markMigratedToWorkspace(workspaceId))
.catch(() => {});
return;
}
setWorkspaceDefaults(defaults === undefined ? null : defaults);
if (!(local === undefined && (defaults === null || defaults === undefined))) {
markMigratedToWorkspace(workspaceId);
}
})
.catch(() => {
if (!cancelled) setWorkspaceDefaults(undefined);
@@ -269,7 +147,7 @@ function useWorkspaceDefaultQueryPresets(workspaceId: string | null) {
export function useDefaultQueryPresets(workspaceId: string | null = null) {
const stored = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
const { workspaceDefaults, setWorkspaceDefaults } = useWorkspaceDefaultQueryPresets(workspaceId);
useLegacyDefaultQueryPresetSync(!workspaceId);
useUserDefaultQueryPresetSync(!workspaceId);
const effectiveStored = workspaceId ? workspaceDefaults : stored;
const prPresets = useMemo(
() => effectiveStored?.pr ?? toStored(BUILTIN_PR_PRESETS),
@@ -285,14 +163,11 @@ export function useDefaultQueryPresets(workspaceId: string | null = null) {
if (workspaceId && workspaceDefaults === undefined) return;
if (workspaceId) {
setWorkspaceDefaults(defaults);
void syncWorkspaceDefaultQueryPresets(workspaceId, defaults)
.then(() => markMigratedToWorkspace(workspaceId))
.catch(() => {});
void syncWorkspaceDefaultQueryPresets(workspaceId, defaults).catch(() => {});
return;
}
publish(defaults);
void syncServer(defaults);
markMigratedToBackend();
},
[workspaceId, workspaceDefaults, setWorkspaceDefaults],
);
@@ -301,14 +176,11 @@ export function useDefaultQueryPresets(workspaceId: string | null = null) {
if (workspaceId && workspaceDefaults === undefined) return;
if (workspaceId) {
setWorkspaceDefaults(null);
void syncWorkspaceDefaultQueryPresets(workspaceId, null)
.then(() => markMigratedToWorkspace(workspaceId))
.catch(() => {});
void syncWorkspaceDefaultQueryPresets(workspaceId, null).catch(() => {});
return;
}
publish(null);
void syncServer(null);
markMigratedToBackend();
}, [workspaceId, workspaceDefaults, setWorkspaceDefaults]);
const isCustomized = effectiveStored !== null && effectiveStored !== undefined;
@@ -5,15 +5,9 @@ import {
fetchGitHubWorkspaceSettings,
updateGitHubWorkspaceSettings,
} from "@/lib/api/domains/github-api";
import {
__resetSnapshotForTests,
readStorage,
useSavedPresets,
type SavedPreset,
} from "./use-saved-presets";
import { __resetSnapshotForTests, useSavedPresets, type SavedPreset } from "./use-saved-presets";
const STORAGE_KEY = "kandev:github-presets:v1";
const SYNC_FAILED_KEY = "kandev:github-presets:sync-failed:v1";
const WORKSPACE_ID = "ws-1";
const SETTINGS_TIMESTAMP = "2026-01-01T00:00:00Z";
@@ -27,30 +21,9 @@ vi.mock("@/lib/api/domains/github-api", () => ({
updateGitHubWorkspaceSettings: vi.fn(),
}));
// Provide a simple in-memory localStorage mock so the tests are not sensitive
// to how the test runner exposes window.localStorage (e.g. Node's
// --localstorage-file flag without a valid path).
function makeLocalStorageMock() {
const store = new Map<string, string>();
return {
getItem: (key: string) => store.get(key) ?? null,
setItem: (key: string, value: string) => store.set(key, value),
removeItem: (key: string) => store.delete(key),
clear: () => store.clear(),
get length() {
return store.size;
},
key: (index: number) => Array.from(store.keys())[index] ?? null,
};
}
const localStorageMock = makeLocalStorageMock();
vi.stubGlobal("localStorage", localStorageMock);
Object.defineProperty(window, "localStorage", { value: localStorageMock, configurable: true });
function set(raw: string | null) {
if (raw === null) localStorageMock.removeItem(STORAGE_KEY);
else localStorageMock.setItem(STORAGE_KEY, raw);
if (raw === null) window.localStorage.removeItem(STORAGE_KEY);
else window.localStorage.setItem(STORAGE_KEY, raw);
}
const valid: SavedPreset = {
@@ -63,7 +36,7 @@ const valid: SavedPreset = {
};
function resetTestState() {
localStorageMock.clear();
window.localStorage.clear();
__resetSnapshotForTests();
vi.mocked(fetchUserSettings).mockReset();
vi.mocked(updateUserSettings).mockReset();
@@ -86,98 +59,21 @@ function workspaceSettings(
} as Awaited<ReturnType<typeof fetchGitHubWorkspaceSettings>>;
}
describe("readStorage", () => {
beforeEach(() => {
resetTestState();
});
it("returns empty array when no value is stored", () => {
expect(readStorage()).toEqual([]);
});
it("returns empty array for malformed JSON", () => {
set("not-json{");
expect(readStorage()).toEqual([]);
});
it("returns empty array when parsed value is not an array", () => {
set(JSON.stringify({ id: "p_1" }));
expect(readStorage()).toEqual([]);
});
it("keeps valid entries", () => {
set(JSON.stringify([valid]));
expect(readStorage()).toEqual([valid]);
});
it("drops entries missing an id", () => {
const missingId = { ...valid } as Partial<SavedPreset>;
delete missingId.id;
set(JSON.stringify([missingId, valid]));
expect(readStorage()).toEqual([valid]);
});
it("drops entries with invalid kind", () => {
set(JSON.stringify([{ ...valid, kind: "commit" }, valid]));
expect(readStorage()).toEqual([valid]);
});
it("drops non-object entries", () => {
set(JSON.stringify(["string", 42, null, valid]));
expect(readStorage()).toEqual([valid]);
});
it("drops entries with non-string label", () => {
set(JSON.stringify([{ ...valid, label: 123 }, valid]));
expect(readStorage()).toEqual([valid]);
});
it("accepts issue kind", () => {
const issue: SavedPreset = { ...valid, kind: "issue" };
set(JSON.stringify([issue]));
expect(readStorage()).toEqual([issue]);
});
});
describe("useSavedPresets", () => {
beforeEach(() => {
resetTestState();
});
it("retries local presets after a failed backend sync and clears the marker", async () => {
it("ignores stale local presets when backend settings are empty", async () => {
set(JSON.stringify([valid]));
localStorageMock.setItem(SYNC_FAILED_KEY, "1");
vi.mocked(fetchUserSettings).mockResolvedValue({
settings: { github_saved_presets: [] },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
vi.mocked(updateUserSettings).mockResolvedValue({
settings: {},
} as Awaited<ReturnType<typeof updateUserSettings>>);
renderHook(() => useSavedPresets());
const { result } = renderHook(() => useSavedPresets());
await waitFor(() => {
expect(updateUserSettings).toHaveBeenCalledWith({ github_saved_presets: [valid] });
expect(localStorageMock.getItem(SYNC_FAILED_KEY)).toBeNull();
});
});
it("retries empty local presets after a failed backend sync", async () => {
set(JSON.stringify([]));
localStorageMock.setItem(SYNC_FAILED_KEY, "1");
vi.mocked(fetchUserSettings).mockResolvedValue({
settings: { github_saved_presets: [valid] },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
vi.mocked(updateUserSettings).mockResolvedValue({
settings: {},
} as Awaited<ReturnType<typeof updateUserSettings>>);
renderHook(() => useSavedPresets());
await waitFor(() => {
expect(updateUserSettings).toHaveBeenCalledWith({ github_saved_presets: [] });
expect(localStorageMock.getItem(SYNC_FAILED_KEY)).toBeNull();
});
await waitFor(() => expect(result.current.presets).toEqual([]));
expect(updateUserSettings).not.toHaveBeenCalled();
});
});
@@ -186,20 +82,14 @@ describe("useSavedPresets workspace sync", () => {
resetTestState();
});
it("migrates local presets into a fresh workspace", async () => {
it("ignores stale local presets when workspace settings are empty", async () => {
set(JSON.stringify([valid]));
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings());
vi.mocked(updateGitHubWorkspaceSettings).mockResolvedValue(
{} as Awaited<ReturnType<typeof updateGitHubWorkspaceSettings>>,
);
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toEqual([valid]));
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledWith({
workspace_id: WORKSPACE_ID,
saved_presets: [valid],
});
await waitFor(() => expect(result.current.presets).toEqual([]));
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
it("does not migrate local presets over existing workspace presets", async () => {
@@ -7,12 +7,6 @@ import {
updateGitHubWorkspaceSettings,
} from "@/lib/api/domains/github-api";
import { createQueuedUserSettingsSync } from "@/lib/user-settings-sync";
import { hasUserSettingsSyncFailure } from "@/lib/user-settings-sync-failure";
const STORAGE_KEY = "kandev:github-presets:v1";
const MIGRATED_KEY = "kandev:github-presets:migrated-to-backend:v1";
const WORKSPACE_MIGRATED_KEY_PREFIX = "kandev:github-presets:migrated-to-workspace:v1:";
const SYNC_FAILED_KEY = "kandev:github-presets:sync-failed:v1";
export type SavedPreset = {
id: string;
@@ -23,42 +17,12 @@ export type SavedPreset = {
createdAt: string;
};
export function readStorage(): SavedPreset[] {
if (typeof window === "undefined") return [];
try {
const raw = window.localStorage.getItem(STORAGE_KEY);
if (!raw) return [];
const parsed = JSON.parse(raw) as unknown;
if (!Array.isArray(parsed)) return [];
return parsed.filter(
(p): p is SavedPreset =>
typeof p === "object" &&
p !== null &&
typeof (p as SavedPreset).id === "string" &&
((p as SavedPreset).kind === "pr" || (p as SavedPreset).kind === "issue") &&
typeof (p as SavedPreset).label === "string",
);
} catch {
return [];
}
}
function writeStorage(presets: SavedPreset[]) {
if (typeof window === "undefined") return;
try {
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(presets));
} catch {
/* ignore quota / access errors */
}
}
// External store: single source of truth shared across all hook consumers.
const listeners = new Set<() => void>();
let snapshot: SavedPreset[] | null = null;
let snapshot: SavedPreset[] = [];
let snapshotVersion = 0;
const emptySnapshot: SavedPreset[] = [];
function getSnapshot(): SavedPreset[] {
if (snapshot === null) snapshot = readStorage();
return snapshot;
}
@@ -75,7 +39,7 @@ function subscribe(cb: () => void) {
function publish(next: SavedPreset[]) {
snapshot = next;
writeStorage(next);
snapshotVersion += 1;
for (const l of listeners) l();
}
@@ -91,16 +55,7 @@ function readServerPresets(value: unknown): SavedPreset[] | null {
);
}
async function readLegacyServerPresets(): Promise<SavedPreset[] | undefined> {
try {
const response = await fetchUserSettings({ cache: "no-store" });
return readServerPresets(response.settings.github_saved_presets) ?? [];
} catch {
return undefined;
}
}
const syncServer = createQueuedUserSettingsSync<SavedPreset[]>(SYNC_FAILED_KEY, (next) => ({
const syncServer = createQueuedUserSettingsSync<SavedPreset[]>((next) => ({
github_saved_presets: next,
}));
@@ -118,65 +73,22 @@ function syncWorkspaceSavedPresets(workspaceId: string, next: SavedPreset[]): Pr
return workspaceSyncQueue;
}
function snapshotKey(value: SavedPreset[]): string {
return JSON.stringify(value);
}
function hasMigratedToBackend(): boolean {
if (typeof window === "undefined") return false;
return window.localStorage.getItem(MIGRATED_KEY) === "1";
}
function markMigratedToBackend(): void {
if (typeof window === "undefined") return;
try {
window.localStorage.setItem(MIGRATED_KEY, "1");
} catch {
/* ignore storage failures */
}
}
function hasMigratedToWorkspace(workspaceId: string): boolean {
if (typeof window === "undefined") return false;
return window.localStorage.getItem(WORKSPACE_MIGRATED_KEY_PREFIX + workspaceId) === "1";
}
function markMigratedToWorkspace(workspaceId: string): void {
if (typeof window === "undefined") return;
try {
window.localStorage.setItem(WORKSPACE_MIGRATED_KEY_PREFIX + workspaceId, "1");
} catch {
/* ignore storage failures */
}
}
export function __resetSnapshotForTests() {
snapshot = null;
snapshot = [];
snapshotVersion = 0;
for (const l of listeners) l();
}
function useLegacySavedPresetsSync(enabled: boolean) {
function useUserSavedPresetsSync(enabled: boolean) {
useEffect(() => {
if (!enabled) return;
let cancelled = false;
const initialKey = snapshotKey(readStorage());
const initialVersion = snapshotVersion;
fetchUserSettings({ cache: "no-store" })
.then((response) => {
const serverPresets = readServerPresets(response.settings.github_saved_presets);
if (cancelled || !serverPresets) return;
const local = readStorage();
if (snapshotKey(local) !== initialKey) return;
if (hasUserSettingsSyncFailure(SYNC_FAILED_KEY)) {
void syncServer(local);
return;
}
if (serverPresets.length === 0 && local.length > 0 && !hasMigratedToBackend()) {
void syncServer(local);
markMigratedToBackend();
return;
}
if (cancelled || !serverPresets || snapshotVersion !== initialVersion) return;
publish(serverPresets);
markMigratedToBackend();
})
.catch(() => {});
return () => {
@@ -197,30 +109,10 @@ function useWorkspaceSavedPresets(workspaceId: string | null) {
const seq = writeSeq.current;
setWorkspacePresets(undefined);
fetchGitHubWorkspaceSettings(workspaceId)
.then(async (settings) => {
.then((settings) => {
if (cancelled || seq !== writeSeq.current) return;
const serverPresets = readServerPresets(settings.saved_presets) ?? [];
let local: SavedPreset[] | undefined = readStorage();
if (local.length === 0) {
local = await readLegacyServerPresets();
}
if (cancelled || seq !== writeSeq.current) return;
if (
serverPresets.length === 0 &&
local !== undefined &&
local.length > 0 &&
!hasMigratedToWorkspace(workspaceId)
) {
setWorkspacePresets(local);
void syncWorkspaceSavedPresets(workspaceId, local)
.then(() => markMigratedToWorkspace(workspaceId))
.catch(() => {});
return;
}
setWorkspacePresets(serverPresets);
if (local !== undefined || serverPresets.length > 0) {
markMigratedToWorkspace(workspaceId);
}
})
.catch(() => {
if (!cancelled) setWorkspacePresets(undefined);
@@ -239,7 +131,7 @@ function useWorkspaceSavedPresets(workspaceId: string | null) {
export function useSavedPresets(workspaceId: string | null = null) {
const presets = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
const { workspacePresets, setWorkspacePresets } = useWorkspaceSavedPresets(workspaceId);
useLegacySavedPresetsSync(!workspaceId);
useUserSavedPresetsSync(!workspaceId);
const activePresets = workspaceId ? (workspacePresets ?? []) : presets;
const save = useCallback(
@@ -253,14 +145,11 @@ export function useSavedPresets(workspaceId: string | null = null) {
const next = [...activePresets, preset];
if (workspaceId) {
setWorkspacePresets(next);
void syncWorkspaceSavedPresets(workspaceId, next)
.then(() => markMigratedToWorkspace(workspaceId))
.catch(() => {});
void syncWorkspaceSavedPresets(workspaceId, next).catch(() => {});
return preset;
}
publish(next);
void syncServer(next);
markMigratedToBackend();
return preset;
},
[activePresets, workspaceId, workspacePresets, setWorkspacePresets],
@@ -272,14 +161,11 @@ export function useSavedPresets(workspaceId: string | null = null) {
const next = activePresets.filter((p) => p.id !== id);
if (workspaceId) {
setWorkspacePresets(next);
void syncWorkspaceSavedPresets(workspaceId, next)
.then(() => markMigratedToWorkspace(workspaceId))
.catch(() => {});
void syncWorkspaceSavedPresets(workspaceId, next).catch(() => {});
return;
}
publish(next);
void syncServer(next);
markMigratedToBackend();
},
[activePresets, workspaceId, workspacePresets, setWorkspacePresets],
);