@hed-hog/core 0.0.373 → 0.0.375

package/src/locale/locale.service.spec.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { LocaleService } from './locale.service';
+
+const makeDeps = () => {
+  const prisma = {
+    createInsensitiveSearch: jest.fn().mockReturnValue([{ name: { contains: 'x' } }]),
+    locale: { create: jest.fn() },
+  };
+  const pagination = { paginate: jest.fn().mockResolvedValue({ data: [] }) };
+  return { prisma, pagination };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new LocaleService(deps.prisma as any, deps.pagination as any),
+  deps,
+});
+
+describe('LocaleService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('findAll', () => {
+    it('não define where.enabled quando enabled indefinido', async () => {
+      const { service, deps } = makeService();
+      await service.findAll({ page: 1, pageSize: 10 } as any);
+      const opts = deps.pagination.paginate.mock.calls[0][2];
+      expect(opts.where).not.toHaveProperty('enabled');
+      expect(opts.where.OR).toBeDefined();
+    });
+
+    it('mapeia enabled="true" para boolean true', async () => {
+      const { service, deps } = makeService();
+      await service.findAll({ page: 1, pageSize: 10 } as any, undefined, 'true');
+      const opts = deps.pagination.paginate.mock.calls[0][2];
+      expect(opts.where.enabled).toBe(true);
+    });
+
+    it('mapeia enabled="false" para boolean false', async () => {
+      const { service, deps } = makeService();
+      await service.findAll({ page: 1, pageSize: 10 } as any, undefined, 'false');
+      const opts = deps.pagination.paginate.mock.calls[0][2];
+      expect(opts.where.enabled).toBe(false);
+    });
+
+    it('usa search explícito sobre paginationDto.search', async () => {
+      const { service, deps } = makeService();
+      await service.findAll({ page: 1, pageSize: 10, search: 'dto' } as any, 'explicit');
+      const params = deps.prisma.createInsensitiveSearch.mock.calls[0][1];
+      expect(params.search).toBe('explicit');
+    });
+
+    it('cai para paginationDto.search quando search ausente', async () => {
+      const { service, deps } = makeService();
+      await service.findAll({ page: 1, pageSize: 10, search: 'dto' } as any);
+      const params = deps.prisma.createInsensitiveSearch.mock.calls[0][1];
+      expect(params.search).toBe('dto');
+    });
+  });
+
+  describe('create', () => {
+    it('aplica defaults region=null e enabled=true', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.locale.create.mockResolvedValue({ id: 1 });
+      await service.create({ name: 'Portuguese', code: 'pt' } as any);
+      expect(deps.prisma.locale.create).toHaveBeenCalledWith({
+        data: { name: 'Portuguese', code: 'pt', region: null, enabled: true },
+      });
+    });
+
+    it('respeita region e enabled fornecidos', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.locale.create.mockResolvedValue({ id: 2 });
+      await service.create({ name: 'X', code: 'x', region: 'BR', enabled: false } as any);
+      expect(deps.prisma.locale.create).toHaveBeenCalledWith({
+        data: { name: 'X', code: 'x', region: 'BR', enabled: false },
+      });
+    });
+  });
+});

package/src/mail/mail.service.spec.ts

