fix(work-orders): persist date before Generate and fix media retry cancel

Keep CompDoc from marking Generated until completedDate is saved. Bind retry AbortControllers to the uploader cancel map with upsert-by-localId.
2026-10-07 16:19:01 +00:00 · 2026-08-03 10:39:50 -03:00 · 2026-08-03 10:39:50 -03:00 · c0d5e556f2
commit c0d5e556f2
parent 9074841125
6 changed files with 220 additions and 42 deletions
--- a/src/app/(protected)/workorders/_components/comp-doc/use-comp-doc-dialog.tsx
+++ b/src/app/(protected)/workorders/_components/comp-doc/use-comp-doc-dialog.tsx
@ -136,8 +136,8 @@ export function useCompDocDialog({

  async function handleSaveDraft() {
    try {
-      await persist({}, "No");
      await syncDateIfChanged();
+      await persist({}, "No");
      notifyDraftSaved();
    } catch (error) {
      toast.error(error instanceof Error ? error.message : "Failed to save draft");
@ -147,8 +147,8 @@ export function useCompDocDialog({
  async function handleGenerate() {
    const ts = fmtDocNow();
    try {
-      await persist({ generatedAt: ts }, "Yes");
      await syncDateIfChanged();
+      await persist({ generatedAt: ts }, "Yes");
      setGeneratedAt(ts);
      setDocState("generated");
    } catch (error) {
--- a/src/app/(protected)/workorders/_components/comp-doc/use-comp-doc-pdf-actions.ts
+++ b/src/app/(protected)/workorders/_components/comp-doc/use-comp-doc-pdf-actions.ts
@ -21,8 +21,8 @@ type UseCompDocPdfActionsArgs = {
  generatedAt: string;
  docFields: DocFields;
  uploadCompletionMutation: ReturnType<typeof useUploadCompletionDoc>;
-  persist: (extra: Partial<CompDocData>, status: CompDocSaveStatus) => void | Promise<void>;
-  syncDateIfChanged: () => void | Promise<void>;
+  persist: (extra: Partial<CompDocData>, status: CompDocSaveStatus) => Promise<void>;
+  syncDateIfChanged: () => Promise<void>;
  setGeneratedAt: (value: string) => void;
  markGenerated: () => void;
 };
@ -67,11 +67,19 @@ export function useCompDocPdfActions({
      { file, workOrderVersion: rowVersion },
      {
        onSuccess: () => {
-          const ts = fmtDocNow();
-          setGeneratedAt(ts);
-          markGenerated();
-          persist({ generatedAt: ts }, "Yes");
-          syncDateIfChanged();
+          void (async () => {
+            const ts = fmtDocNow();
+            try {
+              await syncDateIfChanged();
+              await persist({ generatedAt: ts }, "Yes");
+              setGeneratedAt(ts);
+              markGenerated();
+            } catch (error) {
+              toast.error(
+                error instanceof Error ? error.message : "Failed to finalize completion document",
+              );
+            }
+          })();
        },
      },
    );
--- a/src/app/(protected)/workorders/_components/media/media-uploader.tsx
+++ b/src/app/(protected)/workorders/_components/media/media-uploader.tsx
@ -25,7 +25,7 @@ type MediaUploaderProps = {
  onUpload?: (requests: MediaUploadRequest[]) => void;
  onRemove?: (id: string) => void;
  onCategorize?: (id: string, category: UploadableMediaCategory) => void;
-  onRetry?: (localId: string) => void;
+  onRetry?: (localId: string, signal: AbortSignal) => void;
  onCancel?: (localId: string) => void;
  /** Legacy local-only mode (table modal fallback). */
  onChange?: (next: MediaFile[]) => void;
@ -103,6 +103,13 @@ export function MediaUploader({
    onCancel?.(id);
  };

+  const retry = (id: string) => {
+    controllers[id]?.abort();
+    const controller = new AbortController();
+    setControllers((prev) => ({ ...prev, [id]: controller }));
+    onRetry?.(id, controller.signal);
+  };
+
  return (
    <div>
      {!readOnly && (
@ -114,7 +121,7 @@ export function MediaUploader({
        pending={pending}
        onRemove={remove}
        onCategorize={onCategorize}
-        onRetry={onRetry}
+        onRetry={onRetry ? retry : undefined}
        onCancel={cancel}
      />
    </div>
--- a/src/app/(protected)/workorders/_hooks/use-media-upload-session.ts
+++ b/src/app/(protected)/workorders/_hooks/use-media-upload-session.ts
@ -5,7 +5,7 @@ import type { MediaFile } from "@/domain/work-orders/types/work-order-media";
 import type { WorkOrderBoardDetail } from "@/domain/work-orders/types/work-order-board-detail";
 import { classifyUpload } from "@/domain/work-orders/utils/work-order-media-utils";

-type LocalUpload = MediaFile & { sourceFile?: File };
+type LocalUpload = MediaFile & { sourceFile?: File; signal?: AbortSignal };

 type UploadMutate = (input: {
  file: File;
@ -13,6 +13,26 @@ type UploadMutate = (input: {
  onProgress?: (percent: number) => void;
 }) => Promise<unknown>;

+function toLocalUpload(request: MediaUploadRequest): LocalUpload {
+  const classified = classifyUpload(request.file);
+  return {
+    id: request.localId,
+    name: request.file.name,
+    fileType: classified.fileType,
+    url: URL.createObjectURL(request.file),
+    category: classified.category,
+    purpose: null,
+    progress: 0,
+    uploadStatus: "uploading" as const,
+    sourceFile: request.file,
+    signal: request.signal,
+  };
+}
+
+function isSameAttempt(item: LocalUpload, request: MediaUploadRequest) {
+  return item.id === request.localId && item.signal === request.signal;
+}
+
 export function useMediaUploadSession(
  detail: WorkOrderBoardDetail | undefined,
  uploadMutateAsync: UploadMutate,
@ -33,23 +53,23 @@ export function useMediaUploadSession(
  }, [serverUploads, localUploads]);

  function startUploads(requests: MediaUploadRequest[]) {
-    setLocalUploads((prev) => [
-      ...prev,
-      ...requests.map((request) => {
-        const classified = classifyUpload(request.file);
-        return {
-          id: request.localId,
-          name: request.file.name,
-          fileType: classified.fileType,
-          url: URL.createObjectURL(request.file),
-          category: classified.category,
-          purpose: null,
-          progress: 0,
-          uploadStatus: "uploading" as const,
-          sourceFile: request.file,
-        };
-      }),
-    ]);
+    setLocalUploads((prev) => {
+      const next = [...prev];
+      for (const request of requests) {
+        const entry = toLocalUpload(request);
+        const index = next.findIndex((item) => item.id === request.localId);
+        if (index >= 0) {
+          const previous = next[index];
+          if (previous?.url.startsWith("blob:")) {
+            URL.revokeObjectURL(previous.url);
+          }
+          next[index] = entry;
+        } else {
+          next.push(entry);
+        }
+      }
+      return next;
+    });

    for (const request of requests) {
      void uploadMutateAsync({
@ -58,22 +78,22 @@ export function useMediaUploadSession(
        onProgress: (percent) => {
          setLocalUploads((prev) =>
            prev.map((item) =>
-              item.id === request.localId ? { ...item, progress: percent } : item,
+              isSameAttempt(item, request) ? { ...item, progress: percent } : item,
            ),
          );
        },
      })
        .then(() => {
-          setLocalUploads((prev) => prev.filter((item) => item.id !== request.localId));
+          setLocalUploads((prev) => prev.filter((item) => !isSameAttempt(item, request)));
        })
        .catch((error: Error) => {
          if (error.name === "AbortError") {
-            setLocalUploads((prev) => prev.filter((item) => item.id !== request.localId));
+            setLocalUploads((prev) => prev.filter((item) => !isSameAttempt(item, request)));
            return;
          }
          setLocalUploads((prev) =>
            prev.map((item) =>
-              item.id === request.localId
+              isSameAttempt(item, request)
                ? {
                    ...item,
                    uploadStatus: "failed",
@ -87,15 +107,14 @@ export function useMediaUploadSession(
    }
  }

-  function retryUpload(localId: string) {
+  function retryUpload(localId: string, signal: AbortSignal) {
    const target = localUploads.find((item) => item.id === localId);
    if (!target?.sourceFile) return;
-    const controller = new AbortController();
    startUploads([
      {
        localId,
        file: target.sourceFile,
-        signal: controller.signal,
+        signal,
        onProgress: () => undefined,
      },
    ]);
--- a/src/test/app/(protected)/workorders/comp-doc-dialog-completion-contract.test.tsx
+++ b/src/test/app/(protected)/workorders/comp-doc-dialog-completion-contract.test.tsx
@ -96,12 +96,12 @@ describe("CompDocDialog Save Draft / Generate completion contract", () => {
          row={row}
          open
          onOpenChange={vi.fn()}
-          onSave={(data, status) => {
-            onSave(data, status);
+          onSave={async (data, status) => {
+            await onSave(data, status);
            patches.push({ docStatus: status });
          }}
-          onDateCompletedChange={(date) => {
-            onDateCompletedChange(date);
+          onDateCompletedChange={async (date) => {
+            await onDateCompletedChange(date);
            patches.push({ completedDate: date });
          }}
        />
@ -128,7 +128,7 @@ describe("CompDocDialog Save Draft / Generate completion contract", () => {
      expect(onDateCompletedChange).toHaveBeenCalledWith("2026-07-15");
    });
    expect(onSave).toHaveBeenCalledWith(expect.any(Object), "No");
-    expect(patches).toEqual([{ docStatus: "No" }, { completedDate: "2026-07-15" }]);
+    expect(patches).toEqual([{ completedDate: "2026-07-15" }, { docStatus: "No" }]);
    expect(patches.some((patch) => "scheduledOn" in patch)).toBe(false);
    expect(patches.some((patch) => patch.status === "Completed")).toBe(false);
    expect(row.scheduledOn).toBe(SCHEDULED_ON);
@ -149,10 +149,25 @@ describe("CompDocDialog Save Draft / Generate completion contract", () => {
      expect.objectContaining({ generatedAt: expect.any(String) }),
      "Yes",
    );
-    expect(patches).toEqual([{ docStatus: "Yes" }, { completedDate: "2026-07-20" }]);
+    expect(patches).toEqual([{ completedDate: "2026-07-20" }, { docStatus: "Yes" }]);
    expect(patches.some((patch) => "scheduledOn" in patch)).toBe(false);
    expect(patches.some((patch) => patch.status === "Completed")).toBe(false);
    expect(row.scheduledOn).toBe(SCHEDULED_ON);
    expect(row.status).toBe("Scheduled");
  });
+
+  it("Generate keeps Draft and skips docStatus Yes when completedDate patch fails", async () => {
+    onDateCompletedChange.mockRejectedValueOnce(new Error("conflict"));
+    const row = baseRow({ completedDate: "2026-07-01" });
+    renderDialog(row);
+
+    changeDateCompleted("2026-07-20");
+    fireEvent.click(screen.getByRole("button", { name: /^generate$/i }));
+
+    await waitFor(() => {
+      expect(onDateCompletedChange).toHaveBeenCalledWith("2026-07-20");
+    });
+    expect(onSave).not.toHaveBeenCalled();
+    expect(screen.getByRole("button", { name: /^generate$/i })).toBeInTheDocument();
+  });
 });
--- a/src/test/app/(protected)/workorders/use-media-upload-session.test.tsx
+++ b/src/test/app/(protected)/workorders/use-media-upload-session.test.tsx
@ -0,0 +1,129 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useMediaUploadSession } from "@/app/(protected)/workorders/_hooks/use-media-upload-session";
+
+function makeFile(name = "photo.jpg") {
+  return new File(["bytes"], name, { type: "image/jpeg" });
+}
+
+describe("useMediaUploadSession retry / cancel", () => {
+  it("retry upserts the same localId instead of appending a duplicate", async () => {
+    let rejectFirst!: (error: Error) => void;
+    const uploadMutateAsync = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise((_resolve, reject) => {
+            rejectFirst = reject;
+          }),
+      )
+      .mockImplementation(() => new Promise(() => undefined));
+
+    const { result } = renderHook(() => useMediaUploadSession(undefined, uploadMutateAsync));
+    const firstController = new AbortController();
+    const localId = "local-1";
+    const file = makeFile();
+
+    act(() => {
+      result.current.startUploads([
+        {
+          localId,
+          file,
+          signal: firstController.signal,
+          onProgress: () => undefined,
+        },
+      ]);
+    });
+
+    await waitFor(() => {
+      expect(result.current.uploads).toHaveLength(1);
+    });
+
+    act(() => {
+      rejectFirst(new Error("network"));
+    });
+
+    await waitFor(() => {
+      expect(result.current.uploads[0]?.uploadStatus).toBe("failed");
+    });
+
+    const retryController = new AbortController();
+    act(() => {
+      result.current.retryUpload(localId, retryController.signal);
+    });
+
+    await waitFor(() => {
+      expect(result.current.uploads).toHaveLength(1);
+      expect(result.current.uploads[0]?.id).toBe(localId);
+      expect(result.current.uploads[0]?.uploadStatus).toBe("uploading");
+    });
+    expect(uploadMutateAsync).toHaveBeenCalledTimes(2);
+    expect(uploadMutateAsync.mock.calls[1]?.[0]?.signal).toBe(retryController.signal);
+  });
+
+  it("cancel after retry aborts the replacement upload and removes the local row", async () => {
+    let rejectFirst!: (error: Error) => void;
+    const uploadMutateAsync = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise((_resolve, reject) => {
+            rejectFirst = reject;
+          }),
+      )
+      .mockImplementation(
+        ({ signal }: { signal?: AbortSignal }) =>
+          new Promise((_resolve, reject) => {
+            signal?.addEventListener("abort", () => {
+              const error = new Error("aborted");
+              error.name = "AbortError";
+              reject(error);
+            });
+          }),
+      );
+
+    const { result } = renderHook(() => useMediaUploadSession(undefined, uploadMutateAsync));
+    const localId = "local-retry";
+    const file = makeFile("retry.jpg");
+
+    act(() => {
+      result.current.startUploads([
+        {
+          localId,
+          file,
+          signal: new AbortController().signal,
+          onProgress: () => undefined,
+        },
+      ]);
+    });
+
+    act(() => {
+      rejectFirst(new Error("upload failed"));
+    });
+
+    await waitFor(() => {
+      expect(result.current.uploads[0]?.uploadStatus).toBe("failed");
+    });
+
+    const retryController = new AbortController();
+    act(() => {
+      result.current.retryUpload(localId, retryController.signal);
+    });
+
+    await waitFor(() => {
+      expect(result.current.uploads[0]?.uploadStatus).toBe("uploading");
+    });
+
+    act(() => {
+      // Mirrors MediaUploader.cancel: abort the mapped controller, then removeLocal.
+      retryController.abort();
+      result.current.removeLocal(localId);
+    });
+
+    await waitFor(() => {
+      expect(result.current.uploads).toHaveLength(0);
+    });
+    expect(retryController.signal.aborted).toBe(true);
+    expect(uploadMutateAsync.mock.calls[1]?.[0]?.signal).toBe(retryController.signal);
+  });
+});