@koalarx/nest 3.1.50 → 4.0.2

package/koala-nest/src/test/host/oauth-callback.controller.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'bun:test';
+import { OAuthCallbackController } from '@/host/controllers/oauth2/oauth-callback.controller';
+
+describe('OAuthCallbackController', () => {
+  it('devolve code e state da query string', () => {
+    const controller = new OAuthCallbackController();
+
+    expect(
+      controller.handle({
+        code: 'auth-code',
+        state: 'csrf-state',
+      }),
+    ).toEqual({
+      code: 'auth-code',
+      state: 'csrf-state',
+    });
+  });
+});

package/koala-nest/src/test/infra/cache-service.provider.spec.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'bun:test';
+import { CacheServiceProvider } from '@/infra/common/cache-service.provider';
+import { EnvService } from '@/infra/common/env.service';
+
+function createEnv() {
+  return {
+    get: () => undefined,
+  } as unknown as EnvService;
+}
+
+describe('CacheServiceProvider', () => {
+  it('delega para cache em memória sem REDIS_CONNECTION_STRING', async () => {
+    const provider = new CacheServiceProvider(createEnv());
+
+    await provider.set('key', 'value');
+    await provider.invalidate('other');
+
+    expect(await provider.get('key')).toBe('value');
+    expect(await provider.get('other')).toBeNull();
+  });
+});

package/koala-nest/src/test/infra/in-memory-cache.service.spec.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'bun:test';
+import { InMemoryCacheService } from '@/infra/common/in-memory-cache.service';
+
+describe('InMemoryCacheService', () => {
+  it('armazena e recupera valores', async () => {
+    const cache = new InMemoryCacheService();
+
+    await cache.set('key', 'value');
+
+    expect(await cache.get('key')).toBe('value');
+  });
+
+  it('expira entradas após o TTL', async () => {
+    const cache = new InMemoryCacheService();
+
+    await cache.set('key', 'value', -1);
+
+    expect(await cache.get('key')).toBeNull();
+  });
+
+  it('remove entradas com invalidate', async () => {
+    const cache = new InMemoryCacheService();
+
+    await cache.set('key', 'value');
+    await cache.invalidate('key');
+
+    expect(await cache.get('key')).toBeNull();
+  });
+
+  it('remove entradas por prefixo com invalidateByPrefix', async () => {
+    const cache = new InMemoryCacheService();
+
+    await cache.set('person:list:{"page":0}', 'a');
+    await cache.set('person:list:{"page":1}', 'b');
+    await cache.set('session:1', 'token');
+    await cache.invalidateByPrefix('person:list');
+
+    expect(await cache.get('person:list:{"page":0}')).toBeNull();
+    expect(await cache.get('person:list:{"page":1}')).toBeNull();
+    expect(await cache.get('session:1')).toBe('token');
+  });
+
+  it('setIfNotExists grava somente quando a chave não existe', async () => {
+    const cache = new InMemoryCacheService();
+
+    expect(await cache.setIfNotExists('lock:job', 'held', 60)).toBe(true);
+    expect(await cache.setIfNotExists('lock:job', 'held', 60)).toBe(false);
+  });
+});

package/koala-nest/src/test/infra/jwt-token.service.spec.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'bun:test';
+import { JwtTokenService } from '@/infra/auth/jwt-token.service';
+import { EnvService } from '@/infra/common/env.service';
+import { JwtService } from '@nestjs/jwt';
+
+describe('JwtTokenService', () => {
+  it('gera access e refresh token apenas com sub', () => {
+    const jwtService = {
+      sign: (claims: { sub: string }, options: { expiresIn: string }) =>
+        `${options.expiresIn}:${claims.sub}`,
+    } as unknown as JwtService;
+
+    const envService = {
+      get: (
+        key: 'JWT_ACCESS_TOKEN_EXPIRES_IN' | 'JWT_REFRESH_TOKEN_EXPIRES_IN',
+      ) => (key === 'JWT_ACCESS_TOKEN_EXPIRES_IN' ? '15m' : '7d'),
+    } as unknown as EnvService;
+
+    const service = new JwtTokenService(jwtService, envService);
+
+    expect(service.signTokenPair({ sub: 'user-1' })).toEqual({
+      accessToken: '15m:user-1',
+      access_token: '15m:user-1',
+      refreshToken: '7d:user-1',
+      refresh_token: '7d:user-1',
+    });
+  });
+});