@@ -0,0 +1,257 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from '@jest/globals';
+import { BadRequestException } from '@nestjs/common';
+import { MailService } from './mail.service';
+
+const makeDeps = () => {
+  const prismaService = {
+    mail: {
+      findUnique: jest.fn(),
+      create: jest.fn(),
+      deleteMany: jest.fn(),
+    },
+    mail_locale: { deleteMany: jest.fn(), createMany: jest.fn() },
+    mail_var: {
+      deleteMany: jest.fn(),
+      createMany: jest.fn(),
+      findMany: jest.fn(),
+    },
+    locale: { findMany: jest.fn() },
+  };
+  const mailMainService = { send: jest.fn(), setConfig: jest.fn() };
+  const localeService = {};
+  const setting = { getSettingValues: jest.fn(), setValue: jest.fn() };
+  const integrationApi = { subscribe: jest.fn() };
+  return { prismaService, mailMainService, localeService, setting, integrationApi };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new MailService(
+    deps.prismaService as any,
+    deps.mailMainService as any,
+    deps.localeService as any,
+    deps.setting as any,
+    deps.integrationApi as any,
+  ),
+  deps,
+});
+
+describe('MailService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('interpolateTemplate', () => {
+    const call = (src: string, data: any) =>
+      (makeService().service as any).interpolateTemplate(src, data);
+
+    it('interpola variáveis handlebars', () => {
+      expect(call('Hello {{name}}', { name: 'Bob' })).toBe('Hello Bob');
+    });
+
+    it('converte quebras de linha em <br/>', () => {
+      expect(call('Line1\nLine2', {})).toBe('Line1<br/>Line2');
+      expect(call('A\r\nB', {})).toBe('A<br/>B');
+    });
+
+    it('lança BadRequestException em sintaxe inválida', () => {
+      expect(() => call('{{#if foo}}sem fechar', {})).toThrow(
+        BadRequestException,
+      );
+    });
+  });
+
+  describe('isSettingEnabled', () => {
+    const call = (v: unknown) =>
+      (makeService().service as any).isSettingEnabled(v);
+
+    it('reconhece true booleano e string "true"', () => {
+      expect(call(true)).toBe(true);
+      expect(call('true')).toBe(true);
+    });
+
+    it('rejeita outros valores', () => {
+      expect(call(false)).toBe(false);
+      expect(call('false')).toBe(false);
+      expect(call('1')).toBe(false);
+      expect(call(undefined)).toBe(false);
+      expect(call(null)).toBe(false);
+    });
+  });
+
+  describe('isMailConfigSlug', () => {
+    const call = (v: string) =>
+      (makeService().service as any).isMailConfigSlug(v);
+
+    it('reconhece o slug de config de email', () => {
+      expect(call('mail-integration-profile-id')).toBe(true);
+    });
+
+    it('rejeita outros slugs', () => {
+      expect(call('other-setting')).toBe(false);
+    });
+  });
+
+  describe('onModuleInit', () => {
+    it('registra o subscriber de core.setting.changed', () => {
+      const { service, deps } = makeService();
+      service.onModuleInit();
+      expect(deps.integrationApi.subscribe).toHaveBeenCalledWith(
+        expect.objectContaining({
+          eventName: 'core.setting.changed',
+          consumerName: 'core.mail-config-validator',
+        }),
+      );
+    });
+  });
+
+  describe('create', () => {
+    it('lança BadRequest quando slug já existe', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.mail.findUnique.mockResolvedValue({ id: 1 });
+      await expect(
+        service.create({ slug: 'dup' } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('cria template quando slug é novo', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.mail.findUnique.mockResolvedValue(null);
+      deps.prismaService.mail.create.mockResolvedValue({ id: 2, slug: 'novo' });
+      await expect(
+        service.create({ slug: 'novo' } as any),
+      ).resolves.toMatchObject({ id: 2 });
+    });
+  });
+
+  describe('delete', () => {
+    it('lança BadRequest quando ids ausente', async () => {
+      const { service } = makeService();
+      await expect(service.delete({} as any)).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('deleta pelos ids fornecidos', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.mail.deleteMany.mockResolvedValue({ count: 2 });
+      await expect(service.delete({ ids: [1, 2] } as any)).resolves.toEqual({
+        count: 2,
+      });
+      expect(deps.prismaService.mail.deleteMany).toHaveBeenCalledWith({
+        where: { id: { in: [1, 2] } },
+      });
+    });
+  });
+
+  describe('importTemplates', () => {
+    it('retorna conflitos por slug quando overwrite=false', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.mail.findUnique.mockResolvedValue({ id: 5 });
+      const result = await service.importTemplates({
+        overwrite: false,
+        data: [{ slug: 'welcome', translations: [], variables: [] }],
+      } as any);
+      expect(result).toEqual({ conflicts: ['welcome'] });
+    });
+
+    it('cria template novo quando não existe', async () => {
+      const { service, deps } = makeService();
+      // 1a checagem de conflito: null; 2a checagem dentro do loop: null
+      deps.prismaService.mail.findUnique.mockResolvedValue(null);
+      deps.prismaService.locale.findMany.mockResolvedValue([
+        { code: 'en', id: 1 },
+      ]);
+      deps.prismaService.mail.create.mockResolvedValue({ id: 10 });
+
+      const result = await service.importTemplates({
+        overwrite: false,
+        data: [
+          {
+            slug: 'welcome',
+            translations: [{ code: 'en', subject: 'Hi', body: 'Body' }],
+            variables: ['name'],
+          },
+        ],
+      } as any);
+
+      expect(result).toEqual({
+        success: true,
+        imported: 1,
+        templates: [10],
+      });
+      expect(deps.prismaService.mail.create).toHaveBeenCalled();
+    });
+
+    it('sobrescreve template existente quando overwrite=true', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.mail.findUnique.mockResolvedValue({ id: 7 });
+      deps.prismaService.locale.findMany.mockResolvedValue([
+        { code: 'en', id: 1 },
+      ]);
+      deps.prismaService.mail_locale.deleteMany.mockResolvedValue({});
+      deps.prismaService.mail_var.deleteMany.mockResolvedValue({});
+      deps.prismaService.mail_locale.createMany.mockResolvedValue({});
+      deps.prismaService.mail_var.createMany.mockResolvedValue({});
+
+      const result = await service.importTemplates({
+        overwrite: true,
+        data: [
+          {
+            slug: 'welcome',
+            translations: [{ code: 'en', subject: 'Hi', body: 'Body' }],
+            variables: ['name'],
+          },
+        ],
+      } as any);
+
+      expect(result).toEqual({
+        success: true,
+        imported: 1,
+        templates: [7],
+      });
+      expect(deps.prismaService.mail_locale.deleteMany).toHaveBeenCalledWith({
+        where: { mail_id: 7 },
+      });
+      expect(deps.prismaService.mail_locale.createMany).toHaveBeenCalled();
+      expect(deps.prismaService.mail.create).not.toHaveBeenCalled();
+    });
+
+    it('lança BadRequest quando ocorre erro ao importar', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.mail.findUnique.mockResolvedValue(null);
+      deps.prismaService.locale.findMany.mockRejectedValue(
+        new Error('db down'),
+      );
+      await expect(
+        service.importTemplates({
+          overwrite: true,
+          data: [{ slug: 'welcome', translations: [], variables: [] }],
+        } as any),
+      ).rejects.toThrow(BadRequestException);
+    });
+  });
+
+  describe('sendTemplatedMail', () => {
+    it('aborta silenciosamente quando mail não configurado', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'false',
+      });
+      await expect(
+        service.sendTemplatedMail('en', {
+          email: 'a@b.com',
+          slug: 's',
+          variables: {},
+        } as any),
+      ).resolves.toBeUndefined();
+      expect(deps.mailMainService.send).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/mcp/guards/mcp-auth.guard.spec.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { UnauthorizedException } from '@nestjs/common';
+import { McpAuthGuard } from './mcp-auth.guard';
+
+const makeContext = (request: any) => ({
+  switchToHttp: () => ({ getRequest: () => request }),
+});
+
+const makeDeps = () => {
+  const tokenService = { verify: jest.fn() };
+  const prisma = { mcp_api_key: { findFirst: jest.fn(), update: jest.fn() } };
+  const security = { hashWithPepper: jest.fn().mockReturnValue('hash') };
+  return { tokenService, prisma, security };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  guard: new McpAuthGuard(
+    deps.tokenService as any,
+    deps.prisma as any,
+    deps.security as any,
+  ),
+  deps,
+});
+
+describe('McpAuthGuard', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('nega sem token', async () => {
+    const { guard } = makeService();
+    await expect(
+      guard.canActivate(makeContext({ headers: {} }) as any),
+    ).rejects.toThrow(UnauthorizedException);
+  });
+
+  it('verifica token JWT normal', async () => {
+    const { guard, deps } = makeService();
+    deps.tokenService.verify.mockResolvedValue({ sub: 4 });
+    const request: any = { headers: { authorization: 'Bearer tok' } };
+    await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
+      true,
+    );
+    expect(request.auth).toEqual({ sub: 4 });
+  });
+
+  it('autentica com api key mcp válida', async () => {
+    const { guard, deps } = makeService();
+    deps.prisma.mcp_api_key.findFirst.mockResolvedValue({
+      id: 1,
+      user_id: 8,
+      expires_at: null,
+    });
+    deps.prisma.mcp_api_key.update.mockResolvedValue({});
+    const request: any = {
+      headers: { authorization: 'Bearer hedhog_mcp_x' },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
+      true,
+    );
+    expect(request.auth).toEqual({ sub: 8, sessionId: null });
+  });
+
+  it('nega api key mcp inexistente', async () => {
+    const { guard, deps } = makeService();
+    deps.prisma.mcp_api_key.findFirst.mockResolvedValue(null);
+    const request: any = {
+      headers: { authorization: 'Bearer hedhog_mcp_x' },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).rejects.toThrow(
+      'MCP: Invalid API key',
+    );
+  });
+
+  it('nega api key mcp expirada', async () => {
+    const { guard, deps } = makeService();
+    deps.prisma.mcp_api_key.findFirst.mockResolvedValue({
+      id: 1,
+      user_id: 8,
+      expires_at: new Date(Date.now() - 1000),
+    });
+    const request: any = {
+      headers: { authorization: 'Bearer hedhog_mcp_x' },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).rejects.toThrow(
+      'MCP: API key expired',
+    );
+  });
+});

