@hed-hog/core 0.0.373 → 0.0.375

package/src/session/session.service.spec.ts

@@ -0,0 +1,376 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from '@jest/globals';
+import {
+  BadRequestException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { SessionService } from './session.service';
+
+const makeDeps = () => {
+  const prisma = {
+    user_session: {
+      create: jest.fn(),
+      findFirst: jest.fn(),
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      updateMany: jest.fn(),
+      update: jest.fn(),
+    },
+    user: { findUnique: jest.fn() },
+    $transaction: jest.fn(),
+  };
+  const security = {
+    hashWithPepper: jest.fn((v: string) => `hash(${v})`),
+  };
+  const setting = {
+    getSettingValues: jest.fn().mockResolvedValue({}),
+  };
+  const token = {
+    createOpaqueToken: jest.fn().mockResolvedValue('opaque'),
+    removeRefreshTokenCookie: jest.fn().mockResolvedValue(undefined),
+  };
+  const http = { get: jest.fn() };
+  const user = { registerUserActivity: jest.fn().mockResolvedValue(undefined) };
+  const paginationService = { paginatePrismaModel: jest.fn() };
+  return { prisma, security, setting, token, http, user, paginationService };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new SessionService(
+    deps.prisma as any,
+    deps.security as any,
+    deps.setting as any,
+    deps.token as any,
+    deps.http as any,
+    deps.user as any,
+    deps.paginationService as any,
+  ),
+  deps,
+});
+
+describe('SessionService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  describe('create - validações', () => {
+    it('lança BadRequest sem userId', async () => {
+      const { service } = makeService();
+      await expect(
+        service.create('en', 0 as any, '1.2.3.4', 'ua'),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('lança BadRequest sem ipAddress', async () => {
+      const { service } = makeService();
+      await expect(service.create('en', 1, '', 'ua')).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('lança BadRequest sem userAgent', async () => {
+      const { service } = makeService();
+      await expect(service.create('en', 1, '1.2.3.4', '')).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('cria sessão com expiração default (43200 min) quando setting ausente', async () => {
+      jest.useFakeTimers().setSystemTime(new Date('2026-01-15T12:00:00Z'));
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({});
+      deps.prisma.user_session.create.mockResolvedValue({ id: 1 });
+
+      const result = await service.create('en', 5, '1.2.3.4', 'ua', 'br-1');
+
+      expect(result.token).toBe('opaque');
+      const createArg = deps.prisma.user_session.create.mock.calls[0][0];
+      expect(createArg.data.hash).toBe('hash(opaque)');
+      expect(createArg.data.browser_id).toBe('br-1');
+      const expected = new Date(
+        Date.parse('2026-01-15T12:00:00Z') + 43200 * 60 * 1000,
+      );
+      expect(createArg.data.expires_at.getTime()).toBe(expected.getTime());
+    });
+
+    it('aciona enforceSessionLimit quando max-concurrent-sessions > 0', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'max-concurrent-sessions': 2,
+      });
+      deps.prisma.user_session.findMany.mockResolvedValue([]);
+      deps.prisma.user_session.create.mockResolvedValue({ id: 1 });
+
+      await service.create('en', 5, '1.2.3.4', 'ua');
+
+      expect(deps.prisma.user_session.findMany).toHaveBeenCalled();
+    });
+  });
+
+  describe('enforceSessionLimit', () => {
+    const run = (
+      deps: ReturnType<typeof makeDeps>,
+      service: SessionService,
+      sessions: Array<{ id: number; browser_id: string | null }>,
+      maxSessions: number,
+      isRotation: boolean,
+      currentBrowserId?: string | null,
+    ) => {
+      deps.prisma.user_session.findMany.mockResolvedValue(sessions);
+      return (service as any).enforceSessionLimit(
+        7,
+        maxSessions,
+        isRotation,
+        currentBrowserId,
+      );
+    };
+
+    it('não revoga quando abaixo do limite', async () => {
+      const { service, deps } = makeService();
+      await run(
+        deps,
+        service,
+        [{ id: 1, browser_id: 'a' }],
+        3,
+        false,
+        'b',
+      );
+      expect(deps.prisma.user_session.updateMany).not.toHaveBeenCalled();
+    });
+
+    it('agrupa sessões do mesmo browser em um único slot', async () => {
+      const { service, deps } = makeService();
+      await run(
+        deps,
+        service,
+        [
+          { id: 1, browser_id: 'a' },
+          { id: 2, browser_id: 'a' },
+        ],
+        1,
+        false,
+        'a', // browser já tem slot -> isNewSlot false, currentSlotCount=1, revoke=1-1+0=0
+      );
+      expect(deps.prisma.user_session.updateMany).not.toHaveBeenCalled();
+    });
+
+    it('cada browser_id null conta como slot próprio', async () => {
+      const { service, deps } = makeService();
+      await run(
+        deps,
+        service,
+        [
+          { id: 1, browser_id: null },
+          { id: 2, browser_id: null },
+        ],
+        1,
+        false,
+        null, // novo slot: currentSlotCount=2, revoke=2-1+1=2 -> revoga ambos
+      );
+      expect(deps.prisma.user_session.updateMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: { id: { in: [1, 2] } },
+        }),
+      );
+    });
+
+    it('revoga o slot mais antigo quando novo browser excede o limite', async () => {
+      const { service, deps } = makeService();
+      await run(
+        deps,
+        service,
+        [
+          { id: 1, browser_id: 'old' },
+          { id: 2, browser_id: 'mid' },
+        ],
+        2,
+        false,
+        'new', // currentSlotCount=2, isNewSlot true, revoke=2-2+1=1 -> revoga slot 0 (id 1)
+      );
+      expect(deps.prisma.user_session.updateMany).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { id: { in: [1] } } }),
+      );
+    });
+
+    it('rotação não abre novo slot', async () => {
+      const { service, deps } = makeService();
+      await run(
+        deps,
+        service,
+        [
+          { id: 1, browser_id: 'a' },
+          { id: 2, browser_id: 'b' },
+        ],
+        2,
+        true, // rotation: isNewSlot false, revoke=2-2+0=0
+        'c',
+      );
+      expect(deps.prisma.user_session.updateMany).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('refresh', () => {
+    it('lança Unauthorized sem refreshToken', async () => {
+      const { service } = makeService();
+      await expect(
+        service.refresh('en', '', '1.2.3.4', 'ua'),
+      ).rejects.toThrow(UnauthorizedException);
+    });
+
+    it('lança Unauthorized quando hash não encontrado', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue(null);
+      await expect(
+        service.refresh('en', 'tok', '1.2.3.4', 'ua'),
+      ).rejects.toThrow(UnauthorizedException);
+    });
+
+    it('lança Unauthorized quando sessão revogada', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue({
+        id: 1,
+        user_id: 5,
+        revoked_at: new Date(),
+        expires_at: new Date(Date.now() + 100000),
+      });
+      await expect(
+        service.refresh('en', 'tok', '1.2.3.4', 'ua'),
+      ).rejects.toThrow(UnauthorizedException);
+    });
+
+    it('lança Unauthorized quando sessão expirada', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue({
+        id: 1,
+        user_id: 5,
+        revoked_at: null,
+        expires_at: new Date(Date.now() - 1000),
+      });
+      await expect(
+        service.refresh('en', 'tok', '1.2.3.4', 'ua'),
+      ).rejects.toThrow(UnauthorizedException);
+    });
+
+    it('lança Unauthorized em corrida (updateResult.count === 0)', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue({
+        id: 1,
+        user_id: 5,
+        ip_address: '9.9.9.9',
+        user_agent: 'old-ua',
+        revoked_at: null,
+        expires_at: new Date(Date.now() + 100000),
+        browser_id: 'br',
+      });
+      const tx = {
+        user_session: {
+          updateMany: jest.fn().mockResolvedValue({ count: 0 }),
+          create: jest.fn().mockResolvedValue({ id: 2 }),
+        },
+      };
+      deps.prisma.$transaction.mockImplementation(async (cb: any) => cb(tx));
+
+      await expect(
+        service.refresh('en', 'tok', '1.2.3.4', 'ua'),
+      ).rejects.toThrow(UnauthorizedException);
+    });
+
+    it('rotaciona sessão e usa fallback de ip/ua quando vazios', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue({
+        id: 1,
+        user_id: 5,
+        ip_address: '9.9.9.9',
+        user_agent: 'old-ua',
+        revoked_at: null,
+        expires_at: new Date(Date.now() + 100000),
+        browser_id: 'br',
+      });
+      const tx = {
+        user_session: {
+          updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+          create: jest.fn().mockResolvedValue({ id: 2 }),
+        },
+      };
+      deps.prisma.$transaction.mockImplementation(async (cb: any) => cb(tx));
+
+      const result = await service.refresh('en', 'tok', '   ', '');
+
+      expect(result.token).toBe('opaque');
+      expect(result.session).toEqual({ id: 2 });
+      const createArg = tx.user_session.create.mock.calls[0][0];
+      expect(createArg.data.ip_address).toBe('9.9.9.9');
+      expect(createArg.data.user_agent).toBe('old-ua');
+      expect(createArg.data.browser_id).toBe('br');
+    });
+  });
+
+  describe('getUserSessions - paginação', () => {
+    it('lança BadRequest quando usuário não existe', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user.findUnique.mockResolvedValue(null);
+      await expect(
+        service.getUserSessions({ page: 1, pageSize: 10 } as any, 1, 'en'),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it('calcula lastPage e trata IP localhost', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user.findUnique.mockResolvedValue({ id: 1 });
+      deps.paginationService.paginatePrismaModel.mockResolvedValue({
+        data: [{ id: 1, ip_address: '127.0.0.1' }],
+        total: 25,
+        page: 1,
+        pageSize: 10,
+      });
+
+      const result = await service.getUserSessions(
+        { page: 1, pageSize: 10 } as any,
+        1,
+        'en',
+      );
+
+      expect(result.lastPage).toBe(3); // ceil(25/10)
+      expect(result.total).toBe(25);
+      expect(result.data[0].location).toEqual({
+        ip: '127.0.0.1',
+        country: 'Localhost',
+        region: '',
+        city: '',
+      });
+    });
+  });
+
+  describe('revokeUserSession', () => {
+    it('lança NotFound quando sessão não pertence ao usuário', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue(null);
+      await expect(
+        service.revokeUserSession(1, 99, 'en'),
+      ).rejects.toThrow('Session not found or does not belong to user');
+    });
+
+    it('revoga sessão existente e registra atividade', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_session.findFirst.mockResolvedValue({ id: 5 });
+      deps.prisma.user_session.update.mockResolvedValue({ id: 5 });
+
+      await service.revokeUserSession(1, 5, 'en');
+
+      expect(deps.user.registerUserActivity).toHaveBeenCalledWith(
+        1,
+        'revokeSession',
+      );
+      expect(deps.prisma.user_session.update).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { id: 5 } }),
+      );
+    });
+  });
+});

