@hed-hog/core 0.0.373 → 0.0.374

package/src/integration/services/inbox.service.spec.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { InboxService } from './inbox.service';
+import { InboxEventStatus } from '../types';
+
+const makeDeps = () => {
+  const prisma = {
+    inbox_event: {
+      findFirst: jest.fn(),
+      findUnique: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      count: jest.fn(),
+    },
+  };
+  return { prisma };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new InboxService(deps.prisma as any),
+  deps,
+});
+
+const record = (over: any = {}) => ({
+  id: 1,
+  outbox_event_id: 10,
+  consumer_name: 'crm',
+  status: InboxEventStatus.RECEIVED,
+  attempt_count: 0,
+  last_error: null,
+  processed_at: null,
+  created_at: new Date('2026-01-01'),
+  updated_at: new Date('2026-01-01'),
+  ...over,
+});
+
+describe('InboxService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('toDatabaseId', () => {
+    it('mantém number e converte string', () => {
+      const { service } = makeService();
+      expect((service as any).toDatabaseId(5)).toBe(5);
+      expect((service as any).toDatabaseId('12')).toBe(12);
+    });
+  });
+
+  describe('toDomainEvent', () => {
+    it('mapeia colunas para camelCase', () => {
+      const { service } = makeService();
+      const result = (service as any).toDomainEvent(record({ id: 3, outbox_event_id: 99 }));
+      expect(result).toMatchObject({
+        id: '3',
+        outboxEventId: '99',
+        consumerName: 'crm',
+        attemptCount: 0,
+      });
+    });
+  });
+
+  describe('toDatabaseUpdate', () => {
+    it('retorna undefined sem partial', () => {
+      const { service } = makeService();
+      expect((service as any).toDatabaseUpdate()).toBeUndefined();
+    });
+    it('mapeia campos parciais', () => {
+      const { service } = makeService();
+      expect(
+        (service as any).toDatabaseUpdate({ attemptCount: 2, lastError: 'e', processedAt: null }),
+      ).toEqual({ attempt_count: 2, last_error: 'e', processed_at: null });
+    });
+  });
+
+  describe('getOrCreate (idempotência)', () => {
+    it('retorna existente sem criar', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findFirst.mockResolvedValue(record({ id: 7 }));
+      const result = await service.getOrCreate(10, 'crm');
+      expect(result.id).toBe('7');
+      expect(deps.prisma.inbox_event.create).not.toHaveBeenCalled();
+    });
+
+    it('cria quando não existe com status RECEIVED', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findFirst.mockResolvedValue(null);
+      deps.prisma.inbox_event.create.mockResolvedValue(record({ id: 8 }));
+      await service.getOrCreate('10', 'crm');
+      expect(deps.prisma.inbox_event.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          outbox_event_id: 10,
+          consumer_name: 'crm',
+          status: InboxEventStatus.RECEIVED,
+          attempt_count: 0,
+        }),
+      });
+    });
+  });
+
+  describe('markProcessed', () => {
+    it('define processed_at e status PROCESSED', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.update.mockResolvedValue(record({ status: InboxEventStatus.PROCESSED }));
+      await service.markProcessed(1);
+      const arg = deps.prisma.inbox_event.update.mock.calls[0][0];
+      expect(arg.data.status).toBe(InboxEventStatus.PROCESSED);
+      expect(arg.data.processed_at).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('markFailed', () => {
+    it('lança quando registro não existe', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findUnique.mockResolvedValue(null);
+      await expect(service.markFailed(1, 'boom')).rejects.toThrow('not found');
+    });
+
+    it('incrementa tentativa e registra erro', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findUnique.mockResolvedValue(record({ attempt_count: 2 }));
+      deps.prisma.inbox_event.update.mockResolvedValue(record({ status: InboxEventStatus.FAILED }));
+      await service.markFailed(1, 'boom');
+      const arg = deps.prisma.inbox_event.update.mock.calls[0][0];
+      expect(arg.data.status).toBe(InboxEventStatus.FAILED);
+      expect(arg.data.attempt_count).toBe(3);
+      expect(arg.data.last_error).toBe('boom');
+    });
+  });
+
+  describe('incrementAttempt', () => {
+    it('lança quando registro não existe', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findUnique.mockResolvedValue(null);
+      await expect(service.incrementAttempt(1)).rejects.toThrow('not found');
+    });
+
+    it('mantém status e incrementa tentativa', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findUnique.mockResolvedValue(record({ attempt_count: 5, status: InboxEventStatus.PROCESSING }));
+      deps.prisma.inbox_event.update.mockResolvedValue(record());
+      await service.incrementAttempt(1);
+      const arg = deps.prisma.inbox_event.update.mock.calls[0][0];
+      expect(arg.data.status).toBe(InboxEventStatus.PROCESSING);
+      expect(arg.data.attempt_count).toBe(6);
+    });
+  });
+
+  describe('isProcessed', () => {
+    it('true apenas quando status PROCESSED', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findFirst.mockResolvedValue(record({ status: InboxEventStatus.PROCESSED }));
+      await expect(service.isProcessed(10, 'crm')).resolves.toBe(true);
+    });
+    it('false quando outro status', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findFirst.mockResolvedValue(record({ status: InboxEventStatus.FAILED }));
+      await expect(service.isProcessed(10, 'crm')).resolves.toBe(false);
+    });
+    it('false quando não existe', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findFirst.mockResolvedValue(null);
+      await expect(service.isProcessed(10, 'crm')).resolves.toBe(false);
+    });
+  });
+
+  describe('getById / countUnprocessed', () => {
+    it('getById retorna null quando ausente', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.findUnique.mockResolvedValue(null);
+      await expect(service.getById(1)).resolves.toBeNull();
+    });
+
+    it('countUnprocessed exclui PROCESSED e SKIPPED', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.inbox_event.count.mockResolvedValue(4);
+      await service.countUnprocessed('crm');
+      expect(deps.prisma.inbox_event.count).toHaveBeenCalledWith({
+        where: {
+          consumer_name: 'crm',
+          status: { notIn: [InboxEventStatus.PROCESSED, InboxEventStatus.SKIPPED] },
+        },
+      });
+    });
+  });
+});

