@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/inbox_ops/api/proposals/[id]/replies/[replyId]/send/__tests__/route.test.ts

@@ -1,232 +0,0 @@
-/** @jest-environment node */
-
-import { POST } from '@open-mercato/core/modules/inbox_ops/api/proposals/[id]/replies/[replyId]/send/route'
-import { InboxProposal, InboxProposalAction, InboxEmail } from '@open-mercato/core/modules/inbox_ops/data/entities'
-
-const mockFindOneWithDecryption = jest.fn()
-
-jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
-  findOneWithDecryption: (...args: unknown[]) => mockFindOneWithDecryption(...args),
-}))
-
-const authResult = {
-  sub: 'user-1',
-  tenantId: 'tenant-1',
-  orgId: 'org-1',
-}
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({
-  getAuthFromRequest: jest.fn(async () => authResult),
-}))
-
-const mockEm = {
-  fork: jest.fn(),
-  flush: jest.fn(),
-}
-
-const mockContainer = {
-  resolve: jest.fn((token: string) => {
-    if (token === 'em') return mockEm
-    return null
-  }),
-}
-
-const mockEventBus = { emit: jest.fn() }
-
-const mockResendSend = jest.fn()
-
-jest.mock('resend', () => ({
-  Resend: jest.fn().mockImplementation(() => ({
-    emails: { send: (...args: unknown[]) => mockResendSend(...args) },
-  })),
-}))
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: jest.fn(async () => mockContainer),
-}))
-
-jest.mock('@open-mercato/core/modules/inbox_ops/lib/eventBus', () => ({
-  resolveOptionalEventBus: jest.fn(() => mockEventBus),
-}))
-
-jest.mock('@open-mercato/core/modules/inbox_ops/events', () => ({
-  emitInboxOpsEvent: jest.fn(),
-}))
-
-const originalEnv = process.env
-
-function makeRequest() {
-  return new Request('http://localhost/api/inbox_ops/proposals/proposal-1/replies/reply-1/send', {
-    method: 'POST',
-  })
-}
-
-function setupHappyPath() {
-  const proposal = {
-    id: 'proposal-1',
-    inboxEmailId: 'email-1',
-    isActive: true,
-  } as unknown as InboxProposal
-
-  const action = {
-    id: 'reply-1',
-    proposalId: 'proposal-1',
-    actionType: 'draft_reply',
-    status: 'executed',
-    payload: {
-      to: 'customer@example.com',
-      subject: 'Re: Order inquiry',
-      body: 'Thank you for your order.',
-    },
-    metadata: {},
-  } as unknown as InboxProposalAction
-
-  const email = {
-    id: 'email-1',
-    messageId: '<msg-123@example.com>',
-    emailReferences: ['<ref-1@example.com>'],
-  } as unknown as InboxEmail
-
-  mockFindOneWithDecryption
-    .mockResolvedValueOnce(proposal)
-    .mockResolvedValueOnce(action)
-    .mockResolvedValueOnce(email)
-
-  return { proposal, action, email }
-}
-
-describe('POST /api/inbox_ops/proposals/[id]/replies/[replyId]/send', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockEm.fork.mockReturnValue(mockEm)
-    mockEm.flush.mockResolvedValue(undefined)
-    process.env = { ...originalEnv, RESEND_API_KEY: 'test-api-key' }
-    mockResendSend.mockResolvedValue({ data: { id: 'sent-msg-1' }, error: null })
-  })
-
-  afterAll(() => {
-    process.env = originalEnv
-  })
-
-  it('sends reply and returns sentMessageId', async () => {
-    setupHappyPath()
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(200)
-    expect(payload.ok).toBe(true)
-    expect(payload.sentMessageId).toBe('sent-msg-1')
-    expect(mockResendSend).toHaveBeenCalledWith(
-      expect.objectContaining({
-        to: 'customer@example.com',
-        subject: 'Re: Order inquiry',
-        text: 'Thank you for your order.',
-        headers: expect.objectContaining({
-          'In-Reply-To': '<msg-123@example.com>',
-          'References': '<ref-1@example.com>',
-        }),
-      }),
-    )
-  })
-
-  it('returns 503 when RESEND_API_KEY is not set', async () => {
-    delete process.env.RESEND_API_KEY
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(503)
-    expect(payload.error).toContain('not configured')
-  })
-
-  it('returns 503 when email delivery is disabled', async () => {
-    process.env.OM_DISABLE_EMAIL_DELIVERY = 'true'
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(503)
-    expect(payload.error).toContain('disabled')
-
-    delete process.env.OM_DISABLE_EMAIL_DELIVERY
-  })
-
-  it('returns 404 when proposal not found', async () => {
-    mockFindOneWithDecryption.mockResolvedValueOnce(null)
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(404)
-    expect(payload.error).toContain('not found')
-  })
-
-  it('returns 404 when reply action not found', async () => {
-    const proposal = {
-      id: 'proposal-1',
-      inboxEmailId: 'email-1',
-      isActive: true,
-    } as unknown as InboxProposal
-
-    mockFindOneWithDecryption
-      .mockResolvedValueOnce(proposal)
-      .mockResolvedValueOnce(null)
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(404)
-    expect(payload.error).toContain('Reply action not found')
-  })
-
-  it('returns 409 when action not yet accepted', async () => {
-    const proposal = {
-      id: 'proposal-1',
-      inboxEmailId: 'email-1',
-      isActive: true,
-    } as unknown as InboxProposal
-
-    const action = {
-      id: 'reply-1',
-      proposalId: 'proposal-1',
-      actionType: 'draft_reply',
-      status: 'pending',
-      payload: { to: 'test@test.com', subject: 'Test', body: 'Body' },
-    } as unknown as InboxProposalAction
-
-    mockFindOneWithDecryption
-      .mockResolvedValueOnce(proposal)
-      .mockResolvedValueOnce(action)
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(409)
-    expect(payload.error).toContain('must be accepted first')
-  })
-
-  it('returns 502 when Resend fails', async () => {
-    setupHappyPath()
-    mockResendSend.mockResolvedValueOnce({
-      data: null,
-      error: { message: 'Invalid API key' },
-    })
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(502)
-    expect(payload.error).toContain('Failed to send email')
-  })
-
-  it('returns 401 when not authenticated', async () => {
-    const { getAuthFromRequest } = jest.requireMock('@open-mercato/shared/lib/auth/server') as {
-      getAuthFromRequest: jest.Mock
-    }
-    getAuthFromRequest.mockResolvedValueOnce(null)
-
-    const response = await POST(makeRequest())
-    expect(response.status).toBe(401)
-  })
-})

