@open-mercato/tillio 0.7.1-develop.7176.1.d229567a50

package/src/modules/tillio/__tests__/health.test.ts

@@ -0,0 +1,122 @@
+import { createTillioEnvironmentHealthCheck } from '../lib/health'
+import { createTillioClient } from '../lib/client'
+import { TILLIO_ENVIRONMENT_IDENTITY_INTEGRATION_ID } from '../lib/environment'
+
+jest.mock('../lib/client', () => ({
+  createTillioClient: jest.fn(),
+}))
+
+const createTillioClientMock = createTillioClient as jest.MockedFunction<typeof createTillioClient>
+
+const scope = { tenantId: 'tn', organizationId: 'org' }
+const env = { apiUrl: 'https://x.example.com', apiKey: 'k' }
+
+function mockPlugins(getPlugins = jest.fn().mockResolvedValue({ plugins: [] })) {
+  createTillioClientMock.mockReturnValue({ getPlugins } as unknown as ReturnType<typeof createTillioClient>)
+  return getPlugins
+}
+
+function fakeStore(initial: Record<string, Record<string, unknown> | null> = {}) {
+  const store: Record<string, Record<string, unknown> | null> = { ...initial }
+  return {
+    store,
+    service: {
+      getRaw: jest.fn(async (id: string) => store[id] ?? null),
+      save: jest.fn(async (id: string, credentials: Record<string, unknown>) => {
+        store[id] = credentials
+      }),
+    },
+  }
+}
+
+describe('createTillioEnvironmentHealthCheck.check', () => {
+  beforeEach(() => {
+    createTillioClientMock.mockReset()
+  })
+
+  it('generates and persists tenantSystemId when missing, then reports healthy', async () => {
+    const probe = mockPlugins()
+    const { service, store } = fakeStore()
+    const health = createTillioEnvironmentHealthCheck({ credentialsService: service })
+
+    const res = await health.check({ ...env }, scope)
+
+    expect(service.save).toHaveBeenCalledWith(
+      TILLIO_ENVIRONMENT_IDENTITY_INTEGRATION_ID,
+      { tenantSystemId: expect.stringMatching(/^OM-/) },
+      scope,
+    )
+    expect(store.tillio).toBeUndefined()
+    expect(probe).toHaveBeenCalledWith('test_connection')
+    expect(res.status).toBe('healthy')
+  })
+
+  it('reuses an existing tenantSystemId without re-saving', async () => {
+    mockPlugins()
+    const { service } = fakeStore({
+      [TILLIO_ENVIRONMENT_IDENTITY_INTEGRATION_ID]: { tenantSystemId: 'OM-existing' },
+    })
+    const health = createTillioEnvironmentHealthCheck({ credentialsService: service })
+
+    const res = await health.check({ ...env }, scope)
+
+    expect(service.save).not.toHaveBeenCalled()
+    expect(createTillioClientMock).toHaveBeenCalledWith(expect.objectContaining({ tenantSystemId: 'OM-existing' }))
+    expect(res.status).toBe('healthy')
+  })
+
+  it('adopts an identity left in the credentials record instead of minting a new one', async () => {
+    mockPlugins()
+    const { service } = fakeStore()
+    const health = createTillioEnvironmentHealthCheck({ credentialsService: service })
+
+    const res = await health.check({ ...env, tenantSystemId: 'OM-legacy' }, scope)
+
+    expect(service.save).toHaveBeenCalledWith(
+      TILLIO_ENVIRONMENT_IDENTITY_INTEGRATION_ID,
+      { tenantSystemId: 'OM-legacy' },
+      scope,
+    )
+    expect(createTillioClientMock).toHaveBeenCalledWith(expect.objectContaining({ tenantSystemId: 'OM-legacy' }))
+    expect(res.status).toBe('healthy')
+  })
+
+  it('keeps the identity when the credentials record is saved without it', async () => {
+    mockPlugins()
+    const { service } = fakeStore({
+      [TILLIO_ENVIRONMENT_IDENTITY_INTEGRATION_ID]: { tenantSystemId: 'OM-kept' },
+    })
+    const health = createTillioEnvironmentHealthCheck({ credentialsService: service })
+
+    // What the integration form writes back: the schema fields only.
+    const res = await health.check({ apiUrl: env.apiUrl, apiKey: 'rotated' }, scope)
+
+    expect(service.save).not.toHaveBeenCalled()
+    expect(createTillioClientMock).toHaveBeenCalledWith(expect.objectContaining({ tenantSystemId: 'OM-kept' }))
+    expect(res.status).toBe('healthy')
+  })
+
+  it('reports unhealthy when getPlugins fails', async () => {
+    mockPlugins(jest.fn().mockRejectedValue(new Error('401 unauthorized')))
+    const { service } = fakeStore({
+      [TILLIO_ENVIRONMENT_IDENTITY_INTEGRATION_ID]: { tenantSystemId: 'OM-x' },
+    })
+    const health = createTillioEnvironmentHealthCheck({ credentialsService: service })
+
+    const res = await health.check({ ...env }, scope)
+
+    expect(res.status).toBe('unhealthy')
+    expect(res.message).toContain('401')
+  })
+
+  it('reports unhealthy for an incomplete environment without touching Tillio', async () => {
+    const { service } = fakeStore()
+    const health = createTillioEnvironmentHealthCheck({ credentialsService: service })
+
+    const res = await health.check({ apiUrl: 'https://x.example.com' }, scope)
+
+    expect(res.status).toBe('unhealthy')
+    expect(service.save).not.toHaveBeenCalled()
+    expect(createTillioClientMock).not.toHaveBeenCalled()
+  })
+})