package/src/integration/services/integration-link.service.spec.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { IntegrationLinkService } from './integration-link.service';
+import { LinkType } from '../types';
+
+const makeDelegate = () => ({
+  create: jest.fn(),
+  findMany: jest.fn(),
+  findFirst: jest.fn(),
+  findUnique: jest.fn(),
+  delete: jest.fn(),
+  count: jest.fn(),
+});
+
+describe('IntegrationLinkService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('resolvePersistence', () => {
+    it('prioriza integration_link (snake) do prisma', () => {
+      const snake = makeDelegate();
+      const service = new IntegrationLinkService({ integration_link: snake } as any);
+      const { delegate, useSnakeCase } = (service as any).resolvePersistence();
+      expect(delegate).toBe(snake);
+      expect(useSnakeCase).toBe(true);
+    });
+
+    it('usa integrationLink (camel) quando snake ausente', () => {
+      const camel = makeDelegate();
+      const service = new IntegrationLinkService({ integrationLink: camel } as any);
+      const { delegate, useSnakeCase } = (service as any).resolvePersistence();
+      expect(delegate).toBe(camel);
+      expect(useSnakeCase).toBe(false);
+    });
+
+    it('lança quando não há delegate', () => {
+      const service = new IntegrationLinkService({} as any);
+      expect(() => (service as any).resolvePersistence()).toThrow(
+        'Integration link delegate is not available on the Prisma client.',
+      );
+    });
+
+    it('aceita client de persistência explícito', () => {
+      const explicit = makeDelegate();
+      const service = new IntegrationLinkService({} as any);
+      const { delegate } = (service as any).resolvePersistence({
+        integration_link: explicit,
+      });
+      expect(delegate).toBe(explicit);
+    });
+  });
+
+  describe('toDomainLink', () => {
+    let service: IntegrationLinkService;
+    beforeEach(() => {
+      service = new IntegrationLinkService({} as any);
+    });
+
+    it('mapeia colunas snake_case', () => {
+      const now = new Date('2026-01-01T00:00:00Z');
+      const result = (service as any).toDomainLink({
+        id: 5,
+        source_module: 'crm',
+        source_entity_type: 'person',
+        source_entity_id: '1',
+        target_module: 'finance',
+        target_entity_type: 'invoice',
+        target_entity_id: '2',
+        link_type: LinkType.CASCADE,
+        metadata: { k: 'v' },
+        created_at: now,
+        updated_at: now,
+      });
+      expect(result).toMatchObject({
+        id: '5',
+        sourceModule: 'crm',
+        targetEntityId: '2',
+        linkType: LinkType.CASCADE,
+        metadata: { k: 'v' },
+      });
+    });
+
+    it('usa defaults quando faltam campos', () => {
+      const result = (service as any).toDomainLink({ id: 9 });
+      expect(result.sourceModule).toBe('');
+      expect(result.linkType).toBe(LinkType.REFERENCE);
+      expect(result.metadata).toBeNull();
+      expect(result.createdAt).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('toDatabaseId', () => {
+    let service: IntegrationLinkService;
+    beforeEach(() => {
+      service = new IntegrationLinkService({} as any);
+    });
+
+    it('mantém number', () => {
+      expect((service as any).toDatabaseId(7)).toBe(7);
+    });
+    it('converte string numérica', () => {
+      expect((service as any).toDatabaseId('42')).toBe(42);
+    });
+    it('mantém string não numérica', () => {
+      expect((service as any).toDatabaseId('abc')).toBe('abc');
+    });
+  });
+
+  describe('createLink', () => {
+    it('usa data snake_case', async () => {
+      const delegate = makeDelegate();
+      delegate.create.mockResolvedValue({ id: 1 });
+      const service = new IntegrationLinkService({ integration_link: delegate } as any);
+      await service.createLink({
+        sourceModule: 'a',
+        sourceEntityType: 'b',
+        sourceEntityId: 'c',
+        targetModule: 'd',
+        targetEntityType: 'e',
+        targetEntityId: 'f',
+        linkType: LinkType.REFERENCE,
+      });
+      expect(delegate.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          source_module: 'a',
+          target_entity_id: 'f',
+          link_type: LinkType.REFERENCE,
+          metadata: null,
+        }),
+      });
+    });
+
+    it('usa data camelCase', async () => {
+      const delegate = makeDelegate();
+      delegate.create.mockResolvedValue({ id: 1 });
+      const service = new IntegrationLinkService({ integrationLink: delegate } as any);
+      await service.createLink({
+        sourceModule: 'a',
+        sourceEntityType: 'b',
+        sourceEntityId: 'c',
+        targetModule: 'd',
+        targetEntityType: 'e',
+        targetEntityId: 'f',
+        linkType: LinkType.REFERENCE,
+        metadata: { x: 1 },
+      });
+      expect(delegate.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          sourceModule: 'a',
+          metadata: { x: 1 },
+        }),
+      });
+    });
+  });
+
+  describe('consultas', () => {
+    it('findOutbound monta where snake', async () => {
+      const delegate = makeDelegate();
+      delegate.findMany.mockResolvedValue([]);
+      const service = new IntegrationLinkService({ integration_link: delegate } as any);
+      await service.findOutbound('m', 't', 'i');
+      expect(delegate.findMany).toHaveBeenCalledWith({
+        where: { source_module: 'm', source_entity_type: 't', source_entity_id: 'i' },
+      });
+    });
+
+    it('findInbound monta where camel', async () => {
+      const delegate = makeDelegate();
+      delegate.findMany.mockResolvedValue([]);
+      const service = new IntegrationLinkService({ integrationLink: delegate } as any);
+      await service.findInbound('m', 't', 'i');
+      expect(delegate.findMany).toHaveBeenCalledWith({
+        where: { targetModule: 'm', targetEntityType: 't', targetEntityId: 'i' },
+      });
+    });
+
+    it('findByLinkType filtra por tipo', async () => {
+      const delegate = makeDelegate();
+      delegate.findMany.mockResolvedValue([]);
+      const service = new IntegrationLinkService({ integration_link: delegate } as any);
+      await service.findByLinkType(LinkType.CASCADE);
+      expect(delegate.findMany).toHaveBeenCalledWith({
+        where: { link_type: LinkType.CASCADE },
+      });
+    });
+
+    it('getById retorna null quando ausente', async () => {
+      const delegate = makeDelegate();
+      delegate.findUnique.mockResolvedValue(null);
+      const service = new IntegrationLinkService({ integration_link: delegate } as any);
+      await expect(service.getById('1')).resolves.toBeNull();
+    });
+
+    it('getById mapeia para domínio', async () => {
+      const delegate = makeDelegate();
+      delegate.findUnique.mockResolvedValue({ id: 3, source_module: 'x' });
+      const service = new IntegrationLinkService({ integration_link: delegate } as any);
+      const result = await service.getById('3');
+      expect(result).toMatchObject({ id: '3', sourceModule: 'x' });
+    });
+
+    it('countFromModule delega count', async () => {
+      const delegate = makeDelegate();
+      delegate.count.mockResolvedValue(4);
+      const service = new IntegrationLinkService({ integration_link: delegate } as any);
+      await expect(service.countFromModule('crm')).resolves.toBe(4);
+      expect(delegate.count).toHaveBeenCalledWith({ where: { source_module: 'crm' } });
+    });
+
+    it('deleteLink mapeia registro removido', async () => {
+      const delegate = makeDelegate();
+      delegate.delete.mockResolvedValue({ id: 8 });
+      const service = new IntegrationLinkService({ integration_link: delegate } as any);
+      const result = await service.deleteLink('8');
+      expect(delegate.delete).toHaveBeenCalledWith({ where: { id: 8 } });
+      expect(result.id).toBe('8');
+    });
+  });
+});

