@koalarx/nest 3.1.50 → 4.0.1

package/koala-nest/src/test/core/env.config.spec.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'bun:test';
+import { EnvConfig } from '@/core/utils/env.config';
+
+describe('EnvConfig', () => {
+  it('identifica ambiente develop', () => {
+    const previous = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'develop';
+
+    expect(EnvConfig.isEnvDevelop).toBe(true);
+    expect(EnvConfig.isEnvProduction).toBe(false);
+
+    process.env.NODE_ENV = previous;
+  });
+});

package/koala-nest/src/test/core/env.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'bun:test';
+import { parseOAuth2ProviderEnv } from '@/core/auth/parse-oauth2-provider-env';
+import { envSchema, validateEnvConfig } from '@/core/env';
+
+describe('envSchema', () => {
+  it('interpreta CRON_JOBS_ENABLED=false como desabilitado', () => {
+    const env = envSchema.parse({
+      NODE_ENV: 'test',
+      DATABASE_URL: 'postgres://localhost/test',
+      CRON_JOBS_ENABLED: 'false',
+    });
+
+    expect(env.CRON_JOBS_ENABLED).toBe(false);
+  });
+});
+
+describe('parseOAuth2ProviderEnv', () => {
+  it('agrupa variáveis OAUTH2_{PROVIDER}_* por provider', () => {
+    expect(
+      parseOAuth2ProviderEnv({
+        OAUTH2_GOOGLE_DOMAIN: 'https://accounts.google.com',
+        OAUTH2_GOOGLE_CLIENT_ID: 'client-id',
+        OAUTH2_GOOGLE_CLIENT_SECRET: 'client-secret',
+        OAUTH2_GOOGLE_SCOPE: 'openid profile email',
+        OAUTH2_MYAPP_AUTHORIZATION_URL:
+          'https://auth.myapp.com/oauth/authorize',
+      }),
+    ).toEqual({
+      google: {
+        domain: 'https://accounts.google.com',
+        clientId: 'client-id',
+        clientSecret: 'client-secret',
+        scope: 'openid profile email',
+      },
+      myapp: {
+        authorizationUrl: 'https://auth.myapp.com/oauth/authorize',
+      },
+    });
+  });
+});
+
+describe('validateEnvConfig', () => {
+  it('normaliza OAuth2 no env tipado OAUTH2_PROVIDER_ENV', () => {
+    const env = validateEnvConfig({
+      NODE_ENV: 'test',
+      DATABASE_URL: 'postgres://localhost/test',
+      OAUTH2_GOOGLE_CLIENT_ID: 'client-id',
+      OAUTH2_GOOGLE_CLIENT_SECRET: 'client-secret',
+      OAUTH2_GOOGLE_SCOPE: 'openid',
+      OAUTH2_GOOGLE_DOMAIN: 'https://accounts.google.com',
+    });
+
+    expect(env.OAUTH2_PROVIDER_ENV.google).toEqual({
+      domain: 'https://accounts.google.com',
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      scope: 'openid',
+    });
+    expect(env.NODE_ENV).toBe('test');
+  });
+});

package/koala-nest/src/test/core/event-queue.spec.ts

@@ -0,0 +1,53 @@
+/// <reference types="bun-types/test-globals" />
+
+import { EventClass } from '@/core/background-services/event-service/event-class';
+import { EventHandlerBase } from '@/core/background-services/event-service/event-handler.base';
+import { EventJob } from '@/core/background-services/event-service/event-job';
+import { EventQueue } from '@/core/background-services/event-service/event-queue';
+import { Type } from '@nestjs/common';
+import { afterEach, describe, expect, it, spyOn } from 'bun:test';
+
+class CustomEvent extends EventClass {}
+
+class CustomEventHandler extends EventHandlerBase {
+  constructor() {
+    super(CustomEvent);
+  }
+
+  static async isCalled(): Promise<void> {
+    return undefined;
+  }
+
+  async handleEvent(_event: CustomEvent): Promise<void> {
+    await CustomEventHandler.isCalled();
+  }
+}
+
+class CustomEventJob extends EventJob<unknown> {
+  defineHandlers(): Array<Type<EventHandlerBase>> {
+    return [CustomEventHandler];
+  }
+}
+
+describe('EventQueue', () => {
+  afterEach(() => {
+    EventQueue.clearHandlers();
+    EventQueue.clearMarkedAggregates();
+  });
+
+  it('dispara eventos e executa handlers registrados', () => {
+    const callbackSpy = spyOn(CustomEventHandler, 'isCalled');
+
+    new CustomEventHandler().setupSubscriptions();
+
+    const jobs = new CustomEventJob();
+    jobs.addEvent(new CustomEvent());
+
+    expect(jobs.eventQueue).toHaveLength(1);
+
+    EventQueue.dispatchEventsForAggregate(jobs._id);
+
+    expect(callbackSpy).toHaveBeenCalled();
+    expect(jobs.eventQueue).toHaveLength(0);
+  });
+});

