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

package/src/modules/inbox_ops/lib/__tests__/contactMatcher.test.ts

@@ -1,158 +0,0 @@
-/** @jest-environment node */
-
-import { matchContacts } from '../contactMatcher'
-
-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 mockEm = {} as any
-const MockCustomerEntity = class {} as any
-
-const scope = {
-  tenantId: 'tenant-1',
-  organizationId: 'org-1',
-}
-
-const deps = { customerEntityClass: MockCustomerEntity }
-
-describe('matchContacts', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockFindOneWithDecryption.mockResolvedValue(null)
-    mockFindWithDecryption.mockResolvedValue([])
-  })
-
-  it('returns exact match on email with confidence 1.0', async () => {
-    const contact = {
-      id: 'contact-1',
-      kind: 'person',
-      displayName: 'John Doe',
-      primaryEmail: 'john@example.com',
-    }
-    mockFindOneWithDecryption.mockResolvedValueOnce(contact)
-
-    const results = await matchContacts(mockEm, [
-      { name: 'John Doe', email: 'john@example.com', role: 'buyer' },
-    ], scope, deps)
-
-    expect(results).toHaveLength(1)
-    expect(results[0].match).toEqual({
-      contactId: 'contact-1',
-      contactType: 'person',
-      contactName: 'John Doe',
-      confidence: 1.0,
-    })
-    expect(results[0].participant.matchedContactId).toBe('contact-1')
-  })
-
-  it('returns company type for company entities', async () => {
-    const contact = {
-      id: 'company-1',
-      kind: 'company',
-      displayName: 'Acme Corp',
-      primaryEmail: 'info@acme.com',
-    }
-    mockFindOneWithDecryption.mockResolvedValueOnce(contact)
-
-    const results = await matchContacts(mockEm, [
-      { name: 'Acme Corp', email: 'info@acme.com', role: 'buyer' },
-    ], scope, deps)
-
-    expect(results[0].match?.contactType).toBe('company')
-    expect(results[0].match?.contactId).toBe('company-1')
-  })
-
-  it('falls back to fuzzy name match with lower confidence', async () => {
-    mockFindOneWithDecryption.mockResolvedValueOnce(null) // no email match
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { id: 'contact-2', kind: 'person', displayName: 'John Doe', createdAt: new Date() },
-      { id: 'contact-3', kind: 'person', displayName: 'Jane Smith', createdAt: new Date() },
-    ])
-
-    const results = await matchContacts(mockEm, [
-      { name: 'John Doe', email: 'unknown@example.com', role: 'buyer' },
-    ], scope, deps)
-
-    expect(results).toHaveLength(1)
-    expect(results[0].match).not.toBeNull()
-    expect(results[0].match?.contactId).toBe('contact-2')
-    expect(results[0].match?.confidence).toBe(1.0) // exact name match
-  })
-
-  it('returns null match when no contact found', async () => {
-    mockFindOneWithDecryption.mockResolvedValueOnce(null)
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { id: 'contact-99', kind: 'person', displayName: 'Completely Different', createdAt: new Date() },
-    ])
-
-    const results = await matchContacts(mockEm, [
-      { name: 'John Doe', email: 'notfound@example.com', role: 'buyer' },
-    ], scope, deps)
-
-    expect(results).toHaveLength(1)
-    expect(results[0].match).toBeNull()
-    expect(results[0].participant.matchedContactId).toBeNull()
-  })
-
-  it('handles participants with no email and no name', async () => {
-    const results = await matchContacts(mockEm, [
-      { name: '', email: '', role: 'other' },
-    ], scope, deps)
-
-    expect(results).toHaveLength(1)
-    expect(results[0].match).toBeNull()
-    expect(mockFindOneWithDecryption).not.toHaveBeenCalled()
-    expect(mockFindWithDecryption).not.toHaveBeenCalled()
-  })
-
-  it('handles multiple participants in batch', async () => {
-    const contact1 = { id: 'c-1', kind: 'person', displayName: 'Alice', primaryEmail: 'alice@example.com' }
-    mockFindOneWithDecryption
-      .mockResolvedValueOnce(contact1)  // first participant - email match
-      .mockResolvedValueOnce(null)      // second participant - no match
-
-    mockFindWithDecryption.mockResolvedValueOnce([]) // no fuzzy results for Bob
-
-    const results = await matchContacts(mockEm, [
-      { name: 'Alice', email: 'alice@example.com', role: 'buyer' },
-      { name: 'Bob', email: 'bob@example.com', role: 'seller' },
-    ], scope, deps)
-
-    expect(results).toHaveLength(2)
-    expect(results[0].match?.contactId).toBe('c-1')
-    expect(results[1].match).toBeNull()
-  })
-
-  it('matches by name prefix with 0.9 confidence', async () => {
-    mockFindOneWithDecryption.mockResolvedValueOnce(null)
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { id: 'c-1', kind: 'person', displayName: 'John Doe Jr.', createdAt: new Date() },
-    ])
-
-    const results = await matchContacts(mockEm, [
-      { name: 'John Doe', email: '', role: 'buyer' },
-    ], scope, deps)
-
-    expect(results[0].match).not.toBeNull()
-    // "John Doe Jr." starts with "John Doe" - score should be 0.9
-    // But since 'john doe jr.' includes 'john doe' and vice versa test approach
-    expect(results[0].match?.confidence).toBeGreaterThanOrEqual(0.7)
-  })
-
-  it('skips fuzzy match for very short names', async () => {
-    mockFindOneWithDecryption.mockResolvedValueOnce(null)
-
-    const results = await matchContacts(mockEm, [
-      { name: 'A', email: '', role: 'other' },
-    ], scope, deps)
-
-    expect(results[0].match).toBeNull()
-    // Name is only 1 char — too short for fuzzy search
-    expect(mockFindWithDecryption).not.toHaveBeenCalled()
-  })
-})