package/src/modules/tillio/__tests__/normalizer.test.ts

@@ -0,0 +1,143 @@
+import { mapStatus, normalizeTillioCall } from '../lib/normalizer'
+
+const context = { operatorId: 'ringostat-1', plugin: 'Ringostat' as const }
+
+const answeredCall = {
+  id: 'pl5_-id1235453.9876543',
+  date: '2026-05-26T14:07:23+0200',
+  type: 'OUT',
+  caller: '48579771838',
+  destination: '48726861925',
+  status: 'ANSWERED',
+  waitTime: '10',
+  billSec: '7',
+  extraFields: {
+    caller: '"itrixcom_Kontakt" <itrixcom_Kontakt>',
+    has_recording: '1',
+    recording: 'https://app.ringostat.com/recordings/pl5_-1779797243.25187642.wav?token=fajny_token',
+    call_card: 'https://app.ringostat.com/project/callcards/card/pl5_-1779797243.25187642/?project_id=projekt_id',
+  },
+}
+
+const missedCall = {
+  id: 'kz1_-1775904448.9517822',
+  date: '2026-04-11T12:47:28+0200',
+  type: 'IN',
+  caller: '48739109594',
+  destination: '48579771838',
+  status: 'NO FORWARD',
+  waitTime: '1',
+  billSec: '0',
+  extraFields: {},
+}
+
+describe('mapStatus', () => {
+  it('lets a billed call win over the textual status', () => {
+    expect(mapStatus('NO ANSWER', 12)).toBe('answered')
+  })
+
+  it('maps the answered family', () => {
+    for (const status of ['ANSWERED', 'PROPER', 'REPEATED', 'CONNECTED']) {
+      expect(mapStatus(status, 0)).toBe('answered')
+    }
+  })
+
+  it('maps the missed family', () => {
+    for (const status of ['NO ANSWER', 'NO FORWARD', 'VOICEMAIL', 'NO EXTENSION', 'BUSY']) {
+      expect(mapStatus(status, 0)).toBe('missed')
+    }
+  })
+
+  it('maps a call that never got set up to failed', () => {
+    expect(mapStatus('FAILED', 0)).toBe('failed')
+  })
+
+  it('falls back to unknown for statuses Tillio has not documented', () => {
+    expect(mapStatus('SOMETHING NEW', 0)).toBe('unknown')
+    expect(mapStatus(undefined, null)).toBe('unknown')
+    expect(mapStatus('', 0)).toBe('unknown')
+  })
+})
+
+describe('normalizeTillioCall', () => {
+  it('maps an answered Ringostat call end to end', () => {
+    const normalized = normalizeTillioCall(answeredCall, context)
+
+    expect(normalized.externalCallId).toBe('pl5_-id1235453.9876543')
+    expect(normalized.direction).toBe('outbound')
+    expect(normalized.status).toBe('answered')
+    expect(normalized.durationSeconds).toBe(7)
+    expect(normalized.startedAt?.toISOString()).toBe('2026-05-26T12:07:23.000Z')
+    expect(normalized.recording?.url).toContain('.wav')
+    expect(normalized.participants).toEqual([
+      { role: 'caller', phoneNumber: '48579771838', displayName: 'itrixcom_Kontakt' },
+      { role: 'callee', phoneNumber: '48726861925' },
+    ])
+    expect(normalized.providerFacts).toMatchObject({
+      tillioStatus: 'ANSWERED',
+      tillioType: 'OUT',
+      tillioWaitTimeSeconds: 10,
+      operatorId: 'ringostat-1',
+      plugin: 'Ringostat',
+    })
+    expect(normalized.rawPayload).toBe(answeredCall)
+  })
+
+  it('never invents answeredAt or endedAt', () => {
+    const normalized = normalizeTillioCall(answeredCall, context)
+    expect(normalized.answeredAt).toBeNull()
+    expect(normalized.endedAt).toBeNull()
+  })
+
+  it('maps an inbound missed call without a recording', () => {
+    const normalized = normalizeTillioCall(missedCall, context)
+    expect(normalized.direction).toBe('inbound')
+    expect(normalized.status).toBe('missed')
+    expect(normalized.durationSeconds).toBe(0)
+    expect(normalized.recording).toBeNull()
+    expect(normalized.participants[0].displayName).toBeNull()
+  })
+
+  it('does not preserve decoded markup in a caller display name', () => {
+    const normalized = normalizeTillioCall({
+      ...answeredCall,
+      extraFields: {
+        ...answeredCall.extraFields,
+        caller: '"Safe caller" <script>alert(1)</script>',
+      },
+    }, context)
+
+    expect(normalized.participants[0].displayName).toBe('Safe caller')
+    expect(normalized.participants[0].displayName).not.toContain('<')
+  })
+
+  it('tolerates a missing waitTime, which Tillio does not always send', () => {
+    const { waitTime: _waitTime, ...withoutWaitTime } = missedCall
+    const normalized = normalizeTillioCall(withoutWaitTime, context)
+    expect(normalized.providerFacts).not.toHaveProperty('tillioWaitTimeSeconds')
+    expect(normalized.status).toBe('missed')
+  })
+
+  it('ignores a recording url when has_recording is not set', () => {
+    const normalized = normalizeTillioCall(
+      { ...answeredCall, extraFields: { ...answeredCall.extraFields, has_recording: '0' } },
+      context,
+    )
+    expect(normalized.recording).toBeNull()
+  })
+
+  it('keeps the raw payload untouched for provider_facts remapping later', () => {
+    const normalized = normalizeTillioCall(missedCall, context)
+    expect(normalized.rawPayload).toEqual(missedCall)
+  })
+
+  it('maps an unknown call type to unknown direction', () => {
+    const normalized = normalizeTillioCall({ ...missedCall, type: 'INTERNAL' }, context)
+    expect(normalized.direction).toBe('unknown')
+  })
+
+  it('throws when the payload has no id', () => {
+    const { id: _id, ...withoutId } = missedCall
+    expect(() => normalizeTillioCall(withoutId, context)).toThrow()
+  })
+})