package/src/setting/setting.service.spec.ts

@@ -0,0 +1,316 @@
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  jest,
+} from '@jest/globals';
+import { BadRequestException } from '@nestjs/common';
+import { SettingService } from './setting.service';
+
+const makeDeps = () => {
+  const prisma = {
+    setting: {
+      findMany: jest.fn(),
+      findFirst: jest.fn(),
+      findUnique: jest.fn(),
+    },
+    setting_user: { findMany: jest.fn() },
+    user: { findUnique: jest.fn() },
+    $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+    $queryRawUnsafe: jest.fn().mockResolvedValue([]),
+    $transaction: jest.fn(),
+  };
+  const pagination = { paginate: jest.fn() };
+  const locale = { getEnables: jest.fn().mockResolvedValue([]) };
+  const integrationApi = { publishEvents: jest.fn().mockResolvedValue(undefined) };
+  return { prisma, pagination, locale, integrationApi };
+};
+
+const makeService = (deps = makeDeps()) => ({
+  service: new SettingService(
+    deps.prisma as any,
+    deps.pagination as any,
+    deps.locale as any,
+    deps.integrationApi as any,
+  ),
+  deps,
+});
+
+describe('SettingService', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  describe('setValueFormattedByType', () => {
+    let service: SettingService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+
+    it('coage boolean para "true"/"false"', () => {
+      expect(service.setValueFormattedByType('boolean', true)).toBe('true');
+      expect(service.setValueFormattedByType('boolean', 'true')).toBe('true');
+      expect(service.setValueFormattedByType('boolean', false)).toBe('false');
+      expect(service.setValueFormattedByType('boolean', 'no')).toBe('false');
+    });
+
+    it('number: vazio/null vira ""', () => {
+      expect(service.setValueFormattedByType('number', '')).toBe('');
+      expect(service.setValueFormattedByType('number', null)).toBe('');
+      expect(service.setValueFormattedByType('number', undefined)).toBe('');
+      expect(service.setValueFormattedByType('number', '   ')).toBe('');
+    });
+
+    it('number: converte valor válido e lança em inválido', () => {
+      expect(service.setValueFormattedByType('number', '42')).toBe('42');
+      expect(service.setValueFormattedByType('number', 3.5)).toBe('3.5');
+      expect(() => service.setValueFormattedByType('number', 'abc')).toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('array/json: serializa objeto, mantém string', () => {
+      expect(service.setValueFormattedByType('json', { a: 1 })).toBe('{"a":1}');
+      expect(service.setValueFormattedByType('array', [1, 2])).toBe('[1,2]');
+      expect(service.setValueFormattedByType('json', '{"x":1}')).toBe('{"x":1}');
+    });
+
+    it('default: retorna valor sem alteração', () => {
+      expect(service.setValueFormattedByType('string', 'hello')).toBe('hello');
+    });
+  });
+
+  describe('getValueFormattedByType', () => {
+    let service: SettingService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+
+    it('espelha regras de boolean/number/json', () => {
+      expect(service.getValueFormattedByType('boolean', 'true')).toBe('true');
+      expect(service.getValueFormattedByType('number', '7')).toBe('7');
+      expect(service.getValueFormattedByType('number', '')).toBe('');
+      expect(service.getValueFormattedByType('json', { b: 2 })).toBe('{"b":2}');
+      expect(service.getValueFormattedByType('other', 'x')).toBe('x');
+      expect(() => service.getValueFormattedByType('number', 'NaNzz')).toThrow(
+        BadRequestException,
+      );
+    });
+  });
+
+  describe('parseVersionValue', () => {
+    it('trata number/bigint/string/desconhecido', () => {
+      const { service } = makeService();
+      const p = (v: unknown) => (service as any).parseVersionValue(v);
+      expect(p(5)).toBe(5);
+      expect(p(BigInt(9))).toBe(9);
+      expect(p('12')).toBe(12);
+      expect(p(null)).toBe(0);
+      expect(p({})).toBe(0);
+    });
+  });
+
+  describe('normalizeValueForComparison', () => {
+    let service: SettingService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+    const call = (v: any) => (service as any).normalizeValueForComparison(v);
+
+    it('undefined vira sentinela, null permanece null', () => {
+      expect(call(undefined)).toBe('__undefined__');
+      expect(call(null)).toBeNull();
+    });
+
+    it('faz trim de strings', () => {
+      expect(call('  hi  ')).toBe('hi');
+    });
+
+    it('serializa objeto e cai em String em circular', () => {
+      expect(call({ a: 1 })).toBe('{"a":1}');
+      const circular: any = {};
+      circular.self = circular;
+      expect(call(circular)).toBe('[object Object]');
+    });
+  });
+
+  describe('isValueDefined', () => {
+    let service: SettingService;
+    beforeEach(() => {
+      service = makeService().service;
+    });
+    const call = (v: any) => (service as any).isValueDefined(v);
+
+    it('false para undefined/null/vazio', () => {
+      expect(call(undefined)).toBe(false);
+      expect(call(null)).toBe(false);
+      expect(call('   ')).toBe(false);
+      expect(call([])).toBe(false);
+    });
+
+    it('true para conteúdo', () => {
+      expect(call('x')).toBe(true);
+      expect(call([1])).toBe(true);
+      expect(call(0)).toBe(true);
+      expect(call(true)).toBe(true);
+    });
+  });
+
+  describe('setCache / clearCache', () => {
+    it('mescla e limpa o cache', () => {
+      const { service } = makeService();
+      service.setCache({ a: 1 });
+      service.setCache({ b: 2 });
+      expect((service as any).cachedSettings).toEqual({ a: 1, b: 2 });
+      service.clearCache();
+      expect((service as any).cachedSettings).toEqual({});
+    });
+  });
+
+  describe('getSettingValues', () => {
+    it('coage valores por tipo', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findMany.mockResolvedValue([
+        { id: 1, slug: 'flag', type: 'boolean', value: 'true', user_override: false },
+        { id: 2, slug: 'count', type: 'number', value: '10', user_override: false },
+        { id: 3, slug: 'list', type: 'json', value: '{"a":1}', user_override: false },
+        { id: 4, slug: 'name', type: 'string', value: 'hh', user_override: false },
+      ]);
+
+      const result = await service.getSettingValues(['flag', 'count', 'list', 'name']);
+
+      expect(result).toEqual({
+        flag: true,
+        count: 10,
+        list: { a: 1 },
+        name: 'hh',
+      });
+    });
+
+    it('json inválido cai em string bruta', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findMany.mockResolvedValue([
+        { id: 1, slug: 'bad', type: 'json', value: 'not-json', user_override: false },
+      ]);
+      const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await service.getSettingValues('bad');
+
+      expect(result.bad).toBe('not-json');
+      errSpy.mockRestore();
+    });
+
+    it('serve do cache sem reconsultar quando slug já cacheado', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findMany.mockResolvedValue([
+        { id: 1, slug: 'flag', type: 'boolean', value: 'true', user_override: false },
+      ]);
+
+      await service.getSettingValues('flag');
+      const second = await service.getSettingValues('flag');
+
+      expect(second).toEqual({ flag: true });
+      expect(deps.prisma.setting.findMany).toHaveBeenCalledTimes(1);
+    });
+
+    it('aplica override do usuário sem cachear', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.setting.findMany.mockResolvedValue([
+        { id: 7, slug: 'theme', type: 'string', value: 'light', user_override: true },
+      ]);
+      deps.prisma.setting_user.findMany.mockResolvedValue([
+        { setting_id: 7, value: 'dark' },
+      ]);
+
+      const result = await service.getSettingValues('theme', 99);
+
+      expect(result.theme).toBe('dark');
+      expect(deps.prisma.setting_user.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({ user_id: 99 }),
+        }),
+      );
+    });
+  });
+
+  describe('getEffectiveSettings', () => {
+    it('coage overrides do usuário conforme tipo global', async () => {
+      const { service } = makeService();
+      jest.spyOn(service, 'getSystemSettings').mockResolvedValue({
+        locales: [],
+        setting: {
+          flag: true,
+          count: 5,
+          obj: { a: 1 },
+          name: 'x',
+        },
+      });
+      jest.spyOn(service, 'getUserSettings').mockResolvedValue([
+        { setting: { slug: 'flag' }, value: 'false' },
+        { setting: { slug: 'count' }, value: '9' },
+        { setting: { slug: 'count' }, value: null },
+        { setting: { slug: 'obj' }, value: '{"b":2}' },
+        { setting: { slug: 'name' }, value: 'y' },
+        { setting: { slug: null }, value: 'ignored' },
+      ] as any);
+
+      const { setting } = await service.getEffectiveSettings(1);
+
+      expect(setting.flag).toBe(false);
+      expect(setting.count).toBe(9);
+      expect(setting.obj).toEqual({ b: 2 });
+      expect(setting.name).toBe('y');
+    });
+
+    it('mantém valor global quando número override é NaN', async () => {
+      const { service } = makeService();
+      jest.spyOn(service, 'getSystemSettings').mockResolvedValue({
+        locales: [],
+        setting: { count: 5 },
+      });
+      jest.spyOn(service, 'getUserSettings').mockResolvedValue([
+        { setting: { slug: 'count' }, value: 'abc' },
+      ] as any);
+
+      const { setting } = await service.getEffectiveSettings(1);
+      expect(setting.count).toBe('abc');
+    });
+  });
+
+  describe('emitSettingChangedEvents', () => {
+    it('não publica quando valor não muda', async () => {
+      const { service, deps } = makeService();
+      await (service as any).emitSettingChangedEvents([
+        { slug: 's', oldValue: 'a', newValue: 'a', source: 'test' },
+      ]);
+      expect(deps.integrationApi.publishEvents).not.toHaveBeenCalled();
+    });
+
+    it('publica evento quando valor muda', async () => {
+      const { service, deps } = makeService();
+      await (service as any).emitSettingChangedEvents([
+        { settingId: 3, slug: 's', type: 'string', oldValue: 'a', newValue: 'b', source: 'test' },
+      ]);
+      expect(deps.integrationApi.publishEvents).toHaveBeenCalledWith([
+        expect.objectContaining({
+          eventName: 'core.setting.changed',
+          aggregateId: '3',
+          payload: expect.objectContaining({ slug: 's', hasValue: true }),
+        }),
+      ]);
+    });
+
+    it('engole erro de publishEvents', async () => {
+      const { service, deps } = makeService();
+      deps.integrationApi.publishEvents.mockRejectedValue(new Error('boom'));
+      await expect(
+        (service as any).emitSettingChangedEvents([
+          { slug: 's', oldValue: 'a', newValue: 'b', source: 'test' },
+        ]),
+      ).resolves.toBeUndefined();
+    });
+  });
+});