package/koala-nest/src/test/core/format-typeorm-error.spec.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'bun:test';
+import { HttpStatus } from '@nestjs/common';
+import { EntityNotFoundError, QueryFailedError } from 'typeorm';
+import {
+  formatTypeOrmError,
+  isTypeOrmError,
+} from '@/core/utils/format-typeorm-error';
+
+describe('formatTypeOrmError', () => {
+  it('identifica erros TypeORM', () => {
+    const error = new EntityNotFoundError('person', { id: 1 });
+
+    expect(isTypeOrmError(error)).toBe(true);
+  });
+
+  it('formata EntityNotFoundError como 404', () => {
+    const formatted = formatTypeOrmError(
+      new EntityNotFoundError('person', { id: 1 }),
+    );
+
+    expect(formatted.statusCode).toBe(HttpStatus.NOT_FOUND);
+    expect(formatted.message).toBe('Registro não encontrado.');
+  });
+
+  it('formata violação de unique do Postgres como 409', () => {
+    const driverError = {
+      code: '23505',
+      detail: 'Key (email)=(user@example.com) already exists.',
+      column: 'email',
+    };
+    const error = new QueryFailedError(
+      'INSERT INTO person',
+      [],
+      driverError as Error,
+    );
+
+    const formatted = formatTypeOrmError(error);
+
+    expect(formatted.statusCode).toBe(HttpStatus.CONFLICT);
+    expect(formatted.message).toContain('email');
+  });
+});

package/koala-nest/src/test/core/format-zod-error.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'bun:test';
+import { z } from 'zod';
+import { formatZodError } from '@/core/utils/format-zod-error';
+
+describe('formatZodError', () => {
+  it('formata erro de campo obrigatório', () => {
+    const schema = z.object({ name: z.string() });
+    const result = schema.safeParse({});
+
+    if (result.success) {
+      throw new Error('Esperava falha de validação');
+    }
+
+    const formatted = formatZodError(result.error);
+
+    expect(formatted.message).toBe('O campo name é obrigatório.');
+    expect(formatted.errors).toEqual([
+      { field: 'name', message: 'O campo name é obrigatório.' },
+    ]);
+  });
+
+  it('resume múltiplos erros em uma mensagem', () => {
+    const schema = z.object({
+      name: z.string(),
+      email: z.string(),
+    });
+    const result = schema.safeParse({});
+
+    if (result.success) {
+      throw new Error('Esperava falha de validação');
+    }
+
+    const formatted = formatZodError(result.error);
+
+    expect(formatted.message).toBe('Foram encontrados 2 erros de validação.');
+    expect(formatted.errors).toHaveLength(2);
+  });
+});

package/koala-nest/src/test/core/is-provider-registered.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'bun:test';
+import { IJwtTokenService } from '@/domain/auth/services/iauth.service';
+import { isProviderRegistered } from '@/core/utils/is-provider-registered';
+import { Test } from '@nestjs/testing';
+
+describe('isProviderRegistered', () => {
+  it('retorna true quando o token está registrado em algum módulo', async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        {
+          provide: IJwtTokenService,
+          useValue: {
+            signTokenPair: () => ({ accessToken: 'a', refreshToken: 'r' }),
+          },
+        },
+      ],
+    }).compile();
+    const app = moduleRef.createNestApplication();
+    await app.init();
+
+    expect(isProviderRegistered(app, IJwtTokenService)).toBe(true);
+
+    await app.close();
+  });
+
+  it('retorna false quando o token não está registrado', async () => {
+    const moduleRef = await Test.createTestingModule({}).compile();
+    const app = moduleRef.createNestApplication();
+    await app.init();
+
+    expect(isProviderRegistered(app, IJwtTokenService)).toBe(false);
+
+    await app.close();
+  });
+});