package/src/mcp/guards/mcp-permission.guard.spec.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { ForbiddenException } from '@nestjs/common';
+import { McpPermissionGuard } from './mcp-permission.guard';
+
+const makeContext = (request: any) => ({
+  switchToHttp: () => ({ getRequest: () => request }),
+});
+
+const makeService = () => {
+  const prisma = { route: { count: jest.fn() } };
+  return { guard: new McpPermissionGuard(prisma as any), prisma };
+};
+
+describe('McpPermissionGuard', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('permite métodos não-POST', async () => {
+    const { guard } = makeService();
+    await expect(
+      guard.canActivate(makeContext({ method: 'GET' }) as any),
+    ).resolves.toBe(true);
+  });
+
+  it('permite POST sem tools/call (ex.: tools/list)', async () => {
+    const { guard, prisma } = makeService();
+    await expect(
+      guard.canActivate(
+        makeContext({ method: 'POST', body: { method: 'tools/list' } }) as any,
+      ),
+    ).resolves.toBe(true);
+    expect(prisma.route.count).not.toHaveBeenCalled();
+  });
+
+  it('permite tools/call quando usuário tem permissão', async () => {
+    const { guard, prisma } = makeService();
+    prisma.route.count.mockResolvedValue(1);
+    const request = {
+      method: 'POST',
+      body: { method: 'tools/call', params: { name: 'my_tool' } },
+      auth: { sub: 2 },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).resolves.toBe(
+      true,
+    );
+    expect(prisma.route.count).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ tool_name: 'my_tool' }),
+      }),
+    );
+  });
+
+  it('nega tools/call sem permissão', async () => {
+    const { guard, prisma } = makeService();
+    prisma.route.count.mockResolvedValue(0);
+    const request = {
+      method: 'POST',
+      body: { method: 'tools/call', params: { name: 'secret_tool' } },
+      auth: { sub: 2 },
+    };
+    await expect(guard.canActivate(makeContext(request) as any)).rejects.toThrow(
+      ForbiddenException,
+    );
+  });
+});