package/src/modules/inbox_ops/lib/__tests__/emailParser.test.ts

@@ -1,191 +0,0 @@
-/** @jest-environment node */
-
-import { parseInboundEmail } from '../emailParser'
-
-describe('parseInboundEmail', () => {
-  it('parses basic email fields', () => {
-    const result = parseInboundEmail({
-      from: 'John Doe <john@example.com>',
-      to: 'ops@inbox.mercato.local',
-      subject: 'New order request',
-      text: 'Please create an order for 10 widgets.',
-      messageId: '<msg-001@example.com>',
-    })
-
-    expect(result.from).toEqual({ name: 'John Doe', email: 'john@example.com' })
-    expect(result.subject).toBe('New order request')
-    expect(result.messageId).toBe('<msg-001@example.com>')
-    expect(result.cleanedText).toContain('Please create an order')
-    expect(result.contentHash).toBeTruthy()
-    expect(typeof result.contentHash).toBe('string')
-  })
-
-  it('handles missing subject with fallback', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Some text',
-    })
-
-    expect(result.subject).toBe('(no subject)')
-  })
-
-  it('parses email address without display name', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Hello',
-    })
-
-    expect(result.from).toEqual({ email: 'john@example.com' })
-    expect(result.from.name).toBeUndefined()
-  })
-
-  it('strips HTML to extract text when no plain text provided', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      html: '<p>Hello <b>World</b></p><style>.foo{}</style><script>alert(1)</script>',
-    })
-
-    expect(result.cleanedText).toContain('Hello World')
-    expect(result.cleanedText).not.toContain('<p>')
-    expect(result.cleanedText).not.toContain('<style>')
-    expect(result.cleanedText).not.toContain('alert')
-  })
-
-  it('strips signatures from email body', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Please place the order.\n\n--\nJohn Doe\nSales Manager',
-    })
-
-    expect(result.cleanedText).toContain('Please place the order')
-    expect(result.cleanedText).not.toContain('Sales Manager')
-  })
-
-  it('strips "Sent from" signature patterns', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Order confirmed.\n\nSent from my iPhone',
-    })
-
-    expect(result.cleanedText).toContain('Order confirmed')
-    expect(result.cleanedText).not.toContain('Sent from')
-  })
-
-  it('strips quoted replies', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Yes, confirmed.\n\nOn Jan 15, 2026, Alice wrote:\n> Please confirm your order.\n> Regards,\n> Alice',
-    })
-
-    expect(result.cleanedText).toContain('Yes, confirmed')
-    expect(result.cleanedText).not.toContain('Please confirm your order')
-  })
-
-  it('generates consistent content hash for same input', () => {
-    const payload = {
-      from: 'john@example.com',
-      subject: 'Order',
-      text: 'Some content here',
-    }
-
-    const result1 = parseInboundEmail(payload)
-    const result2 = parseInboundEmail(payload)
-
-    expect(result1.contentHash).toBe(result2.contentHash)
-    expect(result1.contentHash).toHaveLength(64) // SHA-256 hex
-  })
-
-  it('generates different hashes for different content', () => {
-    const result1 = parseInboundEmail({ from: 'a@b.com', subject: 'A', text: 'Hello' })
-    const result2 = parseInboundEmail({ from: 'a@b.com', subject: 'B', text: 'Hello' })
-
-    expect(result1.contentHash).not.toBe(result2.contentHash)
-  })
-
-  it('handles empty body gracefully', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      subject: 'Empty',
-    })
-
-    expect(result.cleanedText).toBe('')
-    expect(result.threadMessages).toHaveLength(1)
-    expect(result.rawText).toBeNull()
-    expect(result.rawHtml).toBeNull()
-  })
-
-  it('parses multiple recipients', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      to: ['ops@inbox.mercato.local', 'Alice <alice@example.com>'],
-      text: 'Hello',
-    })
-
-    expect(result.to).toHaveLength(2)
-    expect(result.to[0].email).toBe('ops@inbox.mercato.local')
-    expect(result.to[1]).toEqual({ name: 'Alice', email: 'alice@example.com' })
-  })
-
-  it('preserves raw text and html', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Raw text content',
-      html: '<p>Raw HTML</p>',
-    })
-
-    expect(result.rawText).toBe('Raw text content')
-    expect(result.rawHtml).toBe('<p>Raw HTML</p>')
-  })
-
-  it('parses references as array', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Hello',
-      references: '<ref-1@example.com> <ref-2@example.com>',
-      inReplyTo: '<ref-2@example.com>',
-      replyTo: 'reply@example.com',
-    })
-
-    expect(result.references).toEqual(['<ref-1@example.com>', '<ref-2@example.com>'])
-    expect(result.inReplyTo).toBe('<ref-2@example.com>')
-    expect(result.replyTo).toBe('reply@example.com')
-  })
-
-  it('splits forwarded message threads', () => {
-    const text = [
-      'Please process this order.',
-      '',
-      '---------- Forwarded message ----------',
-      'From: Alice <alice@example.com>',
-      '',
-      'We need 100 units of Widget A.',
-    ].join('\n')
-
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text,
-    })
-
-    expect(result.threadMessages.length).toBeGreaterThanOrEqual(1)
-    expect(result.threadMessages[0].from.email).toBe('john@example.com')
-  })
-
-  it('normalizes whitespace', () => {
-    const result = parseInboundEmail({
-      from: 'john@example.com',
-      text: 'Line 1\r\nLine 2\r\n\r\n\r\n\r\nLine 3',
-    })
-
-    expect(result.cleanedText).not.toContain('\r')
-    expect(result.cleanedText).not.toMatch(/\n{3,}/)
-  })
-
-  it('handles quoted display names', () => {
-    const result = parseInboundEmail({
-      from: '"Doe, John" <john@example.com>',
-      text: 'Hello',
-    })
-
-    expect(result.from).toEqual({ name: 'Doe, John', email: 'john@example.com' })
-  })
-})