@hed-hog/core 0.0.371 → 0.0.374

package/src/access-log/access-log.service.spec.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+
+jest.mock('@hed-hog/api-prisma', () => ({
+  __esModule: true,
+  PrismaService: class {},
+  Prisma: {
+    sql: (...args: any[]) => ({ __sql: args }),
+    raw: (v: string) => ({ __raw: v }),
+  },
+}));
+
+jest.mock('@hed-hog/api-pagination', () => ({
+  __esModule: true,
+  PaginationService: class {},
+}));
+
+jest.mock('geoip-lite', () => ({
+  __esModule: true,
+  lookup: jest.fn(),
+}));
+
+jest.mock('ua-parser-js', () => ({
+  __esModule: true,
+  UAParser: jest.fn(),
+}));
+
+import * as geoip from 'geoip-lite';
+import { UAParser } from 'ua-parser-js';
+import { AccessLogService } from './access-log.service';
+
+const mockLookup = geoip.lookup as unknown as jest.Mock;
+const mockUAParser = UAParser as unknown as jest.Mock;
+
+const makeService = () => {
+  const prisma = {
+    access_log: { create: jest.fn() },
+    $executeRaw: jest.fn(),
+  };
+  const pagination = {
+    paginate: jest.fn(),
+  };
+  const service = new AccessLogService(prisma as any, pagination as any);
+  return { service, prisma, pagination };
+};
+
+describe('AccessLogService', () => {
+  beforeEach(() => {
+    mockUAParser.mockImplementation(() => ({
+      getResult: () => ({
+        browser: { name: 'Chrome', version: '120' },
+        os: { name: 'Windows', version: '11' },
+      }),
+    }));
+    mockLookup.mockReturnValue({ country: 'BR', city: 'Sao Paulo' });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('recordHttp', () => {
+    it('persiste o log HTTP com os campos mapeados', () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockResolvedValue({});
+
+      service.recordHttp({
+        userId: 3,
+        ip: '1.2.3.4',
+        userAgent: 'UA',
+        method: 'GET',
+        path: '/api/x',
+      });
+
+      expect(prisma.access_log.create).toHaveBeenCalledWith({
+        data: {
+          user_id: 3,
+          ip: '1.2.3.4',
+          user_agent: 'UA',
+          method: 'GET',
+          path: '/api/x',
+        },
+      });
+    });
+
+    it('usa null para campos opcionais ausentes', () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockResolvedValue({});
+
+      service.recordHttp({ method: 'POST', path: '/x' });
+
+      expect(prisma.access_log.create).toHaveBeenCalledWith({
+        data: { user_id: null, ip: null, user_agent: null, method: 'POST', path: '/x' },
+      });
+    });
+
+    it('não propaga erro de persistência (loga warn)', async () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockRejectedValue(new Error('db down'));
+      const warnSpy = jest
+        .spyOn((service as any).logger, 'warn')
+        .mockImplementation(() => undefined);
+
+      expect(() => service.recordHttp({ method: 'GET', path: '/x' })).not.toThrow();
+      await new Promise((r) => process.nextTick(r));
+
+      expect(warnSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('recordMcp', () => {
+    it('persiste o log MCP com tool e prompt', () => {
+      const { service, prisma } = makeService();
+      prisma.access_log.create.mockResolvedValue({});
+
+      service.recordMcp({ userId: 9, mcpTool: 'search', mcpPrompt: 'q' });
+
+      expect(prisma.access_log.create).toHaveBeenCalledWith({
+        data: { user_id: 9, mcp_tool: 'search', mcp_prompt: 'q' },
+      });
+    });
+  });
+
+  describe('list', () => {
+    const paginateResult = (data: any[]) => ({ data, total: data.length, page: 1 });
+
+    it('sem filtros usa where vazio e mantém orderBy/include', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({});
+
+      const [, , opts] = pagination.paginate.mock.calls[0];
+      expect(opts.where).toEqual({});
+      expect(opts.orderBy).toEqual({ created_at: 'desc' });
+      expect(opts.include.user.select).toMatchObject({ id: true, name: true });
+    });
+
+    it('filtra por userId', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ userId: 5 });
+
+      expect(pagination.paginate.mock.calls[0][2].where).toMatchObject({ user_id: 5 });
+    });
+
+    it('filtra por userSearch com contains insensitive', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ userSearch: 'ana' });
+
+      expect(pagination.paginate.mock.calls[0][2].where.user).toEqual({
+        OR: [{ name: { contains: 'ana', mode: 'insensitive' } }],
+      });
+    });
+
+    it('monta o range de datas com fim de dia em createdAtTo', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ createdAtFrom: '2026-01-01', createdAtTo: '2026-01-31' });
+
+      const where = pagination.paginate.mock.calls[0][2].where;
+      expect(where.created_at.gte).toEqual(new Date('2026-01-01'));
+      const lte: Date = where.created_at.lte;
+      expect(lte.getHours()).toBe(23);
+      expect(lte.getMinutes()).toBe(59);
+      expect(lte.getSeconds()).toBe(59);
+      expect(lte.getMilliseconds()).toBe(999);
+    });
+
+    it('type=http filtra method not null; type=mcp filtra mcp_tool not null', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(paginateResult([]));
+
+      await service.list({ type: 'http' });
+      expect(pagination.paginate.mock.calls[0][2].where).toMatchObject({
+        method: { not: null },
+      });
+
+      await service.list({ type: 'mcp' });
+      expect(pagination.paginate.mock.calls[1][2].where).toMatchObject({
+        mcp_tool: { not: null },
+      });
+    });
+
+    it('enriquece cada log com dados de user-agent e geoip', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(
+        paginateResult([{ id: 1, user_agent: 'UA', ip: '8.8.8.8' }]),
+      );
+
+      const result = await service.list({});
+
+      expect(result.data[0]).toMatchObject({
+        browser_name: 'Chrome',
+        browser_version: '120',
+        os_name: 'Windows',
+        os_version: '11',
+        country: 'BR',
+        city: 'Sao Paulo',
+      });
+    });
+
+    it('usa null quando não há user_agent nem ip', async () => {
+      const { service, pagination } = makeService();
+      pagination.paginate.mockResolvedValue(
+        paginateResult([{ id: 2, user_agent: null, ip: null }]),
+      );
+
+      const result = await service.list({});
+
+      expect(result.data[0]).toMatchObject({
+        browser_name: null,
+        os_name: null,
+        country: null,
+        city: null,
+      });
+      expect(mockUAParser).not.toHaveBeenCalled();
+      expect(mockLookup).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('clearOld', () => {
+    it('executa o DELETE em lote via $executeRaw', async () => {
+      const { service, prisma } = makeService();
+      prisma.$executeRaw.mockResolvedValue(1);
+
+      await service.clearOld(30, 500);
+
+      expect(prisma.$executeRaw).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/ai-instruction/ai-prompt-builder.service.spec.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { AiPromptBuilderService } from './ai-prompt-builder.service';
+
+const makeService = () => {
+  const instructionService = {
+    getLayer: jest.fn(),
+    getAgentInstruction: jest.fn(),
+  };
+  const service = new AiPromptBuilderService(instructionService as any);
+  return { service, instructionService };
+};
+
+describe('AiPromptBuilderService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('build', () => {
+    it('inclui apenas a camada system quando é a única disponível', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) =>
+        layer === 'system' ? 'SYS' : null,
+      );
+
+      const result = await service.build({});
+
+      expect(result.layers).toEqual(['SYS']);
+      expect(result.layerNames).toEqual(['system']);
+      expect(result.systemPrompt).toBe('SYS');
+    });
+
+    it('junta system + product com o separador', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) => {
+        if (layer === 'system') return 'SYS';
+        if (layer === 'product') return 'PROD';
+        return null;
+      });
+
+      const result = await service.build({});
+
+      expect(result.layers).toEqual(['SYS', 'PROD']);
+      expect(result.layerNames).toEqual(['system', 'product']);
+      expect(result.systemPrompt).toBe('SYS\n\n---\n\nPROD');
+    });
+
+    it('inclui a camada module quando moduleSlug é fornecido e existe', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(
+        async (layer: string, slug?: string) => {
+          if (layer === 'system') return 'SYS';
+          if (layer === 'module' && slug === 'crm') return 'MOD';
+          return null;
+        },
+      );
+
+      const result = await service.build({ moduleSlug: 'crm' });
+
+      expect(result.layerNames).toEqual(['system', 'module:crm']);
+      expect(instructionService.getLayer).toHaveBeenCalledWith('module', 'crm');
+    });
+
+    it('não inclui module quando moduleSlug é fornecido mas não há conteúdo', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) =>
+        layer === 'system' ? 'SYS' : null,
+      );
+
+      const result = await service.build({ moduleSlug: 'crm' });
+
+      expect(result.layerNames).toEqual(['system']);
+    });
+
+    it('inclui a camada agent quando agentSlug é fornecido e existe', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(async (layer: string) =>
+        layer === 'system' ? 'SYS' : null,
+      );
+      instructionService.getAgentInstruction.mockResolvedValue('AGENT');
+
+      const result = await service.build({ agentSlug: 'support' });
+
+      expect(result.layerNames).toEqual(['system', 'agent:support']);
+      expect(result.layers).toEqual(['SYS', 'AGENT']);
+      expect(instructionService.getAgentInstruction).toHaveBeenCalledWith('support');
+    });
+
+    it('compõe as quatro camadas na ordem de prioridade', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockImplementation(
+        async (layer: string, slug?: string) => {
+          if (layer === 'system') return 'L1';
+          if (layer === 'product') return 'L2';
+          if (layer === 'module' && slug === 'm') return 'L3';
+          return null;
+        },
+      );
+      instructionService.getAgentInstruction.mockResolvedValue('L4');
+
+      const result = await service.build({ moduleSlug: 'm', agentSlug: 'a' });
+
+      expect(result.layers).toEqual(['L1', 'L2', 'L3', 'L4']);
+      expect(result.systemPrompt).toBe('L1\n\n---\n\nL2\n\n---\n\nL3\n\n---\n\nL4');
+    });
+
+    it('retorna prompt vazio quando nenhuma camada tem conteúdo', async () => {
+      const { service, instructionService } = makeService();
+      instructionService.getLayer.mockResolvedValue(null);
+
+      const result = await service.build({});
+
+      expect(result.layers).toEqual([]);
+      expect(result.layerNames).toEqual([]);
+      expect(result.systemPrompt).toBe('');
+    });
+  });
+
+  describe('buildRuntimeContext', () => {
+    it('inclui apenas o cabeçalho quando não há parâmetros', () => {
+      const { service } = makeService();
+      expect(service.buildRuntimeContext({})).toBe('[Runtime context]');
+    });
+
+    it('inclui campos presentes na ordem esperada', () => {
+      const { service } = makeService();
+      const out = service.buildRuntimeContext({
+        userId: 7,
+        locale: 'pt',
+        userRoles: ['admin', 'user'],
+        currentDate: '2026-07-04',
+      });
+      expect(out).toBe(
+        [
+          '[Runtime context]',
+          'user_id: 7',
+          'locale: pt',
+          'roles: admin, user',
+          'date: 2026-07-04',
+        ].join('\n'),
+      );
+    });
+
+    it('ignora userRoles vazio', () => {
+      const { service } = makeService();
+      const out = service.buildRuntimeContext({ userId: 1, userRoles: [] });
+      expect(out).toBe('[Runtime context]\nuser_id: 1');
+    });
+
+    it('anexa extraContext como pares chave: valor', () => {
+      const { service } = makeService();
+      const out = service.buildRuntimeContext({
+        userId: 1,
+        extraContext: { plan: 'pro', tz: 'UTC' },
+      });
+      expect(out).toContain('plan: pro');
+      expect(out).toContain('tz: UTC');
+    });
+  });
+
+  describe('summarizeHistory', () => {
+    it('retorna as mensagens intactas quando o total <= keepLast', () => {
+      const { service } = makeService();
+      const messages = [
+        { role: 'user', content: 'a' },
+        { role: 'assistant', content: 'b' },
+      ];
+      expect(service.summarizeHistory(messages, 6)).toBe(messages);
+    });
+
+    it('resume as mensagens antigas e mantém as recentes verbatim', () => {
+      const { service } = makeService();
+      const messages = Array.from({ length: 10 }, (_, i) => ({
+        role: i % 2 === 0 ? 'user' : 'assistant',
+        content: `msg-${i}`,
+      }));
+
+      const result = service.summarizeHistory(messages, 6);
+
+      // 1 mensagem de resumo + 6 recentes
+      expect(result).toHaveLength(7);
+      expect(result[0].role).toBe('user');
+      expect(result[0].content).toContain('[Earlier conversation summary: 4 messages]');
+      expect(result[0].content).toContain('First question: "msg-0"');
+      // As 6 últimas verbatim.
+      expect(result.slice(1)).toEqual(messages.slice(4));
+    });
+
+    it('inclui a contagem de tool_call quando há chamadas de ferramenta', () => {
+      const { service } = makeService();
+      const messages = [
+        { role: 'user', content: 'q' },
+        { role: 'tool_call', content: 't1' },
+        { role: 'tool_call', content: 't2' },
+        { role: 'assistant', content: 'r' },
+        { role: 'user', content: 'q2' },
+        { role: 'assistant', content: 'r2' },
+        { role: 'user', content: 'q3' },
+        { role: 'assistant', content: 'r3' },
+      ];
+
+      const result = service.summarizeHistory(messages, 2);
+
+      expect(result[0].content).toContain('Tools called: 2');
+    });
+
+    it('trunca a primeira pergunta em 120 caracteres', () => {
+      const { service } = makeService();
+      const longQuestion = 'x'.repeat(200);
+      const messages = [
+        { role: 'user', content: longQuestion },
+        ...Array.from({ length: 6 }, (_, i) => ({
+          role: 'assistant',
+          content: `r-${i}`,
+        })),
+      ];
+
+      const result = service.summarizeHistory(messages, 1);
+
+      expect(result[0].content).toContain(`"${'x'.repeat(120)}"`);
+      expect(result[0].content).not.toContain('x'.repeat(121));
+    });
+  });
+
+  describe('interpolate', () => {
+    it('substitui os placeholders {{var}} pelos valores', () => {
+      const { service } = makeService();
+      expect(
+        service.interpolate('Olá {{name}}, seu plano é {{plan}}', {
+          name: 'Ana',
+          plan: 'pro',
+        }),
+      ).toBe('Olá Ana, seu plano é pro');
+    });
+
+    it('mantém o placeholder quando a variável não existe', () => {
+      const { service } = makeService();
+      expect(service.interpolate('valor {{missing}}', {})).toBe('valor {{missing}}');
+    });
+
+    it('substitui múltiplas ocorrências da mesma variável', () => {
+      const { service } = makeService();
+      expect(service.interpolate('{{x}}-{{x}}', { x: 'a' })).toBe('a-a');
+    });
+
+    it('não altera texto sem placeholders', () => {
+      const { service } = makeService();
+      expect(service.interpolate('sem variaveis', { a: '1' })).toBe('sem variaveis');
+    });
+  });
+});