feat(v2.4): 切换测试与缺陷主写

apps/web/stores/useTestCaseStore.ts

@@ -3,9 +3,18 @@ import { create } from 'zustand';
 import type { CreateTestCaseInput, TestCase, TestCaseStatus } from '@/lib/test-case';
 import { generateCaseNo, normalizeTestCases } from '@/lib/test-case';
 import { applyTestCaseTransition, normalizeTestCaseOnCreate } from '@/lib/test-case-workflow';
+import {
+  createTestCaseByVersionId,
+  createTestCasesByVersionId,
+  deleteTestCaseByVersionId,
+  listTestCasesByVersionId,
+  updateTestCaseByVersionId,
+  updateTestCaseStatusByVersionId,
+} from '@/lib/domain-api';
 import { createEntityId, dedupeEntityIds } from '@/lib/entity-id';
 import { scheduleSaveWithOptimisticRollback } from '@/lib/optimistic-persistence';
 import { loadServerData, saveServerData, SERVER_DATA_CACHE_MS } from '@/lib/server-data';
+import type { WorkActivity } from '@/lib/work-activity';
 import {
   makeTestCaseCreatedActivity,
   makeTestCaseStatusActivity,
@@ -28,7 +37,7 @@ async function loadStored(): Promise<TestCase[] | null> {
 interface TestCaseState {
   testCases: TestCase[];
   loaded: boolean;
-  fetchTestCases: (options?: { force?: boolean }) => Promise<void>;
+  fetchTestCases: (options?: { force?: boolean; versionId?: string }) => Promise<void>;
   createTestCase: (data: CreateTestCaseInput) => TestCase;
   createTestCases: (items: CreateTestCaseInput[]) => TestCase[];
   updateTestCase: (id: string, data: Partial<TestCase>) => void;
@@ -45,7 +54,9 @@ export const useTestCaseStore = create<TestCaseState>((set, get) => ({
 
   fetchTestCases: async (options) => {
     if (!options?.force && get().loaded && Date.now() - lastTestCasesFetchAt < SERVER_DATA_CACHE_MS) return;
-    const cached = await loadStored();
+    const cached = options?.versionId
+      ? await listTestCasesByVersionId(options.versionId).catch(loadStored)
+      : await loadStored();
     if (!options?.force && get().loaded && Date.now() - lastTestCasesFetchAt < SERVER_DATA_CACHE_MS) return;
     lastTestCasesFetchAt = Date.now();
     if (cached) {
@@ -71,12 +82,23 @@ export const useTestCaseStore = create<TestCaseState>((set, get) => ({
     const updated = [...list, tc];
     set({ testCases: updated, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('test-cases', updated),
+      save: async () => {
+        try {
+          const result = await createTestCaseByVersionId(tc.versionId, tc);
+          set({
+            testCases: get().testCases.map((item) => (item.id === tc.id ? { ...tc, ...result.item } : item)),
+            loaded: true,
+          });
+          appendDomainActivities(result.activities);
+        } catch {
+          await saveTestCasesFallback(updated);
+          useWorkActivityStore.getState().addActivity(makeTestCaseCreatedActivity(tc, tc.createdBy));
+        }
+      },
       expected: updated,
       getCurrent: () => get().testCases,
       rollback: () => set({ testCases: list, loaded: true }),
     });
-    useWorkActivityStore.getState().addActivity(makeTestCaseCreatedActivity(tc, tc.createdBy));
     return tc;
   },
 
@@ -100,14 +122,31 @@ export const useTestCaseStore = create<TestCaseState>((set, get) => ({
     }
     set({ testCases: list, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('test-cases', list),
+      save: async () => {
+        try {
+          if (!created[0]?.versionId) throw new Error('missing versionId');
+          const result = await createTestCasesByVersionId(created[0].versionId, created);
+          const byCaseNo = new Map(result.items.map((item) => [item.caseNo, item]));
+          set({
+            testCases: get().testCases.map((item) => {
+              if (!created.some((tc) => tc.id === item.id)) return item;
+              const replacement = byCaseNo.get(item.caseNo);
+              return replacement ? { ...item, ...replacement } : item;
+            }),
+            loaded: true,
+          });
+          appendDomainActivities(result.activities);
+        } catch {
+          await saveTestCasesFallback(list);
+          created.forEach((tc) => {
+            useWorkActivityStore.getState().addActivity(makeTestCaseCreatedActivity(tc, tc.createdBy));
+          });
+        }
+      },
       expected: list,
       getCurrent: () => get().testCases,
       rollback: () => set({ testCases: previous, loaded: true }),
     });
-    created.forEach((tc) => {
-      useWorkActivityStore.getState().addActivity(makeTestCaseCreatedActivity(tc, tc.createdBy));
-    });
     return created;
   },
 
@@ -118,7 +157,16 @@ export const useTestCaseStore = create<TestCaseState>((set, get) => ({
     );
     set({ testCases: updated, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('test-cases', updated),
+      save: async () => {
+        try {
+          const versionId = previous.find((testCase) => testCase.id === id)?.versionId;
+          if (!versionId) throw new Error('missing versionId');
+          const result = await updateTestCaseByVersionId(versionId, id, data);
+          appendDomainActivities(result.activities);
+        } catch {
+          await saveTestCasesFallback(updated);
+        }
+      },
       expected: updated,
       getCurrent: () => get().testCases,
       rollback: () => set({ testCases: previous, loaded: true }),
@@ -130,7 +178,15 @@ export const useTestCaseStore = create<TestCaseState>((set, get) => ({
     const updated = previous.filter((c) => c.id !== id);
     set({ testCases: updated, loaded: true });
     scheduleSaveWithOptimisticRollback({
-      save: () => saveServerData('test-cases', updated),
+      save: async () => {
+        try {
+          const versionId = previous.find((testCase) => testCase.id === id)?.versionId;
+          if (!versionId) throw new Error('missing versionId');
+          await deleteTestCaseByVersionId(versionId, id);
+        } catch {
+          await saveTestCasesFallback(updated);
+        }
+      },
       expected: updated,
       getCurrent: () => get().testCases,
       rollback: () => set({ testCases: previous, loaded: true }),
@@ -146,10 +202,28 @@ export const useTestCaseStore = create<TestCaseState>((set, get) => ({
       blockReason: extra?.blockReason,
     });
     if (!result.ok || !result.patch) return { ok: false, message: result.message };
-    get().updateTestCase(id, result.patch);
+    const previous = get().testCases;
+    const updated = previous.map((item) =>
+      item.id === id ? { ...item, ...result.patch, aiDraft: false, updatedAt: new Date().toISOString() } : item,
+    );
+    set({ testCases: updated, loaded: true });
     const actorId = tc.assigneeId || tc.executedBy || tc.createdBy;
     const activity = makeTestCaseStatusActivity(tc, tc.status, to, actorId);
-    if (activity) useWorkActivityStore.getState().addActivity(activity);
+    scheduleSaveWithOptimisticRollback({
+      save: async () => {
+        try {
+          const result = await updateTestCaseStatusByVersionId(tc.versionId, id, to);
+          appendDomainActivities(result.activities);
+          if (result.activities.length === 0 && activity) useWorkActivityStore.getState().addActivity(activity);
+        } catch {
+          await saveTestCasesFallback(updated);
+          if (activity) useWorkActivityStore.getState().addActivity(activity);
+        }
+      },
+      expected: updated,
+      getCurrent: () => get().testCases,
+      rollback: () => set({ testCases: previous, loaded: true }),
+    });
     return { ok: true };
   },
 
@@ -165,3 +239,15 @@ export const useTestCaseStore = create<TestCaseState>((set, get) => ({
     return get().testCases.filter((c) => c.assigneeId === assigneeId);
   },
 }));
+
+async function saveTestCasesFallback(testCases: TestCase[]) {
+  await saveServerData('test-cases', testCases);
+}
+
+function appendDomainActivities(activities: WorkActivity[]) {
+  if (activities.length === 0) return;
+  useWorkActivityStore.setState((state) => ({
+    activities: [...state.activities, ...activities],
+    loaded: true,
+  }));
+}