package/src/modules/tillio/__tests__/operators-routes.test.ts

@@ -0,0 +1,100 @@
+import { POST } from '../api/operators/route'
+import { DELETE } from '../api/operators/[id]/route'
+import { TillioApiError } from '../lib/errors'
+import { TillioRevocationFailedError } from '../lib/operators'
+
+jest.mock('@open-mercato/shared/lib/auth/server', () => ({ getAuthFromRequest: jest.fn() }))
+jest.mock('@open-mercato/shared/lib/di/container', () => ({ createRequestContainer: jest.fn() }))
+jest.mock('@open-mercato/shared/lib/crud/route-mutation-guard', () => ({ runRouteMutationGuards: jest.fn() }))
+jest.mock('../lib/operators', () => ({
+  ...jest.requireActual('../lib/operators'),
+  attachOperator: jest.fn(),
+  detachOperator: jest.fn(),
+  readTillioIntegrationState: jest.fn(),
+  resolveEnvironment: jest.fn(),
+}))
+
+const { getAuthFromRequest } = jest.requireMock('@open-mercato/shared/lib/auth/server')
+const { createRequestContainer } = jest.requireMock('@open-mercato/shared/lib/di/container')
+const { runRouteMutationGuards } = jest.requireMock('@open-mercato/shared/lib/crud/route-mutation-guard')
+const {
+  attachOperator,
+  detachOperator,
+  readTillioIntegrationState,
+  resolveEnvironment,
+} = jest.requireMock('../lib/operators')
+
+const auth = { sub: 'user-1', tenantId: 'tn', orgId: 'org' }
+const originalAppUrl = process.env.APP_URL
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  process.env.APP_URL = 'https://app.example.com'
+  getAuthFromRequest.mockResolvedValue(auth)
+  createRequestContainer.mockResolvedValue({
+    resolve: (name: string) => {
+      if (name === 'integrationCredentialsService') return {}
+      if (name === 'em') return {}
+      throw new Error(`Unexpected dependency: ${name}`)
+    },
+  })
+  runRouteMutationGuards.mockResolvedValue({
+    ok: true,
+    runAfterSuccess: jest.fn().mockResolvedValue(undefined),
+  })
+  resolveEnvironment.mockResolvedValue({
+    apiUrl: 'https://provider.example.com',
+    apiKey: 'api-key',
+    tenantSystemId: 'OM-x',
+    timeZone: 'Europe/Warsaw',
+  })
+  readTillioIntegrationState.mockResolvedValue({ enabled: true, healthy: true })
+})
+
+afterAll(() => {
+  if (originalAppUrl === undefined) delete process.env.APP_URL
+  else process.env.APP_URL = originalAppUrl
+})
+
+describe('Tillio operator API diagnostics', () => {
+  it('does not expose provider response text when attach fails', async () => {
+    const providerMessage = 'provider response from https://internal.example.invalid: token secret-token'
+    attachOperator.mockRejectedValue(new TillioApiError(providerMessage, 422, 'raw provider body'))
+
+    const response = await POST(new Request('http://localhost/api/tillio/operators', {
+      method: 'POST',
+      body: JSON.stringify({ plugin: 'Ringostat', config: { key: 'operator-key' } }),
+    }))
+    const body = await response.json()
+
+    expect(response.status).toBe(422)
+    expect(body).toEqual({
+      ok: false,
+      code: 'provider_error',
+      section: 'operator',
+      message: 'Tillio rejected the request.',
+    })
+    expect(JSON.stringify(body)).not.toContain(providerMessage)
+  })
+
+  it('does not expose provider response text when detach fails', async () => {
+    const providerMessage = 'provider response from https://internal.example.invalid: token secret-token'
+    detachOperator.mockRejectedValue(new TillioRevocationFailedError(false, providerMessage))
+
+    const response = await DELETE(
+      new Request('http://localhost/api/tillio/operators/ringostat-1', { method: 'DELETE' }),
+      { params: { id: 'ringostat-1' } },
+    )
+    const body = await response.json()
+
+    expect(response.status).toBe(502)
+    expect(body).toEqual({
+      ok: false,
+      code: 'revocation_failed',
+      section: 'operator',
+      message: 'The Tillio token could not be revoked.',
+      canForce: true,
+    })
+    expect(JSON.stringify(body)).not.toContain(providerMessage)
+  })
+})

