@open-mercato/ui 0.6.1-develop.3227.1.2b7b8ab258 → 0.6.1-develop.3256.1.fe3dec2464

package/src/backend/operations/LastOperationBanner.tsx

@@ -24,20 +24,27 @@ export function LastOperationBanner() {
   async function handleUndo() {
     const undoToken = operation?.undoToken
     if (!undoToken || isPending) return
+    const tokens = operation.bulkUndoTokens && operation.bulkUndoTokens.length > 0
+      ? operation.bulkUndoTokens
+      : [undoToken]
     setPendingToken(undoToken)
+    const completed: string[] = []
     try {
-      const call = await apiCall<Record<string, unknown>>('/api/audit_logs/audit-logs/actions/undo', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ undoToken }),
-      })
-      if (!call.ok) {
-        const message =
-          (call.result && typeof call.result.error === 'string' && call.result.error) ||
-          ''
-        throw new Error(message || t('audit_logs.banner.undo_failed', 'Failed to undo'))
+      for (const token of tokens.slice().reverse()) {
+        const call = await apiCall<Record<string, unknown>>('/api/audit_logs/audit-logs/actions/undo', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ undoToken: token }),
+        })
+        if (!call.ok) {
+          const message =
+            (call.result && typeof call.result.error === 'string' && call.result.error) ||
+            ''
+          throw new Error(message || t('audit_logs.banner.undo_failed', 'Failed to undo'))
+        }
+        completed.push(token)
       }
-      markUndoSuccess(undoToken)
+      markUndoSuccess(tokens)
       flash(t('audit_logs.banner.undo_success'), 'success')
       router.refresh()
       if (typeof window !== 'undefined') {
@@ -53,6 +60,7 @@ export function LastOperationBanner() {
         }
       }
     } catch (err) {
+      if (completed.length > 0) markUndoSuccess(completed)
       const message = err instanceof Error && err.message ? err.message : t('audit_logs.banner.undo_error')
       flash(message, 'error')
     } finally {

package/src/backend/operations/__tests__/LastOperationBanner.test.tsx

@@ -78,10 +78,55 @@ describe('LastOperationBanner', () => {
         method: 'POST',
       }))
     })
-    expect(markUndoSuccess).toHaveBeenCalledWith('token-123')
+    expect(markUndoSuccess).toHaveBeenCalledWith(['token-123'])
     expect(flash).toHaveBeenCalledWith('Undo completed', 'success')
   })
 
