@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-cancel.test.ts

@@ -0,0 +1,235 @@
+import type { AwilixContainer } from 'awilix'
+import {
+  executePendingActionCancel,
+  PENDING_ACTION_CANCELLED_EVENT_ID,
+  PENDING_ACTION_EXPIRED_EVENT_ID,
+} from '../pending-action-cancel'
+import type {
+  AiActionCancelledPayload,
+  AiActionExpiredPayload,
+} from '../../events'
+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 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 && 'resolvedByUserId' in extra) {
+        row.resolvedByUserId = extra.resolvedByUserId as never
+      }
+      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',
+    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('executePendingActionCancel', () => {
+  it('atomically transitions pending → cancelled and emits typed ai.action.cancelled', async () => {
+    const repo = makeRepoStub(makeAction())
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const clock = new Date('2026-04-18T10:05:00.000Z')
+
+    const result = await executePendingActionCancel({
+      action: makeAction(),
+      ctx: makeCtx(),
+      reason: 'Customer asked to abort',
+      repo: repo as unknown as never,
+      emitEvent,
+      now: clock,
+    })
+
+    expect(result.status).toBe('cancelled')
+    expect(result.row.status).toBe('cancelled')
+    expect(repo.setStatus).toHaveBeenCalledTimes(1)
+    const [, nextStatus, , extra] = repo.setStatus.mock.calls[0]
+    expect(nextStatus).toBe('cancelled')
+    expect(extra).toMatchObject({
+      resolvedByUserId: 'user-1',
+      executionResult: {
+        error: { code: 'cancelled_by_user', message: 'Customer asked to abort' },
+      },
+    })
+    expect(emitEvent).toHaveBeenCalledTimes(1)
+    const [emittedId, emittedPayload] = emitEvent.mock.calls[0] as [
+      'ai.action.cancelled',
+      AiActionCancelledPayload,
+    ]
+    expect(emittedId).toBe(PENDING_ACTION_CANCELLED_EVENT_ID)
+    expect(emittedPayload).toMatchObject({
+      pendingActionId: 'pa_1',
+      agentId: 'catalog.merchandising_assistant',
+      toolName: 'catalog.update_product',
+      status: 'cancelled',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      userId: 'user-1',
+      resolvedByUserId: 'user-1',
+      reason: 'Customer asked to abort',
+      executionResult: {
+        error: { code: 'cancelled_by_user', message: 'Customer asked to abort' },
+      },
+    })
+    expect(typeof emittedPayload.resolvedAt).toBe('string')
+  })
+
+  it('defaults to "Cancelled by user" message when no reason is supplied', async () => {
+    const repo = makeRepoStub(makeAction())
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const clock = new Date('2026-04-18T10:05:00.000Z')
+
+    const result = await executePendingActionCancel({
+      action: makeAction(),
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+      now: clock,
+    })
+
+    expect(result.status).toBe('cancelled')
+    const [, , , extra] = repo.setStatus.mock.calls[0]
+    expect(extra).toMatchObject({
+      executionResult: {
+        error: { code: 'cancelled_by_user', message: 'Cancelled by user' },
+      },
+    })
+    const [, payload] = emitEvent.mock.calls[0] as [string, AiActionCancelledPayload]
+    expect(payload.reason).toBeUndefined()
+  })
+
+  it('idempotent: already-cancelled action returns row without calling setStatus or emitting', async () => {
+    const cancelledAction = makeAction({ status: 'cancelled' as never })
+    const repo = makeRepoStub(cancelledAction)
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+
+    const result = await executePendingActionCancel({
+      action: cancelledAction,
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+    })
+
+    expect(result.status).toBe('cancelled')
+    expect(result.row).toBe(cancelledAction)
+    expect(repo.setStatus).not.toHaveBeenCalled()
+    expect(emitEvent).not.toHaveBeenCalled()
+  })
+
+  it('expired short-circuit: flips to expired and emits typed ai.action.expired', async () => {
+    const expiredAction = makeAction({
+      expiresAt: new Date('2020-01-01T00:00:00.000Z'),
+    })
+    const repo = makeRepoStub(expiredAction)
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const clock = new Date('2026-04-18T10:05:00.000Z')
+
+    const result = await executePendingActionCancel({
+      action: expiredAction,
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+      now: clock,
+    })
+
+    expect(result.status).toBe('expired')
+    expect(result.row.status).toBe('expired')
+    expect(repo.setStatus).toHaveBeenCalledTimes(1)
+    const [, nextStatus] = repo.setStatus.mock.calls[0]
+    expect(nextStatus).toBe('expired')
+    expect(emitEvent).toHaveBeenCalledTimes(1)
+    const [emittedId, emittedPayload] = emitEvent.mock.calls[0] as [
+      'ai.action.expired',
+      AiActionExpiredPayload,
+    ]
+    expect(emittedId).toBe(PENDING_ACTION_EXPIRED_EVENT_ID)
+    expect(emittedPayload).toMatchObject({
+      pendingActionId: 'pa_1',
+      agentId: 'catalog.merchandising_assistant',
+      toolName: 'catalog.update_product',
+      status: 'expired',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      userId: 'user-1',
+      resolvedByUserId: null,
+    })
+    expect(typeof emittedPayload.resolvedAt).toBe('string')
+    expect(typeof emittedPayload.expiresAt).toBe('string')
+    expect(typeof emittedPayload.expiredAt).toBe('string')
+  })
+
+  it('swallows emit-event errors without failing the cancel', async () => {
+    const repo = makeRepoStub(makeAction())
+    const emitEvent = jest.fn().mockRejectedValue(new Error('bus down'))
+    const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    const clock = new Date('2026-04-18T10:05:00.000Z')
+
+    const result = await executePendingActionCancel({
+      action: makeAction(),
+      ctx: makeCtx(),
+      repo: repo as unknown as never,
+      emitEvent,
+      now: clock,
+    })
+
+    expect(result.status).toBe('cancelled')
+    expect(consoleWarnSpy).toHaveBeenCalled()
+    consoleWarnSpy.mockRestore()
+  })
+})

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

