优化

src/modules/overseas-warehouse/dispatchCommandRecovery.test.ts

@@ -19,8 +19,12 @@ it('keeps a proven result across GET failure and does not send the command a sec
   const send = vi.fn().mockResolvedValue(command('LOADING_COMPLETE')), read = vi.fn().mockRejectedValueOnce(new Error('read failed')).mockResolvedValueOnce({ dispatchNo: 'PC/1', recordVersion: 1 }), find = vi.fn()
   await expect(recovery.execute(send, read, find)).rejects.toThrow('read failed')
   expect(recovery.pending.value?.result?.stage).toBe('AFTER_LOADING')
-  await recovery.execute(send, read, find)
+  expect(JSON.parse(sessionStorage.getItem(`dispatch-command:${owner}`)!).result).toEqual(command('LOADING_COMPLETE'))
+  const reopened = useDispatchCommandRecovery(() => owner)
+  expect(reopened.pending.value?.result).toEqual(command('LOADING_COMPLETE'))
+  await reopened.execute(send, read, find)
   expect(send).toHaveBeenCalledTimes(1); expect(find).not.toHaveBeenCalled()
+  expect(reopened.pending.value).toBeNull(); expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
 })
 it('shares one pending command between empty-create and workflow dialogs and refuses a new command', () => {
   const owner = crypto.randomUUID(), first = useDispatchCommandRecovery(() => owner), second = useDispatchCommandRecovery(() => owner)
@@ -38,6 +42,12 @@ it('does not discard an earlier unknown write on a later business rejection', as
   await expect(stable.execute(send, vi.fn(), find)).rejects.toThrow('unknown')
   await expect(stable.execute(send, vi.fn(), find)).rejects.toThrow('version conflict')
   stable.discardRejected(); expect(stable.pending.value).not.toBeNull()
+  expect(find).toHaveBeenCalledWith('PC/1', 'key')
+  expect(send.mock.calls[1]![0].body).toEqual({ recordVersion: 0, idempotencyKey: 'key' })
+  expect(stable.pending.value?.rejected).toBe(false)
+  const saved = JSON.parse(sessionStorage.getItem(`dispatch-command:${owner}`)!)
+  expect(saved).toMatchObject({ attempted: true, rejected: false, result: null, body: { recordVersion: 0, idempotencyKey: 'key' } })
+  expect(useDispatchCommandRecovery(() => owner).pending.value).toEqual(saved)
 })
 it('rejects a mismatched business number/action/key instead of treating it as successful', async () => {
   const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
@@ -61,3 +71,66 @@ it('treats an internal server error as unknown instead of authorizing a new comm
   await expect(recovery.execute(vi.fn().mockRejectedValue(new ApiResponseError('server failure', 'A0500', 500)), vi.fn(), vi.fn())).rejects.toThrow('server failure')
   recovery.discardRejected(); expect(recovery.pending.value?.rejected).toBe(false)
 })
+it.each(['400', '401', '403', '404', '409', '410', '422'].flatMap(code => [code, `A0${code}`, `HTTP_${code}`]))(
+  'clears the first definite rejection %s from memory and storage and preserves its original error', async code => {
+    const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
+    recovery.begin('PC/1', 'SUBMIT_REVIEW', { recordVersion: 0, idempotencyKey: 'rejected-key' })
+    const rejection = new ApiResponseError('明确拒绝', code)
+    const send = vi.fn().mockRejectedValue(rejection), read = vi.fn(), find = vi.fn()
+    await expect(recovery.execute(send, read, find)).rejects.toBe(rejection)
+    expect(send).toHaveBeenCalledTimes(1)
+    expect(read).not.toHaveBeenCalled(); expect(find).not.toHaveBeenCalled()
+    expect(recovery.pending.value).toBeNull(); expect(recovery.busy.value).toBe(false)
+    expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
+    const reopened = useDispatchCommandRecovery(() => owner)
+    expect(reopened.pending.value).toBeNull()
+    expect(() => reopened.begin('PC/1', 'EDIT', { recordVersion: 2, idempotencyKey: 'fresh-key' })).not.toThrow()
+  },
+)
+it('cleans an explicitly rejected legacy browser record when its scope is restored', () => {
+  const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
+  sessionStorage.setItem(key, JSON.stringify({ dispatchNo: 'PC/1', action: 'SUBMIT_REVIEW',
+    body: { recordVersion: 0, idempotencyKey: 'terminal-key' }, attempted: true, rejected: true, result: null }))
+  const recovery = useDispatchCommandRecovery(() => owner)
+  expect(recovery.pending.value).toBeNull(); expect(sessionStorage.getItem(key)).toBeNull()
+  expect(() => recovery.begin('PC/1', 'EDIT', { recordVersion: 1, idempotencyKey: 'new-key' })).not.toThrow()
+})
+it('cleans a terminal rejected record already shared by dialogs in the same scope', () => {
+  const owner = crypto.randomUUID(), first = useDispatchCommandRecovery(() => owner)
+  first.begin('PC/1', 'SUBMIT_REVIEW', { recordVersion: 0, idempotencyKey: 'terminal-key' })
+  first.pending.value!.attempted = true; first.pending.value!.rejected = true
+  sessionStorage.setItem(`dispatch-command:${owner}`, JSON.stringify(first.pending.value))
+  const second = useDispatchCommandRecovery(() => owner)
+  expect(second.pending).toBe(first.pending)
+  expect(first.pending.value).toBeNull(); expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
+})
+it('retains a restored unknown record without explicit rejection proof and reconciles its original key', async () => {
+  const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
+  const original = { dispatchNo: 'PC/1', action: 'EDIT', body: { recordVersion: 0, idempotencyKey: 'unknown-key', remark: 'original' },
+    attempted: true, rejected: false, result: null }
+  sessionStorage.setItem(key, JSON.stringify(original))
+  const recovery = useDispatchCommandRecovery(() => owner)
+  expect(recovery.pending.value).toEqual(original)
+  const rejection = new ApiResponseError('later rejection', 'A0409')
+  const send = vi.fn().mockRejectedValue(rejection), read = vi.fn()
+  const find = vi.fn().mockRejectedValue(new ApiResponseError('not found', 'HTTP_404'))
+  await expect(recovery.execute(send, read, find)).rejects.toBe(rejection)
+  expect(find).toHaveBeenCalledWith('PC/1', 'unknown-key')
+  expect(send.mock.calls[0]![0].body).toEqual(original.body)
+  expect(read).not.toHaveBeenCalled()
+  expect(recovery.pending.value).toEqual(original); expect(JSON.parse(sessionStorage.getItem(key)!)).toEqual(original)
+})
+it('only rereads a restored proven result and keeps it when the detail read still fails', async () => {
+  const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
+  const original = { dispatchNo: 'PC/1', action: 'LOADING_COMPLETE', body: { recordVersion: 0, idempotencyKey: 'key' },
+    attempted: true, rejected: false, result: command('LOADING_COMPLETE') }
+  sessionStorage.setItem(key, JSON.stringify(original))
+  const recovery = useDispatchCommandRecovery(() => owner)
+  const send = vi.fn(), find = vi.fn(), failure = new Error('detail unavailable')
+  const read = vi.fn().mockRejectedValueOnce(failure).mockResolvedValueOnce({ dispatchNo: 'PC/1', recordVersion: 1 })
+  await expect(recovery.execute(send, read, find)).rejects.toBe(failure)
+  expect(recovery.pending.value).toEqual(original); expect(JSON.parse(sessionStorage.getItem(key)!)).toEqual(original)
+  await recovery.execute(send, read, find)
+  expect(send).not.toHaveBeenCalled(); expect(find).not.toHaveBeenCalled(); expect(read).toHaveBeenCalledTimes(2)
+  expect(recovery.pending.value).toBeNull(); expect(sessionStorage.getItem(key)).toBeNull()
+})