+  it('iterates bulkUndoTokens in reverse and reports completed tokens to the store on full success', async () => {
+    ;(useLastOperation as jest.Mock).mockReturnValue({
+      ...mockOperation,
+      undoToken: 'bulk:abc',
+      bulkUndoTokens: ['tk-1', 'tk-2', 'tk-3'],
+      bulkCount: 3,
+    })
+    ;(apiCall as jest.Mock).mockResolvedValue({
+      ok: true,
+      status: 200,
+      result: {},
+      response: createMockResponse(200),
+    })
+
+    renderWithProviders(<LastOperationBanner />, { dict })
+    fireEvent.click(screen.getByRole('button', { name: /undo/i }))
+
+    await waitFor(() => {
+      expect(apiCall).toHaveBeenCalledTimes(3)
+    })
+    const tokenBodies = (apiCall as jest.Mock).mock.calls.map((call) => JSON.parse(call[1].body))
+    expect(tokenBodies.map((body: { undoToken: string }) => body.undoToken)).toEqual(['tk-3', 'tk-2', 'tk-1'])
+    expect(markUndoSuccess).toHaveBeenCalledWith(['tk-1', 'tk-2', 'tk-3'])
+  })
+
+  it('on partial bulk failure flashes the error and reports only the completed tokens', async () => {
+    ;(useLastOperation as jest.Mock).mockReturnValue({
+      ...mockOperation,
+      undoToken: 'bulk:abc',
+      bulkUndoTokens: ['tk-1', 'tk-2', 'tk-3'],
+      bulkCount: 3,
+    })
+    ;(apiCall as jest.Mock)
+      .mockResolvedValueOnce({ ok: true, status: 200, result: {}, response: createMockResponse(200) })
+      .mockResolvedValueOnce({ ok: false, status: 500, result: { error: 'boom' }, response: createMockResponse(500) })
+
+    renderWithProviders(<LastOperationBanner />, { dict })
+    fireEvent.click(screen.getByRole('button', { name: /undo/i }))
+
+    await waitFor(() => {
+      expect(flash).toHaveBeenCalledWith('boom', 'error')
+    })
+    expect(markUndoSuccess).toHaveBeenCalledWith(['tk-3'])
+  })
+
   it('surfaces undo errors from the API', async () => {
     ;(apiCall as jest.Mock).mockResolvedValue({
       ok: false,

package/src/backend/operations/__tests__/store.test.ts

@@ -0,0 +1,142 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import {
+  coalesceLastOperations,
+  markUndoSuccess,
+  pushOperation,
+  clearAllOperations,
+} from '../store'
+
+function makeMeta(id: string, undoToken: string, commandId = 'customers.companies.delete') {
+  return {
+    id,
+    undoToken,
+    commandId,
+    actionLabel: 'Delete company',
+    resourceKind: 'customers.company',
+    resourceId: id,
+    executedAt: new Date().toISOString(),
+  }
+}
+
+describe('operations store — bulk coalesce', () => {
+  beforeEach(() => {
+    clearAllOperations()
+  })
+
+  it('replaces the last N entries with a single synthetic bulk entry', () => {
+    pushOperation(makeMeta('op-1', 'tk-1'))
+    pushOperation(makeMeta('op-2', 'tk-2'))
+    pushOperation(makeMeta('op-3', 'tk-3'))
+
+    coalesceLastOperations(3, {
+      commandId: 'customers.companies.delete',
+      actionLabel: 'Delete 3 companies',
+    })
+
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack).toHaveLength(1)
+    const synthetic = state.stack[0]
+    expect(synthetic.bulkUndoTokens).toEqual(['tk-1', 'tk-2', 'tk-3'])
+    expect(synthetic.bulkCount).toBe(3)
+    expect(synthetic.actionLabel).toBe('Delete 3 companies')
+  })
+
+  it('is a no-op when count is 1 or less', () => {
+    pushOperation(makeMeta('op-1', 'tk-1'))
+    coalesceLastOperations(1, { commandId: 'customers.companies.delete' })
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack).toHaveLength(1)
+    expect(state.stack[0].bulkUndoTokens).toBeUndefined()
+  })
+
+  it('refuses to coalesce when commandIds in the tail do not match', () => {
+    pushOperation(makeMeta('op-1', 'tk-1', 'customers.companies.delete'))
+    pushOperation(makeMeta('op-2', 'tk-2', 'customers.people.delete'))
+
+    coalesceLastOperations(2, { commandId: 'customers.companies.delete' })
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack).toHaveLength(2)
+    expect(state.stack[1].bulkUndoTokens).toBeUndefined()
+  })
+
+  it('preserves earlier entries that fall outside the coalesce window', () => {
+    pushOperation(makeMeta('earlier', 'tk-earlier', 'customers.deals.update'))
+    pushOperation(makeMeta('op-1', 'tk-1'))
+    pushOperation(makeMeta('op-2', 'tk-2'))
+
+    coalesceLastOperations(2, {
+      commandId: 'customers.companies.delete',
+      actionLabel: 'Delete 2 companies',
+    })
+
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack).toHaveLength(2)
+    expect(state.stack[0].id).toBe('earlier')
+    expect(state.stack[1].bulkCount).toBe(2)
+  })
+})
+
+describe('markUndoSuccess — bulk-aware', () => {
+  beforeEach(() => {
+    clearAllOperations()
+  })
+
+  it('removes a bulk entry when ALL of its bulkUndoTokens match', () => {
+    pushOperation(makeMeta('op-1', 'tk-1'))
+    pushOperation(makeMeta('op-2', 'tk-2'))
+    coalesceLastOperations(2, {
+      commandId: 'customers.companies.delete',
+      actionLabel: 'Delete 2 companies',
+    })
+
+    markUndoSuccess(['tk-1', 'tk-2'])
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack).toHaveLength(0)
+    expect(state.undone).toHaveLength(1)
+    expect(state.undone[0].bulkUndoTokens).toEqual(['tk-1', 'tk-2'])
+  })
+
+  it('splits a bulk entry on partial undo, keeping the unconsumed tokens on the stack', () => {
+    pushOperation(makeMeta('op-1', 'tk-1'))
+    pushOperation(makeMeta('op-2', 'tk-2'))
+    pushOperation(makeMeta('op-3', 'tk-3'))
+    coalesceLastOperations(3, {
+      commandId: 'customers.companies.delete',
+      actionLabel: 'Delete 3 companies',
+    })
+
+    markUndoSuccess(['tk-2', 'tk-3'])
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack).toHaveLength(1)
+    expect(state.stack[0].bulkUndoTokens).toEqual(['tk-1'])
+    expect(state.stack[0].bulkCount).toBe(1)
+    expect(state.undone).toHaveLength(1)
+    expect(state.undone[0].bulkUndoTokens).toEqual(['tk-2', 'tk-3'])
+    expect(state.undone[0].bulkCount).toBe(2)
+  })
+
+  it('coalesce assigns a synthetic id distinct from the source operations', () => {
+    pushOperation(makeMeta('op-1', 'tk-1'))
+    pushOperation(makeMeta('op-2', 'tk-2'))
+    coalesceLastOperations(2, {
+      commandId: 'customers.companies.delete',
+      actionLabel: 'Delete 2 companies',
+    })
+
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack[0].id).not.toBe('op-1')
+    expect(state.stack[0].id).not.toBe('op-2')
+    expect(state.stack[0].id).toMatch(/^bulk:/)
+    expect(state.stack[0].undoToken).toMatch(/^bulk:/)
+  })
+
+  it('accepts a single string for legacy callers', () => {
+    pushOperation(makeMeta('op-solo', 'tk-solo'))
+    markUndoSuccess('tk-solo')
+    const state = JSON.parse(window.localStorage.getItem('om:last-operations:v1')!)
+    expect(state.stack).toHaveLength(0)
+  })
+})

