A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!
TypeScript agent-skillsaidsh-pluginhacktoberfestjavascriptmcp-serverreactresume-builderself-hostedtypescript
fix: bound stalled resume metadata writes (RX-162) (#3771)
Amruth Pillaiff0e82f10601
diff --git a/apps/web/src/dialogs/resume/index.tsx b/apps/web/src/dialogs/resume/index.tsxindex c4d27e1b0..b9091b675 100644--- a/apps/web/src/dialogs/resume/index.tsx+++ b/apps/web/src/dialogs/resume/index.tsx@@ -45,7 +45,9 @@ export function ResumeDialog({ mode, data }: ResumeDialogProps) {const update = useMutation({...updateOptions,mutationFn: (value) =>- saveResumeMetadata(value.id, (expectedUpdatedAt) => orpc.resume.update.call({ ...value, expectedUpdatedAt })),+ saveResumeMetadata(value.id, (expectedUpdatedAt, options) =>+ orpc.resume.update.call({ ...value, expectedUpdatedAt }, options),+ ),});const duplicate = useMutation(orpc.resume.duplicate.mutationOptions());diff --git a/apps/web/src/features/resume/builder/draft.test.ts b/apps/web/src/features/resume/builder/draft.test.tsindex ba6d9394e..ea31a5b31 100644--- a/apps/web/src/features/resume/builder/draft.test.ts+++ b/apps/web/src/features/resume/builder/draft.test.ts@@ -346,6 +346,7 @@ describe("builder resume autosave", () => {const event = handler({ mutation: "update" });await flushMicrotasks();expect(useResumeStore.getState().undoStack).toHaveLength(1);+ expect(useResumeStore.getState().resume?.name).toBe(saved.name);response.resolve(renamed);await writing;await event;@@ -354,6 +355,153 @@ describe("builder resume autosave", () => {hook.unmount();});+ it("releases a stalled metadata request and stream, ignoring its late answer", async () => {+ const initial = makeResume("metadata-stalled");+ routerParamsMock.value = { resumeId: initial.id };+ useResumeStore.getState().initialize(initial);+ const answer = deferred<Resume>();+ const write = vi.fn((_expected?: Date, _options?: { signal: AbortSignal }) => answer.promise);+ let failure: unknown;+ const writing = saveResumeMetadata(initial.id, write).catch((error: unknown) => {+ failure = error;+ });+ await flushMicrotasks();+ const remote = {+ ...withBasicsName(initial, "Remote body"),+ name: "Remote title",+ updatedAt: new Date(initial.updatedAt.getTime() + 2000),+ };+ orpcMocks.getResumeById.mockResolvedValueOnce(remote);+ consumeEventIteratorMock.mockReturnValueOnce(async () => undefined);+ const hook = renderHook(() => useBuilderResumeUpdateSubscription());+ const event = consumeEventIteratorMock.mock.lastCall?.[1].onEvent({ mutation: "update" });+ await flushMicrotasks();+ expect(useResumeStore.getState().resume?.data.basics.name).toBe(initial.data.basics.name);+ await vi.advanceTimersByTimeAsync(10_000);+ expect(failure).toMatchObject({ name: "TimeoutError" });+ await writing;+ await event;+ expect(write.mock.lastCall?.[1]?.signal.aborted).toBe(true);+ expect(useResumeStore.getState().resume).toMatchObject(remote);+ answer.resolve({ ...initial, name: "Late title", updatedAt: new Date(initial.updatedAt.getTime() + 1000) });+ await flushMicrotasks();+ expect(useResumeStore.getState().resume).toMatchObject(remote);+ const next = { ...remote, name: "Next title", updatedAt: new Date(remote.updatedAt.getTime() + 1000) };+ const nextWrite = vi.fn(async (expected?: Date) => {+ expect(expected).toEqual(remote.updatedAt);+ return next;+ });+ await saveResumeMetadata(initial.id, nextWrite);+ expect(useResumeStore.getState().resume?.name).toBe(next.name);+ hook.unmount();+ });++ it("refuses an unversioned metadata write without an open draft", async () => {+ const answer = deferred<Resume>();+ const write = vi.fn((_expected?: Date, _options?: { signal: AbortSignal }) => answer.promise);+ let failure: unknown;+ const writing = saveResumeMetadata("library-rename", write).catch((error: unknown) => {+ failure = error;+ });+ await vi.advanceTimersByTimeAsync(10_000);+ expect(failure).toMatchObject({ name: "AbortError" });+ await writing;+ expect(write).not.toHaveBeenCalled();+ answer.resolve(makeResume("library-rename"));+ });++ it("invalidates unproven same-body revisions after metadata timeout, including receipt history", async () => {+ const store = useResumeStore.getState;+ const initial = makeResume("metadata-unproven-echo");+ routerParamsMock.value = { resumeId: initial.id };+ store().initialize(initial);+ let server = initial;+ orpcMocks.updateResume.mockImplementation(async ({ data }: { data: ResumeData }) => {+ server = { ...server, data, updatedAt: new Date(server.updatedAt.getTime() + 1000) };+ return server;+ });+ store().updateResumeData(+ (draft) => {+ draft.summary.content = "<p>Accepted</p>";+ },+ { newStep: true, applied: [{ id: "edit", after: "<p>Accepted</p>" }] },+ );+ expect(await savePendingChanges(initial.id)).toBe(true);+ store().updateResumeData(+ (draft) => {+ draft.basics.headline = "Later edit";+ },+ { newStep: true },+ );+ expect(await savePendingChanges(initial.id)).toBe(true);+ store().undo();+ expect(await savePendingChanges(initial.id)).toBe(true);+ expect(store().undoStack).toHaveLength(1);+ expect(store().redoStack).toHaveLength(1);+ expect(store().proposalApplications).toEqual({ edit: "<p>Accepted</p>" });++ const answer = deferred<Resume>();+ const writing = saveResumeMetadata(initial.id, () => answer.promise);+ const rejected = expect(writing).rejects.toMatchObject({ name: "TimeoutError" });+ await flushMicrotasks();+ // This read is indistinguishable from a rename followed by another client's receipt-only Undo.+ const remote = { ...server, name: "Unproven rename", updatedAt: new Date(server.updatedAt.getTime() + 1000) };+ orpcMocks.getResumeById.mockResolvedValueOnce(remote);+ consumeEventIteratorMock.mockReturnValueOnce(async () => undefined);+ const hook = renderHook(() => useBuilderResumeUpdateSubscription());+ const event = consumeEventIteratorMock.mock.lastCall?.[1].onEvent({ mutation: "update" });+ await vi.advanceTimersByTimeAsync(10_000);+ await rejected;+ await event;+ expect(store().resume?.data).toEqual(server.data);+ expect(store().undoStack).toEqual([]);+ expect(store().redoStack).toEqual([]);+ expect(store().proposalApplications).toEqual({});+ answer.resolve(remote);+ await flushMicrotasks();+ store().redo();+ expect(store().proposalApplications).toEqual({});+ expect(orpcMocks.updateResume).toHaveBeenCalledTimes(3);+ hook.unmount();+ });++ it("keeps pending edits and receipts on the old revision after an uncertain metadata timeout", async () => {+ const initial = makeResume("metadata-stalled-draft");+ useResumeStore.getState().initialize(initial);+ const answer = deferred<Resume>();+ let failure: unknown;+ const writing = saveResumeMetadata(initial.id, () => answer.promise).catch((error: unknown) => {+ failure = error;+ });+ await flushMicrotasks();+ useResumeStore.getState().updateResumeData(+ (draft) => {+ draft.summary.content = "<p>Keep this proposal</p>";+ },+ { newStep: true, applied: [{ id: "pending-proposal", after: "<p>Keep this proposal</p>" }] },+ );+ orpcMocks.updateResume.mockRejectedValueOnce(new ORPCError("RESUME_VERSION_CONFLICT"));+ await vi.advanceTimersByTimeAsync(10_000);+ expect(failure).toMatchObject({ name: "TimeoutError" });+ await writing;+ expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);+ expect(orpcMocks.updateResume.mock.lastCall?.[0].expectedUpdatedAt).toEqual(initial.updatedAt);+ expect(useResumeStore.getState().saveStatus).toBe("conflict");+ expect(useResumeStore.getState().undoStack).toHaveLength(1);+ expect(useResumeStore.getState().resume?.data.summary.content).toBe("<p>Keep this proposal</p>");+ const recovery = Object.entries(window.localStorage).find(([key]) => key.includes(initial.id));+ assert(recovery);+ expect(JSON.parse(recovery[1])).toMatchObject({+ baseUpdatedAt: initial.updatedAt.toISOString(),+ pendingProposalApplications: { "pending-proposal": "<p>Keep this proposal</p>" },+ });+ answer.resolve({ ...initial, name: "Late title", updatedAt: new Date(initial.updatedAt.getTime() + 1000) });+ await flushMicrotasks();+ expect(useResumeStore.getState().resume?.name).toBe(initial.name);+ expect(useResumeStore.getState().saveStatus).toBe("conflict");+ expect(orpcMocks.updateResume).toHaveBeenCalledTimes(1);+ });+it("keeps the draft and does not send metadata if its earlier body save failed", async () => {const initial = makeResume("metadata-flush-error");useResumeStore.getState().initialize(initial);@@ -374,7 +522,10 @@ describe("builder resume autosave", () => {const first = deferred<Resume>();const earlier = saveResumeMetadata(initial.id, () => first.promise).catch((error: unknown) => error);const renamed = { ...initial, name: "Second request", updatedAt: new Date(initial.updatedAt.getTime() + 2000) };- const write = vi.fn(async () => renamed);+ const write = vi.fn(async (expected?: Date) => {+ expect(expected).toEqual(fails ? initial.updatedAt : new Date(initial.updatedAt.getTime() + 1000));+ return renamed;+ });const later = saveResumeMetadata(initial.id, write);await flushMicrotasks();expect(write).not.toHaveBeenCalled();@@ -391,17 +542,43 @@ describe("builder resume autosave", () => {useResumeStore.getState().initialize(initial);const first = deferred<Resume>();const earlier = saveResumeMetadata(initial.id, () => first.promise);+ const earlierRejected = expect(earlier).rejects.toMatchObject({ name: "AbortError" });await flushMicrotasks();const write = vi.fn(async () => initial);const later = saveResumeMetadata(initial.id, write);const rejected = expect(later).rejects.toMatchObject({ name: "AbortError" });clearResumeDrafts();first.resolve(initial);- await earlier;+ await earlierRejected;await rejected;expect(write).not.toHaveBeenCalled();});+ it("never applies an old visit's delayed metadata stream event to a new visit", async () => {+ const initial = makeResume("metadata-stream-visit");+ routerParamsMock.value = { resumeId: initial.id };+ useResumeStore.getState().initialize(initial);+ const response = deferred<Resume>();+ const writing = saveResumeMetadata(initial.id, () => response.promise);+ const rejected = expect(writing).rejects.toMatchObject({ name: "AbortError" });+ await flushMicrotasks();+ const old = { ...withBasicsName(initial, "Old visit"), updatedAt: new Date(initial.updatedAt.getTime() + 1000) };+ orpcMocks.getResumeById.mockResolvedValueOnce(old);+ consumeEventIteratorMock.mockReturnValueOnce(async () => undefined);+ const hook = renderHook(() => useBuilderResumeUpdateSubscription());+ const event = consumeEventIteratorMock.mock.lastCall?.[1].onEvent({ mutation: "update" });+ await flushMicrotasks();+ clearResumeDrafts();+ const current = withBasicsName(initial, "New visit");+ useResumeStore.getState().initialize(current);+ await rejected;+ await event;+ response.resolve(old);+ await flushMicrotasks();+ expect(useResumeStore.getState().resume).toMatchObject(current);+ hook.unmount();+ });+it("does not send metadata if its visit ends while the pending-save check settles", async () => {const initial = makeResume("metadata-flush-cancelled");useResumeStore.getState().initialize(initial);@@ -492,13 +669,14 @@ describe("builder resume autosave", () => {useResumeStore.getState().initialize(initial);const answer = deferred<Resume>();const writing = saveResumeMetadata(initial.id, () => answer.promise);+ const result = revisit ? expect(writing).rejects.toMatchObject({ name: "AbortError" }) : writing;await flushMicrotasks();if (revisit) {clearResumeDrafts();useResumeStore.getState().initialize(initial);}answer.resolve({ ...server(initial), name: "Renamed", updatedAt: new Date(initial.updatedAt.getTime() + ms) });- await writing;+ await result;expect(useResumeStore.getState().resume?.name).toBe(name);useResumeStore.getState().updateResumeData((draft) => {draft.basics.headline = "Later headline";diff --git a/apps/web/src/features/resume/builder/draft.ts b/apps/web/src/features/resume/builder/draft.tsindex d78ecd781..d0e538563 100644--- a/apps/web/src/features/resume/builder/draft.ts+++ b/apps/web/src/features/resume/builder/draft.ts@@ -144,7 +144,7 @@ type ResumeUpdateSubscriptionOptions = {};const SAVE_DEBOUNCE_MS = 500;-const NAVIGATION_SAVE_WAIT_MS = 10_000;+const SAVE_WAIT_MS = 10_000;// Edits without a field key coalesce within this window (e.g. dragging); keyed edits to the same field// coalesce within FIELD_COALESCE_MS (typing a sentence).const HISTORY_COALESCE_MS = 500;@@ -652,8 +652,7 @@ export const useResumeStore = create<ResumeStore>()(}setRuntimeBaseline(resume);- // This runs both for the echo of our own autosave (identical data → keep history) and for- // external/cross-tab/AI rebases (different data → local undo history no longer applies).+ // Only an acknowledged revision keeps history: identical body data can hide a remote receipt-only Undo.const current = get().resume;// An echo keeps the data object the store already holds: a new but identical one would make everything that// renders from it run again, the preview's PDF render of every page included, after every save.@@ -913,10 +912,33 @@ function trackResumeMetadataWrite(id: string) {/** Shares the autosave owner: finish earlier body writes, then hold later edits until this metadata revision is known. */export async function saveResumeMetadata<T extends Resume>(id: string,- write: (expectedUpdatedAt: Date | undefined) => Promise<T>,+ write: (expectedUpdatedAt: Date | undefined, options?: { signal: AbortSignal }) => Promise<T>,): Promise<T> {const runtime = runtimes.get(id);- if (!runtime) return write(undefined);+ if (!runtime?.baseUpdatedAt) throw new DOMException("", "AbortError");+ /** Cancels transport and releases the local wait without trusting a late response. */+ const writeWithDeadline = async (expectedUpdatedAt: Date | undefined) => {+ const controller = new AbortController();+ const endVisit = () => controller.abort(runtime.abortController.signal.reason);+ runtime.abortController.signal.addEventListener("abort", endVisit, { once: true });+ const timeout = setTimeout(+ () =>+ controller.abort(+ new DOMException(t`Saving is taking longer than expected. Your changes are still open.`, "TimeoutError"),+ ),+ SAVE_WAIT_MS,+ );+ const aborted = new Promise<never>((_, reject) => {+ controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });+ });+ try {+ // A cancelled request may have committed; late answers cannot certify its revision.+ return await Promise.race([write(expectedUpdatedAt, { signal: controller.signal }), aborted]);+ } finally {+ clearTimeout(timeout);+ runtime.abortController.signal.removeEventListener("abort", endVisit);+ }+ };const acknowledge = trackResumeMetadataWrite(id);const pending = (runtime.metadataWrite?.catch(() => undefined) ?? Promise.resolve()).then(async () => {if (runtime.abortController.signal.aborted) throw runtime.abortController.signal.reason;@@ -924,7 +946,7 @@ export async function saveResumeMetadata<T extends Resume>(if (runtime.abortController.signal.aborted) throw runtime.abortController.signal.reason;runtime.metadataWriting = true;try {- const updated = await write(runtime.baseUpdatedAt);+ const updated = await writeWithDeadline(runtime.baseUpdatedAt);acknowledge(updated);return updated;} finally {@@ -1039,15 +1061,18 @@ export function useBuilderResumeUpdateSubscription() {const onUpdate = useCallback(async (event: ResumeUpdateEvent) => {if (!resumeId) return;+ const visit = runtimes.get(resumeId);+ if (!visit) return;bindRuntimeQueryClient(resumeId, queryClient);const resume = (await orpc.resume.getById.call({ id: resumeId })) as Resume;// Let this visit acknowledge its own metadata before an early stream echo can rebase its history.- await runtimes.get(resumeId)?.metadataWrite?.catch(() => undefined);+ await visit.metadataWrite?.catch(() => undefined);const runtime = runtimes.get(resumeId);if (!runtime ||+ runtime !== visit ||useResumeStore.getState().resume?.id !== resumeId ||(runtime.baseUpdatedAt && resume.updatedAt < runtime.baseUpdatedAt))@@ -1137,7 +1162,7 @@ export function savePendingChanges(id: string): boolean | Promise<boolean> {id: runtime.slowSaveToastId,timeout: 0,});- }, NAVIGATION_SAVE_WAIT_MS);+ }, SAVE_WAIT_MS);void flushResumeSave(id);});}diff --git a/apps/web/src/features/resume/share/share-panel.tsx b/apps/web/src/features/resume/share/share-panel.tsxindex 3ebb48d23..9c75453f5 100644--- a/apps/web/src/features/resume/share/share-panel.tsx+++ b/apps/web/src/features/resume/share/share-panel.tsx@@ -140,7 +140,9 @@ function useShareSetting() {const { mutateAsync: updateResume, isPending } = useMutation({...options,mutationFn: (value) =>- saveResumeMetadata(value.id, (expectedUpdatedAt) => orpc.resume.update.call({ ...value, expectedUpdatedAt })),+ saveResumeMetadata(value.id, (expectedUpdatedAt, options) =>+ orpc.resume.update.call({ ...value, expectedUpdatedAt }, options),+ ),});const update = async (settings: ShareSettings) => {diff --git a/apps/web/src/libs/query/client.test.ts b/apps/web/src/libs/query/client.test.tsindex 1fd2c3074..857f0c479 100644--- a/apps/web/src/libs/query/client.test.ts+++ b/apps/web/src/libs/query/client.test.ts@@ -2,32 +2,39 @@ import { describe, expect, it } from "vite-plus/test";import { getQueryClient } from "./client";describe("getQueryClient mutationCache", () => {- it("invalidates data queries but excludes auth session and flags on mutation settled", async () => {- const queryClient = getQueryClient();+ it.each([false, true])(+ "invalidates data queries but excludes auth and flags after settlement (failure: %s)",+ async (fails) => {+ const queryClient = getQueryClient();- queryClient.setQueryData(["auth", "session"], { user: { id: "u-1" } });- queryClient.setQueryData(["flags"], { disableSignups: false });- queryClient.setQueryData(["resume", "list"], [{ id: "res-1" }]);+ queryClient.setQueryData(["auth", "session"], { user: { id: "u-1" } });+ queryClient.setQueryData(["flags"], { disableSignups: false });+ queryClient.setQueryData(["resume", "list"], [{ id: "res-1" }]);- const authQuery = queryClient.getQueryCache().find({ queryKey: ["auth", "session"] });- const flagsQuery = queryClient.getQueryCache().find({ queryKey: ["flags"] });- const resumeQuery = queryClient.getQueryCache().find({ queryKey: ["resume", "list"] });+ const authQuery = queryClient.getQueryCache().find({ queryKey: ["auth", "session"] });+ const flagsQuery = queryClient.getQueryCache().find({ queryKey: ["flags"] });+ const resumeQuery = queryClient.getQueryCache().find({ queryKey: ["resume", "list"] });- expect(authQuery?.isStale()).toBe(false);- expect(flagsQuery?.isStale()).toBe(false);- expect(resumeQuery?.isStale()).toBe(false);+ expect(authQuery?.isStale()).toBe(false);+ expect(flagsQuery?.isStale()).toBe(false);+ expect(resumeQuery?.isStale()).toBe(false);- // Trigger a mutation that settles- const mutation = queryClient.getMutationCache().build(queryClient, {- mutationFn: async () => "success",- });- await mutation.execute(undefined);+ // Trigger a mutation that settles+ const mutation = queryClient.getMutationCache().build(queryClient, {+ mutationFn: async () => {+ if (fails) throw new Error("Unknown write outcome");+ return "success";+ },+ });+ if (fails) await expect(mutation.execute(undefined)).rejects.toThrow("Unknown write outcome");+ else await mutation.execute(undefined);- // Resume query is invalidated (stale)- expect(resumeQuery?.isStale()).toBe(true);+ // Resume query is invalidated (stale)+ expect(resumeQuery?.isStale()).toBe(true);- // Auth and flags are preserved (not stale)- expect(authQuery?.isStale()).toBe(false);- expect(flagsQuery?.isStale()).toBe(false);- });+ // Auth and flags are preserved (not stale)+ expect(authQuery?.isStale()).toBe(false);+ expect(flagsQuery?.isStale()).toBe(false);+ },+ );});diff --git a/tests/e2e/specs/document-title.spec.ts b/tests/e2e/specs/document-title.spec.tsindex ab2c522aa..871d5652b 100644--- a/tests/e2e/specs/document-title.spec.ts+++ b/tests/e2e/specs/document-title.spec.ts@@ -77,3 +77,63 @@ for (const kind of ["resume", "letter"] as const) {await expect(page).toHaveTitle(`${savedName} - Reactive Resume`);});}++test("resume metadata timeout cancels the request and releases stream updates and later saves", async ({+ authPage: page,+}) => {+ test.setTimeout(60_000);+ const created = await page.request.post("/api/openapi/resumes", { data: { name: "Before rename", tags: [] } });+ await expect(created).toBeOK();+ const id: string = await created.json();+ await page.goto(`/builder/${id}`);+ await expect(page).toHaveTitle("Before rename - Reactive Resume");++ let committed!: () => void;+ let release!: () => void;+ const serverCommitted = new Promise<void>((resolve) => {+ committed = resolve;+ });+ const lateResponse = new Promise<void>((resolve) => {+ release = resolve;+ });+ const updateUrl = "**/api/rpc/resume/update";+ await page.route(updateUrl, async (route) => {+ const response = await route.fetch();+ committed();+ await lateResponse;+ // The client deliberately aborts after the server has committed.+ await route.fulfill({ response }).catch(() => undefined);+ });+ try {+ const cancelled = page.waitForEvent("requestfailed", {+ predicate: (request) => request.url().endsWith("/resume/update"),+ });+ await rename(page, "resume", "Server accepted rename");+ await serverCommitted;+ await cancelled;+ const dialog = page.getByRole("dialog", { name: "Update resume", exact: true });+ await expect(dialog.getByRole("button", { name: "Save changes", exact: true })).toBeEnabled();+ await expect(page).toHaveTitle("Server accepted rename - Reactive Resume");+ await page.unroute(updateUrl);+ await dialog.getByRole("textbox", { name: "Name", exact: true }).fill("Renamed after timeout");+ await dialog.getByRole("button", { name: "Save changes", exact: true }).click();+ await expect(dialog).not.toBeVisible();+ await expect(page).toHaveTitle("Renamed after timeout - Reactive Resume");+ const saved = page.waitForResponse((response) => response.url().endsWith("/resume/update") && response.ok());+ await page.getByRole("textbox", { name: "Headline", exact: true }).fill("Saved after timeout");+ await saved;+ release();+ const read = await page.request.get(`/api/openapi/resumes/${id}`);+ await expect(read).toBeOK();+ expect(await read.json()).toMatchObject({+ name: "Renamed after timeout",+ data: { basics: { headline: "Saved after timeout" } },+ });+ await page.reload();+ await expect(page).toHaveTitle("Renamed after timeout - Reactive Resume");+ await expect(page.getByRole("textbox", { name: "Headline", exact: true })).toHaveValue("Saved after timeout");+ } finally {+ release();+ if (!page.isClosed()) await page.unroute(updateUrl);+ }+});