package/koala-nest/src/test/infra/logged-user-info.service.spec.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'bun:test';
+import { AuthProfile } from '@/core/auth/auth-profile.enum';
+import { LoggedUserInfoService } from '@/infra/services/logged-user-info.service';
+import { UnauthorizedException } from '@nestjs/common';
+
+describe('LoggedUserInfoService', () => {
+  it('retorna usuário a partir do request', () => {
+    const service = new LoggedUserInfoService({
+      user: {
+        sub: 'user-1',
+        name: 'Demo User',
+        profile: AuthProfile.admin,
+        login: 'user-login',
+        email: 'user@example.com',
+      },
+      headers: {},
+    } as never);
+
+    expect(service.getUser()).toEqual({
+      sub: 'user-1',
+      name: 'Demo User',
+      profile: AuthProfile.admin,
+      login: 'user-login',
+      email: 'user@example.com',
+    });
+  });
+
+  it('lança UnauthorizedException quando não há usuário no request', () => {
+    const service = new LoggedUserInfoService({ headers: {} } as never);
+
+    expect(() => service.getUser()).toThrow(UnauthorizedException);
+  });
+});

package/koala-nest/src/test/infra/oauth2-auth.service.spec.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'bun:test';
+import { OAuth2AuthService } from '@/infra/auth/oauth2-auth.service';
+import { EnvService } from '@/infra/common/env.service';
+import type { OAuthProviderEnvConfig } from '@/core/auth/oauth-provider.registry';
+import { UnauthorizedException } from '@nestjs/common';
+import { CacheStub } from '@/test/services/cache.stub';
+
+class RegistryStub {
+  getProvider(key: string): OAuthProviderEnvConfig {
+    return {
+      key,
+      domain: 'https://idp.example.com',
+      clientId: 'client-id',
+      clientSecret: 'client-secret',
+      scope: 'openid',
+      redirectPath: '/sso/callback',
+    };
+  }
+}
+
+function createService(cache = new CacheStub()) {
+  const env = {
+    get: (key: string) =>
+      key === 'API_HOST'
+        ? 'http://localhost:3000'
+        : key === 'PORT'
+          ? 3000
+          : undefined,
+  } as unknown as EnvService;
+
+  return new OAuth2AuthService(env, new RegistryStub() as never, cache);
+}
+
+function stubOAuthFetch() {
+  globalThis.fetch = ((url: string) => {
+    if (url.includes('openid-configuration')) {
+      return Promise.resolve({
+        json: () =>
+          Promise.resolve({
+            authorization_endpoint: 'https://idp.example.com/authorize',
+            token_endpoint: 'https://idp.example.com/token',
+            userinfo_endpoint: 'https://idp.example.com/userinfo',
+          }),
+      });
+    }
+
+    if (url.includes('/token')) {
+      return Promise.resolve({
+        json: () => Promise.resolve({ access_token: 'access-token' }),
+      });
+    }
+
+    return Promise.resolve({
+      json: () =>
+        Promise.resolve({
+          email: 'user@example.com',
+          preferred_username: 'user',
+        }),
+    });
+  }) as typeof fetch;
+}
+
+describe('OAuth2AuthService — state', () => {
+  it('rejeita exchange quando o state não foi gravado no auth-link', async () => {
+    stubOAuthFetch();
+    const service = createService();
+
+    await expect(
+      service.exchangeCode('auth0', 'code-1', 'missing-state'),
+    ).rejects.toBeInstanceOf(UnauthorizedException);
+  });
+
+  it('valida state gravado no providerConfig e invalida após uso', async () => {
+    stubOAuthFetch();
+    const cache = new CacheStub();
+    const service = createService(cache);
+
+    const config = await service.providerConfig('auth0');
+    const stateKey = `oauth2:state:${config.state}`;
+
+    expect(cache.store.get(stateKey)).toContain('auth0');
+
+    const user = await service.exchangeCode('auth0', 'code-1', config.state);
+
+    expect(user.email).toBe('user@example.com');
+    expect(cache.store.has(stateKey)).toBe(false);
+  });
+
+  it('rejeita quando o provider do body não bate com o state gravado', async () => {
+    stubOAuthFetch();
+    const service = createService();
+
+    const config = await service.providerConfig('auth0');
+
+    await expect(
+      service.exchangeCode('keycloak', 'code-1', config.state),
+    ).rejects.toBeInstanceOf(UnauthorizedException);
+  });
+
+  it('trocar code sem state (fluxo Scalar)', async () => {
+    stubOAuthFetch();
+    const service = createService();
+
+    const user = await service.exchangeScalarCode(
+      'auth0',
+      'code-1',
+      'http://localhost:3000/sso/callback',
+    );
+
+    expect(user.email).toBe('user@example.com');
+  });
+});