package/src/backend/operations/store.ts

@@ -4,6 +4,8 @@ import type { OperationMetadataPayload } from '@open-mercato/shared/lib/commands
 
 export type OperationEntry = OperationMetadataPayload & {
   receivedAt: number
+  bulkUndoTokens?: string[]
+  bulkCount?: number
 }
 
 export type UndoneEntry = OperationEntry & {
@@ -71,6 +73,12 @@ function isValidEntry(entry: unknown): entry is OperationEntry {
 
 function hydrateEntry(entry: unknown): OperationEntry {
   const source = entry as Partial<OperationEntry> & Record<string, unknown>
+  const bulkTokens = Array.isArray(source.bulkUndoTokens)
+    ? source.bulkUndoTokens.filter((t): t is string => typeof t === 'string' && t.length > 0)
+    : undefined
+  const bulkCount = typeof source.bulkCount === 'number' && Number.isFinite(source.bulkCount)
+    ? source.bulkCount
+    : undefined
   return {
     id: String(source.id),
     undoToken: String(source.undoToken),
@@ -80,6 +88,8 @@ function hydrateEntry(entry: unknown): OperationEntry {
     resourceId: typeof source.resourceId === 'string' ? source.resourceId : null,
     executedAt: typeof source.executedAt === 'string' ? source.executedAt : new Date((source.receivedAt as number | undefined) || now()).toISOString(),
     receivedAt: typeof source.receivedAt === 'number' ? source.receivedAt : now(),
+    ...(bulkTokens && bulkTokens.length > 0 ? { bulkUndoTokens: bulkTokens } : {}),
+    ...(bulkCount && bulkCount > 0 ? { bulkCount } : {}),
   }
 }
 
@@ -154,21 +164,80 @@ export function pushOperation(meta: OperationMetadataPayload) {
   })
 }
 
-export function markUndoSuccess(undoToken: string) {
+export function markUndoSuccess(undoTokens: string | string[]) {
   if (typeof window === 'undefined') return
+  const tokenSet = new Set(Array.isArray(undoTokens) ? undoTokens : [undoTokens])
+  if (tokenSet.size === 0) return
   const removed: OperationEntry[] = []
   updateState((prev) => {
-    const stack = prev.stack.filter((entry) => {
-      if (entry.undoToken === undoToken) {
+    const nextStack: OperationEntry[] = []
+    for (const entry of prev.stack) {
+      const bulk = entry.bulkUndoTokens && entry.bulkUndoTokens.length > 0 ? entry.bulkUndoTokens : null
+      if (!bulk) {
+        if (tokenSet.has(entry.undoToken)) removed.push(entry)
+        else nextStack.push(entry)
+        continue
+      }
+      const consumed: string[] = []
+      const remaining: string[] = []
+      for (const token of bulk) {
+        if (tokenSet.has(token)) consumed.push(token)
+        else remaining.push(token)
+      }
+      if (consumed.length === 0) {
+        nextStack.push(entry)
+      } else if (remaining.length === 0) {
         removed.push(entry)
-        return false
+      } else {
+        removed.push({ ...entry, bulkUndoTokens: consumed, bulkCount: consumed.length })
+        nextStack.push({ ...entry, bulkUndoTokens: remaining, bulkCount: remaining.length })
       }
-      return true
-    })
+    }
     const undone = removed.length
       ? [...prev.undone, ...removed.map((entry) => ({ ...entry, undoneAt: now() }))]
       : prev.undone
-    return { stack, undone }
+    return { stack: nextStack, undone }
+  })
+}
+
+export type CoalesceOptions = {
+  commandId?: string
+  actionLabel?: string | null
+  resourceKind?: string | null
+}
+
+function generateBulkId(seed: string): string {
+  const cryptoRef = typeof globalThis !== 'undefined' ? (globalThis as { crypto?: { randomUUID?: () => string } }).crypto : undefined
+  if (cryptoRef && typeof cryptoRef.randomUUID === 'function') {
+    return `bulk:${cryptoRef.randomUUID()}`
+  }
+  return `bulk:${seed}:${now()}`
+}
+
+export function coalesceLastOperations(count: number, options: CoalesceOptions = {}): void {
+  if (typeof window === 'undefined' || count <= 1) return
+  updateState((prev) => {
+    if (prev.stack.length < count) return prev
+    const tail = prev.stack.slice(-count)
+    if (options.commandId && !tail.every((entry) => entry.commandId === options.commandId)) {
+      return prev
+    }
+    const head = prev.stack.slice(0, prev.stack.length - count)
+    const last = tail[tail.length - 1]
+    const tokens = tail.map((entry) => entry.undoToken)
+    const bulkId = generateBulkId(last.id)
+    const synthetic: OperationEntry = {
+      ...last,
+      id: bulkId,
+      undoToken: bulkId,
+      actionLabel: options.actionLabel ?? last.actionLabel,
+      resourceKind: options.resourceKind ?? last.resourceKind,
+      resourceId: null,
+      bulkUndoTokens: tokens,
+      bulkCount: tail.length,
+      receivedAt: now(),
+    }
+    return { stack: [...head, synthetic], undone: prev.undone }
   })
 }
 

package/src/backend/utils/__tests__/bulkDelete.test.ts

@@ -0,0 +1,103 @@
+import { groupBulkDeleteFailures, runBulkDelete, type BulkDeleteFailure } from '../bulkDelete'
+
+describe('runBulkDelete', () => {
+  it('captures error message and code from thrown error', async () => {
+    const dependencyErr = Object.assign(new Error('Cannot delete company: linked deals (2).'), {
+      code: 'COMPANY_HAS_DEPENDENTS',
+      status: 422,
+    })
+    const rows = [{ id: 'a' }, { id: 'b' }, { id: 'c' }]
+    const deleteOne = jest.fn().mockImplementation(async (row: { id: string }) => {
+      if (row.id === 'b') throw dependencyErr
+    })
+
+    const { succeeded, failures } = await runBulkDelete(rows, deleteOne)
+
+    expect(succeeded).toEqual([{ id: 'a' }, { id: 'c' }])
+    expect(failures).toEqual([
+      { id: 'b', code: 'COMPANY_HAS_DEPENDENTS', message: 'Cannot delete company: linked deals (2).' },
+    ])
+  })
+
+  it('falls back to fallbackErrorMessage when the error has no message', async () => {
+    const empty = Object.assign(new Error(''), {})
+    const deleteOne = jest.fn().mockRejectedValue(empty)
+
+    const { failures } = await runBulkDelete([{ id: 'x' }], deleteOne, {
+      fallbackErrorMessage: 'Failed to delete record.',
+    })
+
+    expect(failures[0]).toEqual({ id: 'x', code: null, message: 'Failed to delete record.' })
+  })
+
+  it('treats non-string code as null', async () => {
+    const err = Object.assign(new Error('boom'), { code: 500 })
+    const deleteOne = jest.fn().mockRejectedValue(err)
+
+    const { failures } = await runBulkDelete([{ id: 'x' }], deleteOne)
+
+    expect(failures[0].code).toBeNull()
+  })
+
+  it('logs failures via console.warn when logTag is provided', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+    try {
+      const err = Object.assign(new Error('linked deals (2).'), { code: 'COMPANY_HAS_DEPENDENTS' })
+      const deleteOne = jest.fn().mockRejectedValue(err)
+
+      await runBulkDelete([{ id: 'x' }], deleteOne, { logTag: 'customers.companies.list' })
+
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+      const [tag, payload] = warnSpy.mock.calls[0]
+      expect(tag).toBe('[customers.companies.list] bulk delete failed')
+      expect(payload).toMatchObject({ id: 'x', code: 'COMPANY_HAS_DEPENDENTS' })
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  it('does not log when logTag is omitted', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+    try {
+      const deleteOne = jest.fn().mockRejectedValue(new Error('boom'))
+      await runBulkDelete([{ id: 'x' }], deleteOne)
+      expect(warnSpy).not.toHaveBeenCalled()
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+})
+
+describe('groupBulkDeleteFailures', () => {
+  it('groups failures by error code and counts occurrences', () => {
+    const failures: BulkDeleteFailure[] = [
+      { id: '1', code: 'HAS_DEPENDENTS', message: 'Cannot delete (a)' },
+      { id: '2', code: 'HAS_DEPENDENTS', message: 'Cannot delete (b)' },
+      { id: '3', code: 'OTHER_ERROR', message: 'Different' },
+    ]
+
+    const groups = groupBulkDeleteFailures(failures)
+
+    expect(groups).toHaveLength(2)
+    const dependents = groups.find((g) => g.key === 'HAS_DEPENDENTS')!
+    expect(dependents.count).toBe(2)
+    expect(dependents.ids).toEqual(['1', '2'])
+    expect(dependents.sampleMessage).toBe('Cannot delete (a)')
+  })
+
+  it('falls back to message when no code is present', () => {
+    const failures: BulkDeleteFailure[] = [
+      { id: '1', code: null, message: 'Same reason' },
+      { id: '2', code: null, message: 'Same reason' },
+      { id: '3', code: null, message: 'Different reason' },
+    ]
+
+    const groups = groupBulkDeleteFailures(failures)
+
+    expect(groups.map((g) => g.count).sort()).toEqual([1, 2])
+  })
+
+  it('returns empty array when no failures', () => {
+    expect(groupBulkDeleteFailures([])).toEqual([])
+  })
+})

package/src/backend/utils/bulkDelete.ts

@@ -0,0 +1,77 @@
+"use client"
+
+export type BulkDeleteFailure = {
+  id: string
+  code: string | null
+  message: string
+}
+
+export type BulkDeleteOutcome<T extends { id: string }> = {
+  succeeded: T[]
+  failures: BulkDeleteFailure[]
+}
+
+export type BulkDeleteOptions = {
+  fallbackErrorMessage?: string
+  logTag?: string
+}
+
+export async function runBulkDelete<T extends { id: string }>(
+  rows: T[],
+  deleteOne: (row: T) => Promise<void>,
+  options?: BulkDeleteOptions,
+): Promise<BulkDeleteOutcome<T>> {
+  const fallback = options?.fallbackErrorMessage ?? 'Delete failed'
+  const logTag = options?.logTag
+  const succeeded: T[] = []
+  const failures: BulkDeleteFailure[] = []
+  for (const row of rows) {
+    try {
+      await deleteOne(row)
+      succeeded.push(row)
+    } catch (err) {
+      const message =
+        err instanceof Error && err.message.trim().length > 0 ? err.message : fallback
+      const rawCode =
+        err && typeof err === 'object' ? (err as { code?: unknown }).code : undefined
+      const code = typeof rawCode === 'string' && rawCode.length > 0 ? rawCode : null
+      failures.push({ id: row.id, code, message })
+      if (logTag && typeof console !== 'undefined' && typeof console.warn === 'function') {
+        console.warn(`[${logTag}] bulk delete failed`, { id: row.id, code, message, err })
+      }
+    }
+  }
+  return { succeeded, failures }
+}
+
+export type BulkDeleteFailureGroup = {
+  key: string
+  count: number
+  sampleMessage: string
+  ids: string[]
+}
+
+// Keyed by `code` when present so semantically identical failures collapse into
+// one toast even if their message text varies (e.g. row-specific dependency
+// counts). Falls back to the raw message when the server did not surface a code.
+export function groupBulkDeleteFailures(
+  failures: BulkDeleteFailure[],
+): BulkDeleteFailureGroup[] {
+  const buckets = new Map<string, BulkDeleteFailureGroup>()
+  for (const failure of failures) {
+    const key = failure.code || failure.message || 'unknown'
+    const existing = buckets.get(key)
+    if (existing) {
+      existing.count += 1
+      existing.ids.push(failure.id)
+      continue
+    }
+    buckets.set(key, {
+      key,
+      count: 1,
+      sampleMessage: failure.message,
+      ids: [failure.id],
+    })
+  }
+  return Array.from(buckets.values())
+}