@hed-hog/core 0.0.373 → 0.0.375

package/src/mcp/mcp-registry.service.spec.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { McpRegistryService } from './mcp-registry.service';
+import { MCP_TOOL_METADATA } from './decorators/mcp-tool.decorator';
+
+class ToolProvider {
+  myTool() {
+    return 'result';
+  }
+  notATool() {
+    return 'nope';
+  }
+}
+
+class DuplicateProvider {
+  alsoMyTool() {
+    return 'dup';
+  }
+}
+
+const makeReflector = (defs: Array<[Function, any]>) => {
+  const map = new Map(defs);
+  return {
+    get: jest.fn((_key: any, target: any) => map.get(target)),
+  };
+};
+
+describe('McpRegistryService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('registra tools decoradas e ignora métodos sem metadata', () => {
+    const instance = new ToolProvider();
+    const reflector = makeReflector([
+      [ToolProvider.prototype.myTool, { name: 'my_tool', description: 'd' }],
+    ]);
+    const discovery = { getProviders: () => [{ instance }] };
+    const service = new McpRegistryService(discovery as any, reflector as any);
+
+    service.onModuleInit();
+
+    expect(service.has('my_tool')).toBe(true);
+    expect(service.getAll()).toHaveLength(1);
+    expect(reflector.get).toHaveBeenCalledWith(
+      MCP_TOOL_METADATA,
+      ToolProvider.prototype.myTool,
+    );
+  });
+
+  it('deduplica tools com mesmo nome (mantém a primeira)', () => {
+    const first = new ToolProvider();
+    const dup = new DuplicateProvider();
+    const reflector = makeReflector([
+      [ToolProvider.prototype.myTool, { name: 'my_tool', description: 'first' }],
+      [DuplicateProvider.prototype.alsoMyTool, { name: 'my_tool', description: 'dup' }],
+    ]);
+    const discovery = { getProviders: () => [{ instance: first }, { instance: dup }] };
+    const service = new McpRegistryService(discovery as any, reflector as any);
+
+    service.onModuleInit();
+
+    expect(service.getAll()).toHaveLength(1);
+    expect(service.get('my_tool')?.definition.description).toBe('first');
+  });
+
+  it('ignora providers sem instância', () => {
+    const reflector = makeReflector([]);
+    const discovery = {
+      getProviders: () => [{ instance: null }, { instance: undefined }],
+    };
+    const service = new McpRegistryService(discovery as any, reflector as any);
+    service.onModuleInit();
+    expect(service.getAll()).toHaveLength(0);
+  });
+
+  it('handler executa o método vinculado à instância', async () => {
+    const instance = new ToolProvider();
+    const reflector = makeReflector([
+      [ToolProvider.prototype.myTool, { name: 'my_tool', description: 'd' }],
+    ]);
+    const discovery = { getProviders: () => [{ instance }] };
+    const service = new McpRegistryService(discovery as any, reflector as any);
+    service.onModuleInit();
+
+    const entry = service.get('my_tool');
+    expect(entry!.handler({}, {} as any)).toBe('result');
+  });
+
+  it('get retorna undefined para tool inexistente', () => {
+    const service = new McpRegistryService(
+      { getProviders: () => [] } as any,
+      makeReflector([]) as any,
+    );
+    service.onModuleInit();
+    expect(service.get('missing')).toBeUndefined();
+    expect(service.has('missing')).toBe(false);
+  });
+});