package/src/modules/inbox_ops/api/proposals/[id]/translate/__tests__/route.test.ts

@@ -1,173 +0,0 @@
-/** @jest-environment node */
-
-import { POST } from '@open-mercato/core/modules/inbox_ops/api/proposals/[id]/translate/route'
-
-const mockFindOneWithDecryption = jest.fn()
-const mockFindWithDecryption = jest.fn()
-
-jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
-  findOneWithDecryption: (...args: unknown[]) => mockFindOneWithDecryption(...args),
-  findWithDecryption: (...args: unknown[]) => mockFindWithDecryption(...args),
-}))
-
-const mockTranslateProposalContent = jest.fn()
-jest.mock('@open-mercato/core/modules/inbox_ops/lib/translationProvider', () => ({
-  translateProposalContent: (...args: unknown[]) => mockTranslateProposalContent(...args),
-}))
-
-const authResult = {
-  sub: 'user-1',
-  tenantId: 'tenant-1',
-  orgId: 'org-1',
-}
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({
-  getAuthFromRequest: jest.fn(async () => authResult),
-}))
-
-const mockFlush = jest.fn()
-const mockEm = { fork: jest.fn(), flush: mockFlush }
-
-const mockContainer = {
-  resolve: jest.fn((token: string) => {
-    if (token === 'em') return mockEm
-    return null
-  }),
-}
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: jest.fn(async () => mockContainer),
-}))
-
-function makeRequest(proposalId: string, body: Record<string, unknown>) {
-  return new Request(`http://localhost/api/inbox_ops/proposals/${proposalId}/translate`, {
-    method: 'POST',
-    body: JSON.stringify(body),
-    headers: { 'Content-Type': 'application/json' },
-  })
-}
-
-describe('POST /api/inbox_ops/proposals/[id]/translate', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockEm.fork.mockReturnValue(mockEm)
-    mockFlush.mockResolvedValue(undefined)
-    mockFindWithDecryption.mockResolvedValue([])
-  })
-
-  it('returns cached translation when available', async () => {
-    const proposal = {
-      id: 'proposal-1',
-      summary: 'Order for widgets',
-      workingLanguage: 'en',
-      translations: {
-        de: {
-          summary: 'Bestellung für Widgets',
-          actions: { 'a-1': 'Bestellung erstellen' },
-          translatedAt: '2026-01-01T00:00:00Z',
-        },
-      },
-      isActive: true,
-    }
-    mockFindOneWithDecryption.mockResolvedValueOnce(proposal)
-
-    const res = await POST(makeRequest('proposal-1', { targetLocale: 'de' }))
-    const json = await res.json()
-
-    expect(res.status).toBe(200)
-    expect(json.cached).toBe(true)
-    expect(json.translation.summary).toBe('Bestellung für Widgets')
-    expect(mockTranslateProposalContent).not.toHaveBeenCalled()
-  })
-
-  it('calls LLM translation when no cache exists', async () => {
-    const proposal = {
-      id: 'proposal-1',
-      summary: 'Order for widgets',
-      workingLanguage: 'en',
-      translations: null,
-      isActive: true,
-    }
-    mockFindOneWithDecryption.mockResolvedValueOnce(proposal)
-
-    const actions = [
-      { id: 'a-1', description: 'Create order', sortOrder: 0 },
-      { id: 'a-2', description: 'Create contact', sortOrder: 1 },
-    ]
-    mockFindWithDecryption.mockResolvedValueOnce(actions)
-
-    mockTranslateProposalContent.mockResolvedValueOnce({
-      summary: 'Zamówienie na widgety',
-      actions: { 'a-1': 'Utwórz zamówienie', 'a-2': 'Utwórz kontakt' },
-    })
-
-    const res = await POST(makeRequest('proposal-1', { targetLocale: 'pl' }))
-    const json = await res.json()
-
-    expect(res.status).toBe(200)
-    expect(json.cached).toBe(false)
-    expect(json.translation.summary).toBe('Zamówienie na widgety')
-    expect(mockTranslateProposalContent).toHaveBeenCalledWith({
-      summary: 'Order for widgets',
-      actionDescriptions: { 'a-1': 'Create order', 'a-2': 'Create contact' },
-      sourceLanguage: 'en',
-      targetLocale: 'pl',
-    })
-    expect(mockFlush).toHaveBeenCalled()
-  })
-
-  it('returns 400 when target locale matches working language', async () => {
-    const proposal = {
-      id: 'proposal-1',
-      summary: 'Order for widgets',
-      workingLanguage: 'de',
-      translations: null,
-      isActive: true,
-    }
-    mockFindOneWithDecryption.mockResolvedValueOnce(proposal)
-
-    const res = await POST(makeRequest('proposal-1', { targetLocale: 'de' }))
-    const json = await res.json()
-
-    expect(res.status).toBe(400)
-    expect(json.error).toContain('already in the requested language')
-  })
-
-  it('returns 404 when proposal not found', async () => {
-    mockFindOneWithDecryption.mockResolvedValueOnce(null)
-
-    const res = await POST(makeRequest('missing-id', { targetLocale: 'de' }))
-    expect(res.status).toBe(404)
-  })
-
-  it('returns 400 for invalid target locale', async () => {
-    const proposal = {
-      id: 'proposal-1',
-      summary: 'Order',
-      workingLanguage: 'en',
-      translations: null,
-      isActive: true,
-    }
-    mockFindOneWithDecryption.mockResolvedValueOnce(proposal)
-
-    const res = await POST(makeRequest('proposal-1', { targetLocale: 'fr' }))
-    expect(res.status).toBe(400)
-  })
-
-  it('treats null workingLanguage as "en" for same-language check', async () => {
-    const proposal = {
-      id: 'proposal-1',
-      summary: 'Order',
-      workingLanguage: null,
-      translations: null,
-      isActive: true,
-    }
-    mockFindOneWithDecryption.mockResolvedValueOnce(proposal)
-
-    const res = await POST(makeRequest('proposal-1', { targetLocale: 'en' }))
-    const json = await res.json()
-
-    expect(res.status).toBe(400)
-    expect(json.error).toContain('already in the requested language')
-  })
-})