package/src/integration/services/outbox.service.spec.ts

@@ -0,0 +1,290 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { OutboxService } from './outbox.service';
+import { OutboxEventStatus } from '../types';
+
+const makeDeps = () => {
+  const prisma = {
+    outbox_event: {
+      create: jest.fn(),
+      update: jest.fn(),
+      findUnique: jest.fn(),
+      count: jest.fn(),
+    },
+    $transaction: jest.fn(),
+  };
+  return { prisma };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new OutboxService(deps.prisma as any),
+  deps,
+});
+
+const record = (over: any = {}) => ({
+  id: 1,
+  event_name: 'person.created',
+  source_module: 'crm',
+  aggregate_type: 'person',
+  aggregate_id: '10',
+  payload: { foo: 'bar' },
+  status: OutboxEventStatus.PENDING,
+  attempt_count: 0,
+  last_error: null,
+  available_at: new Date('2026-01-01'),
+  processed_at: null,
+  created_at: new Date('2026-01-01'),
+  updated_at: new Date('2026-01-01'),
+  ...over,
+});
+
+describe('OutboxService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  describe('toDatabaseId', () => {
+    it('mantém number e converte string', () => {
+      const { service } = makeService();
+      expect((service as any).toDatabaseId(5)).toBe(5);
+      expect((service as any).toDatabaseId('12')).toBe(12);
+    });
+  });
+
+  describe('toDomainEvent', () => {
+    it('mapeia colunas para camelCase', () => {
+      const { service } = makeService();
+      const result = (service as any).toDomainEvent(record({ id: 3 }));
+      expect(result).toMatchObject({
+        id: '3',
+        eventName: 'person.created',
+        sourceModule: 'crm',
+        aggregateType: 'person',
+        aggregateId: '10',
+        payload: { foo: 'bar' },
+        attemptCount: 0,
+      });
+    });
+  });
+
+  describe('toDatabaseUpdate', () => {
+    it('retorna undefined sem partial', () => {
+      const { service } = makeService();
+      expect((service as any).toDatabaseUpdate()).toBeUndefined();
+    });
+
+    it('mapeia campos parciais', () => {
+      const { service } = makeService();
+      const availableAt = new Date('2026-02-01');
+      expect(
+        (service as any).toDatabaseUpdate({
+          attemptCount: 2,
+          lastError: 'e',
+          availableAt,
+          processedAt: null,
+        }),
+      ).toEqual({
+        attempt_count: 2,
+        last_error: 'e',
+        available_at: availableAt,
+        processed_at: null,
+      });
+    });
+  });
+
+  describe('createEvent', () => {
+    it('cria com status PENDING e attempt_count 0 usando prisma padrão', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.create.mockResolvedValue(record({ id: 5 }));
+
+      const result = await service.createEvent({
+        eventName: 'person.created',
+        sourceModule: 'crm',
+        aggregateType: 'person',
+        aggregateId: '10',
+        payload: { foo: 'bar' },
+      });
+
+      expect(deps.prisma.outbox_event.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          event_name: 'person.created',
+          source_module: 'crm',
+          aggregate_type: 'person',
+          aggregate_id: '10',
+          payload: { foo: 'bar' },
+          status: OutboxEventStatus.PENDING,
+          attempt_count: 0,
+        }),
+      });
+      expect(result.id).toBe('5');
+    });
+
+    it('usa persistenceClient alternativo (ex.: dentro de uma transação) quando fornecido', async () => {
+      const { service } = makeService();
+      const altClient = {
+        outbox_event: {
+          create: jest.fn<any>().mockResolvedValue(record({ id: 9 })),
+        },
+      };
+
+      const result = await service.createEvent(
+        {
+          eventName: 'x',
+          sourceModule: 'crm',
+          aggregateType: 'person',
+          aggregateId: '1',
+          payload: {},
+        },
+        altClient as any,
+      );
+
+      expect(altClient.outbox_event.create).toHaveBeenCalled();
+      expect(result.id).toBe('9');
+    });
+  });
+
+  describe('findPendingAndLock', () => {
+    it('retorna [] quando não há linhas pendentes', async () => {
+      const { service, deps } = makeService();
+      const tx = {
+        $queryRaw: jest.fn<any>().mockResolvedValue([]),
+        $executeRaw: jest.fn(),
+      };
+      deps.prisma.$transaction.mockImplementation(async (cb: any) => cb(tx));
+
+      const result = await service.findPendingAndLock(10, 5000);
+
+      expect(result).toEqual([]);
+      expect(tx.$executeRaw).not.toHaveBeenCalled();
+    });
+
+    it('bloqueia linhas encontradas e marca como PROCESSING', async () => {
+      const { service, deps } = makeService();
+      const rows = [record({ id: 1 }), record({ id: 2 })];
+      const tx = {
+        $queryRaw: jest.fn<any>().mockResolvedValue(rows),
+        $executeRaw: jest.fn(),
+      };
+      deps.prisma.$transaction.mockImplementation(async (cb: any) => cb(tx));
+
+      const result = await service.findPendingAndLock(10, 5000);
+
+      expect(tx.$executeRaw).toHaveBeenCalledTimes(1);
+      expect(result).toHaveLength(2);
+      expect(result[0].status).toBe(OutboxEventStatus.PROCESSING);
+      expect(result[1].status).toBe(OutboxEventStatus.PROCESSING);
+    });
+  });
+
+  describe('updateStatus', () => {
+    it('atualiza status e campos parciais', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.update.mockResolvedValue(
+        record({ status: OutboxEventStatus.PROCESSED }),
+      );
+
+      const result = await service.updateStatus(1, OutboxEventStatus.PROCESSED, {
+        attemptCount: 1,
+      });
+
+      expect(deps.prisma.outbox_event.update).toHaveBeenCalledWith({
+        where: { id: 1 },
+        data: expect.objectContaining({
+          status: OutboxEventStatus.PROCESSED,
+          attempt_count: 1,
+        }),
+      });
+      expect(result.status).toBe(OutboxEventStatus.PROCESSED);
+    });
+
+    it('converte eventId string para número no where', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.update.mockResolvedValue(record());
+
+      await service.updateStatus('42', OutboxEventStatus.PENDING);
+
+      expect(deps.prisma.outbox_event.update).toHaveBeenCalledWith({
+        where: { id: 42 },
+        data: { status: OutboxEventStatus.PENDING },
+      });
+    });
+  });
+
+  describe('markProcessing', () => {
+    it('define availableAt com base no leaseMs', async () => {
+      jest.useFakeTimers().setSystemTime(new Date('2026-01-01T00:00:00Z'));
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.update.mockResolvedValue(
+        record({ status: OutboxEventStatus.PROCESSING }),
+      );
+
+      await service.markProcessing(1, 5000);
+
+      const arg = deps.prisma.outbox_event.update.mock.calls[0][0];
+      expect(arg.data.status).toBe(OutboxEventStatus.PROCESSING);
+      expect(arg.data.available_at).toEqual(new Date('2026-01-01T00:00:05Z'));
+    });
+  });
+
+  describe('incrementAttempt', () => {
+    it('lança quando registro não existe', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.findUnique.mockResolvedValue(null);
+      await expect(service.incrementAttempt(1)).rejects.toThrow('not found');
+    });
+
+    it('incrementa attempt_count e mantém status atual, registrando erro', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.findUnique.mockResolvedValue(
+        record({ attempt_count: 2, status: OutboxEventStatus.PROCESSING }),
+      );
+      deps.prisma.outbox_event.update.mockResolvedValue(record());
+
+      await service.incrementAttempt(1, 'boom');
+
+      const arg = deps.prisma.outbox_event.update.mock.calls[0][0];
+      expect(arg.data.status).toBe(OutboxEventStatus.PROCESSING);
+      expect(arg.data.attempt_count).toBe(3);
+      expect(arg.data.last_error).toBe('boom');
+    });
+
+    it('usa null como last_error quando erro não é informado', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.findUnique.mockResolvedValue(
+        record({ attempt_count: 0, status: OutboxEventStatus.PENDING }),
+      );
+      deps.prisma.outbox_event.update.mockResolvedValue(record());
+
+      await service.incrementAttempt(1);
+
+      const arg = deps.prisma.outbox_event.update.mock.calls[0][0];
+      expect(arg.data.last_error).toBeNull();
+    });
+  });
+
+  describe('getById', () => {
+    it('retorna null quando ausente', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.findUnique.mockResolvedValue(null);
+      await expect(service.getById(1)).resolves.toBeNull();
+    });
+
+    it('retorna evento mapeado quando existe', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.findUnique.mockResolvedValue(record({ id: 4 }));
+      await expect(service.getById(4)).resolves.toMatchObject({ id: '4' });
+    });
+  });
+
+  describe('countByStatus', () => {
+    it('conta por status', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.outbox_event.count.mockResolvedValue(7);
+
+      await expect(service.countByStatus(OutboxEventStatus.PENDING)).resolves.toBe(7);
+      expect(deps.prisma.outbox_event.count).toHaveBeenCalledWith({
+        where: { status: OutboxEventStatus.PENDING },
+      });
+    });
+  });
+});