package/koala-nest/src/test/core/jwt.strategy.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'bun:test';
+import { JwtStrategy } from '@/host/security/strategies/jwt.strategy';
+import { UnauthorizedException } from '@nestjs/common';
+import type { Request } from 'express';
+
+describe('JwtStrategy', () => {
+  const accessTokenTtlSeconds = 900;
+  const strategy = Object.create(JwtStrategy.prototype) as JwtStrategy;
+  (strategy as { accessTokenTtlSeconds: number }).accessTokenTtlSeconds =
+    accessTokenTtlSeconds;
+
+  it('rejeita refresh token em rotas que não são /auth/refresh', () => {
+    const request = { url: '/person', get: () => undefined } as Request;
+    const now = Math.floor(Date.now() / 1000);
+
+    expect(() =>
+      strategy.validate(request, {
+        sub: 'user-1',
+        iat: now,
+        exp: now + 7 * 86400,
+      }),
+    ).toThrow(UnauthorizedException);
+  });
+
+  it('aceita refresh token em /auth/refresh', () => {
+    const request = { url: '/auth/refresh', get: () => undefined } as Request;
+    const now = Math.floor(Date.now() / 1000);
+
+    const user = strategy.validate(request, {
+      sub: 'user-1',
+      iat: now,
+      exp: now + 7 * 86400,
+    });
+
+    expect(user.sub).toBe('user-1');
+    expect(user.profile).toBeUndefined();
+  });
+});

package/koala-nest/src/test/core/mapping.spec.ts

@@ -0,0 +1,177 @@
+import {
+  AutoMap,
+  AutoMapper,
+  createMap,
+  forMember,
+} from '@/core/tools/mapping';
+import { MappingStore } from '@/core/tools/mapping/mapping-store';
+import {
+  Person,
+  PersonAddress,
+  PersonContact,
+} from '../mockup/person/person.entities';
+import {
+  PersonAddressRequest,
+  PersonContactRequest,
+  PersonRequest,
+} from '../mockup/person/person.requests';
+import {
+  PersonAddressResponse,
+  PersonContactResponse,
+  PersonResponse,
+} from '../mockup/person/person.responses';
+
+describe('AutoMapper', () => {
+  it('should map the entity properties', () => {
+    expect(MappingStore.getPropType(Person, 'contacts')).toBe(PersonContact);
+    expect(MappingStore.getPropType(Person, 'address')).toBe(PersonAddress);
+    expect(MappingStore.getPropType(Person, 'id')).toBe(Number);
+    expect(MappingStore.getPropType(Person, 'name')).toBe(String);
+  });
+
+  it('should create a mapping', () => {
+    createMap(Person, PersonResponse);
+    createMap(PersonContact, PersonContactResponse);
+    createMap(PersonAddress, PersonAddressResponse);
+    createMap(PersonRequest, Person);
+    createMap(PersonAddressRequest, PersonAddress);
+    createMap(PersonContactRequest, PersonContact);
+
+    const personMapping = MappingStore.getMapping(Person, PersonResponse);
+    expect(personMapping).toBeDefined();
+    expect(personMapping?.source).toBe(Person);
+    expect(personMapping?.target).toBe(PersonResponse);
+  });
+
+  it('should map the entity to response', () => {
+    const person = Person.from({
+      id: 1,
+      name: 'John Doe',
+      address: PersonAddress.from({
+        id: 1,
+        address: '123 Main St',
+      }),
+      contacts: [],
+    });
+
+    person.contacts.push(
+      PersonContact.from({
+        id: 1,
+        contact: 'john.doe@example.com',
+        person: person,
+      }),
+    );
+
+    const personDto = AutoMapper.map(person, Person, PersonResponse);
+
+    expect(personDto).toBeDefined();
+    expect(personDto.id).toBe(person.id);
+    expect(personDto.name).toBe(person.name);
+
+    expect(personDto.address).toBeInstanceOf(PersonAddressResponse);
+    expect(personDto.address.id).toBe(person.address.id);
+    expect(personDto.address.address).toBe(person.address.address);
+
+    expect(personDto.contacts).toBeInstanceOf(Array);
+    expect(personDto.contacts.length).toBe(person.contacts.length);
+    expect(personDto.contacts[0]).toBeInstanceOf(PersonContactResponse);
+    expect(personDto.contacts[0].id).toBe(person.contacts[0].id);
+    expect(personDto.contacts[0].contact).toBe(person.contacts[0].contact);
+  });
+
+  it('should map the request to entity', () => {
+    const personRequest = PersonRequest.from({
+      name: 'John Doe',
+      address: {
+        address: '123 Main St',
+      },
+      contacts: [
+        {
+          contact: 'john.doe@example.com',
+        },
+      ],
+    });
+
+    const person = AutoMapper.map(personRequest, PersonRequest, Person);
+
+    expect(person).toBeDefined();
+    expect(person.name).toBe(personRequest.name);
+    expect(person.address).toBeInstanceOf(PersonAddress);
+    expect(person.address.address).toBe(personRequest.address.address);
+    expect(person.contacts).toBeInstanceOf(Array);
+    expect(person.contacts.length).toBe(personRequest.contacts.length);
+    expect(person.contacts[0]).toBeInstanceOf(PersonContact);
+    expect(person.contacts[0].contact).toBe(personRequest.contacts[0].contact);
+  });
+
+  it('should apply forMember custom mappings', () => {
+    class SourceRequest {
+      @AutoMap()
+      firstName: string;
+
+      @AutoMap()
+      lastName: string;
+    }
+
+    class TargetEntity {
+      @AutoMap()
+      fullName: string;
+    }
+
+    createMap(
+      SourceRequest,
+      TargetEntity,
+      forMember(
+        'fullName',
+        (source) => `${source.firstName} ${source.lastName}`,
+      ),
+    );
+
+    const source = Object.assign(new SourceRequest(), {
+      firstName: 'John',
+      lastName: 'Doe',
+    });
+
+    const target = AutoMapper.map(source, SourceRequest, TargetEntity);
+
+    expect(target.fullName).toBe('John Doe');
+  });
+
+  it('should map nested objects using the target property name', () => {
+    class SourceChild {
+      @AutoMap()
+      street: string;
+    }
+
+    class SourceParent {
+      @AutoMap()
+      address: SourceChild;
+    }
+
+    class TargetChild {
+      @AutoMap()
+      line1: string;
+    }
+
+    class TargetParent {
+      @AutoMap()
+      address: TargetChild;
+    }
+
+    createMap(
+      SourceChild,
+      TargetChild,
+      forMember('line1', (source) => source.street),
+    );
+    createMap(SourceParent, TargetParent);
+
+    const source = Object.assign(new SourceParent(), {
+      address: Object.assign(new SourceChild(), { street: '123 Main St' }),
+    });
+
+    const target = AutoMapper.map(source, SourceParent, TargetParent);
+
+    expect(target.address).toBeInstanceOf(TargetChild);
+    expect(target.address.line1).toBe('123 Main St');
+  });
+});