package/src/modules/inbox_ops/api/proposals/__tests__/route.test.ts

@@ -1,185 +0,0 @@
-/** @jest-environment node */
-
-import { GET } from '@open-mercato/core/modules/inbox_ops/api/proposals/route'
-import { InboxProposal, InboxEmail, InboxProposalAction, InboxDiscrepancy } from '@open-mercato/core/modules/inbox_ops/data/entities'
-
-const mockFindAndCountWithDecryption = jest.fn()
-const mockFindWithDecryption = jest.fn()
-
-jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
-  findAndCountWithDecryption: (...args: unknown[]) => mockFindAndCountWithDecryption(...args),
-  findWithDecryption: (...args: unknown[]) => mockFindWithDecryption(...args),
-}))
-
-jest.mock('@open-mercato/shared/lib/db/escapeLikePattern', () => ({
-  escapeLikePattern: (value: string) => value.replace(/\\/g, '\\\\').replace(/[%_]/g, '\\$&'),
-}))
-
-const authResult = {
-  sub: 'user-1',
-  tenantId: 'tenant-1',
-  orgId: 'org-1',
-}
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({
-  getAuthFromRequest: jest.fn(async () => authResult),
-}))
-
-const mockEm = { fork: jest.fn() }
-
-const mockContainer = {
-  resolve: jest.fn((token: string) => {
-    if (token === 'em') return mockEm
-    return null
-  }),
-}
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: jest.fn(async () => mockContainer),
-}))
-
-function makeRequest(params?: Record<string, string>) {
-  const url = new URL('http://localhost/api/inbox_ops/proposals')
-  if (params) {
-    for (const [key, value] of Object.entries(params)) {
-      url.searchParams.set(key, value)
-    }
-  }
-  return new Request(url.toString(), { method: 'GET' })
-}
-
-describe('GET /api/inbox_ops/proposals', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockEm.fork.mockReturnValue(mockEm)
-    mockFindWithDecryption.mockResolvedValue([])
-  })
-
-  it('returns paginated proposal list', async () => {
-    const proposals = [
-      {
-        id: 'proposal-1',
-        inboxEmailId: 'email-1',
-        summary: 'Order for widgets',
-        status: 'pending',
-        createdAt: new Date('2026-02-18'),
-      },
-    ]
-    mockFindAndCountWithDecryption.mockResolvedValueOnce([proposals, 1])
-
-    const email = {
-      id: 'email-1',
-      subject: 'Order request',
-      forwardedByName: 'John Doe',
-      receivedAt: new Date('2026-02-18'),
-    }
-    mockFindWithDecryption
-      .mockResolvedValueOnce([email])
-      .mockResolvedValueOnce([])
-      .mockResolvedValueOnce([])
-
-    const response = await GET(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(200)
-    expect(payload.items).toHaveLength(1)
-    expect(payload.total).toBe(1)
-    expect(payload.items[0].emailSubject).toBe('Order request')
-    expect(payload.items[0].emailFrom).toBe('John Doe')
-    expect(payload.items[0].actionCount).toBe(0)
-  })
-
-  it('filters by status when provided', async () => {
-    mockFindAndCountWithDecryption.mockResolvedValueOnce([[], 0])
-
-    await GET(makeRequest({ status: 'pending' }))
-
-    expect(mockFindAndCountWithDecryption).toHaveBeenCalledWith(
-      mockEm,
-      InboxProposal,
-      expect.objectContaining({
-        status: 'pending',
-        isActive: true,
-        deletedAt: null,
-      }),
-      expect.any(Object),
-      expect.any(Object),
-    )
-  })
-
-  it('escapes LIKE wildcards in search', async () => {
-    mockFindAndCountWithDecryption.mockResolvedValueOnce([[], 0])
-
-    await GET(makeRequest({ search: '100%_off' }))
-
-    expect(mockFindAndCountWithDecryption).toHaveBeenCalledWith(
-      mockEm,
-      InboxProposal,
-      expect.objectContaining({
-        summary: { $ilike: '%100\\%\\_off%' },
-      }),
-      expect.any(Object),
-      expect.any(Object),
-    )
-  })
-
-  it('passes pagination parameters', async () => {
-    mockFindAndCountWithDecryption.mockResolvedValueOnce([[], 0])
-
-    await GET(makeRequest({ page: '2', pageSize: '10' }))
-
-    expect(mockFindAndCountWithDecryption).toHaveBeenCalledWith(
-      mockEm,
-      InboxProposal,
-      expect.any(Object),
-      expect.objectContaining({
-        limit: 10,
-        offset: 10,
-      }),
-      expect.any(Object),
-    )
-  })
-
-  it('includes tenant scope in sub-queries', async () => {
-    const proposals = [{ id: 'proposal-1', inboxEmailId: 'email-1', summary: 'Test', status: 'pending', createdAt: new Date() }]
-    mockFindAndCountWithDecryption.mockResolvedValueOnce([proposals, 1])
-    mockFindWithDecryption
-      .mockResolvedValueOnce([])
-      .mockResolvedValueOnce([])
-      .mockResolvedValueOnce([])
-
-    await GET(makeRequest())
-
-    expect(mockFindWithDecryption).toHaveBeenCalledWith(
-      mockEm,
-      InboxProposalAction,
-      expect.objectContaining({
-        organizationId: 'org-1',
-        tenantId: 'tenant-1',
-        deletedAt: null,
-      }),
-      expect.any(Object),
-      expect.any(Object),
-    )
-    expect(mockFindWithDecryption).toHaveBeenCalledWith(
-      mockEm,
-      InboxDiscrepancy,
-      expect.objectContaining({
-        organizationId: 'org-1',
-        tenantId: 'tenant-1',
-      }),
-      expect.any(Object),
-      expect.any(Object),
-    )
-  })
-
-  it('returns 401 when not authenticated', async () => {
-    const { getAuthFromRequest } = jest.requireMock('@open-mercato/shared/lib/auth/server') as {
-      getAuthFromRequest: jest.Mock
-    }
-    getAuthFromRequest.mockResolvedValueOnce(null)
-
-    const response = await GET(makeRequest())
-    expect(response.status).toBe(401)
-  })
-})