package/koala-nest/src/test/infra/red-lock.service.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'bun:test';
+import { RedLockService } from '@/infra/common/red-lock.service';
+import { EnvService } from '@/infra/common/env.service';
+import { CacheStub } from '@/test/services/cache.stub';
+
+function createEnv(overrides: Record<string, string | undefined> = {}) {
+  return {
+    get: (key: string) => overrides[key],
+  } as unknown as EnvService;
+}
+
+describe('RedLockService', () => {
+  it('adquire lock distribuído apenas na primeira instância', async () => {
+    const cache = new CacheStub();
+    const service = new RedLockService(
+      cache,
+      createEnv({ REDIS_CONNECTION_STRING: 'redis://localhost:6379' }),
+    );
+
+    expect(await service.acquiredLock('job:create-person', 60)).toBe(true);
+    expect(await service.acquiredLock('job:create-person', 60)).toBe(false);
+  });
+
+  it('libera o lock para permitir nova execução', async () => {
+    const cache = new CacheStub();
+    const service = new RedLockService(
+      cache,
+      createEnv({ REDIS_CONNECTION_STRING: 'redis://localhost:6379' }),
+    );
+
+    expect(await service.acquiredLock('job:create-person', 60)).toBe(true);
+    await service.releaseLock('job:create-person');
+    expect(await service.acquiredLock('job:create-person', 60)).toBe(true);
+  });
+
+  it('ignora lock em test ou sem Redis configurado', async () => {
+    const cache = new CacheStub();
+    const service = new RedLockService(cache, createEnv({ NODE_ENV: 'test' }));
+
+    expect(await service.acquiredLock('job:create-person', 60)).toBe(true);
+    expect(await service.acquiredLock('job:create-person', 60)).toBe(true);
+  });
+});

package/koala-nest/src/test/infra/redis-cache.service.spec.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'bun:test';
+import { RedisCacheService } from '@/infra/common/redis-cache.service';
+import type Redis from 'ioredis';
+
+class RedisStub {
+  readonly store = new Map<string, string>();
+
+  get(key: string) {
+    return Promise.resolve(this.store.get(key) ?? null);
+  }
+
+  set(key: string, value: string, ...args: unknown[]) {
+    const hasNx = args.includes('NX');
+
+    if (hasNx && this.store.has(key)) {
+      return Promise.resolve(null);
+    }
+
+    this.store.set(key, value);
+    return Promise.resolve('OK');
+  }
+
+  del(...keys: string[]) {
+    for (const key of keys) {
+      this.store.delete(key);
+    }
+
+    return Promise.resolve(keys.length);
+  }
+
+  keys(pattern: string) {
+    const prefix = pattern.replace(/\*$/, '');
+    return Promise.resolve(
+      [...this.store.keys()].filter((key) => key.startsWith(prefix)),
+    );
+  }
+
+  disconnect() {}
+}
+
+describe('RedisCacheService', () => {
+  it('prefixa chaves ao gravar e ler', async () => {
+    const stub = new RedisStub();
+    const cache = new RedisCacheService(
+      'redis://localhost:6379',
+      'koala-nest',
+      stub as unknown as Redis,
+    );
+
+    await cache.set('session:1', 'token');
+
+    expect(stub.store.get('koala-nest:session:1')).toBe('token');
+    expect(await cache.get('session:1')).toBe('token');
+  });
+
+  it('remove chaves com invalidate', async () => {
+    const stub = new RedisStub();
+    const cache = new RedisCacheService(
+      'redis://localhost:6379',
+      'koala-nest',
+      stub as unknown as Redis,
+    );
+
+    await cache.set('session:1', 'token');
+    await cache.invalidate('session:1');
+
+    expect(await cache.get('session:1')).toBeNull();
+  });
+
+  it('remove chaves por prefixo com invalidateByPrefix', async () => {
+    const stub = new RedisStub();
+    const cache = new RedisCacheService(
+      'redis://localhost:6379',
+      'koala-nest',
+      stub as unknown as Redis,
+    );
+
+    await cache.set('person:list:{"page":0}', 'a');
+    await cache.set('person:list:{"page":1}', 'b');
+    await cache.set('session:1', 'token');
+    await cache.invalidateByPrefix('person:list');
+
+    expect(await cache.get('person:list:{"page":0}')).toBeNull();
+    expect(await cache.get('person:list:{"page":1}')).toBeNull();
+    expect(await cache.get('session:1')).toBe('token');
+  });
+
+  it('setIfNotExists grava somente quando a chave não existe', async () => {
+    const stub = new RedisStub();
+    const cache = new RedisCacheService(
+      'redis://localhost:6379',
+      'koala-nest',
+      stub as unknown as Redis,
+    );
+
+    expect(await cache.setIfNotExists('lock:job', 'held', 60)).toBe(true);
+    expect(await cache.setIfNotExists('lock:job', 'held', 60)).toBe(false);
+    expect(await cache.get('lock:job')).toBe('held');
+  });
+});

