@open-mercato/ai-assistant 0.5.1-develop.3036.f02c281f23 → 0.5.1-develop.3045.b4b3320cc2

package/src/modules/ai_assistant/lib/__tests__/pending-action-executor.test.ts

@@ -0,0 +1,348 @@
+import { z } from 'zod'
+import type { AwilixContainer } from 'awilix'
+import {
+  executePendingActionConfirm,
+  PENDING_ACTION_CONFIRMED_EVENT_ID,
+} from '../pending-action-executor'
+import type { AiActionConfirmedPayload } from '../../events'
+import type { AiAgentDefinition } from '../ai-agent-definition'
+import type { AiToolDefinition } from '../types'
+import type { AiPendingAction } from '../../data/entities'
+
+function makeAction(overrides: Partial<AiPendingAction> = {}): AiPendingAction {
+  return {
+    id: 'pa_1',
+    tenantId: 'tenant-1',
+    organizationId: 'org-1',
+    agentId: 'catalog.merchandising_assistant',
+    toolName: 'catalog.update_product',
+    status: 'pending',
+    fieldDiff: [],
+    records: null,
+    failedRecords: null,
+    sideEffectsSummary: null,
+    recordVersion: 'v-1',
+    attachmentIds: [],
+    normalizedInput: { productId: 'p-1', patch: { title: 'New' } },
+    queueMode: 'inline',
+    executionResult: null,
+    targetEntityType: 'product',
+    targetRecordId: 'p-1',
+    conversationId: null,
+    idempotencyKey: 'idem_1',
+    createdByUserId: 'user-1',
+    createdAt: new Date('2026-04-18T10:00:00.000Z'),
+    expiresAt: new Date('2026-04-18T11:00:00.000Z'),
+    resolvedAt: null,
+    resolvedByUserId: null,
+    ...overrides,
+  } as unknown as AiPendingAction
+}
+
+function makeAgent(): AiAgentDefinition {
+  return {
+    id: 'catalog.merchandising_assistant',
+    moduleId: 'catalog',
+    label: 'Catalog Agent',
+    description: '...',
+    systemPrompt: '...',
+    allowedTools: ['catalog.update_product'],
+    readOnly: false,
+    mutationPolicy: 'confirm-required',
+  }
+}
+
+function makeTool(overrides: Partial<AiToolDefinition> = {}): AiToolDefinition {
+  return {
+    name: 'catalog.update_product',
+    description: 'Update product',
+    inputSchema: z.object({ productId: z.string(), patch: z.object({}).passthrough() }),
+    handler: async () => ({ recordId: 'p-1', commandName: 'catalog.product.update' }),
+    isMutation: true,
+    ...overrides,
+  } as AiToolDefinition
+}
+
+function makeRepoStub(initialRow: AiPendingAction) {
+  let row = { ...initialRow } as AiPendingAction & Record<string, unknown>
+  const setStatus = jest.fn(
+    async (_id: string, nextStatus: string, _scope: unknown, extra?: Record<string, unknown>) => {
+      row = {
+        ...row,
+        status: nextStatus as never,
+      }
+      if (extra && 'executionResult' in extra) {
+        row.executionResult = (extra.executionResult ?? null) as never
+      }
+      if (extra && 'failedRecords' in extra) {
+        row.failedRecords = (extra.failedRecords ?? null) as never
+      }
+      if (extra && 'resolvedByUserId' in extra) {
+        row.resolvedByUserId = extra.resolvedByUserId as never
+      }
+      if (nextStatus !== 'executing') {
+        row.resolvedAt = ((extra?.now as Date | undefined) ?? new Date()) as never
+      }
+      return row as AiPendingAction
+    },
+  )
+  return {
+    setStatus,
+    get current() {
+      return row
+    },
+  }
+}
+
+function makeCtx() {
+  return {
+    tenantId: 'tenant-1',
+    organizationId: 'org-1',
+    userId: 'user-1',
+    userFeatures: ['ai_assistant.view'],
+    isSuperAdmin: false,
+    container: {
+      resolve: (name: string) => {
+        if (name === 'em') return {}
+        if (name === 'eventBus') return { emitEvent: async () => {} }
+        throw new Error(`unknown dep ${name}`)
+      },
+    } as unknown as AwilixContainer,
+  }
+}
+
+describe('executePendingActionConfirm', () => {
+  it('transitions pending → confirmed → executing → confirmed on handler success and emits typed ai.action.confirmed', async () => {
+    const repo = makeRepoStub(makeAction())
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const result = await executePendingActionConfirm({
+      action: makeAction(),
+      agent: makeAgent(),
+      tool: makeTool(),
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+    })
+    expect(result.ok).toBe(true)
+    expect(repo.setStatus).toHaveBeenCalledTimes(3)
+    expect(repo.setStatus.mock.calls.map((call) => call[1])).toEqual([
+      'confirmed',
+      'executing',
+      'confirmed',
+    ])
+    expect(result.executionResult).toEqual({
+      recordId: 'p-1',
+      commandName: 'catalog.product.update',
+    })
+    expect(emitEvent).toHaveBeenCalledTimes(1)
+    const [emittedId, emittedPayload] = emitEvent.mock.calls[0] as [
+      'ai.action.confirmed',
+      AiActionConfirmedPayload,
+    ]
+    expect(emittedId).toBe(PENDING_ACTION_CONFIRMED_EVENT_ID)
+    expect(emittedPayload).toMatchObject({
+      pendingActionId: 'pa_1',
+      agentId: 'catalog.merchandising_assistant',
+      toolName: 'catalog.update_product',
+      status: 'confirmed',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      userId: 'user-1',
+      resolvedByUserId: 'user-1',
+      executionResult: {
+        recordId: 'p-1',
+        commandName: 'catalog.product.update',
+      },
+    })
+    expect(typeof emittedPayload.resolvedAt).toBe('string')
+  })
+
+  it('transitions pending → confirmed → executing → failed on handler throw and emits typed failure payload', async () => {
+    const repo = makeRepoStub(makeAction())
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const throwingTool = makeTool({
+      handler: async () => {
+        throw new Error('db constraint')
+      },
+    })
+    const result = await executePendingActionConfirm({
+      action: makeAction(),
+      agent: makeAgent(),
+      tool: throwingTool,
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+    })
+    expect(result.ok).toBe(false)
+    expect(repo.setStatus.mock.calls.map((call) => call[1])).toEqual([
+      'confirmed',
+      'executing',
+      'failed',
+    ])
+    expect(result.executionResult.error).toMatchObject({ code: 'handler_error', message: 'db constraint' })
+    expect(emitEvent).toHaveBeenCalledTimes(1)
+    const [emittedId, emittedPayload] = emitEvent.mock.calls[0] as [
+      'ai.action.confirmed',
+      AiActionConfirmedPayload,
+    ]
+    expect(emittedId).toBe(PENDING_ACTION_CONFIRMED_EVENT_ID)
+    expect(emittedPayload.status).toBe('failed')
+    expect(emittedPayload.executionResult).toMatchObject({
+      error: { code: 'handler_error', message: 'db constraint' },
+    })
+  })
+
+  it('idempotent: calling twice on already-confirmed row returns prior result without re-executing', async () => {
+    const priorResult = { recordId: 'p-1', commandName: 'catalog.product.update' }
+    const repo = makeRepoStub(
+      makeAction({
+        status: 'confirmed' as never,
+        executionResult: priorResult as never,
+      }),
+    )
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const handlerSpy = jest.fn(async () => ({ recordId: 'p-2' }))
+    const result = await executePendingActionConfirm({
+      action: makeAction({
+        status: 'confirmed' as never,
+        executionResult: priorResult as never,
+      }),
+      agent: makeAgent(),
+      tool: makeTool({ handler: handlerSpy }),
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+    })
+    expect(result.ok).toBe(true)
+    expect(result.executionResult).toEqual(priorResult)
+    expect(handlerSpy).not.toHaveBeenCalled()
+    expect(repo.setStatus).not.toHaveBeenCalled()
+    expect(emitEvent).not.toHaveBeenCalled()
+  })
+
+  it('carries partial-stale failedRecords[] onto the confirmed row', async () => {
+    const repo = makeRepoStub(makeAction())
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const failed = [
+      { recordId: 'r-2', error: { code: 'stale_version', message: 'x' } },
+    ]
+    const result = await executePendingActionConfirm({
+      action: makeAction(),
+      agent: makeAgent(),
+      tool: makeTool(),
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+      failedRecords: failed,
+    })
+    expect(result.ok).toBe(true)
+    const firstCallExtra = repo.setStatus.mock.calls[0][3]
+    expect(firstCallExtra).toMatchObject({ failedRecords: failed })
+  })
+
+  it('Step 5.18 — batch handler returns per-record failures: merged into row.failedRecords[]', async () => {
+    const repo = makeRepoStub(makeAction({ toolName: 'catalog.bulk_update_products' }))
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const batchTool = makeTool({
+      name: 'catalog.bulk_update_products',
+      handler: async () => ({
+        commandName: 'catalog.products.update',
+        records: [
+          { recordId: 'p-1', status: 'updated', before: { title: 'A' }, after: { title: 'A*' } },
+          { recordId: 'p-2', status: 'updated', before: { title: 'B' }, after: { title: 'B*' } },
+          {
+            recordId: 'p-3',
+            status: 'failed',
+            before: { title: 'C' },
+            after: null,
+            error: { code: 'command_failed', message: 'db constraint' },
+          },
+        ],
+        failedRecordIds: ['p-3'],
+      }),
+    })
+    const result = await executePendingActionConfirm({
+      action: makeAction({ toolName: 'catalog.bulk_update_products' }),
+      agent: makeAgent(),
+      tool: batchTool,
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+    })
+    expect(result.ok).toBe(true)
+    expect(repo.setStatus.mock.calls.map((call) => call[1])).toEqual([
+      'confirmed',
+      'executing',
+      'confirmed',
+    ])
+    const finalExtra = repo.setStatus.mock.calls[2][3] as Record<string, unknown>
+    expect(finalExtra.failedRecords).toEqual([
+      { recordId: 'p-3', error: { code: 'command_failed', message: 'db constraint' } },
+    ])
+    expect(repo.current.failedRecords).toEqual([
+      { recordId: 'p-3', error: { code: 'command_failed', message: 'db constraint' } },
+    ])
+    expect(emitEvent).toHaveBeenCalledTimes(1)
+    const [, emittedPayload] = emitEvent.mock.calls[0] as [
+      'ai.action.confirmed',
+      AiActionConfirmedPayload,
+    ]
+    expect(emittedPayload.failedRecords).toEqual([
+      { recordId: 'p-3', error: { code: 'command_failed', message: 'db constraint' } },
+    ])
+  })
+
+  it('Step 5.18 — partial-stale + handler failure merged into one failedRecords[] list', async () => {
+    const repo = makeRepoStub(makeAction({ toolName: 'catalog.bulk_update_products' }))
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const stale = [
+      { recordId: 'p-2', error: { code: 'stale_version', message: 'x' } },
+    ]
+    const batchTool = makeTool({
+      name: 'catalog.bulk_update_products',
+      handler: async () => ({
+        commandName: 'catalog.products.update',
+        records: [
+          { recordId: 'p-1', status: 'updated', before: { title: 'A' }, after: { title: 'A*' } },
+          {
+            recordId: 'p-3',
+            status: 'failed',
+            before: { title: 'C' },
+            after: null,
+            error: { code: 'command_failed', message: 'db constraint' },
+          },
+        ],
+        failedRecordIds: ['p-3'],
+      }),
+    })
+    const result = await executePendingActionConfirm({
+      action: makeAction({ toolName: 'catalog.bulk_update_products' }),
+      agent: makeAgent(),
+      tool: batchTool,
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+      failedRecords: stale,
+    })
+    expect(result.ok).toBe(true)
+    const finalExtra = repo.setStatus.mock.calls[2][3] as Record<string, unknown>
+    const merged = finalExtra.failedRecords as Array<{ recordId: string }>
+    expect(merged.map((entry) => entry.recordId).sort()).toEqual(['p-2', 'p-3'])
+  })
+
+  it('Step 5.18 — single-record success: row.failedRecords remains null', async () => {
+    const repo = makeRepoStub(makeAction())
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const result = await executePendingActionConfirm({
+      action: makeAction(),
+      agent: makeAgent(),
+      tool: makeTool(),
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+    })
+    expect(result.ok).toBe(true)
+    const finalExtra = repo.setStatus.mock.calls[2][3] as Record<string, unknown>
+    expect(finalExtra.failedRecords).toBeNull()
+  })
+})