package/src/mcp/mcp-server.service.spec.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+
+const setRequestHandlerMock = jest.fn();
+const connectMock = jest.fn<any>().mockResolvedValue(undefined);
+const handleRequestMock = jest.fn<any>().mockResolvedValue(undefined);
+
+jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+  Server: jest.fn().mockImplementation(function (this: any) {
+    this.setRequestHandler = setRequestHandlerMock;
+    this.connect = connectMock;
+  }),
+}));
+
+jest.mock('@modelcontextprotocol/sdk/server/streamableHttp.js', () => ({
+  StreamableHTTPServerTransport: jest.fn().mockImplementation(function (this: any) {
+    this.handleRequest = handleRequestMock;
+  }),
+}));
+
+import { McpServerService } from './mcp-server.service';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { McpContext } from './types/mcp-context.type';
+
+const makeDeps = () => {
+  const registry = {
+    getAll: jest.fn(),
+    get: jest.fn(),
+  };
+  const audit = {
+    record: jest.fn<any>().mockResolvedValue(undefined),
+  };
+  return { registry, audit };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new McpServerService(deps.registry as any, deps.audit as any),
+  deps,
+});
+
+const getRegisteredHandler = (schema: any) => {
+  const call = setRequestHandlerMock.mock.calls.find((c: any) => c[0] === schema);
+  return call?.[1];
+};
+
+const context: McpContext = {
+  userId: 1,
+  sessionId: 'sess-1',
+  locale: 'pt-BR',
+  toolName: '',
+};
+
+describe('McpServerService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('buildServer / ListTools handler', () => {
+    it('lista as ferramentas registradas mapeando definition para o schema MCP', async () => {
+      const { service, deps } = makeService();
+      deps.registry.getAll.mockReturnValue([
+        {
+          definition: { name: 'tool-a', description: 'desc a', inputSchema: { type: 'object', properties: { x: {} } } },
+          handler: jest.fn(),
+        },
+        {
+          definition: { name: 'tool-b', description: 'desc b' },
+          handler: jest.fn(),
+        },
+      ]);
+
+      (service as any).buildServer(context);
+      const listHandler = getRegisteredHandler(ListToolsRequestSchema);
+      const result = await listHandler();
+
+      expect(result.tools).toEqual([
+        { name: 'tool-a', description: 'desc a', inputSchema: { type: 'object', properties: { x: {} } } },
+        { name: 'tool-b', description: 'desc b', inputSchema: { type: 'object', properties: {} } },
+      ]);
+    });
+  });
+
+  describe('buildServer / CallTool handler', () => {
+    it('retorna erro quando a ferramenta não é encontrada e não audita', async () => {
+      const { service, deps } = makeService();
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue(undefined);
+
+      (service as any).buildServer(context);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+
+      const result = await callHandler({
+        params: { name: 'missing-tool', arguments: {} },
+      });
+
+      expect(result).toEqual({
+        isError: true,
+        content: [{ type: 'text', text: `Tool 'missing-tool' not found` }],
+      });
+      expect(deps.audit.record).not.toHaveBeenCalled();
+    });
+
+    it('executa a ferramenta com sucesso, audita success:true e retorna o resultado serializado', async () => {
+      const { service, deps } = makeService();
+      const handler = jest.fn<any>().mockResolvedValue({ ok: true, value: 42 });
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue({
+        definition: { name: 'tool-a' },
+        handler,
+      });
+
+      (service as any).buildServer(context);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+
+      const result = await callHandler({
+        params: { name: 'tool-a', arguments: { a: 1 } },
+      });
+
+      expect(handler).toHaveBeenCalledWith({ a: 1 }, { ...context, toolName: 'tool-a' });
+      expect(result).toEqual({
+        content: [{ type: 'text', text: JSON.stringify({ ok: true, value: 42 }) }],
+      });
+      expect(deps.audit.record).toHaveBeenCalledWith(
+        expect.objectContaining({
+          userId: context.userId,
+          toolName: 'tool-a',
+          input: { a: 1 },
+          success: true,
+        }),
+      );
+    });
+
+    it('trata argumentos ausentes como objeto vazio', async () => {
+      const { service, deps } = makeService();
+      const handler = jest.fn<any>().mockResolvedValue({});
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue({ definition: { name: 'tool-a' }, handler });
+
+      (service as any).buildServer(context);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+
+      await callHandler({ params: { name: 'tool-a' } });
+
+      expect(handler).toHaveBeenCalledWith({}, expect.anything());
+    });
+
+    it('captura exceção do handler, audita success:false com o erro e retorna isError', async () => {
+      const { service, deps } = makeService();
+      const handler = jest.fn<any>().mockRejectedValue(new Error('boom'));
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue({ definition: { name: 'tool-a' }, handler });
+
+      (service as any).buildServer(context);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+
+      const result = await callHandler({
+        params: { name: 'tool-a', arguments: {} },
+      });
+
+      expect(result).toEqual({
+        isError: true,
+        content: [{ type: 'text', text: 'boom' }],
+      });
+      expect(deps.audit.record).toHaveBeenCalledWith(
+        expect.objectContaining({
+          toolName: 'tool-a',
+          success: false,
+          error: 'boom',
+        }),
+      );
+    });
+  });
+
+  describe('handleRequest', () => {
+    it('conecta o servidor e delega ao transport HTTP', async () => {
+      const { service, deps } = makeService();
+      deps.registry.getAll.mockReturnValue([]);
+      const req = { body: { hello: 'world' } } as any;
+      const res = {} as any;
+
+      await service.handleRequest(req, res, context);
+
+      expect(connectMock).toHaveBeenCalledTimes(1);
+      expect(handleRequestMock).toHaveBeenCalledWith(req, res, req.body);
+    });
+  });
+});