package/src/mcp/mcp-api-key.service.spec.ts

@@ -0,0 +1,125 @@
+import { NotFoundException } from '@nestjs/common';
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { McpApiKeyService } from './mcp-api-key.service';
+
+const makeService = () => {
+  const prisma = {
+    mcp_api_key: {
+      create: jest.fn(),
+      findFirst: jest.fn(),
+      update: jest.fn(),
+    },
+  };
+  const security = {
+    randomOpaque: jest.fn(() => 'abcdefghijklmnopqrstuvwxyz0123456789'),
+    hashWithPepper: jest.fn((v: string) => `hash(${v})`),
+  };
+  const pagination = {
+    paginatePrismaModel: jest.fn(),
+  };
+  const service = new McpApiKeyService(prisma as any, security as any, pagination as any);
+  return { service, prisma, security, pagination };
+};
+
+describe('McpApiKeyService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('list', () => {
+    it('pagina apenas as chaves ativas do usuário e devolve o resultado', async () => {
+      const { service, prisma, pagination } = makeService();
+      const paginated = { data: [], total: 0 };
+      pagination.paginatePrismaModel.mockResolvedValue(paginated);
+
+      const result = await service.list(42, { page: 1, pageSize: 10 } as any);
+
+      expect(result).toBe(paginated);
+      expect(pagination.paginatePrismaModel).toHaveBeenCalledWith(
+        prisma.mcp_api_key,
+        expect.objectContaining({
+          page: 1,
+          pageSize: 10,
+          where: { user_id: 42, revoked_at: null },
+          orderBy: { created_at: 'desc' },
+        }),
+      );
+    });
+  });
+
+  describe('create', () => {
+    it('usa o prefixo mcp por padrão e monta hash/prefixo do token', async () => {
+      const { service, prisma, security } = makeService();
+      prisma.mcp_api_key.create.mockResolvedValue({
+        id: 1,
+        name: 'my key',
+        type: 'mcp',
+        token_prefix: 'hedhog_mcp_abcde',
+        created_at: new Date('2026-01-01'),
+      });
+
+      const result = await service.create(7, 'my key');
+
+      const rawToken = 'hedhog_mcp_abcdefghijklmnopqrstuvwxyz0123456789';
+      expect(security.randomOpaque).toHaveBeenCalledWith(36);
+      expect(security.hashWithPepper).toHaveBeenCalledWith(rawToken);
+      expect(prisma.mcp_api_key.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: {
+            user_id: 7,
+            name: 'my key',
+            type: 'mcp',
+            token_hash: `hash(${rawToken})`,
+            token_prefix: 'hedhog_mcp_abcde',
+          },
+        }),
+      );
+      // O rawToken (em claro) só é devolvido uma vez, na criação.
+      expect(result.rawToken).toBe(rawToken);
+      expect(result.id).toBe(1);
+    });
+
+    it('usa o prefixo api quando type = api', async () => {
+      const { service, prisma } = makeService();
+      prisma.mcp_api_key.create.mockResolvedValue({ id: 2 });
+
+      const result = await service.create(7, 'api key', 'api');
+
+      expect(result.rawToken).toBe('hedhog_api_abcdefghijklmnopqrstuvwxyz0123456789');
+      expect(prisma.mcp_api_key.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: expect.objectContaining({ type: 'api', token_prefix: 'hedhog_api_abcde' }),
+        }),
+      );
+    });
+  });
+
+  describe('revoke', () => {
+    it('lança NotFoundException quando a chave não existe para o usuário', async () => {
+      const { service, prisma } = makeService();
+      prisma.mcp_api_key.findFirst.mockResolvedValue(null);
+
+      await expect(service.revoke(7, 99)).rejects.toThrow(NotFoundException);
+      expect(prisma.mcp_api_key.update).not.toHaveBeenCalled();
+    });
+
+    it('marca revoked_at e retorna success quando a chave existe', async () => {
+      const { service, prisma } = makeService();
+      prisma.mcp_api_key.findFirst.mockResolvedValue({ id: 5, user_id: 7 });
+      prisma.mcp_api_key.update.mockResolvedValue({});
+
+      const result = await service.revoke(7, 5);
+
+      expect(prisma.mcp_api_key.findFirst).toHaveBeenCalledWith({
+        where: { id: 5, user_id: 7 },
+      });
+      expect(prisma.mcp_api_key.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: { id: 5 },
+          data: expect.objectContaining({ revoked_at: expect.any(Date) }),
+        }),
+      );
+      expect(result).toEqual({ success: true });
+    });
+  });
+});