package/koala-nest/src/test/infra/redis-indicator.service.spec.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  isMissingIoredisModule,
+  RedisIndicator,
+} from '@/infra/services/redis.indicator.service';
+import type { HealthIndicatorService } from '@nestjs/terminus';
+
+function createHealthIndicatorServiceMock(): HealthIndicatorService {
+  return {
+    check: (key: string) => ({
+      up: (details?: Record<string, unknown>) => ({
+        [key]: { status: 'up' as const, ...details },
+      }),
+      down: (details?: Record<string, unknown> | string) => {
+        const data =
+          typeof details === 'string' ? { message: details } : details;
+
+        return { [key]: { status: 'down' as const, ...data } };
+      },
+    }),
+  } as HealthIndicatorService;
+}
+
+describe('RedisIndicator', () => {
+  it('retorna up quando REDIS_CONNECTION_STRING não está definido', async () => {
+    const indicator = new RedisIndicator(
+      {
+        get: () => undefined,
+      } as never,
+      createHealthIndicatorServiceMock(),
+    );
+
+    await expect(indicator.isHealthy()).resolves.toEqual({
+      redis: { status: 'up' },
+    });
+  });
+
+  it('isConfigured reflete presença de REDIS_CONNECTION_STRING', () => {
+    const healthIndicatorService = createHealthIndicatorServiceMock();
+
+    const configured = new RedisIndicator(
+      {
+        get: (key: string) =>
+          key === 'REDIS_CONNECTION_STRING'
+            ? 'redis://localhost:6379'
+            : undefined,
+      } as never,
+      healthIndicatorService,
+    );
+
+    const notConfigured = new RedisIndicator(
+      {
+        get: () => undefined,
+      } as never,
+      healthIndicatorService,
+    );
+
+    expect(configured.isConfigured()).toBe(true);
+    expect(notConfigured.isConfigured()).toBe(false);
+  });
+});
+
+describe('isMissingIoredisModule', () => {
+  it('detecta módulo ioredis ausente', () => {
+    const error = new Error("Cannot find module 'ioredis'");
+    (error as NodeJS.ErrnoException).code = 'ERR_MODULE_NOT_FOUND';
+
+    expect(isMissingIoredisModule(error)).toBe(true);
+  });
+
+  it('ignora outros erros', () => {
+    expect(isMissingIoredisModule(new Error('ECONNREFUSED'))).toBe(false);
+    expect(isMissingIoredisModule('fail')).toBe(false);
+  });
+});

package/koala-nest/src/test/mockup/person/person.entities.ts

@@ -0,0 +1,35 @@
+import { EntityBase } from '@/core/base/entity.base';
+import { AutoMap } from '@/core/tools/mapping';
+
+export class PersonAddress extends EntityBase<PersonAddress> {
+  @AutoMap()
+  id: number;
+
+  @AutoMap()
+  address: string;
+}
+
+export class Person extends EntityBase<Person> {
+  @AutoMap()
+  id: number;
+
+  @AutoMap()
+  name: string;
+
+  @AutoMap()
+  address: PersonAddress;
+
+  @AutoMap({ type: () => PersonContact })
+  contacts: PersonContact[];
+}
+
+export class PersonContact extends EntityBase<PersonContact> {
+  @AutoMap()
+  id: number;
+
+  @AutoMap()
+  contact: string;
+
+  @AutoMap()
+  person: Person;
+}

