fix(first-leg): preserve edit commands and add versioned cancellation

src/modules/first-leg/store/firstLegDraftCommands.test.mjs

@@ -0,0 +1,196 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { readFileSync } from 'node:fs'
+import ts from 'typescript'
+import * as vue from 'vue'
+import * as pinia from 'pinia'
+
+function compile(path, dependencies) {
+  const source = readFileSync(new URL(path, import.meta.url), 'utf8')
+  const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
+  const exports = {}
+  new Function('require', 'exports', code)(id => { assert.ok(id in dependencies, id); return dependencies[id] }, exports)
+  return exports
+}
+function harness(t) {
+  const context = pinia.createPinia(); pinia.setActivePinia(context)
+  t.after(() => pinia.disposePinia(context))
+  const calls = []
+  const behavior = { failWrite: false, failRead: false, version: 9, status: 'DRAFT' }
+  const api = compile('../api/firstLeg.ts', { '@/api/http': { apiRequest: async config => {
+    calls.push(structuredClone(config))
+    if (config.method === 'GET') {
+      if (behavior.failRead) throw new Error('读取失败')
+      return { order: { id: 'one', orderNo: 'FL-ONE', version: behavior.version, status: behavior.status, receivingWarehouseId: 'warehouse', destinationCountryCode: 'US' }, cargoes: [] }
+    }
+    if (behavior.failWrite) throw new Error('响应丢失')
+  } } })
+  const module = compile('./firstLegOrders.ts', {
+    vue, pinia,
+    '@/modules/first-leg/api/firstLeg': api,
+    '@/modules/first-leg/api/unifiedOrders': {},
+    '@/modules/first-leg/utils/firstLegOrder': { canClientEditFirstLegOrder: status => status === 'DRAFT', getFirstLegStatusLabel: value => value },
+    '@/modules/first-leg/utils/warehousePagination': {},
+  })
+  const store = module.useFirstLegOrdersStore()
+  store.warehouses = [{ id: 'warehouse', name: '国内仓', warehouseType: 'DOMESTIC' }]
+  const draft = { receivingWarehouseId: 'warehouse', destinationType: 'PRIVATE', destinationCountryCode: 'US', items: [], customerRemark: '原草稿' }
+  return { store, api, calls, behavior, draft }
+}
+
+test('edit freezes detail version rather than cached list version and replays same key/body after uncertain result', async t => {
+  const h = harness(t)
+  const original = await h.store.loadDraftDetail('one')
+  const session = h.store.beginDraftEdit(original)
+  h.store.orders[0].version = 0
+  h.behavior.failWrite = true
+  await assert.rejects(h.store.saveDraft(h.draft, '测试企业', 'one', session), /响应丢失/)
+  const first = h.calls.find(call => call.method === 'PUT')
+  assert.equal(first.data.expectedVersion, 9)
+  assert.equal(first.data.draft.customerRemark, '原草稿')
+  assert.ok(first.headers['Idempotency-Key'])
+  assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT'], 'no pre-save version refresh')
+  h.behavior.failWrite = false; h.behavior.version = 10
+  const result = await h.store.saveDraft(h.draft, '测试企业', 'one', session)
+  const writes = h.calls.filter(call => call.method === 'PUT')
+  assert.deepEqual(writes[1], first)
+  assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT', 'GET', 'PUT', 'GET'])
+  assert.equal(result.version, 10)
+})
+
+test('changed retry payload or missing edit session fails closed without issuing a new write', async t => {
+  const h = harness(t)
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one'), /重新打开/)
+  assert.equal(h.calls.length, 0)
+  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
+  h.behavior.failWrite = true
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session))
+  h.draft.customerRemark = '不同内容'
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /重试原内容/)
+  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
+  assert.equal(session.expectedVersion, 9)
+  assert.ok(Object.isFrozen(session))
+})
+
+test('read failure after successful edit preserves the same command for retry', async t => {
+  const h = harness(t)
+  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
+  h.behavior.failRead = true
+  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /读取失败/)
+  h.behavior.failRead = false
+  await h.store.saveDraft(h.draft, '客户', 'one', session)
+  const writes = h.calls.filter(call => call.method === 'PUT')
+  assert.deepEqual(writes[0], writes[1])
+})
+
+test('cancel forwards version and reason without rejecting submitted orders locally; retry keeps key and body', async t => {
+  const h = harness(t)
+  h.behavior.status = 'SUBMITTED'
+  h.store.orders = [{ id: 'one', status: 'PENDING_REVIEW', version: 0 }]
+  h.behavior.failWrite = true
+  await assert.rejects(h.store.cancelOrder('one', 12, '客户要求取消'), /响应丢失/)
+  const first = h.calls[0]
+  assert.equal(first.method, 'POST')
+  assert.equal(first.url, '/merchant/v1/orders/first-leg/one/cancel')
+  assert.deepEqual(first.data, { expectedVersion: 12, reason: '客户要求取消' })
+  await assert.rejects(h.store.cancelOrder('one', 13, '其他原因'), /原版本和原因/)
+  assert.equal(h.calls.length, 1)
+  h.behavior.failWrite = false
+  await h.store.cancelOrder('one', 12, '客户要求取消')
+  assert.deepEqual(h.calls[2], first)
+  assert.equal(h.calls[1].method, 'GET')
+  assert.equal(h.store.orders.length, 0)
+})
+
+test('cancel requires a detail version and a nonempty reason', async t => {
+  const h = harness(t)
+  await assert.rejects(h.store.cancelOrder('one', undefined, '理由'))
+  await assert.rejects(h.store.cancelOrder('one', 1, ' '))
+  assert.equal(h.calls.length, 0)
+})
+
+test('cancellation decision reads raw server status and version including SUBMITTED', async t => {
+  const h = harness(t)
+  for (const status of ['DRAFT', 'SUBMITTED', 'APPROVED', 'ACCEPTED', 'REJECTED']) {
+    h.behavior.status = status
+    const target = await h.store.prepareCancellation('one')
+    assert.equal(target.expectedVersion, 9)
+    assert.equal(target.businessNo, 'FL-ONE')
+  }
+  for (const status of ['PROCESSING', 'COMPLETED', 'CANCELLED']) {
+    h.behavior.status = status
+    await assert.rejects(h.store.prepareCancellation('one'), /不允许取消/)
+  }
+  assert.ok(h.calls.every(call => call.method === 'GET'))
+})
+
+function cancellationViewHarness() {
+  const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
+  const ast = ts.createSourceFile('view.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  const functions = ast.statements.filter(node => ts.isFunctionDeclaration(node) && ['canOfferCancellation', 'cancelOrder'].includes(node.name?.text)).map(node => node.getText(ast)).join('\n')
+  const code = ts.transpileModule(functions, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
+  const calls = [], messages = [], prompts = []
+  const canCancelOrder = vue.ref(true), cancellingOrderId = vue.ref(''), pendingCancellation = vue.shallowRef()
+  class ApiError extends Error { constructor() { super('订单版本已变化'); this.code = 'A0409'; this.status = 409 } }
+  const behavior = { error: null }
+  const store = {
+    prepareCancellation: async id => { calls.push(['prepare', id]); return { id, expectedVersion: 12, businessNo: 'FL-ONE', statusLabel: '审核中' } },
+    cancelOrder: async (...args) => { calls.push(['cancel', ...args]); if (behavior.error) throw behavior.error },
+    load: async query => calls.push(['load', query]),
+  }
+  const ElMessageBox = {
+    prompt: async (message, title, options) => { prompts.push({ message, title, options }); return { value: '客户申请取消' } },
+    confirm: async (...args) => calls.push(['confirm', ...args]),
+  }
+  const ElMessage = { error: message => messages.push(message), warning: message => messages.push(message), success: message => messages.push(message) }
+  const globals = { canCancelOrder, cancellingOrderId, pendingCancellation, store, ElMessageBox, ElMessage, ApiError,
+    isDetailPage: vue.ref(true), router: { push: async route => calls.push(['route', route]) } }
+  const handler = new Function(...Object.keys(globals), code + '\nreturn cancelOrder')(...Object.values(globals))
+  return { handler, calls, messages, prompts, canCancelOrder, pendingCancellation, behavior, ApiError }
+}
+
+test('cancel UI uses mandatory-reason centered prompt and refreshes after successful submitted-order cancellation', async () => {
+  const h = cancellationViewHarness()
+  await h.handler({ id: 'one', status: 'PENDING_REVIEW' })
+  assert.match(h.prompts[0].message, /FL-ONE.*审核中/)
+  const validate = h.prompts[0].options.inputValidator
+  assert.notEqual(validate(' '), true)
+  assert.notEqual(validate('x'.repeat(501)), true)
+  assert.equal(validate('合理原因'), true)
+  assert.deepEqual(h.calls.map(call => call[0]), ['prepare', 'cancel', 'load', 'route'])
+  assert.deepEqual(h.calls[1], ['cancel', 'one', 12, '客户申请取消'])
+})
+
+test('cancel UI keeps an uncertain command for explicit retry, but conflict requires a fresh decision', async () => {
+  const h = cancellationViewHarness()
+  const order = { id: 'one', status: 'DRAFT' }
+  h.behavior.error = new Error('网络无响应')
+  await h.handler(order)
+  assert.equal(h.pendingCancellation.value.expectedVersion, 12)
+  h.behavior.error = null
+  await h.handler(order)
+  assert.equal(h.prompts.length, 1)
+  assert.equal(h.calls.filter(call => call[0] === 'prepare').length, 1)
+  assert.equal(h.calls.filter(call => call[0] === 'confirm').length, 1)
+  assert.deepEqual(h.calls.filter(call => call[0] === 'cancel')[0], h.calls.filter(call => call[0] === 'cancel')[1])
+  h.behavior.error = new h.ApiError()
+  await h.handler(order)
+  assert.equal(h.pendingCancellation.value, undefined)
+  assert.match(h.messages.at(-1), /刷新订单后重新确认/)
+})
+
+test('cancel UI blocks unavailable permission and irreversible visible stages before reads or writes', async () => {
+  const h = cancellationViewHarness()
+  h.canCancelOrder.value = false
+  await h.handler({ id: 'one', status: 'DRAFT' })
+  h.canCancelOrder.value = true
+  await h.handler({ id: 'one', status: 'LOADED' })
+  assert.equal(h.calls.length, 0)
+  assert.equal(h.prompts.length, 0)
+})
+
+test('both editor entry points capture detail sessions and both save paths pass them', () => {
+  const view = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
+  assert.equal((view.match(/editingSession\.value = store\.beginDraftEdit\(detailedOrder\)/g) ?? []).length, 2)
+  assert.equal((view.match(/store\.saveDraft\(cloneDraft\(form\), tenantStore\.company\.companyName, editingId\.value, editingSession\.value\)/g) ?? []).length, 2)
+})

src/modules/first-leg/store/firstLegOrders.test.mjs

@@ -206,9 +206,9 @@ test('only blocks submission when a known company audit status is not active', (
   assert.match(storeSource, /if \(companyAuditStatus && companyAuditStatus !== 'ACTIVE'\)/)
 })
 
-test('does not expose the out-of-scope cancellation write', () => {
-  assert.doesNotMatch(storeSource, /cancelMerchant|function cancel|\/cancel/)
-  assert.doesNotMatch(apiSource, /\/cancel/)
+test('uses the versioned merchant cancellation contract', () => {
+  assert.match(storeSource, /cancelMerchantFirstLegOrder\(id, pending\.payload, pending\.key\)/)
+  assert.match(apiSource, /cancelMerchantFirstLegOrder\(id: number \| string, payload: \{ expectedVersion: number; reason: string \}, idempotencyKey: string\)/)
 })
 
 test('sends an idempotency key for create and submit writes', () => {

src/modules/first-leg/store/firstLegOrders.ts

@@ -10,6 +10,7 @@ import {
   getMerchantWarehouses,
   submitMerchantFirstLegOrder,
   updateMerchantFirstLegOrder,
+  cancelMerchantFirstLegOrder,
   type ApiFirstLegStatus,
   type FirstLegOrderSaveRequest,
   type MerchantFirstLegOrder,
@@ -468,9 +469,21 @@ function mapWarehouse(item: MerchantWarehouse): ClientWarehouse {
   }
 }
 
+export interface DraftEditSession {
+  readonly orderId: string
+  readonly expectedVersion: number
+}
+
 export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', () => {
   const orders = ref<FirstLegOrder[]>([])
   const pendingSubmitKeys = new Map<string, string>()
+  const pendingEdits = new WeakMap<DraftEditSession, { key: string; payload: { expectedVersion: number; draft: FirstLegOrderSaveRequest } }>()
+  const pendingCancellations = new Map<string, { key: string; payload: { expectedVersion: number; reason: string } }>()
+
+  function beginDraftEdit(detail: FirstLegOrder): DraftEditSession {
+    if (!canClientEditFirstLegOrder(detail.status) || !Number.isSafeInteger(detail.version) || detail.version < 0) throw new Error('请重新打开草稿详情后编辑')
+    return Object.freeze({ orderId: detail.id, expectedVersion: detail.version })
+  }
   const warehouses = ref<ClientWarehouse[]>([])
   const loading = ref(false)
   const loadedFromApi = ref(false)
@@ -588,18 +601,52 @@ export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', ()
     return mapped
   }
 
-  async function saveDraft(draft: FirstLegOrderDraft, customerName: string, id?: string) {
+  async function saveDraft(draft: FirstLegOrderDraft, customerName: string, id?: string, editSession?: DraftEditSession) {
     const warehouse = prepareDraftForSave(draft, warehouses.value)
     if (id) {
-      const order = getById(id)
-      if (!order || !canClientEditFirstLegOrder(order.status)) throw new Error('当前订单状态不允许编辑')
-      await updateMerchantFirstLegOrder(id, savePayload(draft, warehouse, customerName))
-      return loadLegacyDetail(id)
+      if (!editSession || editSession.orderId !== id) throw new Error('请重新打开草稿详情后编辑')
+      const payload = { expectedVersion: editSession.expectedVersion, draft: savePayload(draft, warehouse, customerName) }
+      let pending = pendingEdits.get(editSession)
+      if (pending && JSON.stringify(pending.payload) !== JSON.stringify(payload)) throw new Error('上次保存结果未确认，请重试原内容，或重新打开详情后编辑')
+      // Observe an uncertain previous outcome without replacing its frozen version.
+      if (pending) await getMerchantFirstLegOrder(id)
+      if (!pending) {
+        pending = { key: createIdempotencyKey(`first-leg-edit-${id}`), payload: JSON.parse(JSON.stringify(payload)) }
+        pendingEdits.set(editSession, pending)
+      }
+      await updateMerchantFirstLegOrder(id, pending.payload, pending.key)
+      const saved = await loadLegacyDetail(id)
+      pendingEdits.delete(editSession)
+      return saved
     }
     const createdId = await createMerchantFirstLegOrder(savePayload(draft, warehouse, customerName))
     return loadLegacyDetail(String(createdId))
   }
 
+  async function cancelOrder(id: string, expectedVersion: number, reason: string) {
+    if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0 || !reason.trim() || reason.trim().length > 500) throw new Error('取消订单需要详情版本及 1–500 字取消原因')
+    const payload = { expectedVersion, reason: reason.trim() }
+    let pending = pendingCancellations.get(id)
+    if (pending && JSON.stringify(pending.payload) !== JSON.stringify(payload)) throw new Error('上次取消结果未确认，请使用原版本和原因重试')
+    if (pending) await getMerchantFirstLegOrder(id)
+    if (!pending) {
+      pending = { key: createIdempotencyKey(`first-leg-cancel-${id}`), payload }
+      pendingCancellations.set(id, pending)
+    }
+    await cancelMerchantFirstLegOrder(id, pending.payload, pending.key)
+    pendingCancellations.delete(id)
+    orders.value = orders.value.filter(order => order.id !== id)
+  }
+
+  async function prepareCancellation(id: string) {
+    const { order } = await getMerchantFirstLegOrder(id)
+    const labels: Record<string, string> = { DRAFT: '草稿', SUBMITTED: '审核中', APPROVED: '已审核', ACCEPTED: '已接单', REJECTED: '已退回' }
+    if (!Object.hasOwn(labels, order.status)) throw new Error('当前订单状态不允许取消，请刷新订单查看最新进度')
+    if (!Number.isSafeInteger(order.version) || order.version < 0) throw new Error('订单版本缺失，请重新加载详情')
+    pendingCancellations.delete(id)
+    return { id, expectedVersion: order.version, businessNo: order.orderNo || order.inboundCode || '—', statusLabel: labels[order.status] }
+  }
+
   async function saveDraftBatch(
     drafts: Array<{ clientRowId: string; draft: FirstLegOrderDraft }>,
     customerName: string,
@@ -621,8 +668,8 @@ export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', ()
     return loadUnifiedDetail(id)
   }
 
-  async function submit(draft: FirstLegOrderDraft, customerName: string, id?: string, companyAuditStatus?: MerchantTenantStatus) {
-    const order = await saveDraft(draft, customerName, id)
+  async function submit(draft: FirstLegOrderDraft, customerName: string, id?: string, companyAuditStatus?: MerchantTenantStatus, editSession?: DraftEditSession) {
+    const order = await saveDraft(draft, customerName, id, editSession)
     return submitSaved(order.id, companyAuditStatus)
   }
 
@@ -630,5 +677,5 @@ export const useFirstLegOrdersStore = defineStore('client-first-leg-orders', ()
     return loadLegacyDetail(id, getById(id))
   }
 
-  return { orders, warehouses, loading, loadedFromApi, loadError, warehouseLoadError, draftLoadError, activeCount, pendingCount, getById, load, loadDetail, loadDraftDetail, loadWarehouseDetail, loadWarehouseType, saveDraft, saveDraftBatch, submitSaved, submit }
+  return { orders, warehouses, loading, loadedFromApi, loadError, warehouseLoadError, draftLoadError, activeCount, pendingCount, getById, load, loadDetail, loadDraftDetail, loadWarehouseDetail, loadWarehouseType, beginDraftEdit, saveDraft, prepareCancellation, cancelOrder, saveDraftBatch, submitSaved, submit }
 })