package/koala-nest/src/test/core/oauth-provider.registry.spec.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'bun:test';
+import { OAuthProviderRegistry } from '@/core/auth/oauth-provider.registry';
+import { validateEnvConfig } from '@/core/env';
+import { EnvService } from '@/infra/common/env.service';
+
+function createRegistry(flat: Record<string, string | undefined>) {
+  const env = validateEnvConfig({
+    NODE_ENV: 'test',
+    DATABASE_URL: 'postgres://localhost/test',
+    ...flat,
+  });
+  const envService = {
+    get: <T extends keyof typeof env>(key: T) => env[key],
+  } as unknown as EnvService;
+
+  return new OAuthProviderRegistry(envService);
+}
+
+describe('OAuthProviderRegistry', () => {
+  it('retorna lista vazia quando OAUTH2_PROVIDERS não está definido', () => {
+    const registry = createRegistry({});
+
+    expect(registry.listProviders()).toEqual([]);
+  });
+
+  it('lista providers normalizados a partir do env', () => {
+    const registry = createRegistry({
+      OAUTH2_PROVIDERS: ' Google , Microsoft ',
+    });
+
+    expect(registry.listProviders()).toEqual(['google', 'microsoft']);
+  });
+
+  it('resolve configuração do provider pelas variáveis OAUTH2_{KEY}_*', () => {
+    const registry = createRegistry({
+      OAUTH2_PROVIDERS: 'google',
+      OAUTH2_GOOGLE_DOMAIN: 'https://accounts.google.com',
+      OAUTH2_GOOGLE_CLIENT_ID: 'client-id',
+      OAUTH2_GOOGLE_CLIENT_SECRET: 'client-secret',
+      OAUTH2_GOOGLE_SCOPE: 'openid profile email',
+    });
+
+    expect(registry.getProvider('google')).toEqual({
+      key: 'google',
+      domain: 'https://accounts.google.com',
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      scope: 'openid profile email',
+      redirectPath: '/sso/callback',
+      authorizationUrl: undefined,
+      tokenUrl: undefined,
+      userInfoUrl: undefined,
+    });
+  });
+
+  it('resolve provider com endpoints manuais para servidor OAuth próprio', () => {
+    const registry = createRegistry({
+      OAUTH2_PROVIDERS: 'myapp',
+      OAUTH2_MYAPP_CLIENT_ID: 'client-id',
+      OAUTH2_MYAPP_CLIENT_SECRET: 'client-secret',
+      OAUTH2_MYAPP_SCOPE: 'openid profile email',
+      OAUTH2_MYAPP_AUTHORIZATION_URL: 'https://auth.myapp.com/oauth/authorize',
+      OAUTH2_MYAPP_TOKEN_URL: 'https://auth.myapp.com/oauth/token',
+      OAUTH2_MYAPP_USERINFO_URL: 'https://auth.myapp.com/oauth/userinfo',
+    });
+
+    expect(registry.getProvider('myapp')).toEqual({
+      key: 'myapp',
+      domain: undefined,
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      scope: 'openid profile email',
+      redirectPath: '/sso/callback',
+      authorizationUrl: 'https://auth.myapp.com/oauth/authorize',
+      tokenUrl: 'https://auth.myapp.com/oauth/token',
+      userInfoUrl: 'https://auth.myapp.com/oauth/userinfo',
+    });
+  });
+});