package/koala-nest/src/test/mockup/person/person.requests.ts

@@ -0,0 +1,23 @@
+import { ObjectClass } from '@/core/base/object-class';
+import { AutoMap } from '@/core/tools/mapping';
+
+export class PersonAddressRequest extends ObjectClass<PersonAddressRequest> {
+  @AutoMap()
+  address: string;
+}
+
+export class PersonContactRequest extends ObjectClass<PersonContactRequest> {
+  @AutoMap()
+  contact: string;
+}
+
+export class PersonRequest extends ObjectClass<PersonRequest> {
+  @AutoMap()
+  name: string;
+
+  @AutoMap()
+  address: PersonAddressRequest;
+
+  @AutoMap({ type: () => PersonContactRequest })
+  contacts: PersonContactRequest[];
+}

package/koala-nest/src/test/mockup/person/person.responses.ts

@@ -0,0 +1,31 @@
+import { AutoMap } from '@/core/tools/mapping';
+
+export class PersonAddressResponse {
+  @AutoMap()
+  id: number;
+
+  @AutoMap()
+  address: string;
+}
+
+export class PersonContactResponse {
+  @AutoMap()
+  id: number;
+
+  @AutoMap()
+  contact: string;
+}
+
+export class PersonResponse {
+  @AutoMap()
+  id: number;
+
+  @AutoMap()
+  name: string;
+
+  @AutoMap()
+  address: PersonAddressResponse;
+
+  @AutoMap({ type: () => PersonContactResponse })
+  contacts: PersonContactResponse[];
+}

package/koala-nest/src/test/services/cache.stub.ts

@@ -0,0 +1,41 @@
+import type { ICacheService } from '@/domain/common/icache.service';
+
+export class CacheStub implements ICacheService {
+  readonly store = new Map<string, string>();
+  readonly invalidateByPrefixCalls: string[] = [];
+
+  get(key: string) {
+    return Promise.resolve(this.store.get(key) ?? null);
+  }
+
+  set(key: string, value: string, _ttl?: number) {
+    this.store.set(key, value);
+    return Promise.resolve();
+  }
+
+  setIfNotExists(key: string, value: string, _ttl: number) {
+    if (this.store.has(key)) {
+      return Promise.resolve(false);
+    }
+
+    this.store.set(key, value);
+    return Promise.resolve(true);
+  }
+
+  invalidate(key: string) {
+    this.store.delete(key);
+    return Promise.resolve();
+  }
+
+  invalidateByPrefix(prefix: string) {
+    this.invalidateByPrefixCalls.push(prefix);
+
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        this.store.delete(key);
+      }
+    }
+
+    return Promise.resolve();
+  }
+}

package/koala-nest/src/test/services/fake-logging.service.ts

@@ -0,0 +1,13 @@
+import {
+  ILoggingService,
+  LoggingReportProps,
+} from '@/domain/common/ilogging.service';
+
+export class FakeLoggingService implements ILoggingService {
+  reports: LoggingReportProps[] = [];
+
+  report(data: LoggingReportProps): Promise<void> {
+    this.reports.push(data);
+    return Promise.resolve();
+  }
+}

package/koala-nest/src/test/services/fake-red-lock.service.ts

@@ -0,0 +1,11 @@
+import { IRedLockService } from '@/domain/common/ired-lock.service';
+
+export class FakeRedLockService implements IRedLockService {
+  acquiredLock(_key: string, _ttlSecondsLock: number): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  releaseLock(_key: string): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/koala-nest/src/test/services/logged-user-info.fake-service.ts

@@ -0,0 +1,18 @@
+import { LoggedUserInfoDto } from '@/domain/dtos/logged-user-info.dto';
+import { ILoggedUserInfoService } from '@/domain/services/ilogged-user-info.service';
+
+export class LoggedUserInfoFakeService implements ILoggedUserInfoService {
+  private user: LoggedUserInfoDto | null = null;
+
+  setContext(context: { user?: LoggedUserInfoDto | null }) {
+    this.user = context.user ?? this.user;
+  }
+
+  getUser(): LoggedUserInfoDto {
+    if (!this.user) {
+      throw new Error('Usuário logado não configurado no fake service');
+    }
+
+    return this.user;
+  }
+}