feat(github): add saved query default views (#2399)

This commit is contained in:
José Almeida
2026-08-11 11:52:34 +01:00
committed by GitHub
parent 58e7be4b78
commit 437f610d60
37 changed files with 4102 additions and 349 deletions
@@ -0,0 +1,208 @@
import { cleanup, fireEvent, render, screen } from "@testing-library/react";
import { useRef } from "react";
import { afterEach, describe, expect, it, vi } from "vitest";
import type { SavedPreset } from "./saved-preset-model";
import { PresetsScopeBar } from "./presets-scope-bar";
const savedPreset: SavedPreset = {
id: "saved-pr",
kind: "pr",
label: "Needs review",
customQuery: "review-requested:@me is:open",
repoFilter: "kdlbs/kandev",
createdAt: "2026-08-10T00:00:00Z",
isDefault: false,
};
vi.mock("@/components/integrations/presets-scope-bar-base", () => ({
IntegrationScopeBar: ({
defaultMutationPendingId,
onKindChange,
onToggleSavedDefault,
savedPresets,
}: {
defaultMutationPendingId?: string | null;
onKindChange?: (kind: "pr" | "issue") => void;
onToggleSavedDefault?: (id: string) => void;
savedPresets: Array<{ id: string }>;
}) => {
const initialDefaultAction = useRef(onToggleSavedDefault);
return (
<div
data-testid="scope-bar-default-action"
data-pending={defaultMutationPendingId !== null}
data-pending-id={defaultMutationPendingId}
data-callback-stable={initialDefaultAction.current === onToggleSavedDefault}
>
<button
type="button"
data-testid="scope-bar-default-toggle"
onClick={() => onToggleSavedDefault?.(savedPresets[0]?.id ?? "missing-preset")}
/>
<button
type="button"
data-testid="scope-bar-kind-switch"
onClick={() => onKindChange?.("issue")}
/>
<button
type="button"
data-testid="scope-bar-active-kind"
onClick={() => onKindChange?.("pr")}
/>
</div>
);
},
}));
afterEach(() => {
cleanup();
vi.restoreAllMocks();
});
function expectExplicitKindSwitchRequest() {
const onSelect = vi.fn();
render(
<PresetsScopeBar
selected={{ kind: "pr", source: "preset", id: "review" }}
onSelect={onSelect}
savedPresets={[]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={vi.fn()}
defaultMutationPendingId={null}
prPresets={[]}
issuePresets={[]}
/>,
);
fireEvent.click(screen.getByTestId("scope-bar-kind-switch"));
expect(onSelect).toHaveBeenCalledWith({ kind: "issue", source: "kind-switch" });
}
function expectActiveKindRequestIgnored() {
const onSelect = vi.fn();
render(
<PresetsScopeBar
selected={{ kind: "pr", source: "preset", id: "review" }}
onSelect={onSelect}
savedPresets={[]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={vi.fn()}
defaultMutationPendingId={null}
prPresets={[]}
issuePresets={[]}
/>,
);
fireEvent.click(screen.getByTestId("scope-bar-active-kind"));
expect(onSelect).not.toHaveBeenCalled();
}
describe("PresetsScopeBar default adapter", () => {
it("emits an explicit kind-switch request", expectExplicitKindSwitchRequest);
it("ignores an active-kind request at the wrapper boundary", expectActiveKindRequestIgnored);
it("forwards pending state to the desktop default action", () => {
render(
<PresetsScopeBar
selected={{ kind: "pr", source: "saved", id: savedPreset.id }}
onSelect={vi.fn()}
savedPresets={[savedPreset]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={vi.fn()}
defaultMutationPendingId={savedPreset.id}
prPresets={[]}
issuePresets={[]}
/>,
);
expect(screen.getByTestId("scope-bar-default-action").getAttribute("data-pending")).toBe(
"true",
);
expect(screen.getByTestId("scope-bar-default-action").getAttribute("data-pending-id")).toBe(
savedPreset.id,
);
});
it("forwards a matching saved preset to the domain callback", () => {
const onToggleSavedDefault = vi.fn();
render(
<PresetsScopeBar
selected={{ kind: "pr", source: "saved", id: savedPreset.id }}
onSelect={vi.fn()}
savedPresets={[savedPreset]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={onToggleSavedDefault}
defaultMutationPendingId={null}
prPresets={[]}
issuePresets={[]}
/>,
);
fireEvent.click(screen.getByTestId("scope-bar-default-toggle"));
expect(onToggleSavedDefault).toHaveBeenCalledWith(savedPreset);
});
it("keeps the default adapter stable while using refreshed presets", () => {
const savedPresets = [savedPreset];
const props = {
selected: { kind: "pr", source: "saved", id: savedPreset.id } as const,
onSelect: vi.fn(),
savedPresets,
onDeleteSaved: vi.fn(),
canSaveCurrent: false,
onSaveCurrent: vi.fn(),
onToggleSavedDefault: vi.fn(),
defaultMutationPendingId: null,
prPresets: [],
issuePresets: [],
};
const { rerender } = render(<PresetsScopeBar {...props} />);
const refreshedPreset = { ...savedPreset, label: "Updated", isDefault: true };
rerender(<PresetsScopeBar {...props} savedPresets={[refreshedPreset]} />);
expect(
screen.getByTestId("scope-bar-default-action").getAttribute("data-callback-stable"),
).toBe("true");
fireEvent.click(screen.getByTestId("scope-bar-default-toggle"));
expect(props.onToggleSavedDefault).toHaveBeenCalledWith(refreshedPreset);
});
it("warns in development when a stale default target is requested", () => {
const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
const onToggleSavedDefault = vi.fn();
render(
<PresetsScopeBar
selected={{ kind: "pr", source: "preset", id: "review" }}
onSelect={vi.fn()}
savedPresets={[]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={onToggleSavedDefault}
defaultMutationPendingId={null}
prPresets={[]}
issuePresets={[]}
/>,
);
fireEvent.click(screen.getByTestId("scope-bar-default-toggle"));
expect(warn).toHaveBeenCalledWith("[github:presets] default toggle target missing", {
id: "missing-preset",
});
expect(onToggleSavedDefault).not.toHaveBeenCalled();
});
});
@@ -1,19 +1,22 @@
"use client";
import { useCallback, useRef } from "react";
import { useTranslation } from "react-i18next";
import { IntegrationScopeBar } from "@/components/integrations/presets-scope-bar-base";
import { PR_PRESETS, ISSUE_PRESETS, type PresetOption } from "./search-bar";
import type { SavedPreset } from "./use-saved-presets";
import type { SidebarSelection } from "./presets-sidebar";
import { useTranslation } from "react-i18next";
import type { SavedPreset } from "./saved-preset-model";
import type { SidebarSelection, SidebarSelectionRequest } from "./presets-sidebar";
type PresetsScopeBarProps = {
className?: string;
selected: SidebarSelection;
onSelect: (s: SidebarSelection) => void;
onSelect: (request: SidebarSelectionRequest) => void;
savedPresets: SavedPreset[];
onDeleteSaved: (id: string) => void;
canSaveCurrent: boolean;
onSaveCurrent: () => void;
onToggleSavedDefault: (preset: SavedPreset) => void;
defaultMutationPendingId: string | null;
prPresets?: PresetOption[];
issuePresets?: PresetOption[];
};
@@ -32,12 +35,42 @@ const KINDS = [
export function PresetsScopeBar({
prPresets = PR_PRESETS,
issuePresets = ISSUE_PRESETS,
savedPresets,
selected,
onSelect,
onToggleSavedDefault,
...props
}: PresetsScopeBarProps) {
const { t } = useTranslation();
const savedPresetsRef = useRef(savedPresets);
savedPresetsRef.current = savedPresets;
const handleToggleSavedDefault = useCallback(
(id: string) => {
const preset = savedPresetsRef.current.find((candidate) => candidate.id === id);
if (!preset) {
if (process.env.NODE_ENV !== "production") {
console.warn("[github:presets] default toggle target missing", { id });
}
return;
}
void onToggleSavedDefault(preset);
},
[onToggleSavedDefault],
);
const handleKindChange = useCallback(
(kind: SidebarSelection["kind"]) => {
if (kind !== selected.kind) onSelect({ kind, source: "kind-switch" });
},
[onSelect, selected.kind],
);
return (
<IntegrationScopeBar
{...props}
selected={selected}
onSelect={onSelect}
onKindChange={handleKindChange}
savedPresets={savedPresets}
onToggleSavedDefault={handleToggleSavedDefault}
testId="github-presets-scope-bar"
savedMenuTestId="github-saved-queries-menu"
kinds={KINDS.map(({ value, labelKey }) => ({ value, label: t(labelKey) }))}
@@ -0,0 +1,115 @@
import { cleanup, fireEvent, render, screen } from "@testing-library/react";
import { afterEach, describe, expect, it, vi } from "vitest";
import type { SavedPreset } from "./saved-preset-model";
import { PresetsSidebar } from "./presets-sidebar";
afterEach(cleanup);
const savedPreset: SavedPreset = {
id: "saved-pr",
kind: "pr",
label: "Kandev PRs",
customQuery: "author:@me is:open",
repoFilter: "kdlbs/kandev",
createdAt: "2026-08-10T00:00:00Z",
isDefault: false,
};
function expectDeleteDoesNotSelect() {
const onSelect = vi.fn();
const onDeleteSaved = vi.fn();
render(
<PresetsSidebar
selected={{ kind: "pr", source: "saved", id: savedPreset.id }}
onSelect={onSelect}
savedPresets={[savedPreset]}
onDeleteSaved={onDeleteSaved}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={vi.fn()}
defaultMutationPendingId={null}
prPresets={[]}
issuePresets={[]}
/>,
);
fireEvent.click(screen.getByRole("button", { name: "Delete Kandev PRs saved query" }));
expect(onDeleteSaved).toHaveBeenCalledWith(savedPreset.id);
expect(onSelect).not.toHaveBeenCalled();
}
describe("PresetsSidebar saved defaults", () => {
it("disables saved-query actions while a default mutation is pending", () => {
render(
<PresetsSidebar
selected={{ kind: "pr", source: "saved", id: savedPreset.id }}
onSelect={vi.fn()}
savedPresets={[savedPreset]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={vi.fn()}
defaultMutationPendingId={savedPreset.id}
prPresets={[]}
issuePresets={[]}
/>,
);
expect(
(
screen.getByRole("button", {
name: "Updating default view… Delete Kandev PRs saved query",
}) as HTMLButtonElement
).disabled,
).toBe(true);
const defaultAction = screen.getByRole("button", {
name: "Updating default view… Set Kandev PRs as default view",
}) as HTMLButtonElement;
expect(defaultAction.disabled).toBe(true);
expect(defaultAction.getAttribute("aria-busy")).toBeNull();
expect(defaultAction.querySelector("svg")?.getAttribute("class")).toContain("animate-pulse");
});
it("sends only the destination kind when switching views", () => {
const onSelect = vi.fn();
render(
<PresetsSidebar
selected={{ kind: "pr", source: "saved", id: savedPreset.id }}
onSelect={onSelect}
savedPresets={[savedPreset]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={vi.fn()}
defaultMutationPendingId={null}
/>,
);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
expect(onSelect).toHaveBeenCalledWith({ kind: "issue", source: "kind-switch" });
});
it("ignores reselecting the active kind", () => {
const onSelect = vi.fn();
render(
<PresetsSidebar
selected={{ kind: "pr", source: "saved", id: savedPreset.id }}
onSelect={onSelect}
savedPresets={[savedPreset]}
onDeleteSaved={vi.fn()}
canSaveCurrent={false}
onSaveCurrent={vi.fn()}
onToggleSavedDefault={vi.fn()}
defaultMutationPendingId={null}
/>,
);
fireEvent.click(screen.getByRole("button", { name: "Pull requests" }));
expect(onSelect).not.toHaveBeenCalled();
});
it("deletes a saved query without selecting it", expectDeleteDoesNotSelect);
});
@@ -2,10 +2,12 @@
import { IconX, IconDeviceFloppy, IconBookmark } from "@tabler/icons-react";
import type { Icon } from "@tabler/icons-react";
import { useCallback } from "react";
import { cn } from "@/lib/utils";
import { PR_PRESETS, ISSUE_PRESETS, type PresetOption, type PresetGroup } from "./search-bar";
import type { SavedPreset } from "./use-saved-presets";
import type { SavedPreset } from "./saved-preset-model";
import { useTranslation } from "react-i18next";
import { SavedQueryDefaultButton } from "@/components/integrations/saved-query-default-button";
export type SidebarSelection = {
kind: "pr" | "issue";
@@ -13,13 +15,19 @@ export type SidebarSelection = {
id: string;
};
export type SidebarSelectionRequest =
| SidebarSelection
| { kind: SidebarSelection["kind"]; source: "kind-switch" };
type PresetsSidebarProps = {
selected: SidebarSelection;
onSelect: (s: SidebarSelection) => void;
onSelect: (request: SidebarSelectionRequest) => void;
savedPresets: SavedPreset[];
onDeleteSaved: (id: string) => void;
canSaveCurrent: boolean;
onSaveCurrent: () => void;
onToggleSavedDefault: (preset: SavedPreset) => void;
defaultMutationPendingId: string | null;
prPresets?: PresetOption[];
issuePresets?: PresetOption[];
};
@@ -40,7 +48,7 @@ function KindToggle({
type="button"
onClick={() => onChange(value)}
className={cn(
"px-2 py-1 rounded cursor-pointer transition-colors",
"min-h-11 px-2 py-1 rounded cursor-pointer transition-colors",
kind === value
? "bg-muted font-medium text-foreground"
: "text-muted-foreground hover:text-foreground",
@@ -74,27 +82,22 @@ function PresetItem({
onClick: () => void;
trailing?: React.ReactNode;
}) {
const onKeyDown = (e: React.KeyboardEvent<HTMLDivElement>) => {
if (e.key === "Enter" || e.key === " ") {
e.preventDefault();
onClick();
}
};
return (
<div
role="button"
tabIndex={0}
aria-pressed={active}
className={cn(
"group/item mx-1 flex items-center gap-2 rounded-md px-2 py-1.5 text-sm cursor-pointer transition-colors",
"focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
"group/item mx-1 flex min-w-0 items-center rounded-md text-sm transition-colors",
active ? "bg-muted font-medium text-foreground" : "text-muted-foreground hover:bg-muted/50",
)}
onClick={onClick}
onKeyDown={onKeyDown}
>
<Icon className="h-4 w-4 shrink-0" />
<span className="truncate flex-1">{label}</span>
<button
type="button"
aria-pressed={active}
onClick={onClick}
className="flex min-h-11 min-w-0 flex-1 cursor-pointer items-center gap-2 rounded-md px-2 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
>
<Icon className="h-4 w-4 shrink-0" />
<span className="min-w-0 flex-1 truncate">{label}</span>
</button>
{trailing}
</div>
);
@@ -140,6 +143,8 @@ function SavedSection({
kind,
canSaveCurrent,
onSaveCurrent,
onToggleSavedDefault,
defaultMutationPendingId,
}: {
saved: SavedPreset[];
selected: SidebarSelection;
@@ -148,8 +153,11 @@ function SavedSection({
kind: "pr" | "issue";
canSaveCurrent: boolean;
onSaveCurrent: () => void;
onToggleSavedDefault: (preset: SavedPreset) => void;
defaultMutationPendingId: string | null;
}) {
const { t } = useTranslation();
const defaultMutationPending = defaultMutationPendingId !== null;
return (
<>
<SectionHeader title={t("github:saved")} />
@@ -158,34 +166,49 @@ function SavedSection({
{t("github:noSavedQueriesYet")}
</div>
)}
{saved.map((s) => (
<PresetItem
key={s.id}
label={s.label}
Icon={IconBookmark}
active={selected.source === "saved" && selected.id === s.id}
onClick={() => onSelect({ kind, source: "saved", id: s.id })}
trailing={
<button
type="button"
onClick={(e) => {
e.stopPropagation();
onDelete(s.id);
}}
className="opacity-0 group-hover/item:opacity-100 transition-opacity text-muted-foreground hover:text-foreground cursor-pointer"
title={t("github:deleteSavedQuery")}
>
<IconX className="h-3.5 w-3.5" />
</button>
}
/>
))}
{saved.map((s) => {
const deleteLabel = t("integrations:deleteSavedQueryNamed", { label: s.label });
const accessibleDeleteLabel = defaultMutationPending
? t("integrations:savedQueryDefaultUpdateInProgress", { action: deleteLabel })
: deleteLabel;
return (
<PresetItem
key={s.id}
label={s.label}
Icon={IconBookmark}
active={selected.source === "saved" && selected.id === s.id}
onClick={() => onSelect({ kind, source: "saved", id: s.id })}
trailing={
<div className="flex shrink-0 items-center">
<SavedQueryDefaultButton
label={s.label}
isDefault={s.isDefault}
disabled={defaultMutationPending}
pending={defaultMutationPendingId === s.id}
testId={`github-saved-query-default-${s.id}`}
onToggle={() => void onToggleSavedDefault(s)}
/>
<button
type="button"
disabled={defaultMutationPending}
onClick={() => onDelete(s.id)}
className="flex h-11 w-11 shrink-0 cursor-pointer items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground disabled:cursor-wait disabled:opacity-50"
title={accessibleDeleteLabel}
aria-label={accessibleDeleteLabel}
>
<IconX className="h-4 w-4" />
</button>
</div>
}
/>
);
})}
<button
type="button"
onClick={onSaveCurrent}
disabled={!canSaveCurrent}
className={cn(
"mx-1 mt-1 flex items-center gap-2 rounded-md px-2 py-1.5 text-xs transition-colors",
"mx-1 mt-1 flex min-h-11 items-center gap-2 rounded-md px-2 py-1.5 text-xs transition-colors",
canSaveCurrent
? "text-muted-foreground hover:bg-muted/50 hover:text-foreground cursor-pointer"
: "text-muted-foreground/50 cursor-not-allowed",
@@ -206,17 +229,22 @@ export function PresetsSidebar({
onDeleteSaved,
canSaveCurrent,
onSaveCurrent,
onToggleSavedDefault,
defaultMutationPendingId,
prPresets = PR_PRESETS,
issuePresets = ISSUE_PRESETS,
}: PresetsSidebarProps) {
const presets = selected.kind === "pr" ? prPresets : issuePresets;
const saved = savedPresets.filter((p) => p.kind === selected.kind);
const onKindChange = (kind: "pr" | "issue") => {
const fallback = (kind === "pr" ? prPresets : issuePresets)[0]?.value ?? "";
onSelect({ kind, source: "preset", id: fallback });
};
const onKindChange = useCallback(
(kind: "pr" | "issue") => {
if (kind === selected.kind) return;
onSelect({ kind, source: "kind-switch" });
},
[onSelect, selected.kind],
);
return (
<nav className="flex flex-col py-3">
<nav className="flex w-full min-w-0 flex-col overflow-x-hidden py-3">
<KindToggle kind={selected.kind} onChange={onKindChange} />
<PresetGroupList
presets={presets}
@@ -240,6 +268,8 @@ export function PresetsSidebar({
kind={selected.kind}
canSaveCurrent={canSaveCurrent}
onSaveCurrent={onSaveCurrent}
onToggleSavedDefault={onToggleSavedDefault}
defaultMutationPendingId={defaultMutationPendingId}
/>
</nav>
);
@@ -0,0 +1,147 @@
import { describe, expect, it } from "vitest";
import {
findDefaultSavedPreset,
readSavedPresets,
resolveDefaultSidebarTarget,
setSavedPresetDefault,
type SavedPreset,
type SavedPresetKind,
} from "./saved-preset-model";
function preset(id: string, kind: SavedPresetKind, isDefault = false): SavedPreset {
return {
id,
kind,
label: id,
customQuery: `query:${id}`,
repoFilter: `repo/${id}`,
createdAt: "2026-08-07T00:00:00Z",
isDefault,
};
}
describe("saved preset parsing", () => {
it("returns an empty list for non-array input", () => {
expect(readSavedPresets(undefined)).toEqual([]);
});
it.each([
{ field: "customQuery", value: undefined },
{ field: "customQuery", value: 42 },
{ field: "createdAt", value: undefined },
{ field: "createdAt", value: 42 },
])("rejects an entry with an invalid $field", ({ field, value }) => {
const valid = preset("valid", "pr");
const malformed = { ...preset("malformed", "pr"), [field]: value };
expect(readSavedPresets([malformed, valid])).toEqual([valid]);
});
it("drops entries that omit required query or timestamp fields", () => {
const valid = preset("valid", "pr");
const missingCustomQuery = {
id: "missing-query",
kind: "pr",
label: "Missing query",
repoFilter: "repo/missing-query",
createdAt: "2026-08-07T00:00:00Z",
isDefault: false,
};
const missingCreatedAt = {
id: "missing-created-at",
kind: "pr",
label: "Missing created at",
customQuery: "query:missing-created-at",
repoFilter: "repo/missing-created-at",
isDefault: false,
};
expect(readSavedPresets([missingCustomQuery, missingCreatedAt, valid])).toEqual([valid]);
});
it("returns only validated saved-preset fields", () => {
const valid = preset("valid", "pr");
expect(readSavedPresets([{ ...valid, serverOnly: "discard me" }])).toEqual([valid]);
});
});
describe("saved preset defaults", () => {
it("replaces one kind's default without changing the other kind", () => {
const initial = [
preset("pr-a", "pr", true),
preset("pr-b", "pr"),
preset("issue-a", "issue", true),
];
const next = setSavedPresetDefault(initial, "pr", "pr-b");
expect(next.map(({ id, isDefault }) => ({ id, isDefault }))).toEqual([
{ id: "pr-a", isDefault: false },
{ id: "pr-b", isDefault: true },
{ id: "issue-a", isDefault: true },
]);
expect(initial[0].isDefault).toBe(true);
});
it("clears only the requested kind's default", () => {
const initial = [preset("pr-a", "pr", true), preset("issue-a", "issue", true)];
const next = setSavedPresetDefault(initial, "pr", null);
expect(next.map(({ id, isDefault }) => ({ id, isDefault }))).toEqual([
{ id: "pr-a", isDefault: false },
{ id: "issue-a", isDefault: true },
]);
});
it("keeps the current default when the requested saved query does not exist", () => {
const initial = [preset("pr-a", "pr", true)];
expect(setSavedPresetDefault(initial, "pr", "missing")).toBe(initial);
});
it("returns the original list when the target is already the default", () => {
const initial = [preset("pr-a", "pr", true), preset("pr-b", "pr")];
expect(setSavedPresetDefault(initial, "pr", "pr-a")).toBe(initial);
});
it("finds the effective default for a result kind", () => {
const issueDefault = preset("issue-a", "issue", true);
expect(findDefaultSavedPreset([preset("pr-a", "pr", true), issueDefault], "issue")).toBe(
issueDefault,
);
});
it("resolves a saved default with its query and repository", () => {
const saved = preset("pr-default", "pr", true);
expect(
resolveDefaultSidebarTarget("pr", [saved], [{ value: "review", filter: "review:@me" }]),
).toEqual({
selection: { kind: "pr", source: "saved", id: "pr-default" },
query: "query:pr-default",
repoFilter: "repo/pr-default",
});
});
it("falls back to the first configured query with all repositories", () => {
expect(
resolveDefaultSidebarTarget("issue", [], [{ value: "assigned", filter: "assignee:@me" }]),
).toEqual({
selection: { kind: "issue", source: "preset", id: "assigned" },
query: "assignee:@me",
repoFilter: "",
});
});
it("falls back to an empty query when no query is configured", () => {
expect(resolveDefaultSidebarTarget("issue", [], [])).toEqual({
selection: { kind: "issue", source: "preset", id: "" },
query: "",
repoFilter: "",
});
});
});
@@ -0,0 +1,100 @@
export type SavedPresetKind = "pr" | "issue";
export type SavedPreset = {
id: string;
kind: SavedPresetKind;
label: string;
customQuery: string;
repoFilter: string;
createdAt: string;
isDefault: boolean;
};
export type DefaultSidebarTarget = {
selection: {
kind: SavedPresetKind;
source: "preset" | "saved";
id: string;
};
query: string;
repoFilter: string;
};
export function readSavedPresets(value: unknown): SavedPreset[] {
if (!Array.isArray(value)) return [];
const defaultKinds = new Set<SavedPresetKind>();
return value.flatMap((candidate): SavedPreset[] => {
if (typeof candidate !== "object" || candidate === null) return [];
const preset = candidate as Record<string, unknown>;
const kind = preset.kind;
if (
typeof preset.id !== "string" ||
(kind !== "pr" && kind !== "issue") ||
typeof preset.label !== "string" ||
typeof preset.customQuery !== "string" ||
typeof preset.createdAt !== "string"
) {
return [];
}
const isDefault = preset.isDefault === true && !defaultKinds.has(kind);
if (isDefault) defaultKinds.add(kind);
return [
{
id: preset.id,
kind,
label: preset.label,
customQuery: preset.customQuery,
repoFilter: typeof preset.repoFilter === "string" ? preset.repoFilter : "",
createdAt: preset.createdAt,
isDefault,
},
];
});
}
export function findDefaultSavedPreset(
presets: SavedPreset[],
kind: SavedPresetKind,
): SavedPreset | undefined {
return presets.find((preset) => preset.kind === kind && preset.isDefault);
}
export function setSavedPresetDefault(
presets: SavedPreset[],
kind: SavedPresetKind,
id: string | null,
): SavedPreset[] {
if (id !== null && !presets.some((preset) => preset.kind === kind && preset.id === id)) {
return presets;
}
let changed = false;
const next = presets.map((preset) => {
if (preset.kind !== kind) return preset;
const isDefault = id !== null && preset.id === id;
if (preset.isDefault === isDefault) return preset;
changed = true;
return { ...preset, isDefault };
});
return changed ? next : presets;
}
export function resolveDefaultSidebarTarget(
kind: SavedPresetKind,
savedPresets: SavedPreset[],
configuredPresets: ReadonlyArray<{ value: string; filter: string }>,
): DefaultSidebarTarget {
const saved = findDefaultSavedPreset(savedPresets, kind);
if (saved) {
return {
selection: { kind, source: "saved", id: saved.id },
query: saved.customQuery,
repoFilter: saved.repoFilter,
};
}
const configured = configuredPresets[0];
return {
selection: { kind, source: "preset", id: configured?.value ?? "" },
query: configured?.filter ?? "",
repoFilter: "",
};
}
@@ -5,12 +5,20 @@ import type { PresetOption } from "./search-bar";
import { useSavedPresetActions } from "./use-saved-preset-actions";
import { useSavedPresets, type SavedPreset } from "./use-saved-presets";
const mockToast = vi.fn();
vi.mock("./use-saved-presets", () => ({
useSavedPresets: vi.fn(),
}));
vi.mock("@/components/toast-provider", () => ({
useToast: () => ({ toast: mockToast }),
}));
const QUERY = "assignee:@me is:open";
const REPO = "kdlbs/kandev";
const FIRST_WORKSPACE_ID = "workspace-1";
const SECOND_WORKSPACE_ID = "workspace-2";
const savedPreset: SavedPreset = {
id: "saved-1",
@@ -19,6 +27,7 @@ const savedPreset: SavedPreset = {
customQuery: QUERY,
repoFilter: REPO,
createdAt: "2026-07-17T00:00:00Z",
isDefault: false,
};
const prPreset: PresetOption = {
@@ -37,14 +46,29 @@ const issuePreset: PresetOption = {
icon: IconInbox,
};
type SavedPresetStore = ReturnType<typeof useSavedPresets>;
type Options = Parameters<typeof useSavedPresetActions>[0];
function renderActions(overrides: Partial<Options> = {}) {
function makeStore(overrides: Partial<SavedPresetStore> = {}): SavedPresetStore {
return {
presets: [],
save: vi.fn(async () => null),
remove: vi.fn(async () => false),
setDefault: vi.fn(async () => false),
...overrides,
} as SavedPresetStore;
}
function renderActions(
overrides: Partial<Options> = {},
savedPresetStore = makeStore({ presets: [savedPreset] }),
) {
const setProgrammaticSelection = vi.fn();
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const markSearchInteracted = vi.fn();
const options: Options = {
workspaceId: "workspace-1",
workspaceId: FIRST_WORKSPACE_ID,
selection: { kind: "issue", source: "saved", id: savedPreset.id },
customQuery: QUERY,
resolvedPrPresets: [prPreset],
@@ -52,39 +76,231 @@ function renderActions(overrides: Partial<Options> = {}) {
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
savedPresetStore,
markSearchInteracted,
...overrides,
};
const rendered = renderHook((currentOptions: Options) => useSavedPresetActions(currentOptions), {
initialProps: options,
});
return {
...renderHook(() => useSavedPresetActions(options)),
...rendered,
rerender: (nextOverrides: Partial<Options> = {}) =>
rendered.rerender({ ...options, ...nextOverrides }),
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
};
}
describe("useSavedPresetActions", () => {
beforeEach(() => {
vi.mocked(useSavedPresets).mockReset();
async function expectLatestPresetCatalogAfterDelete() {
let finishRemove!: (removed: boolean) => void;
const remove = vi.fn(
() =>
new Promise<boolean>((resolve) => {
finishRemove = resolve;
}),
);
const refreshedIssuePreset: PresetOption = {
...issuePreset,
value: "mentioned",
label: "Mentioned",
filter: "mentions:@me is:open",
};
const { result, rerender, setProgrammaticSelection, setQueryImmediate } = renderActions(
{},
makeStore({ presets: [savedPreset], remove }),
);
let deletion!: Promise<void>;
act(() => {
deletion = result.current.onDeleteSaved(savedPreset.id);
});
rerender({ resolvedIssuePresets: [refreshedIssuePreset] });
await act(async () => {
finishRemove(true);
await deletion;
});
it("saves the current query, commits it, selects it, and applies its repository", () => {
const save = vi.fn(() => savedPreset);
const remove = vi.fn();
vi.mocked(useSavedPresets).mockReturnValue({ presets: [savedPreset], save, remove });
const { result, setProgrammaticSelection, setQueryImmediate, setRepoFilter } = renderActions({
selection: { kind: "issue", source: "preset", id: "assigned" },
});
expect(setProgrammaticSelection).toHaveBeenCalledWith({
kind: "issue",
source: "preset",
id: refreshedIssuePreset.value,
});
expect(setQueryImmediate).toHaveBeenCalledWith(refreshedIssuePreset.filter);
}
act(() => result.current.onConfirmSave("Assigned in Kandev", REPO));
async function expectStaleSaveOutcomeIgnored() {
let finishSave!: () => void;
const save = vi.fn(
() =>
new Promise<SavedPreset>((resolve) => {
finishSave = () => resolve(savedPreset);
}),
);
const {
result,
rerender,
markSearchInteracted,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
} = renderActions({}, makeStore({ save }));
expect(useSavedPresets).toHaveBeenCalledWith("workspace-1");
let mutation!: Promise<void>;
act(() => {
mutation = result.current.onConfirmSave(savedPreset.label, savedPreset.repoFilter);
});
rerender({ workspaceId: SECOND_WORKSPACE_ID });
await act(async () => {
finishSave();
await mutation;
});
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(setProgrammaticSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
}
async function expectStaleDeleteOutcomeIgnored() {
let finishRemove!: () => void;
const remove = vi.fn(
() =>
new Promise<boolean>((resolve) => {
finishRemove = () => resolve(true);
}),
);
const {
result,
rerender,
markSearchInteracted,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
} = renderActions({}, makeStore({ remove }));
let mutation!: Promise<void>;
act(() => {
mutation = result.current.onDeleteSaved(savedPreset.id);
});
rerender({ workspaceId: SECOND_WORKSPACE_ID });
await act(async () => {
finishRemove();
await mutation;
});
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(setProgrammaticSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
}
async function expectStaleToggleDefaultOutcomeIgnored() {
let finishSetDefault!: () => void;
const setDefault = vi.fn(
() =>
new Promise<boolean>((resolve) => {
finishSetDefault = () => resolve(true);
}),
);
const { result, rerender, markSearchInteracted } = renderActions(
{},
makeStore({ presets: [savedPreset], setDefault }),
);
let mutation!: Promise<void>;
act(() => {
mutation = result.current.onToggleSavedDefault(savedPreset);
});
rerender({ workspaceId: SECOND_WORKSPACE_ID });
await act(async () => {
finishSetDefault();
await mutation;
});
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(result.current.defaultMutationPendingId).toBeNull();
}
async function expectDefaultPendingScopedToWorkspace() {
let finishFirst!: () => void;
let finishSecond!: () => void;
const setDefault = vi.fn(
() =>
new Promise<boolean>((resolve) => {
const finish = () => resolve(true);
if (setDefault.mock.calls.length === 1) finishFirst = finish;
else finishSecond = finish;
}),
);
const { result, rerender, markSearchInteracted } = renderActions({}, makeStore({ setDefault }));
let firstMutation!: Promise<void>;
act(() => {
firstMutation = result.current.onToggleSavedDefault(savedPreset);
});
expect(result.current.defaultMutationPendingId).toBe(savedPreset.id);
rerender({ workspaceId: SECOND_WORKSPACE_ID });
expect(result.current.defaultMutationPendingId).toBeNull();
let secondMutation!: Promise<void>;
act(() => {
secondMutation = result.current.onToggleSavedDefault(savedPreset);
});
expect(setDefault).toHaveBeenCalledTimes(2);
expect(result.current.defaultMutationPendingId).toBe(savedPreset.id);
await act(async () => {
finishFirst();
await firstMutation;
});
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(result.current.defaultMutationPendingId).toBe(savedPreset.id);
await act(async () => {
finishSecond();
await secondMutation;
});
expect(markSearchInteracted).toHaveBeenCalledOnce();
expect(result.current.defaultMutationPendingId).toBeNull();
}
beforeEach(() => {
vi.mocked(useSavedPresets).mockReset();
mockToast.mockReset();
});
describe("useSavedPresetActions save actions", () => {
it("ignores a completed save after changing workspace", expectStaleSaveOutcomeIgnored);
it("saves the current query, commits it, selects it, and applies its repository", async () => {
const save = vi.fn(async () => savedPreset);
const store = makeStore({ presets: [savedPreset], save });
const {
result,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
} = renderActions({ selection: { kind: "issue", source: "preset", id: "assigned" } }, store);
await act(async () => result.current.onConfirmSave("Assigned in Kandev", REPO));
expect(useSavedPresets).not.toHaveBeenCalled();
expect(markSearchInteracted).toHaveBeenCalledOnce();
expect(save).toHaveBeenCalledWith({
kind: "issue",
label: "Assigned in Kandev",
customQuery: QUERY,
repoFilter: REPO,
});
expect(save.mock.invocationCallOrder[0]).toBeLessThan(
markSearchInteracted.mock.invocationCallOrder[0],
);
expect(setProgrammaticSelection).toHaveBeenCalledWith({
kind: "issue",
source: "saved",
@@ -95,13 +311,19 @@ describe("useSavedPresetActions", () => {
expect(result.current.savedPresets).toEqual([savedPreset]);
});
it("leaves selection and repository unchanged when saving returns null", () => {
const save = vi.fn(() => null);
vi.mocked(useSavedPresets).mockReturnValue({ presets: [], save, remove: vi.fn() });
const { result, setProgrammaticSelection, setQueryImmediate, setRepoFilter } = renderActions();
it("leaves selection and repository unchanged when saving returns null", async () => {
const save = vi.fn(async () => null);
const {
result,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
} = renderActions({}, makeStore({ save }));
act(() => result.current.onConfirmSave("Unavailable", REPO));
await act(async () => result.current.onConfirmSave("Unavailable", REPO));
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(save).toHaveBeenCalledWith({
kind: "issue",
label: "Unavailable",
@@ -113,14 +335,49 @@ describe("useSavedPresetActions", () => {
expect(setRepoFilter).not.toHaveBeenCalled();
});
it("deletes the active saved query and selects the first same-kind preset", () => {
const remove = vi.fn();
vi.mocked(useSavedPresets).mockReturnValue({ presets: [savedPreset], save: vi.fn(), remove });
const { result, setProgrammaticSelection, setQueryImmediate, setRepoFilter } = renderActions();
it("reports a save persistence failure without selecting the optimistic preset", async () => {
const failure = Promise.reject(new Error("settings down"));
void failure.catch(() => undefined);
const save = vi.fn(() => failure);
const { result, setProgrammaticSelection, markSearchInteracted } = renderActions(
{},
makeStore({ save }),
);
act(() => result.current.onDeleteSaved(savedPreset.id));
await act(async () => result.current.onConfirmSave("Unavailable", REPO));
expect(mockToast).toHaveBeenCalledWith({
description: "Failed to save saved query",
variant: "error",
});
expect(setProgrammaticSelection).not.toHaveBeenCalled();
expect(markSearchInteracted).not.toHaveBeenCalled();
});
});
describe("useSavedPresetActions delete actions", () => {
it("ignores a completed delete after changing workspace", expectStaleDeleteOutcomeIgnored);
it("deletes the active saved query and selects the first same-kind preset", async () => {
const remove = vi.fn(async () => true);
const {
result,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
} = renderActions({}, makeStore({ presets: [savedPreset], remove }));
await act(async () => result.current.onDeleteSaved(savedPreset.id));
expect(markSearchInteracted).toHaveBeenCalledOnce();
expect(remove).toHaveBeenCalledWith(savedPreset.id);
expect(remove.mock.invocationCallOrder[0]).toBeLessThan(
markSearchInteracted.mock.invocationCallOrder[0],
);
expect(remove.mock.invocationCallOrder[0]).toBeLessThan(
setProgrammaticSelection.mock.invocationCallOrder[0],
);
expect(setProgrammaticSelection).toHaveBeenCalledWith({
kind: "issue",
source: "preset",
@@ -128,23 +385,209 @@ describe("useSavedPresetActions", () => {
});
expect(setQueryImmediate).toHaveBeenCalledWith(issuePreset.filter);
expect(setRepoFilter).toHaveBeenCalledWith("");
expect(remove.mock.invocationCallOrder[0]).toBeLessThan(
setProgrammaticSelection.mock.invocationCallOrder[0],
);
});
it("deletes an inactive saved query without changing the active search", () => {
const remove = vi.fn();
vi.mocked(useSavedPresets).mockReturnValue({ presets: [savedPreset], save: vi.fn(), remove });
const { result, setProgrammaticSelection, setQueryImmediate, setRepoFilter } = renderActions({
selection: { kind: "issue", source: "saved", id: "saved-active" },
});
it(
"uses the latest preset catalog when an active deletion finishes",
expectLatestPresetCatalogAfterDelete,
);
act(() => result.current.onDeleteSaved(savedPreset.id));
it("deletes an inactive saved query without changing the active search", async () => {
const remove = vi.fn(async () => true);
const {
result,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
} = renderActions(
{ selection: { kind: "issue", source: "saved", id: "saved-active" } },
makeStore({ presets: [savedPreset], remove }),
);
await act(async () => result.current.onDeleteSaved(savedPreset.id));
expect(markSearchInteracted).toHaveBeenCalledOnce();
expect(remove).toHaveBeenCalledWith(savedPreset.id);
expect(setProgrammaticSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
});
it("does not mark search interaction when the saved query no longer exists", async () => {
const remove = vi.fn(async () => false);
const { result, markSearchInteracted } = renderActions({}, makeStore({ remove }));
await act(async () => result.current.onDeleteSaved(savedPreset.id));
expect(markSearchInteracted).not.toHaveBeenCalled();
});
it("reports a delete persistence failure", async () => {
const failure = Promise.reject(new Error("settings down"));
void failure.catch(() => undefined);
const remove = vi.fn(() => failure);
const {
result,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
} = renderActions({}, makeStore({ remove }));
await act(async () => result.current.onDeleteSaved(savedPreset.id));
expect(mockToast).toHaveBeenCalledWith({
description: "Failed to delete saved query",
variant: "error",
});
expect(setProgrammaticSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
expect(markSearchInteracted).not.toHaveBeenCalled();
});
});
describe("useSavedPresetActions default deletion", () => {
it("deletes an inactive default without changing the active search", async () => {
const inactiveDefault = { ...savedPreset, isDefault: true };
const remove = vi.fn(async () => true);
const {
result,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
} = renderActions(
{ selection: { kind: "issue", source: "saved", id: "saved-active" } },
makeStore({ presets: [inactiveDefault], remove }),
);
await act(async () => result.current.onDeleteSaved(inactiveDefault.id));
expect(markSearchInteracted).toHaveBeenCalledOnce();
expect(remove).toHaveBeenCalledWith(inactiveDefault.id);
expect(setProgrammaticSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
});
});
describe("useSavedPresetActions default actions", () => {
it("scopes pending default toggles to their workspace", expectDefaultPendingScopedToWorkspace);
it(
"ignores a completed default toggle after changing workspace",
expectStaleToggleDefaultOutcomeIgnored,
);
it("keeps action handlers stable across unchanged renders", () => {
const { result, rerender } = renderActions();
const initialConfirm = result.current.onConfirmSave;
const initialDelete = result.current.onDeleteSaved;
const initialToggle = result.current.onToggleSavedDefault;
rerender();
expect(result.current.onConfirmSave).toBe(initialConfirm);
expect(result.current.onDeleteSaved).toBe(initialDelete);
expect(result.current.onToggleSavedDefault).toBe(initialToggle);
});
it("does not mark search interaction when the default mutation is unavailable", async () => {
const { result, markSearchInteracted } = renderActions();
await act(async () => {
await result.current.onToggleSavedDefault(savedPreset);
});
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(result.current.defaultMutationPendingId).toBeNull();
});
it("ignores a second default toggle while the first is pending", async () => {
let finish!: () => void;
const setDefault = vi.fn(
() =>
new Promise<boolean>((resolve) => {
finish = () => resolve(true);
}),
);
const { result } = renderActions({}, makeStore({ presets: [savedPreset], setDefault }));
const toggle = result.current.onToggleSavedDefault;
let firstMutation!: Promise<void>;
let secondMutation!: Promise<void>;
act(() => {
firstMutation = toggle(savedPreset);
secondMutation = toggle(savedPreset);
});
expect(setDefault).toHaveBeenCalledOnce();
await act(async () => {
finish();
await Promise.all([firstMutation, secondMutation]);
});
});
it("sets a future default without changing the current search and exposes pending state", async () => {
let finish!: () => void;
const setDefault = vi.fn(
() =>
new Promise<boolean>((resolve) => {
finish = () => resolve(true);
}),
);
const store = makeStore({ presets: [savedPreset], setDefault });
const {
result,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
markSearchInteracted,
} = renderActions({}, store);
let mutation!: Promise<void>;
act(() => {
mutation = result.current.onToggleSavedDefault(savedPreset);
});
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(setDefault).toHaveBeenCalledWith("issue", savedPreset.id);
expect(result.current.defaultMutationPendingId).toBe(savedPreset.id);
expect(setProgrammaticSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
await act(async () => {
finish();
await mutation;
});
expect(markSearchInteracted).toHaveBeenCalledOnce();
expect(result.current.defaultMutationPendingId).toBeNull();
});
it("clears an existing default and reports persistence failure", async () => {
const currentDefault = { ...savedPreset, isDefault: true };
const setDefault = vi.fn(async () => {
throw new Error("settings down");
});
const { result, markSearchInteracted } = renderActions(
{},
makeStore({ presets: [currentDefault], setDefault }),
);
await act(async () => {
await result.current.onToggleSavedDefault(currentDefault);
});
expect(setDefault).toHaveBeenCalledWith("issue", null);
expect(mockToast).toHaveBeenCalledWith({
description: "Failed to update default view",
variant: "error",
});
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(result.current.defaultMutationPendingId).toBeNull();
});
});
@@ -1,8 +1,19 @@
"use client";
import { useCallback, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { useToast } from "@/components/toast-provider";
import type { PresetOption } from "./search-bar";
import type { SidebarSelection } from "./presets-sidebar";
import { useSavedPresets } from "./use-saved-presets";
import type { SavedPreset } from "./saved-preset-model";
import type { useSavedPresets } from "./use-saved-presets";
type SavedPresetStore = ReturnType<typeof useSavedPresets>;
type WorkspaceId = string | null;
type IsCurrentWorkspace = (workspaceId: WorkspaceId) => boolean;
type PendingDefaultMutation = {
presetId: string;
};
type SavedPresetActionsOptions = {
workspaceId: string | null;
@@ -13,6 +24,8 @@ type SavedPresetActionsOptions = {
setProgrammaticSelection: (selection: SidebarSelection) => void;
setQueryImmediate: (query: string) => void;
setRepoFilter: (repo: string) => void;
savedPresetStore: SavedPresetStore;
markSearchInteracted: () => void;
};
function firstPresetSelection(
@@ -27,43 +40,228 @@ function firstPresetSelection(
};
}
function useIsCurrentWorkspace(workspaceId: WorkspaceId): IsCurrentWorkspace {
const workspaceIdRef = useRef(workspaceId);
workspaceIdRef.current = workspaceId;
return useCallback((candidate) => workspaceIdRef.current === candidate, []);
}
function useConfirmSave({
workspaceId,
kind,
customQuery,
save,
markSearchInteracted,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
reportError,
isCurrentWorkspace,
}: {
workspaceId: WorkspaceId;
kind: SidebarSelection["kind"];
customQuery: string;
save: SavedPresetStore["save"];
markSearchInteracted: () => void;
setProgrammaticSelection: (selection: SidebarSelection) => void;
setQueryImmediate: (query: string) => void;
setRepoFilter: (repo: string) => void;
reportError: () => void;
isCurrentWorkspace: IsCurrentWorkspace;
}) {
return useCallback(
async (label: string, defaultRepoFilter: string) => {
try {
const created = await save({ kind, label, customQuery, repoFilter: defaultRepoFilter });
// No persistence started when workspace presets are not available yet.
if (!created) return;
if (!isCurrentWorkspace(workspaceId)) return;
markSearchInteracted();
setProgrammaticSelection({ kind, source: "saved", id: created.id });
setQueryImmediate(customQuery);
setRepoFilter(defaultRepoFilter);
} catch {
reportError();
}
},
[
customQuery,
isCurrentWorkspace,
kind,
markSearchInteracted,
reportError,
save,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
workspaceId,
],
);
}
function useDeleteSaved({
workspaceId,
selection,
prPresets,
issuePresets,
remove,
markSearchInteracted,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
reportError,
isCurrentWorkspace,
}: {
workspaceId: WorkspaceId;
selection: SidebarSelection;
prPresets: PresetOption[];
issuePresets: PresetOption[];
remove: SavedPresetStore["remove"];
markSearchInteracted: () => void;
setProgrammaticSelection: (selection: SidebarSelection) => void;
setQueryImmediate: (query: string) => void;
setRepoFilter: (repo: string) => void;
reportError: () => void;
isCurrentWorkspace: IsCurrentWorkspace;
}) {
const selectionRef = useRef(selection);
selectionRef.current = selection;
const presetsRef = useRef({ prPresets, issuePresets });
presetsRef.current = { prPresets, issuePresets };
return useCallback(
async (id: string) => {
try {
const removed = await remove(id);
// Loading or a stale target is a no-op, not a persistence failure.
if (!removed) return;
if (!isCurrentWorkspace(workspaceId)) return;
markSearchInteracted();
const currentSelection = selectionRef.current;
if (currentSelection.source === "saved" && currentSelection.id === id) {
const fallback = firstPresetSelection(
currentSelection.kind,
presetsRef.current.prPresets,
presetsRef.current.issuePresets,
);
setProgrammaticSelection(fallback.selection);
setQueryImmediate(fallback.filter);
setRepoFilter("");
}
} catch {
reportError();
}
},
[
isCurrentWorkspace,
markSearchInteracted,
remove,
reportError,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
workspaceId,
],
);
}
export function useSavedPresetActions({
workspaceId,
selection,
customQuery,
resolvedPrPresets,
resolvedIssuePresets,
resolvedPrPresets: prPresets,
resolvedIssuePresets: issuePresets,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
savedPresetStore,
markSearchInteracted,
}: SavedPresetActionsOptions) {
const { t } = useTranslation();
const { toast } = useToast();
const [, setDefaultMutationVersion] = useState(0);
const pendingDefaultMutationsRef = useRef(new Map<WorkspaceId, PendingDefaultMutation>());
const isCurrentWorkspace = useIsCurrentWorkspace(workspaceId);
const pendingDefaultMutation = pendingDefaultMutationsRef.current.get(workspaceId);
const defaultMutationPendingId = pendingDefaultMutation?.presetId ?? null;
const {
presets: savedPresets,
save: saveSavedPreset,
remove: removeSavedPreset,
} = useSavedPresets(workspaceId);
setDefault: setSavedPresetDefault,
} = savedPresetStore;
const onConfirmSave = (label: string, defaultRepoFilter: string) => {
const created = saveSavedPreset({
kind: selection.kind,
label,
customQuery,
repoFilter: defaultRepoFilter,
});
if (!created) return;
setProgrammaticSelection({ kind: selection.kind, source: "saved", id: created.id });
setQueryImmediate(customQuery);
setRepoFilter(defaultRepoFilter);
const reportSaveError = useCallback(
() => toast({ description: t("integrations:failedToSaveSavedQuery"), variant: "error" }),
[t, toast],
);
const reportDeleteError = useCallback(
() => toast({ description: t("integrations:failedToDeleteSavedQuery"), variant: "error" }),
[t, toast],
);
const onConfirmSave = useConfirmSave({
workspaceId,
kind: selection.kind,
customQuery,
save: saveSavedPreset,
markSearchInteracted,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
reportError: reportSaveError,
isCurrentWorkspace,
});
const onDeleteSaved = useDeleteSaved({
workspaceId,
selection,
prPresets,
issuePresets,
remove: removeSavedPreset,
markSearchInteracted,
setProgrammaticSelection,
setQueryImmediate,
setRepoFilter,
reportError: reportDeleteError,
isCurrentWorkspace,
});
const onToggleSavedDefault = useCallback(
async (preset: SavedPreset) => {
const pendingMutations = pendingDefaultMutationsRef.current;
if (pendingMutations.has(workspaceId)) return;
const pendingMutation: PendingDefaultMutation = { presetId: preset.id };
pendingMutations.set(workspaceId, pendingMutation);
setDefaultMutationVersion((version) => version + 1);
try {
const defaultId = preset.isDefault ? null : preset.id;
const persisted = await setSavedPresetDefault(preset.kind, defaultId);
// Loading or an already-matching default is a no-op, not a persistence failure.
if (!persisted) return;
if (!isCurrentWorkspace(workspaceId)) return;
// Mark interaction so the initial-selection effect does not switch the
// active view to the newly set default on the same render cycle.
markSearchInteracted();
} catch {
toast({
description: t("integrations:failedToUpdateDefaultView"),
variant: "error",
});
} finally {
if (pendingMutations.get(workspaceId) === pendingMutation) {
pendingMutations.delete(workspaceId);
if (isCurrentWorkspace(workspaceId)) {
setDefaultMutationVersion((version) => version + 1);
}
}
}
},
[isCurrentWorkspace, markSearchInteracted, setSavedPresetDefault, t, toast, workspaceId],
);
return {
savedPresets,
onConfirmSave,
onDeleteSaved,
onToggleSavedDefault,
defaultMutationPendingId,
};
const onDeleteSaved = (id: string) => {
removeSavedPreset(id);
if (selection.source !== "saved" || selection.id !== id) return;
const fallback = firstPresetSelection(selection.kind, resolvedPrPresets, resolvedIssuePresets);
setProgrammaticSelection(fallback.selection);
setQueryImmediate(fallback.filter);
setRepoFilter("");
};
return { savedPresets, onConfirmSave, onDeleteSaved };
}
@@ -0,0 +1,590 @@
import { act, renderHook, waitFor } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { fetchUserSettings, updateUserSettings } from "@/lib/api/domains/settings-api";
import {
fetchGitHubWorkspaceSettings,
updateGitHubWorkspaceSettings,
} from "@/lib/api/domains/github-api";
import { __resetSnapshotForTests, useSavedPresets, type SavedPreset } from "./use-saved-presets";
const WORKSPACE_ID = "ws-1";
const SETTINGS_TIMESTAMP = "2026-01-01T00:00:00Z";
const WORKSPACE_MODE = "workspace";
const PORTABLE_USER_MODE = "portable user";
const MODES = [WORKSPACE_MODE, PORTABLE_USER_MODE] as const;
type PersistenceMode = (typeof MODES)[number];
const valid: SavedPreset = {
id: "pr-a",
kind: "pr",
label: "PR A",
customQuery: "author:@me",
repoFilter: "",
createdAt: SETTINGS_TIMESTAMP,
isDefault: false,
};
vi.mock("@/lib/api/domains/settings-api", () => ({
fetchUserSettings: vi.fn(),
updateUserSettings: vi.fn(),
}));
vi.mock("@/lib/api/domains/github-api", () => ({
fetchGitHubWorkspaceSettings: vi.fn(),
updateGitHubWorkspaceSettings: vi.fn(),
}));
function deferred<T>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((res) => {
resolve = res;
});
return { promise, resolve };
}
function workspaceSettings(
savedPresets: unknown = [],
): Awaited<ReturnType<typeof fetchGitHubWorkspaceSettings>> {
return {
workspace_id: WORKSPACE_ID,
repo_scope_mode: "all",
repo_scope_orgs: [],
repo_scope_repos: [],
saved_presets: savedPresets,
default_query_presets: null,
created_at: SETTINGS_TIMESTAMP,
updated_at: SETTINGS_TIMESTAMP,
} as Awaited<ReturnType<typeof fetchGitHubWorkspaceSettings>>;
}
function requirePreset(value: SavedPreset | null): SavedPreset {
expect(value).not.toBeNull();
if (value === null) throw new Error("Expected a saved preset");
return value;
}
function mockHydration(mode: PersistenceMode, presets: SavedPreset[]) {
if (mode === WORKSPACE_MODE) {
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings(presets));
return;
}
vi.mocked(fetchUserSettings).mockResolvedValue({
settings: { github_saved_presets: presets },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
}
function deferFirstPersistence(mode: PersistenceMode): () => void {
if (mode === WORKSPACE_MODE) {
const first = deferred<Awaited<ReturnType<typeof updateGitHubWorkspaceSettings>>>();
vi.mocked(updateGitHubWorkspaceSettings)
.mockReturnValueOnce(first.promise)
.mockResolvedValueOnce(workspaceSettings());
return () => first.resolve(workspaceSettings());
}
const first = deferred<Awaited<ReturnType<typeof updateUserSettings>>>();
const success = undefined as unknown as Awaited<ReturnType<typeof updateUserSettings>>;
vi.mocked(updateUserSettings).mockReturnValueOnce(first.promise).mockResolvedValueOnce(success);
return () => first.resolve(success);
}
function expectPersistenceCalls(mode: PersistenceMode, count: number) {
if (mode === WORKSPACE_MODE) {
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledTimes(count);
} else {
expect(updateUserSettings).toHaveBeenCalledTimes(count);
}
}
function expectLastPersisted(mode: PersistenceMode, presets: SavedPreset[]) {
if (mode === WORKSPACE_MODE) {
expect(updateGitHubWorkspaceSettings).toHaveBeenLastCalledWith({
workspace_id: WORKSPACE_ID,
saved_presets: presets,
});
} else {
expect(updateUserSettings).toHaveBeenLastCalledWith({ github_saved_presets: presets });
}
}
async function renderLoaded(mode: PersistenceMode, presets: SavedPreset[]) {
mockHydration(mode, presets);
const hook = renderHook(() => useSavedPresets(mode === WORKSPACE_MODE ? WORKSPACE_ID : null));
await waitFor(() => expect(hook.result.current.presets).toEqual(presets));
return hook;
}
async function expectPendingDefaultTargetRemoval(mode: PersistenceMode) {
const prA = { ...valid, isDefault: true };
const prB = { ...valid, id: "pr-b", label: "PR B" };
const resolveDefault = deferFirstPersistence(mode);
const { result } = await renderLoaded(mode, [prA, prB]);
let defaultMutation!: Promise<boolean>;
act(() => {
defaultMutation = result.current.setDefault("pr", "pr-b");
});
await waitFor(() => expectPersistenceCalls(mode, 1));
let removeMutation!: Promise<boolean>;
act(() => {
removeMutation = result.current.remove("pr-b");
});
await act(async () => {
resolveDefault();
await Promise.all([defaultMutation, removeMutation]);
});
await waitFor(() => expectPersistenceCalls(mode, 2));
const expected = [prA];
expect(result.current.presets).toEqual(expected);
expectLastPersisted(mode, expected);
}
async function expectIndependentWorkspacePersistence() {
const firstWorkspaceId = "ws-first";
const secondWorkspaceId = "ws-second";
const firstWrite = deferred<Awaited<ReturnType<typeof updateGitHubWorkspaceSettings>>>();
vi.mocked(fetchGitHubWorkspaceSettings).mockImplementation(async (workspaceId) => ({
...workspaceSettings([valid]),
workspace_id: workspaceId,
}));
vi.mocked(updateGitHubWorkspaceSettings).mockImplementation((settings) => {
const response = { ...workspaceSettings(), workspace_id: settings.workspace_id };
return settings.workspace_id === firstWorkspaceId
? firstWrite.promise
: Promise.resolve(response);
});
const firstHook = renderHook(() => useSavedPresets(firstWorkspaceId));
const secondHook = renderHook(() => useSavedPresets(secondWorkspaceId));
await waitFor(() => expect(firstHook.result.current.presets).toEqual([valid]));
await waitFor(() => expect(secondHook.result.current.presets).toEqual([valid]));
let firstSave!: Promise<SavedPreset | null>;
act(() => {
firstSave = firstHook.result.current.save({
kind: "pr",
label: "First workspace",
customQuery: "is:open",
repoFilter: "",
});
});
await waitFor(() =>
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledWith(
expect.objectContaining({ workspace_id: firstWorkspaceId }),
),
);
let secondSave!: Promise<SavedPreset | null>;
act(() => {
secondSave = secondHook.result.current.save({
kind: "pr",
label: "Second workspace",
customQuery: "is:closed",
repoFilter: "",
});
});
try {
await waitFor(
() =>
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledWith(
expect.objectContaining({ workspace_id: secondWorkspaceId }),
),
{ timeout: 250 },
);
} finally {
await act(async () => {
firstWrite.resolve({ ...workspaceSettings(), workspace_id: firstWorkspaceId });
await Promise.all([firstSave, secondSave]);
});
}
}
async function expectQueuedWorkspaceSaveIsolation() {
const firstWorkspaceId = "ws-first";
const secondWorkspaceId = "ws-second";
const firstWorkspacePreset = { ...valid, label: "Workspace A" };
const secondWorkspacePreset = { ...valid, id: "pr-b", label: "Workspace B" };
const firstWrite = deferred<Awaited<ReturnType<typeof updateGitHubWorkspaceSettings>>>();
vi.mocked(fetchGitHubWorkspaceSettings).mockImplementation(async (workspaceId) => ({
...workspaceSettings(
workspaceId === firstWorkspaceId ? [firstWorkspacePreset] : [secondWorkspacePreset],
),
workspace_id: workspaceId,
}));
vi.mocked(updateGitHubWorkspaceSettings)
.mockReturnValueOnce(firstWrite.promise)
.mockResolvedValueOnce({ ...workspaceSettings(), workspace_id: firstWorkspaceId });
const { result, rerender } = renderHook(({ workspaceId }) => useSavedPresets(workspaceId), {
initialProps: { workspaceId: firstWorkspaceId },
});
await waitFor(() => expect(result.current.presets).toEqual([firstWorkspacePreset]));
let firstSave!: Promise<SavedPreset | null>;
act(() => {
firstSave = result.current.save({
kind: "pr",
label: "First queued",
customQuery: "is:open",
repoFilter: "",
});
});
await waitFor(() => expect(updateGitHubWorkspaceSettings).toHaveBeenCalledTimes(1));
let secondSave!: Promise<SavedPreset | null>;
act(() => {
secondSave = result.current.save({
kind: "pr",
label: "Second queued",
customQuery: "is:closed",
repoFilter: "",
});
});
rerender({ workspaceId: secondWorkspaceId });
await waitFor(() => expect(result.current.presets).toEqual([secondWorkspacePreset]));
await act(async () => {
firstWrite.resolve({ ...workspaceSettings(), workspace_id: firstWorkspaceId });
await Promise.all([firstSave, secondSave]);
});
await waitFor(() => expect(updateGitHubWorkspaceSettings).toHaveBeenCalledTimes(2));
const secondPayload = vi.mocked(updateGitHubWorkspaceSettings).mock.calls[1]?.[0];
expect(secondPayload?.workspace_id).toBe(firstWorkspaceId);
expect((secondPayload?.saved_presets as SavedPreset[]).map((preset) => preset.label)).toEqual([
"Workspace A",
"First queued",
"Second queued",
]);
expect(result.current.presets).toEqual([secondWorkspacePreset]);
}
async function expectWorkspaceNavigationUnblocksNewMutations() {
const firstWorkspaceId = "ws-first";
const secondWorkspaceId = "ws-second";
const firstWorkspacePreset = { ...valid, label: "Workspace A" };
const secondWorkspacePreset = { ...valid, id: "pr-b", label: "Workspace B" };
const firstWrite = deferred<Awaited<ReturnType<typeof updateGitHubWorkspaceSettings>>>();
vi.mocked(fetchGitHubWorkspaceSettings).mockImplementation(async (workspaceId) => ({
...workspaceSettings(
workspaceId === firstWorkspaceId ? [firstWorkspacePreset] : [secondWorkspacePreset],
),
workspace_id: workspaceId,
}));
vi.mocked(updateGitHubWorkspaceSettings)
.mockReturnValueOnce(firstWrite.promise)
.mockResolvedValue(workspaceSettings());
const { result, rerender } = renderHook(({ workspaceId }) => useSavedPresets(workspaceId), {
initialProps: { workspaceId: firstWorkspaceId },
});
await waitFor(() => expect(result.current.presets).toEqual([firstWorkspacePreset]));
let firstSave!: Promise<SavedPreset | null>;
act(() => {
firstSave = result.current.save({
kind: "pr",
label: "First pending",
customQuery: "is:open",
repoFilter: "",
});
});
await waitFor(() => expect(updateGitHubWorkspaceSettings).toHaveBeenCalledTimes(1));
rerender({ workspaceId: secondWorkspaceId });
await waitFor(() => expect(result.current.presets).toEqual([secondWorkspacePreset]));
let secondSave!: Promise<SavedPreset | null>;
act(() => {
secondSave = result.current.save({
kind: "pr",
label: "Second immediate",
customQuery: "is:closed",
repoFilter: "",
});
});
try {
await waitFor(
() =>
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledWith(
expect.objectContaining({ workspace_id: secondWorkspaceId }),
),
{ timeout: 250 },
);
} finally {
await act(async () => {
firstWrite.resolve(workspaceSettings());
await Promise.all([firstSave, secondSave]);
});
}
}
async function expectSaveThenRemove(mode: PersistenceMode) {
const resolveSave = deferFirstPersistence(mode);
const { result } = await renderLoaded(mode, [valid]);
let saveMutation!: Promise<SavedPreset | null>;
act(() => {
saveMutation = result.current.save({
kind: "pr",
label: "Saved while deleting",
customQuery: "is:open",
repoFilter: "",
});
});
await waitFor(() => expectPersistenceCalls(mode, 1));
let removeMutation!: Promise<boolean>;
act(() => {
removeMutation = result.current.remove(valid.id);
});
let created: SavedPreset | null = null;
let removed = false;
await act(async () => {
resolveSave();
[created, removed] = await Promise.all([saveMutation, removeMutation]);
});
await waitFor(() => expectPersistenceCalls(mode, 2));
const expected = [requirePreset(created)];
expect(removed).toBe(true);
expect(result.current.presets).toEqual(expected);
expectLastPersisted(mode, expected);
}
async function expectPortableDefaultsAcrossHookInstances() {
const pr = { ...valid, isDefault: false };
const issue = { ...valid, id: "issue-a", kind: "issue" as const, isDefault: false };
const resolveFirst = deferFirstPersistence(PORTABLE_USER_MODE);
mockHydration(PORTABLE_USER_MODE, [pr, issue]);
const first = renderHook(() => useSavedPresets());
const second = renderHook(() => useSavedPresets());
await waitFor(() => expect(first.result.current.presets).toEqual([pr, issue]));
await waitFor(() => expect(second.result.current.presets).toEqual([pr, issue]));
let firstMutation!: Promise<boolean>;
act(() => {
firstMutation = first.result.current.setDefault("pr", pr.id);
});
await waitFor(() => expectPersistenceCalls(PORTABLE_USER_MODE, 1));
let secondMutation!: Promise<boolean>;
act(() => {
secondMutation = second.result.current.setDefault("issue", issue.id);
});
await act(async () => {
resolveFirst();
await Promise.all([firstMutation, secondMutation]);
});
await waitFor(() => expectPersistenceCalls(PORTABLE_USER_MODE, 2));
const expected = [
{ ...pr, isDefault: true },
{ ...issue, isDefault: true },
];
expectLastPersisted(PORTABLE_USER_MODE, expected);
expect(first.result.current.presets).toEqual(expected);
expect(second.result.current.presets).toEqual(expected);
}
async function expectPortableDefaultLastWriteWins() {
const prA = { ...valid, isDefault: false };
const prB = { ...valid, id: "pr-b", label: "PR B", isDefault: false };
const resolveFirst = deferFirstPersistence(PORTABLE_USER_MODE);
mockHydration(PORTABLE_USER_MODE, [prA, prB]);
const first = renderHook(() => useSavedPresets());
const second = renderHook(() => useSavedPresets());
await waitFor(() => expect(first.result.current.presets).toEqual([prA, prB]));
await waitFor(() => expect(second.result.current.presets).toEqual([prA, prB]));
let firstMutation!: Promise<boolean>;
act(() => {
firstMutation = first.result.current.setDefault("pr", prA.id);
});
await waitFor(() => expectPersistenceCalls(PORTABLE_USER_MODE, 1));
let secondMutation!: Promise<boolean>;
act(() => {
secondMutation = second.result.current.setDefault("pr", prB.id);
});
await act(async () => {
resolveFirst();
await Promise.all([firstMutation, secondMutation]);
});
await waitFor(() => expectPersistenceCalls(PORTABLE_USER_MODE, 2));
const expected = [
{ ...prA, isDefault: false },
{ ...prB, isDefault: true },
];
expectLastPersisted(PORTABLE_USER_MODE, expected);
expect(first.result.current.presets).toEqual(expected);
expect(second.result.current.presets).toEqual(expected);
}
async function expectWorkspaceResetDetachesStaleMutation() {
const firstWrite = deferred<Awaited<ReturnType<typeof updateGitHubWorkspaceSettings>>>();
vi.mocked(updateGitHubWorkspaceSettings)
.mockReturnValueOnce(firstWrite.promise)
.mockResolvedValue(workspaceSettings());
const firstHook = await renderLoaded(WORKSPACE_MODE, [valid]);
let firstSave!: Promise<SavedPreset | null>;
act(() => {
firstSave = firstHook.result.current.save({
kind: "pr",
label: "First write",
customQuery: "is:open",
repoFilter: "",
});
});
await waitFor(() => expect(updateGitHubWorkspaceSettings).toHaveBeenCalledTimes(1));
firstHook.unmount();
__resetSnapshotForTests();
const secondHook = await renderLoaded(WORKSPACE_MODE, [valid]);
let secondSave!: Promise<SavedPreset | null>;
act(() => {
secondSave = secondHook.result.current.save({
kind: "pr",
label: "Second write",
customQuery: "is:closed",
repoFilter: "",
});
});
await waitFor(() => expect(updateGitHubWorkspaceSettings).toHaveBeenCalledTimes(2));
await act(async () => {
firstWrite.resolve(workspaceSettings());
await Promise.all([firstSave, secondSave]);
});
}
async function expectPortableResetDetachesStaleMutation() {
const resolveFirst = deferFirstPersistence(PORTABLE_USER_MODE);
const firstHook = await renderLoaded(PORTABLE_USER_MODE, [valid]);
let firstDefault!: Promise<boolean>;
act(() => {
firstDefault = firstHook.result.current.setDefault("pr", valid.id);
});
await waitFor(() => expectPersistenceCalls(PORTABLE_USER_MODE, 1));
firstHook.unmount();
__resetSnapshotForTests();
const freshPreset = { ...valid, label: "Fresh test state" };
const secondHook = await renderLoaded(PORTABLE_USER_MODE, [freshPreset]);
await act(async () => {
resolveFirst();
await firstDefault;
});
expect(secondHook.result.current.presets).toEqual([freshPreset]);
}
function resetMutationTestState() {
__resetSnapshotForTests();
vi.mocked(fetchUserSettings).mockReset();
vi.mocked(updateUserSettings).mockReset();
vi.mocked(fetchGitHubWorkspaceSettings).mockReset();
vi.mocked(updateGitHubWorkspaceSettings).mockReset();
}
describe("useSavedPresets mutation ordering", () => {
beforeEach(resetMutationTestState);
it.each(MODES)("preserves a %s save while a default update is pending", async (mode) => {
const prA = { ...valid, isDefault: true };
const prB = { ...valid, id: "pr-b", label: "PR B" };
const resolveDefault = deferFirstPersistence(mode);
const { result } = await renderLoaded(mode, [prA, prB]);
let defaultMutation!: Promise<boolean>;
act(() => {
defaultMutation = result.current.setDefault("pr", "pr-b");
});
await waitFor(() => expectPersistenceCalls(mode, 1));
let saveMutation!: Promise<SavedPreset | null>;
act(() => {
saveMutation = result.current.save({
kind: "pr",
label: "Saved while pending",
customQuery: "is:open",
repoFilter: "kdlbs/kandev",
});
});
let created: SavedPreset | null = null;
await act(async () => {
resolveDefault();
[, created] = await Promise.all([defaultMutation, saveMutation]);
});
await waitFor(() => expectPersistenceCalls(mode, 2));
const saved = requirePreset(created);
const expected = [{ ...prA, isDefault: false }, { ...prB, isDefault: true }, saved];
expect(result.current.presets).toEqual(expected);
expectLastPersisted(mode, expected);
});
it.each(MODES)("preserves a %s delete while a default update is pending", async (mode) => {
const prA = { ...valid, isDefault: true };
const prB = { ...valid, id: "pr-b", label: "PR B" };
const resolveDefault = deferFirstPersistence(mode);
const { result } = await renderLoaded(mode, [prA, prB]);
let defaultMutation!: Promise<boolean>;
act(() => {
defaultMutation = result.current.setDefault("pr", "pr-b");
});
await waitFor(() => expectPersistenceCalls(mode, 1));
let removeMutation!: Promise<boolean>;
act(() => {
removeMutation = result.current.remove("pr-a");
});
await act(async () => {
resolveDefault();
await Promise.all([defaultMutation, removeMutation]);
});
await waitFor(() => expectPersistenceCalls(mode, 2));
const expected = [{ ...prB, isDefault: true }];
expect(result.current.presets).toEqual(expected);
expectLastPersisted(mode, expected);
});
it.each(MODES)("applies a %s delete while a save is pending", expectSaveThenRemove);
it(
"serializes portable defaults across hook instances",
expectPortableDefaultsAcrossHookInstances,
);
it("last portable default wins across hook instances", expectPortableDefaultLastWriteWins);
it.each(MODES)("removes a pending %s default target", expectPendingDefaultTargetRemoval);
it("persists different workspaces independently", expectIndependentWorkspacePersistence);
it("keeps queued saves scoped across workspace navigation", expectQueuedWorkspaceSaveIsolation);
it("new workspace skips the old mutation queue", expectWorkspaceNavigationUnblocksNewMutations);
it(
"detaches future workspace writes from a stale test queue",
expectWorkspaceResetDetachesStaleMutation,
);
it(
"ignores stale portable outcomes after a test reset",
expectPortableResetDetachesStaleMutation,
);
});
@@ -1,4 +1,4 @@
import { describe, it, expect, beforeEach, vi } from "vitest";
import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
import { act, renderHook, waitFor } from "@testing-library/react";
import { fetchUserSettings, updateUserSettings } from "@/lib/api/domains/settings-api";
import {
@@ -7,9 +7,9 @@ import {
} from "@/lib/api/domains/github-api";
import { __resetSnapshotForTests, useSavedPresets, type SavedPreset } from "./use-saved-presets";
const STORAGE_KEY = "kandev:github-presets:v1";
const WORKSPACE_ID = "ws-1";
const SETTINGS_TIMESTAMP = "2026-01-01T00:00:00Z";
const SETTINGS_DOWN = "settings down";
vi.mock("@/lib/api/domains/settings-api", () => ({
fetchUserSettings: vi.fn(),
@@ -21,22 +21,18 @@ vi.mock("@/lib/api/domains/github-api", () => ({
updateGitHubWorkspaceSettings: vi.fn(),
}));
function set(raw: string | null) {
if (raw === null) window.localStorage.removeItem(STORAGE_KEY);
else window.localStorage.setItem(STORAGE_KEY, raw);
}
const valid: SavedPreset = {
const legacyValid = {
id: "p_1",
kind: "pr",
kind: "pr" as const,
label: "My PRs",
customQuery: "author:@me",
repoFilter: "",
createdAt: SETTINGS_TIMESTAMP,
};
const valid: SavedPreset = { ...legacyValid, isDefault: false };
function resetTestState() {
window.localStorage.clear();
__resetSnapshotForTests();
vi.mocked(fetchUserSettings).mockReset();
vi.mocked(updateUserSettings).mockReset();
@@ -59,13 +55,38 @@ function workspaceSettings(
} as Awaited<ReturnType<typeof fetchGitHubWorkspaceSettings>>;
}
async function expectRandomUuidPresetId() {
const uuid = "123e4567-e89b-42d3-a456-426614174000";
vi.spyOn(globalThis.crypto, "randomUUID").mockReturnValue(uuid);
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings());
vi.mocked(updateGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings());
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toEqual([]));
let created: SavedPreset | null = null;
await act(async () => {
created = await result.current.save({
kind: "pr",
label: "UUID preset",
customQuery: "is:open",
repoFilter: "",
});
});
expect((created as SavedPreset | null)?.id).toBe(`p_${uuid}`);
}
afterEach(() => {
vi.unstubAllEnvs();
vi.restoreAllMocks();
});
describe("useSavedPresets", () => {
beforeEach(() => {
resetTestState();
});
it("ignores stale local presets when backend settings are empty", async () => {
set(JSON.stringify([valid]));
it("uses empty backend settings without writing", async () => {
vi.mocked(fetchUserSettings).mockResolvedValue({
settings: { github_saved_presets: [] },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
@@ -75,6 +96,14 @@ describe("useSavedPresets", () => {
await waitFor(() => expect(result.current.presets).toEqual([]));
expect(updateUserSettings).not.toHaveBeenCalled();
});
it("rejects the test reset in production", () => {
vi.stubEnv("NODE_ENV", "production");
expect(() => __resetSnapshotForTests()).toThrow(
"__resetSnapshotForTests must not be called in production",
);
});
});
describe("useSavedPresets workspace sync", () => {
@@ -82,8 +111,7 @@ describe("useSavedPresets workspace sync", () => {
resetTestState();
});
it("ignores stale local presets when workspace settings are empty", async () => {
set(JSON.stringify([valid]));
it("uses empty workspace settings without writing", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings());
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
@@ -92,9 +120,8 @@ describe("useSavedPresets workspace sync", () => {
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
it("does not migrate local presets over existing workspace presets", async () => {
it("uses existing workspace presets without writing", async () => {
const server = { ...valid, id: "p_server", label: "Server" };
set(JSON.stringify([valid]));
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings([server]));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
@@ -103,14 +130,16 @@ describe("useSavedPresets workspace sync", () => {
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
it("does not save while workspace presets are still loading", () => {
it("uses a random UUID for new preset ids", expectRandomUuidPresetId);
it("does not save while workspace presets are still loading", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockReturnValue(new Promise(() => {}));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
let created: SavedPreset | null = null;
act(() => {
created = result.current.save({
let created: SavedPreset | null = valid;
await act(async () => {
created = await result.current.save({
kind: "pr",
label: "Loading",
customQuery: "is:open",
@@ -123,15 +152,15 @@ describe("useSavedPresets workspace sync", () => {
});
it("does not save after workspace presets fail to load", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockRejectedValue(new Error("settings down"));
vi.mocked(fetchGitHubWorkspaceSettings).mockRejectedValue(new Error(SETTINGS_DOWN));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(fetchGitHubWorkspaceSettings).toHaveBeenCalled());
let created: SavedPreset | null = valid;
act(() => {
created = result.current.save({
await act(async () => {
created = await result.current.save({
kind: "pr",
label: "Failed load",
customQuery: "is:open",
@@ -143,33 +172,105 @@ describe("useSavedPresets workspace sync", () => {
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
it("does not remove while workspace presets are still loading", () => {
it("does not remove while workspace presets are still loading", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockReturnValue(new Promise(() => {}));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
act(() => {
result.current.remove("p_1");
await act(async () => {
await result.current.remove("p_1");
});
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
it("does not set a default while workspace presets are still loading", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockReturnValue(new Promise(() => {}));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await expect(result.current.setDefault("pr", "p_1")).resolves.toBe(false);
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
it("keeps mutation callbacks stable across optimistic workspace updates", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings([valid]));
vi.mocked(updateGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings());
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toEqual([valid]));
const callbacks = {
save: result.current.save,
remove: result.current.remove,
setDefault: result.current.setDefault,
};
await act(async () => {
await result.current.save({
kind: "pr",
label: "Stable callbacks",
customQuery: "is:open",
repoFilter: "",
});
});
expect(result.current.save).toBe(callbacks.save);
expect(result.current.remove).toBe(callbacks.remove);
expect(result.current.setDefault).toBe(callbacks.setDefault);
});
it("does not remove after workspace presets fail to load", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockRejectedValue(new Error("settings down"));
vi.mocked(fetchGitHubWorkspaceSettings).mockRejectedValue(new Error(SETTINGS_DOWN));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(fetchGitHubWorkspaceSettings).toHaveBeenCalled());
act(() => {
result.current.remove("p_1");
await act(async () => {
await result.current.remove("p_1");
});
expect(updateGitHubWorkspaceSettings).not.toHaveBeenCalled();
});
});
describe("useSavedPresets workspace mutation failures", () => {
beforeEach(() => {
resetTestState();
});
it("rolls back an optimistic save when persistence fails", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings([valid]));
vi.mocked(updateGitHubWorkspaceSettings).mockRejectedValue(new Error(SETTINGS_DOWN));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toEqual([valid]));
await act(async () => {
await expect(
result.current.save({
kind: "pr",
label: "Unsaved",
customQuery: "is:open",
repoFilter: "",
}),
).rejects.toThrow(SETTINGS_DOWN);
});
expect(result.current.presets).toEqual([valid]);
});
it("rolls back an optimistic removal when persistence fails", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings([valid]));
vi.mocked(updateGitHubWorkspaceSettings).mockRejectedValue(new Error(SETTINGS_DOWN));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toEqual([valid]));
await act(async () => {
await expect(result.current.remove(valid.id)).rejects.toThrow(SETTINGS_DOWN);
});
expect(result.current.presets).toEqual([valid]);
});
});
describe("useSavedPresets repository defaults", () => {
beforeEach(() => {
resetTestState();
@@ -183,8 +284,9 @@ describe("useSavedPresets repository defaults", () => {
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toEqual([server]));
act(() => {
result.current.save({
let created: SavedPreset | null = null;
await act(async () => {
created = await result.current.save({
kind: "pr",
label: "Kandev PRs",
customQuery: "is:open",
@@ -192,6 +294,8 @@ describe("useSavedPresets repository defaults", () => {
});
});
expect((created as SavedPreset | null)?.isDefault).toBe(false);
await waitFor(() =>
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledWith({
workspace_id: WORKSPACE_ID,
@@ -236,7 +340,128 @@ describe("useSavedPresets repository defaults", () => {
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() =>
expect(result.current.presets).toEqual([{ ...serverPreset, repoFilter: "" }]),
expect(result.current.presets).toEqual([
{ ...serverPreset, repoFilter: "", isDefault: false },
]),
);
});
it("normalizes a legacy saved query to a non-default view", async () => {
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings([legacyValid]));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() =>
expect(result.current.presets).toEqual([{ ...legacyValid, isDefault: false }]),
);
});
it("keeps only the first persisted default for each result kind", async () => {
const issue = { ...valid, id: "issue-1", kind: "issue", isDefault: true };
const duplicates = [
{ ...valid, id: "pr-1", isDefault: true },
{ ...valid, id: "pr-2", isDefault: true },
issue,
];
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings(duplicates));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() =>
expect(result.current.presets.map(({ id, isDefault }) => ({ id, isDefault }))).toEqual([
{ id: "pr-1", isDefault: true },
{ id: "pr-2", isDefault: false },
{ id: "issue-1", isDefault: true },
]),
);
});
});
describe("useSavedPresets default persistence", () => {
beforeEach(() => {
resetTestState();
});
it("publishes a workspace default only after persistence succeeds", async () => {
const prA = { ...valid, id: "pr-a", isDefault: true };
const prB = { ...valid, id: "pr-b" };
const issue = { ...valid, id: "issue-a", kind: "issue" as const, isDefault: true };
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings([prA, prB, issue]));
let resolveUpdate!: (value: Awaited<ReturnType<typeof updateGitHubWorkspaceSettings>>) => void;
vi.mocked(updateGitHubWorkspaceSettings).mockReturnValue(
new Promise((resolve) => {
resolveUpdate = resolve;
}),
);
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toHaveLength(3));
let mutation!: Promise<boolean>;
act(() => {
mutation = result.current.setDefault("pr", "pr-b");
});
expect(result.current.presets.map((preset) => preset.isDefault)).toEqual([true, false, true]);
let persisted!: boolean;
await act(async () => {
resolveUpdate(workspaceSettings());
persisted = await mutation;
});
expect(persisted).toBe(true);
expect(updateGitHubWorkspaceSettings).toHaveBeenCalledWith({
workspace_id: WORKSPACE_ID,
saved_presets: [{ ...prA, isDefault: false }, { ...prB, isDefault: true }, issue],
});
expect(result.current.presets.map((preset) => preset.isDefault)).toEqual([false, true, true]);
});
it("retains the prior workspace default when persistence fails", async () => {
const prA = { ...valid, id: "pr-a", isDefault: true };
const prB = { ...valid, id: "pr-b" };
vi.mocked(fetchGitHubWorkspaceSettings).mockResolvedValue(workspaceSettings([prA, prB]));
vi.mocked(updateGitHubWorkspaceSettings).mockRejectedValue(new Error(SETTINGS_DOWN));
const { result } = renderHook(() => useSavedPresets(WORKSPACE_ID));
await waitFor(() => expect(result.current.presets).toHaveLength(2));
await expect(result.current.setDefault("pr", "pr-b")).rejects.toThrow(SETTINGS_DOWN);
expect(result.current.presets.map((preset) => preset.isDefault)).toEqual([true, false]);
});
it("persists and publishes a portable user default", async () => {
const prA = { ...valid, id: "pr-a" };
vi.mocked(fetchUserSettings).mockResolvedValue({
settings: { github_saved_presets: [prA] },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
vi.mocked(updateUserSettings).mockResolvedValue(
undefined as unknown as Awaited<ReturnType<typeof updateUserSettings>>,
);
const { result } = renderHook(() => useSavedPresets());
await waitFor(() => expect(result.current.presets).toEqual([prA]));
await act(async () => {
await result.current.setDefault("pr", "pr-a");
});
expect(updateUserSettings).toHaveBeenCalledWith({
github_saved_presets: [{ ...prA, isDefault: true }],
});
expect(result.current.presets).toEqual([{ ...prA, isDefault: true }]);
});
it("retains the prior portable user default when persistence fails", async () => {
const prA = { ...valid, id: "pr-a", isDefault: true };
const prB = { ...valid, id: "pr-b" };
vi.mocked(fetchUserSettings).mockResolvedValue({
settings: { github_saved_presets: [prA, prB] },
} as Awaited<ReturnType<typeof fetchUserSettings>>);
vi.mocked(updateUserSettings).mockRejectedValue(new Error(SETTINGS_DOWN));
const { result } = renderHook(() => useSavedPresets());
await waitFor(() => expect(result.current.presets).toHaveLength(2));
await expect(result.current.setDefault("pr", "pr-b")).rejects.toThrow(SETTINGS_DOWN);
expect(result.current.presets.map((preset) => preset.isDefault)).toEqual([true, false]);
});
});
@@ -7,15 +7,14 @@ import {
updateGitHubWorkspaceSettings,
} from "@/lib/api/domains/github-api";
import { createQueuedUserSettingsSync } from "@/lib/user-settings-sync";
import {
readSavedPresets,
setSavedPresetDefault,
type SavedPreset,
type SavedPresetKind,
} from "./saved-preset-model";
export type SavedPreset = {
id: string;
kind: "pr" | "issue";
label: string;
customQuery: string;
repoFilter: string;
createdAt: string;
};
export type { SavedPreset } from "./saved-preset-model";
const listeners = new Set<() => void>();
let snapshot: SavedPreset[] = [];
@@ -43,36 +42,33 @@ function publish(next: SavedPreset[]) {
for (const l of listeners) l();
}
function readServerPresets(value: unknown): SavedPreset[] | null {
if (!Array.isArray(value)) return null;
return value.flatMap((candidate): SavedPreset[] => {
if (typeof candidate !== "object" || candidate === null) return [];
const preset = candidate as Record<string, unknown>;
const kind = preset.kind;
if (
typeof preset.id !== "string" ||
(kind !== "pr" && kind !== "issue") ||
typeof preset.label !== "string"
) {
return [];
}
return [
{
...(preset as SavedPreset),
repoFilter: typeof preset.repoFilter === "string" ? preset.repoFilter : "",
},
];
});
}
const syncServer = createQueuedUserSettingsSync<SavedPreset[]>((next) => ({
github_saved_presets: next,
}));
// Portable presets use a module snapshot shared by every hook instance, so queue the
// complete read/persist/publish mutation rather than only its already-built payload.
let portableMutationQueue = Promise.resolve();
let portableMutationGeneration = 0;
let workspaceSyncQueue = Promise.resolve();
function queuePortableMutation(mutation: () => Promise<void>): Promise<void> {
const generation = portableMutationGeneration;
const queued = portableMutationQueue
.catch(() => undefined)
.then(() => {
if (generation !== portableMutationGeneration) return;
return mutation();
});
portableMutationQueue = queued;
return queued;
}
// Shared across hook instances so writes for the same workspace stay ordered.
// Separate workspaces remain independent during navigation between them.
const workspaceSyncQueues = new Map<string, Promise<void>>();
function syncWorkspaceSavedPresets(workspaceId: string, next: SavedPreset[]): Promise<void> {
workspaceSyncQueue = workspaceSyncQueue
const previous = workspaceSyncQueues.get(workspaceId) ?? Promise.resolve();
const queued = previous
.catch(() => undefined)
.then(() =>
updateGitHubWorkspaceSettings({
@@ -80,12 +76,24 @@ function syncWorkspaceSavedPresets(workspaceId: string, next: SavedPreset[]): Pr
saved_presets: next,
}).then(() => undefined),
);
return workspaceSyncQueue;
workspaceSyncQueues.set(workspaceId, queued);
void queued
.finally(() => {
if (workspaceSyncQueues.get(workspaceId) === queued) workspaceSyncQueues.delete(workspaceId);
})
.catch(() => undefined);
return queued;
}
export function __resetSnapshotForTests() {
if (process.env.NODE_ENV === "production") {
throw new Error("__resetSnapshotForTests must not be called in production");
}
snapshot = [];
snapshotVersion = 0;
portableMutationGeneration += 1;
portableMutationQueue = Promise.resolve();
workspaceSyncQueues.clear();
for (const l of listeners) l();
}
@@ -96,8 +104,8 @@ function useUserSavedPresetsSync(enabled: boolean) {
const initialVersion = snapshotVersion;
fetchUserSettings({ cache: "no-store" })
.then((response) => {
const serverPresets = readServerPresets(response.settings.github_saved_presets);
if (cancelled || !serverPresets || snapshotVersion !== initialVersion) return;
const serverPresets = readSavedPresets(response.settings.github_saved_presets);
if (cancelled || snapshotVersion !== initialVersion) return;
publish(serverPresets);
})
.catch(() => {});
@@ -121,11 +129,11 @@ function useWorkspaceSavedPresets(workspaceId: string | null) {
fetchGitHubWorkspaceSettings(workspaceId)
.then((settings) => {
if (cancelled || seq !== writeSeq.current) return;
const serverPresets = readServerPresets(settings.saved_presets) ?? [];
const serverPresets = readSavedPresets(settings.saved_presets);
setWorkspacePresets(serverPresets);
})
.catch(() => {
if (!cancelled) setWorkspacePresets(undefined);
if (!cancelled && seq === writeSeq.current) setWorkspacePresets(undefined);
});
return () => {
cancelled = true;
@@ -138,47 +146,210 @@ function useWorkspaceSavedPresets(workspaceId: string | null) {
return { workspacePresets, setWorkspacePresets: setWorkspacePresetsFromLocal };
}
function discardSavedPreset(presets: SavedPreset[], id: string): SavedPreset[] {
return presets.filter((preset) => preset.id !== id);
}
function restoreSavedPreset(
presets: SavedPreset[],
preset: SavedPreset,
originalIndex: number,
): SavedPreset[] {
if (presets.some((candidate) => candidate.id === preset.id)) return presets;
const restored =
preset.isDefault &&
presets.some((candidate) => candidate.kind === preset.kind && candidate.isDefault)
? { ...preset, isDefault: false }
: preset;
// Best-effort: the insertion point may shift if concurrent saves ran before rollback.
const insertionIndex = Math.min(originalIndex, presets.length);
return [...presets.slice(0, insertionIndex), restored, ...presets.slice(insertionIndex)];
}
type SavedPresetMutationContext = {
workspaceId: string | null;
presets: SavedPreset[];
portableGeneration: number;
};
function readMutationPresets(context: SavedPresetMutationContext): SavedPreset[] {
return context.workspaceId === null ? snapshot : context.presets;
}
function persistSavedPresets(
context: SavedPresetMutationContext,
next: SavedPreset[],
): Promise<void> {
if (context.workspaceId !== null) {
return syncWorkspaceSavedPresets(context.workspaceId, next);
}
return syncServer(next);
}
function useSavedPresetMutationContext(
workspaceId: string | null,
activePresets: SavedPreset[],
setWorkspacePresets: (next: SavedPreset[]) => void,
) {
const mutationContextRef = useRef<SavedPresetMutationContext>({
workspaceId,
presets: activePresets,
portableGeneration: portableMutationGeneration,
});
if (
mutationContextRef.current.workspaceId !== workspaceId ||
mutationContextRef.current.portableGeneration !== portableMutationGeneration
) {
mutationContextRef.current = {
workspaceId,
presets: activePresets,
portableGeneration: portableMutationGeneration,
};
} else {
mutationContextRef.current.presets = activePresets;
}
const applyLocal = useCallback(
(context: SavedPresetMutationContext, next: SavedPreset[]) => {
if (
context.workspaceId === null &&
context.portableGeneration !== portableMutationGeneration
) {
return;
}
context.presets = next;
if (mutationContextRef.current !== context) return;
if (context.workspaceId !== null) setWorkspacePresets(next);
else publish(next);
},
[setWorkspacePresets],
);
return { mutationContextRef, applyLocal };
}
export function useSavedPresets(workspaceId: string | null = null) {
const presets = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
const { workspacePresets, setWorkspacePresets } = useWorkspaceSavedPresets(workspaceId);
const workspacePresetsRef = useRef(workspacePresets);
workspacePresetsRef.current = workspacePresets;
useUserSavedPresetsSync(!workspaceId);
const activePresets = workspaceId ? (workspacePresets ?? []) : presets;
const activePresets = workspaceId ? (workspacePresets ?? emptySnapshot) : presets;
const { mutationContextRef, applyLocal } = useSavedPresetMutationContext(
workspaceId,
activePresets,
setWorkspacePresets,
);
const mutationQueueRef = useRef<Promise<void>>(Promise.resolve());
const previousWorkspaceIdRef = useRef(workspaceId);
if (previousWorkspaceIdRef.current !== workspaceId) {
previousWorkspaceIdRef.current = workspaceId;
mutationQueueRef.current = Promise.resolve();
}
const queueMutation = useCallback(
(mutation: () => Promise<void>) => {
if (workspaceId === null) return queuePortableMutation(mutation);
const queued = mutationQueueRef.current.catch(() => undefined).then(mutation);
mutationQueueRef.current = queued;
return queued;
},
[workspaceId],
);
/**
* @returns The created preset, or null while workspace settings are unavailable.
* @throws The persistence error after rolling back the optimistic update.
*/
const save = useCallback(
(input: Omit<SavedPreset, "id" | "createdAt">) => {
if (workspaceId && workspacePresets === undefined) return null;
async (input: Omit<SavedPreset, "id" | "createdAt" | "isDefault">) => {
if (workspaceId && workspacePresetsRef.current === undefined) return null;
const context = mutationContextRef.current;
const preset: SavedPreset = {
...input,
id: `p_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
id: `p_${crypto.randomUUID()}`,
createdAt: new Date().toISOString(),
isDefault: false,
};
const next = [...activePresets, preset];
if (workspaceId) {
setWorkspacePresets(next);
void syncWorkspaceSavedPresets(workspaceId, next).catch(() => {});
const append = (current: SavedPreset[]) =>
current.some((saved) => saved.id === preset.id) ? current : [...current, preset];
applyLocal(context, append(readMutationPresets(context)));
try {
await queueMutation(async () => {
await persistSavedPresets(context, append(readMutationPresets(context)));
});
return preset;
} catch (error) {
const current = readMutationPresets(context);
const rolledBack = discardSavedPreset(current, preset.id);
if (rolledBack.length !== current.length) applyLocal(context, rolledBack);
throw error;
}
publish(next);
void syncServer(next);
return preset;
},
[activePresets, workspaceId, workspacePresets, setWorkspacePresets],
[applyLocal, queueMutation, workspaceId],
);
/**
* @returns Whether an existing preset was removed.
* @throws The persistence error; the removed preset is restored before rejection.
*/
const remove = useCallback(
(id: string) => {
if (workspaceId && workspacePresets === undefined) return;
const next = activePresets.filter((p) => p.id !== id);
if (workspaceId) {
setWorkspacePresets(next);
void syncWorkspaceSavedPresets(workspaceId, next).catch(() => {});
return;
async (id: string) => {
if (workspaceId && workspacePresetsRef.current === undefined) return false;
const context = mutationContextRef.current;
const current = readMutationPresets(context);
const originalIndex = current.findIndex((preset) => preset.id === id);
if (originalIndex === -1) return false;
const removedPreset = current[originalIndex];
applyLocal(context, discardSavedPreset(current, id));
try {
await queueMutation(async () => {
// Re-read the scoped context so concurrent saves appended after the optimistic remove
// are included in the persisted payload; the removed id is already absent.
await persistSavedPresets(context, discardSavedPreset(readMutationPresets(context), id));
});
return true;
} catch (error) {
const latest = readMutationPresets(context);
const rolledBack = restoreSavedPreset(latest, removedPreset, originalIndex);
if (rolledBack !== latest) applyLocal(context, rolledBack);
throw error;
}
publish(next);
void syncServer(next);
},
[activePresets, workspaceId, workspacePresets, setWorkspacePresets],
[applyLocal, queueMutation, workspaceId],
);
return { presets: activePresets, save, remove };
/**
* @returns Whether a changed default was persisted; loading and unchanged targets return false.
* @remarks Queued same-kind calls run in invocation order, so the last changed target wins.
* @throws The persistence error when the settings update fails.
*/
const setDefault = useCallback(
async (kind: SavedPresetKind, id: string | null) => {
if (workspaceId && workspacePresetsRef.current === undefined) return false;
const context = mutationContextRef.current;
let persisted = false;
await queueMutation(async () => {
const current = readMutationPresets(context);
const next = setSavedPresetDefault(current, kind, id);
if (next === current) {
// No-op when already matched or the target was removed while queued.
return;
}
await persistSavedPresets(context, next);
persisted = true;
// `setDefault` publishes only after persistence succeeds (no optimistic update).
// Re-read the scoped context so that concurrent mutations applied
// during the await (e.g. sibling-hook writes for portable user settings)
// are merged in before publishing the new default state.
// This is also a no-op when a concurrent remove deleted the target:
// setSavedPresetDefault returns the same reference for a missing id.
const latest = readMutationPresets(context);
const remerged = setSavedPresetDefault(latest, kind, id);
if (remerged !== latest) applyLocal(context, remerged);
});
return persisted;
},
[applyLocal, queueMutation, workspaceId],
);
return { presets: activePresets, save, remove, setDefault };
}
@@ -0,0 +1,409 @@
import { act, renderHook, waitFor } from "@testing-library/react";
import { IconInbox } from "@tabler/icons-react";
import { describe, expect, it, vi } from "vitest";
import type { PresetOption } from "./search-bar";
import type { SidebarSelection } from "./presets-sidebar";
import type { SavedPreset } from "./saved-preset-model";
import { useInitialSidebarSelection, useSidebarSelectionHandler } from "./use-sidebar-selection";
const prPreset: PresetOption = {
value: "review-requested",
label: "Review requested",
filter: "review-requested:@me is:open",
group: "inbox",
icon: IconInbox,
};
const issuePreset: PresetOption = {
value: "assigned",
label: "Assigned",
filter: "assignee:@me is:open",
group: "inbox",
icon: IconInbox,
};
const prPresets = [prPreset];
const issuePresets = [issuePreset];
const WORKSPACE_ID = "workspace-1";
const KIND_SWITCH = "kind-switch" as const;
type HandlerRenderProps = {
savedPresets: SavedPreset[];
currentPrPresets: PresetOption[];
currentIssuePresets: PresetOption[];
currentKind: SidebarSelection["kind"];
};
const prDefault: SavedPreset = {
id: "saved-pr",
kind: "pr",
label: "Kandev PRs",
customQuery: "author:@me is:open",
repoFilter: "kdlbs/kandev",
createdAt: "2026-08-07T00:00:00Z",
isDefault: true,
};
const issueDefault: SavedPreset = {
...prDefault,
id: "saved-issue",
kind: "issue",
label: "Kandev issues",
customQuery: "assignee:@me label:bug",
};
function createAutoResetControls() {
let enabled = true;
return {
shouldAutoResetSearch: () => enabled,
resetSearchOnWorkspaceChange: vi.fn(() => {
enabled = true;
}),
disable: () => {
enabled = false;
},
};
}
async function expectNewWorkspaceDefaultAfterManualSelection() {
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const autoReset = createAutoResetControls();
const { result, rerender } = renderHook(
({ workspaceId, savedPresets }) =>
useInitialSidebarSelection({
workspaceId,
resolvedPrPresets: prPresets,
shouldAutoResetSearch: autoReset.shouldAutoResetSearch,
resetSearchOnWorkspaceChange: autoReset.resetSearchOnWorkspaceChange,
setQueryImmediate,
setRepoFilter,
savedPresets,
}),
{
initialProps: {
workspaceId: WORKSPACE_ID,
savedPresets: [] as SavedPreset[],
},
},
);
const manual: SidebarSelection = { kind: "pr", source: "preset", id: "manual" };
act(() => {
result.current.setUserSelection(manual);
autoReset.disable();
});
autoReset.resetSearchOnWorkspaceChange.mockClear();
rerender({ workspaceId: "workspace-2", savedPresets: [prDefault] });
await waitFor(() => expect(result.current.selection.id).toBe(prDefault.id));
expect(setQueryImmediate).toHaveBeenLastCalledWith(prDefault.customQuery);
expect(setRepoFilter).toHaveBeenLastCalledWith(prDefault.repoFilter);
expect(autoReset.resetSearchOnWorkspaceChange).toHaveBeenCalledOnce();
}
function expectConfiguredPresetFallbackOnKindSwitch() {
const setUserSelection = vi.fn();
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const { result } = renderHook(() =>
useSidebarSelectionHandler({
currentKind: "pr",
savedPresets: [],
resolvedPrPresets: prPresets,
resolvedIssuePresets: issuePresets,
setQueryImmediate,
setRepoFilter,
setUserSelection,
markSearchInteracted: vi.fn(),
}),
);
act(() => result.current({ kind: "issue", source: KIND_SWITCH }));
expect(setUserSelection).toHaveBeenCalledWith({
kind: "issue",
source: "preset",
id: issuePreset.value,
});
expect(setQueryImmediate).toHaveBeenCalledWith(issuePreset.filter);
expect(setRepoFilter).toHaveBeenCalledWith("");
}
function expectSameKindSentinelNoop() {
const setUserSelection = vi.fn();
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const markSearchInteracted = vi.fn();
const { result } = renderHook(() =>
useSidebarSelectionHandler({
currentKind: "pr",
savedPresets: [],
resolvedPrPresets: prPresets,
resolvedIssuePresets: issuePresets,
setQueryImmediate,
setRepoFilter,
setUserSelection,
markSearchInteracted,
}),
);
act(() => result.current({ kind: "pr", source: KIND_SWITCH }));
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(setUserSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
}
function expectStableHandlerWithRefreshedPresetCatalogs() {
const setUserSelection = vi.fn();
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const markSearchInteracted = vi.fn();
const { result, rerender } = renderHook(
({ savedPresets, currentPrPresets, currentIssuePresets, currentKind }: HandlerRenderProps) =>
useSidebarSelectionHandler({
currentKind,
savedPresets,
resolvedPrPresets: currentPrPresets,
resolvedIssuePresets: currentIssuePresets,
setQueryImmediate,
setRepoFilter,
setUserSelection,
markSearchInteracted,
}),
{
initialProps: {
savedPresets: [prDefault],
currentPrPresets: prPresets,
currentIssuePresets: issuePresets,
currentKind: "pr",
},
},
);
const initialHandler = result.current;
rerender({
savedPresets: [prDefault, issueDefault],
currentPrPresets: [...prPresets],
currentIssuePresets: [...issuePresets],
currentKind: "pr",
});
expect(result.current).toBe(initialHandler);
act(() => initialHandler({ kind: "issue", source: KIND_SWITCH }));
expect(setUserSelection).toHaveBeenCalledWith({
kind: "issue",
source: "saved",
id: issueDefault.id,
});
expect(setQueryImmediate).toHaveBeenCalledWith(issueDefault.customQuery);
expect(setRepoFilter).toHaveBeenCalledWith(issueDefault.repoFilter);
const refreshedIssuePreset = {
...issuePreset,
value: "mentioned",
filter: "mentions:@me is:open",
};
setUserSelection.mockClear();
setQueryImmediate.mockClear();
setRepoFilter.mockClear();
rerender({
savedPresets: [prDefault],
currentPrPresets: [...prPresets],
currentIssuePresets: [refreshedIssuePreset],
currentKind: "pr",
});
expect(result.current).toBe(initialHandler);
act(() => initialHandler({ kind: "issue", source: KIND_SWITCH }));
expect(setUserSelection).toHaveBeenCalledWith({
kind: "issue",
source: "preset",
id: refreshedIssuePreset.value,
});
expect(setQueryImmediate).toHaveBeenCalledWith(refreshedIssuePreset.filter);
expect(setRepoFilter).toHaveBeenCalledWith("");
markSearchInteracted.mockClear();
setUserSelection.mockClear();
setQueryImmediate.mockClear();
setRepoFilter.mockClear();
rerender({
savedPresets: [prDefault],
currentPrPresets: [...prPresets],
currentIssuePresets: [refreshedIssuePreset],
currentKind: "issue",
});
expect(result.current).toBe(initialHandler);
act(() => initialHandler({ kind: "issue", source: KIND_SWITCH }));
expect(markSearchInteracted).not.toHaveBeenCalled();
expect(setUserSelection).not.toHaveBeenCalled();
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
}
describe("useInitialSidebarSelection", () => {
it("does not reapply an unchanged default when preset references change", async () => {
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const autoReset = createAutoResetControls();
const { rerender } = renderHook(
({ savedPresets }) =>
useInitialSidebarSelection({
workspaceId: WORKSPACE_ID,
resolvedPrPresets: prPresets,
shouldAutoResetSearch: autoReset.shouldAutoResetSearch,
resetSearchOnWorkspaceChange: autoReset.resetSearchOnWorkspaceChange,
setQueryImmediate,
setRepoFilter,
savedPresets,
}),
{ initialProps: { savedPresets: [prDefault] } },
);
await waitFor(() => expect(setQueryImmediate).toHaveBeenCalledOnce());
rerender({ savedPresets: [{ ...prDefault }] });
expect(setQueryImmediate).toHaveBeenCalledOnce();
expect(setRepoFilter).toHaveBeenCalledOnce();
});
it("applies a saved PR default when saved queries hydrate", async () => {
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const autoReset = createAutoResetControls();
const { result, rerender } = renderHook(
({ savedPresets }) =>
useInitialSidebarSelection({
workspaceId: WORKSPACE_ID,
resolvedPrPresets: prPresets,
shouldAutoResetSearch: autoReset.shouldAutoResetSearch,
resetSearchOnWorkspaceChange: autoReset.resetSearchOnWorkspaceChange,
setQueryImmediate,
setRepoFilter,
savedPresets,
}),
{ initialProps: { savedPresets: [] as SavedPreset[] } },
);
await waitFor(() => expect(result.current.selection.id).toBe(prPreset.value));
rerender({ savedPresets: [prDefault] });
await waitFor(() =>
expect(result.current.selection).toEqual({
kind: "pr",
source: "saved",
id: prDefault.id,
}),
);
expect(setQueryImmediate).toHaveBeenLastCalledWith(prDefault.customQuery);
expect(setRepoFilter).toHaveBeenLastCalledWith(prDefault.repoFilter);
});
it("does not apply a late default after manual selection", async () => {
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const autoReset = createAutoResetControls();
const { result, rerender } = renderHook(
({ savedPresets }) =>
useInitialSidebarSelection({
workspaceId: WORKSPACE_ID,
resolvedPrPresets: prPresets,
shouldAutoResetSearch: autoReset.shouldAutoResetSearch,
resetSearchOnWorkspaceChange: autoReset.resetSearchOnWorkspaceChange,
setQueryImmediate,
setRepoFilter,
savedPresets,
}),
{ initialProps: { savedPresets: [] as SavedPreset[] } },
);
const manual: SidebarSelection = { kind: "pr", source: "preset", id: "manual" };
act(() => result.current.setUserSelection(manual));
setQueryImmediate.mockClear();
setRepoFilter.mockClear();
rerender({ savedPresets: [prDefault] });
expect(result.current.selection).toEqual(manual);
expect(setQueryImmediate).not.toHaveBeenCalled();
expect(setRepoFilter).not.toHaveBeenCalled();
});
it("resets manual selection before applying a new workspace default", async () => {
await expectNewWorkspaceDefaultAfterManualSelection();
});
});
describe("useSidebarSelectionHandler", () => {
it("applies the destination kind's saved default on a kind switch", () => {
const setUserSelection = vi.fn();
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const markSearchInteracted = vi.fn();
const { result } = renderHook(() =>
useSidebarSelectionHandler({
currentKind: "pr",
savedPresets: [prDefault, issueDefault],
resolvedPrPresets: prPresets,
resolvedIssuePresets: issuePresets,
setQueryImmediate,
setRepoFilter,
setUserSelection,
markSearchInteracted,
}),
);
act(() => result.current({ kind: "issue", source: KIND_SWITCH }));
expect(markSearchInteracted).toHaveBeenCalledOnce();
expect(setUserSelection).toHaveBeenCalledWith({
kind: "issue",
source: "saved",
id: issueDefault.id,
});
expect(setQueryImmediate).toHaveBeenCalledWith(issueDefault.customQuery);
expect(setRepoFilter).toHaveBeenCalledWith(issueDefault.repoFilter);
});
it(
"falls back to the first configured preset when the destination has no saved default",
expectConfiguredPresetFallbackOnKindSwitch,
);
it("ignores a same-kind toggle sentinel", expectSameKindSentinelNoop);
it(
"keeps the handler stable while using refreshed catalogs and current kind",
expectStableHandlerWithRefreshedPresetCatalogs,
);
it("keeps an explicit selection within the current kind", () => {
const setUserSelection = vi.fn();
const setQueryImmediate = vi.fn();
const setRepoFilter = vi.fn();
const requested: SidebarSelection = {
kind: "pr",
source: "preset",
id: prPreset.value,
};
const { result } = renderHook(() =>
useSidebarSelectionHandler({
currentKind: "pr",
savedPresets: [prDefault],
resolvedPrPresets: prPresets,
resolvedIssuePresets: issuePresets,
setQueryImmediate,
setRepoFilter,
setUserSelection,
markSearchInteracted: vi.fn(),
}),
);
act(() => result.current(requested));
expect(setUserSelection).toHaveBeenCalledWith(requested);
expect(setQueryImmediate).toHaveBeenCalledWith(prPreset.filter);
expect(setRepoFilter).toHaveBeenCalledWith("");
});
});
@@ -0,0 +1,154 @@
"use client";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import type { PresetOption } from "./search-bar";
import type { SidebarSelection, SidebarSelectionRequest } from "./presets-sidebar";
import {
findDefaultSavedPreset,
resolveDefaultSidebarTarget,
type SavedPreset,
} from "./saved-preset-model";
type InitialSidebarSelectionOptions = {
workspaceId: string | null;
resolvedPrPresets: PresetOption[];
shouldAutoResetSearch: () => boolean;
resetSearchOnWorkspaceChange: () => void;
setQueryImmediate: (query: string) => void;
setRepoFilter: (repo: string) => void;
savedPresets?: SavedPreset[];
};
type AppliedSidebarTarget = ReturnType<typeof resolveDefaultSidebarTarget> & {
workspaceId: string | null;
};
function sameAppliedSidebarTarget(
current: AppliedSidebarTarget | null,
next: AppliedSidebarTarget,
) {
return (
current !== null &&
current.workspaceId === next.workspaceId &&
current.selection.kind === next.selection.kind &&
current.selection.source === next.selection.source &&
current.selection.id === next.selection.id &&
current.query === next.query &&
current.repoFilter === next.repoFilter
);
}
export function useInitialSidebarSelection({
workspaceId,
resolvedPrPresets,
shouldAutoResetSearch,
resetSearchOnWorkspaceChange,
setQueryImmediate,
setRepoFilter,
savedPresets = [],
}: InitialSidebarSelectionOptions) {
const userSelectedRef = useRef(false);
const resetWorkspaceIdRef = useRef<string | null | undefined>(undefined);
const lastAppliedTargetRef = useRef<AppliedSidebarTarget | null>(null);
const savedPrDefault = useMemo(() => findDefaultSavedPreset(savedPresets, "pr"), [savedPresets]);
const resolvedPrTarget = useMemo(
() =>
resolveDefaultSidebarTarget("pr", savedPrDefault ? [savedPrDefault] : [], resolvedPrPresets),
[savedPrDefault, resolvedPrPresets],
);
const [selection, setSelection] = useState<SidebarSelection>(() => resolvedPrTarget.selection);
useEffect(() => {
if (resetWorkspaceIdRef.current !== workspaceId) {
resetWorkspaceIdRef.current = workspaceId;
userSelectedRef.current = false;
resetSearchOnWorkspaceChange();
}
if (userSelectedRef.current || !shouldAutoResetSearch()) return;
const target = resolvedPrTarget;
const appliedTarget = { workspaceId, ...target };
if (sameAppliedSidebarTarget(lastAppliedTargetRef.current, appliedTarget)) return;
lastAppliedTargetRef.current = appliedTarget;
setSelection((current) =>
current.kind === target.selection.kind &&
current.source === target.selection.source &&
current.id === target.selection.id
? current
: target.selection,
);
setQueryImmediate(target.query);
setRepoFilter(target.repoFilter);
}, [
workspaceId,
resolvedPrTarget,
setQueryImmediate,
setRepoFilter,
resetSearchOnWorkspaceChange,
shouldAutoResetSearch,
]);
const setUserSelection = useCallback((next: SidebarSelection) => {
userSelectedRef.current = true;
setSelection(next);
}, []);
return { selection, setProgrammaticSelection: setSelection, setUserSelection };
}
export function useSidebarSelectionHandler({
savedPresets,
resolvedPrPresets,
resolvedIssuePresets,
setQueryImmediate,
setRepoFilter,
setUserSelection,
markSearchInteracted,
currentKind,
}: {
savedPresets: SavedPreset[];
resolvedPrPresets: PresetOption[];
resolvedIssuePresets: PresetOption[];
setQueryImmediate: (query: string) => void;
setRepoFilter: (repo: string) => void;
setUserSelection: (next: SidebarSelection) => void;
markSearchInteracted: () => void;
currentKind: SidebarSelection["kind"];
}) {
const savedPresetsRef = useRef(savedPresets);
savedPresetsRef.current = savedPresets;
const resolvedPresetsRef = useRef({ pr: resolvedPrPresets, issue: resolvedIssuePresets });
resolvedPresetsRef.current = { pr: resolvedPrPresets, issue: resolvedIssuePresets };
const currentKindRef = useRef(currentKind);
currentKindRef.current = currentKind;
return useCallback(
(selection: SidebarSelectionRequest) => {
if (selection.source === "kind-switch") {
if (selection.kind === currentKindRef.current) return;
markSearchInteracted();
const target = resolveDefaultSidebarTarget(
selection.kind,
savedPresetsRef.current,
resolvedPresetsRef.current[selection.kind],
);
setUserSelection(target.selection);
setQueryImmediate(target.query);
setRepoFilter(target.repoFilter);
return;
}
markSearchInteracted();
setUserSelection(selection);
if (selection.source === "saved") {
const found = savedPresetsRef.current.find((preset) => preset.id === selection.id);
setQueryImmediate(found?.customQuery ?? "");
setRepoFilter(found?.repoFilter ?? "");
return;
}
const preset = resolvedPresetsRef.current[selection.kind].find(
(candidate) => candidate.value === selection.id,
);
setQueryImmediate(preset?.filter ?? "");
setRepoFilter("");
},
[setQueryImmediate, setUserSelection, markSearchInteracted, setRepoFilter],
);
}