package/src/menu/menu.service.spec.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { BadRequestException } from '@nestjs/common';
+import { MenuService } from './menu.service';
+
+const makeService = (prisma: any) =>
+  new MenuService(prisma as any, {} as any);
+
+describe('MenuService.ensureValidParent', () => {
+  let prisma: any;
+  let service: MenuService;
+
+  beforeEach(() => {
+    prisma = {
+      menu: { findUnique: jest.fn() },
+    };
+    service = makeService(prisma);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const call = (
+    locale: string,
+    currentMenuId: number | null,
+    parentId?: number | null,
+  ) => (service as any).ensureValidParent(locale, currentMenuId, parentId);
+
+  it('retorna sem consultar quando parentId é null/undefined', async () => {
+    await expect(call('en', 5, null)).resolves.toBeUndefined();
+    await expect(call('en', 5, undefined)).resolves.toBeUndefined();
+    expect(prisma.menu.findUnique).not.toHaveBeenCalled();
+  });
+
+  it('lança BadRequestException quando parent não existe', async () => {
+    prisma.menu.findUnique.mockResolvedValue(null);
+    await expect(call('en', 5, 99)).rejects.toThrow(BadRequestException);
+  });
+
+  it('lança quando parentId é igual ao próprio menu', async () => {
+    prisma.menu.findUnique.mockResolvedValue({ id: 5, menu_id: null });
+    await expect(call('en', 5, 5)).rejects.toThrow(BadRequestException);
+  });
+
+  it('retorna quando currentMenuId é null (criação) e parent existe', async () => {
+    prisma.menu.findUnique.mockResolvedValue({ id: 10, menu_id: null });
+    await expect(call('en', null, 10)).resolves.toBeUndefined();
+    // apenas a busca inicial do parent
+    expect(prisma.menu.findUnique).toHaveBeenCalledTimes(1);
+  });
+
+  it('aceita mover para um parent de raiz distinto (sem ciclo)', async () => {
+    // parent 10 tem pai 20, e 20 é raiz. currentMenu é 5, não aparece na cadeia.
+    prisma.menu.findUnique
+      .mockResolvedValueOnce({ id: 10, menu_id: 20 }) // parent inicial
+      .mockResolvedValueOnce({ id: 20, menu_id: null }); // sobe até raiz
+    await expect(call('en', 5, 10)).resolves.toBeUndefined();
+  });
+
+  it('detecta ciclo quando o parent é descendente do menu atual', async () => {
+    // currentMenu = 5; parent = 10 cujo ancestral é 5 → mover 5 para dentro de 10 formaria ciclo
+    prisma.menu.findUnique
+      .mockResolvedValueOnce({ id: 10, menu_id: 5 }) // parent inicial, pai é o próprio menu 5
+      .mockResolvedValueOnce({ id: 5, menu_id: null });
+    await expect(call('en', 5, 10)).rejects.toThrow(BadRequestException);
+  });
+
+  it('detecta ciclo mais profundo na cadeia de ancestrais', async () => {
+    // 5 é o atual; cadeia: parent 10 -> 11 -> 5 (ciclo)
+    prisma.menu.findUnique
+      .mockResolvedValueOnce({ id: 10, menu_id: 11 })
+      .mockResolvedValueOnce({ id: 11, menu_id: 5 })
+      .mockResolvedValueOnce({ id: 5, menu_id: null });
+    await expect(call('en', 5, 10)).rejects.toThrow(BadRequestException);
+  });
+});

package/src/notification/notification.service.spec.ts

@@ -0,0 +1,297 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import {
+  BadRequestException,
+  ForbiddenException,
+  NotFoundException,
+} from '@nestjs/common';
+import { NotificationService } from './notification.service';
+
+const makeDeps = () => {
+  const prisma = {
+    notification: {
+      count: jest.fn(),
+      findUnique: jest.fn(),
+      update: jest.fn(),
+      updateMany: jest.fn(),
+      delete: jest.fn(),
+      deleteMany: jest.fn(),
+      create: jest.fn(),
+    },
+    $executeRaw: jest.fn().mockResolvedValue(0),
+    $executeRawUnsafe: jest.fn().mockResolvedValue(0),
+  };
+  const pagination = { paginate: jest.fn().mockResolvedValue({ data: [] }) };
+  const eventEmitter = { emitAsync: jest.fn().mockResolvedValue([]) };
+  return { prisma, pagination, eventEmitter };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new NotificationService(
+    deps.prisma as any,
+    deps.pagination as any,
+    deps.eventEmitter as any,
+  ),
+  deps,
+});
+
+describe('NotificationService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  describe('isActiveAsyncNotification', () => {
+    let service: NotificationService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+    const call = (n: any) => (service as any).isActiveAsyncNotification(n);
+
+    it('true quando progresso em andamento e não finalizado', () => {
+      expect(call({ progress: 50, finished_at: null })).toBe(true);
+    });
+    it('false quando progress null', () => {
+      expect(call({ progress: null, finished_at: null })).toBe(false);
+    });
+    it('false quando progress >= 100', () => {
+      expect(call({ progress: 100, finished_at: null })).toBe(false);
+    });
+    it('false quando já finalizado', () => {
+      expect(call({ progress: 50, finished_at: new Date() })).toBe(false);
+    });
+  });
+
+  describe('assertOwnership', () => {
+    it('lança NotFound quando não existe', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue(null);
+      await expect((service as any).assertOwnership(1, 5)).rejects.toThrow(
+        NotFoundException,
+      );
+    });
+    it('lança Forbidden quando dono diverge', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({ user_id: 2 });
+      await expect((service as any).assertOwnership(1, 5)).rejects.toThrow(
+        ForbiddenException,
+      );
+    });
+    it('retorna notificação do dono', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({ user_id: 1 });
+      await expect((service as any).assertOwnership(1, 5)).resolves.toMatchObject(
+        { user_id: 1 },
+      );
+    });
+  });
+
+  describe('unreadCount', () => {
+    it('retorna contagem de não lidas', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.count.mockResolvedValue(3);
+      await expect(service.unreadCount(1)).resolves.toEqual({ count: 3 });
+    });
+  });
+
+  describe('markRead', () => {
+    it('remove quando auto_remove e não ativa', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({
+        user_id: 1,
+        auto_remove: true,
+        progress: null,
+        finished_at: null,
+      });
+      deps.prisma.notification.delete.mockResolvedValue({ id: 5 });
+      await service.markRead(1, 5);
+      expect(deps.prisma.notification.delete).toHaveBeenCalledWith({
+        where: { id: 5 },
+      });
+    });
+
+    it('rejeita remover async ativa auto_remove', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({
+        user_id: 1,
+        auto_remove: true,
+        progress: 40,
+        finished_at: null,
+      });
+      await expect(service.markRead(1, 5)).rejects.toThrow(BadRequestException);
+    });
+
+    it('marca como lida quando não auto_remove', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({
+        user_id: 1,
+        auto_remove: false,
+        progress: null,
+        finished_at: null,
+      });
+      deps.prisma.notification.update.mockResolvedValue({ id: 5, status: 'read' });
+      await service.markRead(1, 5);
+      expect(deps.prisma.notification.update).toHaveBeenCalledWith({
+        where: { id: 5 },
+        data: { status: 'read' },
+      });
+    });
+  });
+
+  describe('delete', () => {
+    it('rejeita async ativa', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({
+        user_id: 1,
+        progress: 40,
+        finished_at: null,
+      });
+      await expect(service.delete(1, 5)).rejects.toThrow(BadRequestException);
+    });
+
+    it('remove notificação normal', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({
+        user_id: 1,
+        progress: null,
+        finished_at: null,
+      });
+      deps.prisma.notification.delete.mockResolvedValue({ id: 5 });
+      await expect(service.delete(1, 5)).resolves.toEqual({ id: 5 });
+    });
+  });
+
+  describe('create', () => {
+    it('aplica defaults (info/url/auto_remove false)', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.create.mockResolvedValue({ id: 9 });
+      await service.create({ user_id: 1, title: 't', body: 'b' } as any);
+      const arg = deps.prisma.notification.create.mock.calls[0][0];
+      expect(arg.data.type).toBe('info');
+      expect(arg.data.action_type).toBe('url');
+      expect(arg.data.auto_remove).toBe(false);
+    });
+  });
+
+  describe('updateProgress', () => {
+    it('finaliza com sucesso quando progress >= 100', async () => {
+      jest.useFakeTimers().setSystemTime(new Date('2026-01-01T00:00:00Z'));
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({ user_id: 1 });
+      deps.prisma.notification.update.mockResolvedValue({ id: 5 });
+      await service.updateProgress(1, 5, { progress: 100 } as any);
+      const data = deps.prisma.notification.update.mock.calls[0][0].data;
+      expect(data.type).toBe('success');
+      expect(data.finished_at).toBeInstanceOf(Date);
+    });
+
+    it('marca erro quando finaliza com success=false', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({ user_id: 1 });
+      deps.prisma.notification.update.mockResolvedValue({ id: 5 });
+      await service.updateProgress(1, 5, { progress: 100, success: false } as any);
+      expect(deps.prisma.notification.update.mock.calls[0][0].data.type).toBe(
+        'error',
+      );
+    });
+
+    it('não finaliza quando progress < 100', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.findUnique.mockResolvedValue({ user_id: 1 });
+      deps.prisma.notification.update.mockResolvedValue({ id: 5 });
+      await service.updateProgress(1, 5, { progress: 30 } as any);
+      const data = deps.prisma.notification.update.mock.calls[0][0].data;
+      expect(data.type).toBeUndefined();
+      expect(data.finished_at).toBeUndefined();
+    });
+  });
+
+  describe('markAllRead / deleteAll', () => {
+    it('markAllRead limpa auto_remove e marca restantes como lidas', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.deleteMany.mockResolvedValue({ count: 1 });
+      deps.prisma.notification.updateMany.mockResolvedValue({ count: 2 });
+      await expect(service.markAllRead(1)).resolves.toEqual({ count: 2 });
+    });
+
+    it('deleteAll remove concluídas', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.notification.deleteMany.mockResolvedValue({ count: 4 });
+      await expect(service.deleteAll(1)).resolves.toEqual({ count: 4 });
+    });
+  });
+
+  describe('broadcastNotificationEvent', () => {
+    it('engole erro do $executeRaw', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.$executeRaw.mockRejectedValue(new Error('down'));
+      await expect(
+        (service as any).broadcastNotificationEvent(1, { type: 'notification.updated' }),
+      ).resolves.toBeUndefined();
+    });
+
+    it('emite evento local para o usuário', async () => {
+      const { service } = makeService();
+      const received: any[] = [];
+      (service as any).notificationEvents.on('notification:7', (e: any) =>
+        received.push(e),
+      );
+      await (service as any).broadcastNotificationEvent(7, {
+        type: 'notification.created',
+      });
+      expect(received).toHaveLength(1);
+    });
+  });
+
+  describe('handleClusterNotification', () => {
+    it('ignora canal diferente', () => {
+      const { service } = makeService();
+      const spy = jest.spyOn(service as any, 'emitLocalNotificationEvent');
+      (service as any).handleClusterNotification({ channel: 'other', payload: '{}' });
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it('ignora mensagem da própria instância', () => {
+      const { service } = makeService();
+      const instanceId = (service as any).instanceId;
+      const spy = jest.spyOn(service as any, 'emitLocalNotificationEvent');
+      (service as any).handleClusterNotification({
+        channel: 'notification_events',
+        payload: JSON.stringify({ originInstanceId: instanceId, userId: 1 }),
+      });
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it('reemite evento de outra instância', () => {
+      const { service } = makeService();
+      const spy = jest.spyOn(service as any, 'emitLocalNotificationEvent');
+      (service as any).handleClusterNotification({
+        channel: 'notification_events',
+        payload: JSON.stringify({
+          originInstanceId: 'other',
+          userId: 3,
+          type: 'notification.updated',
+        }),
+      });
+      expect(spy).toHaveBeenCalledWith(3, expect.objectContaining({
+        type: 'notification.updated',
+      }));
+    });
+
+    it('ignora payload inválido', () => {
+      const { service } = makeService();
+      const spy = jest.spyOn(service as any, 'emitLocalNotificationEvent');
+      (service as any).handleClusterNotification({
+        channel: 'notification_events',
+        payload: 'not-json',
+      });
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getEventKey', () => {
+    it('formata chave por usuário', () => {
+      const { service } = makeService();
+      expect((service as any).getEventKey(42)).toBe('notification:42');
+    });
+  });
+});