package/src/modules/tillio/__tests__/operators-store.test.ts

@@ -0,0 +1,104 @@
+import {
+  buildTenantDomain,
+  computeEnvFingerprint,
+  readOperatorsBlob,
+  resolveAppHost,
+  saveOperatorsBlob,
+  TILLIO_OPERATORS_INTEGRATION_ID,
+  type TillioCredentialsService,
+} from '../lib/operators-store'
+
+const scope = { tenantId: 'tn', organizationId: 'org' }
+
+function fakeCredentialsService(initial: Record<string, Record<string, unknown> | null> = {}): {
+  service: TillioCredentialsService
+  store: Record<string, Record<string, unknown> | null>
+} {
+  const store: Record<string, Record<string, unknown> | null> = { ...initial }
+  return {
+    store,
+    service: {
+      getRaw: jest.fn(async (id: string) => store[id] ?? null),
+      save: jest.fn(async (id: string, credentials: Record<string, unknown>) => {
+        store[id] = credentials
+      }),
+    },
+  }
+}
+
+describe('computeEnvFingerprint', () => {
+  const env = { tenantSystemId: 'OM-x', apiUrl: 'https://a.example.com', apiKey: 'k' }
+
+  it('is deterministic for the same input', () => {
+    expect(computeEnvFingerprint(env)).toBe(computeEnvFingerprint({ ...env }))
+    expect(computeEnvFingerprint(env)).toMatch(/^[a-f0-9]{64}$/)
+  })
+
+  it('changes when any field changes', () => {
+    expect(computeEnvFingerprint(env)).not.toBe(computeEnvFingerprint({ ...env, apiKey: 'k2' }))
+    expect(computeEnvFingerprint(env)).not.toBe(computeEnvFingerprint({ ...env, apiUrl: 'https://b.example.com' }))
+    expect(computeEnvFingerprint(env)).not.toBe(computeEnvFingerprint({ ...env, tenantSystemId: 'OM-y' }))
+  })
+})
+
+describe('resolveAppHost / buildTenantDomain', () => {
+  it('strips the scheme and keeps host', () => {
+    expect(resolveAppHost('https://app.example.com')).toBe('app.example.com')
+  })
+
+  it('keeps the port when present', () => {
+    expect(resolveAppHost('https://app.example.com:8443')).toBe('app.example.com:8443')
+  })
+
+  it('falls back to the authority when there is no scheme', () => {
+    expect(resolveAppHost('app.example.com/ignored')).toBe('app.example.com')
+  })
+
+  it('returns empty for a blank url', () => {
+    expect(resolveAppHost('   ')).toBe('')
+  })
+
+  it('builds host/{tenantSystemId}-{operatorId}', () => {
+    expect(buildTenantDomain('https://app.example.com', 'OM-x', 'ringostat-1')).toBe('app.example.com/OM-x-ringostat-1')
+  })
+
+  it('throws when APP_URL cannot be resolved to a host', () => {
+    expect(() => buildTenantDomain('   ', 'OM-x', 'ringostat-1')).toThrow()
+  })
+})
+
+describe('readOperatorsBlob / saveOperatorsBlob', () => {
+  it('returns an empty blob when nothing is stored', async () => {
+    const { service } = fakeCredentialsService()
+    expect(await readOperatorsBlob(service, scope)).toEqual({ operators: [], defaultOperatorId: null })
+  })
+
+  it('returns an empty blob when the stored value is malformed', async () => {
+    const { service } = fakeCredentialsService({ [TILLIO_OPERATORS_INTEGRATION_ID]: { operators: 'nope' } })
+    expect(await readOperatorsBlob(service, scope)).toEqual({ operators: [], defaultOperatorId: null })
+  })
+
+  it('parses a valid stored blob', async () => {
+    const operator = {
+      id: 'ringostat-1',
+      plugin: 'Ringostat',
+      config: { key: 'secret' },
+      token: 'tok',
+      tenantDomain: 'app.example.com/OM-x-ringostat-1',
+      envFingerprint: 'fp',
+    }
+    const { service } = fakeCredentialsService({
+      [TILLIO_OPERATORS_INTEGRATION_ID]: { operators: [operator], defaultOperatorId: 'ringostat-1' },
+    })
+    const blob = await readOperatorsBlob(service, scope)
+    expect(blob.operators).toHaveLength(1)
+    expect(blob.defaultOperatorId).toBe('ringostat-1')
+  })
+
+  it('saves under the tillio_operators key', async () => {
+    const { service, store } = fakeCredentialsService()
+    await saveOperatorsBlob(service, scope, { operators: [], defaultOperatorId: null })
+    expect(service.save).toHaveBeenCalledWith(TILLIO_OPERATORS_INTEGRATION_ID, { operators: [], defaultOperatorId: null }, scope)
+    expect(store[TILLIO_OPERATORS_INTEGRATION_ID]).toEqual({ operators: [], defaultOperatorId: null })
+  })
+})