package/koala-nest/src/test/core/profiles.guard.spec.ts

@@ -0,0 +1,42 @@
+import { AuthProfile } from '@/core/auth/auth-profile.enum';
+import { describe, expect, it } from 'bun:test';
+import { ProfilesGuard } from '@/host/security/guards/profiles.guard';
+import { PROFILES_KEY } from '@/host/decorators/restriction-by-profile.decorator';
+import { Reflector } from '@nestjs/core';
+import { createGuardContext } from '@/test/utils/guard-test-context';
+
+describe('ProfilesGuard', () => {
+  it('permite acesso quando não há restrição de perfil', () => {
+    const reflector = new Reflector();
+    const guard = new ProfilesGuard(reflector);
+    const { context } = createGuardContext({
+      user: { sub: '1', profile: AuthProfile.admin },
+    });
+
+    expect(guard.canActivate(context)).toBe(true);
+  });
+
+  it('permite acesso quando o perfil do token está na lista', () => {
+    const reflector = new Reflector();
+    const guard = new ProfilesGuard(reflector);
+    const { context } = createGuardContext({
+      user: { sub: '1', profile: AuthProfile.admin },
+      metadataKey: PROFILES_KEY,
+      metadata: { [PROFILES_KEY]: [AuthProfile.admin, AuthProfile.user] },
+    });
+
+    expect(guard.canActivate(context)).toBe(true);
+  });
+
+  it('bloqueia acesso quando o perfil não está autorizado', () => {
+    const reflector = new Reflector();
+    const guard = new ProfilesGuard(reflector);
+    const { context } = createGuardContext({
+      user: { sub: '1', profile: AuthProfile.user },
+      metadataKey: PROFILES_KEY,
+      metadata: { [PROFILES_KEY]: [AuthProfile.admin] },
+    });
+
+    expect(guard.canActivate(context)).toBe(false);
+  });
+});

package/koala-nest/src/test/core/resolve-api-host.spec.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'bun:test';
+import { resolveApiHost } from '@/core/utils/resolve-api-host';
+
+describe('resolveApiHost', () => {
+  it('usa localhost com porta quando API_HOST não está definido', () => {
+    expect(resolveApiHost(undefined, 3000)).toBe('http://localhost:3000');
+  });
+
+  it('normaliza host sem protocolo', () => {
+    expect(resolveApiHost('api.example.com', 3000)).toBe(
+      'http://api.example.com',
+    );
+  });
+
+  it('remove barra final do host', () => {
+    expect(resolveApiHost('https://api.example.com/', 3000)).toBe(
+      'https://api.example.com',
+    );
+  });
+});