@@ -0,0 +1,148 @@
+import {
+  serializePendingActionForClient,
+  type SerializablePendingActionRow,
+  type SerializedPendingAction,
+} from '../pending-action-client'
+
+function makeRow(
+  overrides: Partial<SerializablePendingActionRow> = {},
+): SerializablePendingActionRow {
+  const base: SerializablePendingActionRow = {
+    id: 'pa_123',
+    agentId: 'catalog.merchandising_assistant',
+    toolName: 'catalog.update_product',
+    status: 'pending',
+    fieldDiff: [{ field: 'title', before: 'Old', after: 'New' }],
+    records: null,
+    failedRecords: null,
+    sideEffectsSummary: null,
+    attachmentIds: [],
+    targetEntityType: 'product',
+    targetRecordId: 'prod_1',
+    recordVersion: 'v1',
+    queueMode: 'inline',
+    executionResult: null,
+    createdAt: new Date('2026-04-18T10:00:00.000Z'),
+    expiresAt: new Date('2026-04-18T10:15:00.000Z'),
+    resolvedAt: null,
+    resolvedByUserId: null,
+  }
+  return { ...base, ...overrides }
+}
+
+describe('serializePendingActionForClient (Step 5.7)', () => {
+  it('produces the full whitelist in the documented shape', () => {
+    const row = makeRow()
+    const out = serializePendingActionForClient(row)
+
+    const expected: SerializedPendingAction = {
+      id: 'pa_123',
+      agentId: 'catalog.merchandising_assistant',
+      toolName: 'catalog.update_product',
+      status: 'pending',
+      fieldDiff: [{ field: 'title', before: 'Old', after: 'New' }],
+      records: null,
+      failedRecords: null,
+      sideEffectsSummary: null,
+      attachmentIds: [],
+      targetEntityType: 'product',
+      targetRecordId: 'prod_1',
+      recordVersion: 'v1',
+      queueMode: 'inline',
+      executionResult: null,
+      createdAt: '2026-04-18T10:00:00.000Z',
+      expiresAt: '2026-04-18T10:15:00.000Z',
+      resolvedAt: null,
+      resolvedByUserId: null,
+    }
+    expect(out).toEqual(expected)
+  })
+
+  it('never exposes server-internal fields even when they exist on the row', () => {
+    const row = {
+      ...makeRow(),
+      // Simulate the real MikroORM entity shape with internal fields present.
+      normalizedInput: { secret: 'do-not-leak' },
+      createdByUserId: 'user-1',
+      idempotencyKey: 'idem_abc123',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+    } as unknown as SerializablePendingActionRow
+
+    const out = serializePendingActionForClient(row)
+
+    expect(out).not.toHaveProperty('normalizedInput')
+    expect(out).not.toHaveProperty('createdByUserId')
+    expect(out).not.toHaveProperty('idempotencyKey')
+    expect(out).not.toHaveProperty('tenantId')
+    expect(out).not.toHaveProperty('organizationId')
+  })
+
+  it('keeps the exact whitelist of keys', () => {
+    const row = makeRow()
+    const out = serializePendingActionForClient(row)
+    const keys = Object.keys(out).sort()
+    expect(keys).toEqual(
+      [
+        'agentId',
+        'attachmentIds',
+        'createdAt',
+        'executionResult',
+        'expiresAt',
+        'failedRecords',
+        'fieldDiff',
+        'id',
+        'queueMode',
+        'recordVersion',
+        'records',
+        'resolvedAt',
+        'resolvedByUserId',
+        'sideEffectsSummary',
+        'status',
+        'targetEntityType',
+        'targetRecordId',
+        'toolName',
+      ].sort(),
+    )
+  })
+
+  it('normalizes batch records + failedRecords and strips empty arrays', () => {
+    const out = serializePendingActionForClient(
+      makeRow({
+        records: [
+          {
+            recordId: 'p_1',
+            entityType: 'product',
+            label: 'SKU 1',
+            fieldDiff: [{ field: 'price', before: 10, after: 12 }],
+            recordVersion: 'v1',
+          },
+        ],
+        failedRecords: [],
+      }),
+    )
+    expect(out.records).toHaveLength(1)
+    expect(out.records?.[0]?.recordId).toBe('p_1')
+    expect(out.failedRecords).toBeNull()
+  })
+
+  it('accepts ISO strings for Date fields (round-trip safety)', () => {
+    const out = serializePendingActionForClient(
+      makeRow({
+        createdAt: '2026-01-01T00:00:00.000Z',
+        expiresAt: '2026-01-01T00:10:00.000Z',
+        resolvedAt: '2026-01-01T00:05:00.000Z',
+      }),
+    )
+    expect(out.createdAt).toBe('2026-01-01T00:00:00.000Z')
+    expect(out.expiresAt).toBe('2026-01-01T00:10:00.000Z')
+    expect(out.resolvedAt).toBe('2026-01-01T00:05:00.000Z')
+  })
+
+  it('defaults queueMode to "inline" when absent', () => {
+    const out = serializePendingActionForClient(
+      makeRow({ queueMode: undefined as unknown as SerializablePendingActionRow['queueMode'] }),
+    )
+    expect(out.queueMode).toBe('inline')
+  })
+})