@koalarx/nest 3.1.50 → 4.0.2

package/koala-nest/src/application/auth/login/login.handler.ts

@@ -0,0 +1,42 @@
+import { userToJwtClaims } from '@/application/auth/common/user-claims';
+import { assertUserIsActive } from '@/core/auth/assert-user-active';
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { IUserRepository } from '@/domain/repositories/iuser.repository';
+import { IJwtTokenService } from '@/domain/auth/services/iauth.service';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { compare } from 'bcrypt';
+import { LoginRequest } from './login.request';
+import { LoginResponse } from './login.response';
+import { LoginValidator } from './login.validator';
+
+@Injectable()
+export class LoginHandler extends RequestHandlerBase<
+  LoginRequest,
+  LoginResponse
+> {
+  constructor(
+    private readonly userRepository: IUserRepository,
+    private readonly jwtTokenService: IJwtTokenService,
+  ) {
+    super();
+  }
+
+  async handle(request: LoginRequest): Promise<LoginResponse> {
+    const credentials = new LoginValidator(request).validate();
+    const user = await this.userRepository.getByEmail(credentials.username);
+
+    if (!user) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    assertUserIsActive(user);
+
+    const isPasswordValid = await compare(credentials.password, user.password);
+
+    if (!isPasswordValid) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    return this.jwtTokenService.signTokenPair(userToJwtClaims(user));
+  }
+}

package/koala-nest/src/application/auth/login/login.request.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class LoginRequest {
+  @ApiProperty({ example: 'admin@example.com' })
+  username: string;
+
+  @ApiProperty({ example: 'admin123' })
+  password: string;
+}

package/koala-nest/src/application/auth/login/login.response.ts

@@ -0,0 +1,3 @@
+import { AuthTokenResponse } from '@/application/auth/common/auth-token.response';
+
+export class LoginResponse extends AuthTokenResponse {}

package/koala-nest/src/application/auth/login/login.validator.ts

@@ -0,0 +1,12 @@
+import { RequestValidatorBase } from '@/application/common/request-validator.base';
+import { z } from 'zod';
+import { LoginRequest } from './login.request';
+
+export class LoginValidator extends RequestValidatorBase<LoginRequest> {
+  protected get schema() {
+    return z.object({
+      username: z.string().email(),
+      password: z.string().min(1),
+    });
+  }
+}

package/koala-nest/src/application/auth/oauth2/auth-link/auth-link.handler.ts

@@ -0,0 +1,24 @@
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { IOAuth2Service } from '@/domain/auth/services/iauth.service';
+import { Injectable } from '@nestjs/common';
+import { OAuthAuthLinkRequest } from './auth-link.request';
+import { OAuthAuthLinkResponse } from './auth-link.response';
+import { OAuthAuthLinkValidator } from './auth-link.validator';
+
+@Injectable()
+export class OAuthAuthLinkHandler extends RequestHandlerBase<
+  OAuthAuthLinkRequest,
+  OAuthAuthLinkResponse
+> {
+  constructor(private readonly oauth2Service: IOAuth2Service) {
+    super();
+  }
+
+  async handle(request: OAuthAuthLinkRequest): Promise<OAuthAuthLinkResponse> {
+    const data = new OAuthAuthLinkValidator(request).validate();
+
+    return {
+      url: await this.oauth2Service.authLink(data.provider, data.redirectUri),
+    };
+  }
+}

package/koala-nest/src/application/auth/oauth2/auth-link/auth-link.request.ts

@@ -0,0 +1,10 @@
+import { ObjectClass } from '@/core/base/object-class';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class OAuthAuthLinkRequest extends ObjectClass<OAuthAuthLinkRequest> {
+  @ApiProperty({ example: 'google' })
+  provider: string;
+
+  @ApiProperty({ required: false })
+  redirectUri?: string;
+}

package/koala-nest/src/application/auth/oauth2/auth-link/auth-link.response.ts

@@ -0,0 +1,6 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class OAuthAuthLinkResponse {
+  @ApiProperty()
+  url: string;
+}

package/koala-nest/src/application/auth/oauth2/auth-link/auth-link.validator.ts

@@ -0,0 +1,12 @@
+import { RequestValidatorBase } from '@/application/common/request-validator.base';
+import { z } from 'zod';
+import { OAuthAuthLinkRequest } from './auth-link.request';
+
+export class OAuthAuthLinkValidator extends RequestValidatorBase<OAuthAuthLinkRequest> {
+  protected get schema() {
+    return z.object({
+      provider: z.string().min(1),
+      redirectUri: z.string().url().optional(),
+    });
+  }
+}

package/koala-nest/src/application/auth/oauth2/callback/oauth-callback.response.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+/** Resposta mínima do callback OAuth — o Scalar lê `code` (e opcionalmente `state`). */
+export class OAuthCallbackResponse {
+  @ApiProperty()
+  code: string;
+
+  @ApiProperty({ required: false })
+  state?: string;
+}

package/koala-nest/src/application/auth/oauth2/exchange-code/exchange-code.handler.ts

@@ -0,0 +1,73 @@
+import { userToJwtClaims } from '@/application/auth/common/user-claims';
+import { AuthTokenResponse } from '@/application/auth/common/auth-token.response';
+import { assertUserIsActive } from '@/core/auth/assert-user-active';
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { AuthProfile } from '@/core/auth/auth-profile.enum';
+import { hashPassword } from '@/core/utils/hash-password';
+import { nameToLogin } from '@/core/utils/name-to-login';
+import { User } from '@/domain/entities/user/user';
+import { UserStatus } from '@/domain/entities/user/enums/user-status.enum';
+import {
+  IOAuth2Service,
+  IJwtTokenService,
+} from '@/domain/auth/services/iauth.service';
+import { IUserRepository } from '@/domain/repositories/iuser.repository';
+import { Injectable } from '@nestjs/common';
+import { randomString } from '@koalarx/utils';
+import { OAuthExchangeCodeRequest } from './exchange-code.request';
+import { OAuthExchangeCodeValidator } from './exchange-code.validator';
+
+@Injectable()
+export class OAuthExchangeCodeHandler extends RequestHandlerBase<
+  OAuthExchangeCodeRequest,
+  AuthTokenResponse
+> {
+  constructor(
+    private readonly oauth2Service: IOAuth2Service,
+    private readonly userRepository: IUserRepository,
+    private readonly jwtTokenService: IJwtTokenService,
+  ) {
+    super();
+  }
+
+  async handle(request: OAuthExchangeCodeRequest): Promise<AuthTokenResponse> {
+    const data = new OAuthExchangeCodeValidator(request).validate();
+    const userInfo = data.state
+      ? await this.oauth2Service.exchangeCode(
+          data.provider,
+          data.code,
+          data.state,
+          data.redirectUri,
+        )
+      : await this.oauth2Service.exchangeScalarCode(
+          data.provider,
+          data.code,
+          data.redirectUri,
+        );
+
+    let user = await this.userRepository.getByEmail(userInfo.email);
+
+    if (!user) {
+      user = new User();
+      user.email = userInfo.email;
+      user.name =
+        userInfo.name ?? userInfo.email.split('@')[0] ?? userInfo.login;
+      user.login = await nameToLogin(user.name, this.userRepository);
+      user.profile = userInfo.profile ?? AuthProfile.user;
+      user.status = UserStatus.active;
+      user.password = await hashPassword(
+        randomString(16, {
+          lowercase: true,
+          uppercase: true,
+          numbers: true,
+          specialCharacters: true,
+        }),
+      );
+      user = await this.userRepository.save(user);
+    }
+
+    assertUserIsActive(user);
+
+    return this.jwtTokenService.signTokenPair(userToJwtClaims(user));
+  }
+}

package/koala-nest/src/application/auth/oauth2/exchange-code/exchange-code.request.ts

@@ -0,0 +1,16 @@
+import { ObjectClass } from '@/core/base/object-class';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class OAuthExchangeCodeRequest extends ObjectClass<OAuthExchangeCodeRequest> {
+  @ApiProperty({ example: 'google' })
+  provider: string;
+
+  @ApiProperty()
+  code: string;
+
+  @ApiProperty({ required: false })
+  state?: string;
+
+  @ApiProperty({ required: false })
+  redirectUri?: string;
+}

package/koala-nest/src/application/auth/oauth2/exchange-code/exchange-code.validator.ts

@@ -0,0 +1,14 @@
+import { RequestValidatorBase } from '@/application/common/request-validator.base';
+import { z } from 'zod';
+import { OAuthExchangeCodeRequest } from './exchange-code.request';
+
+export class OAuthExchangeCodeValidator extends RequestValidatorBase<OAuthExchangeCodeRequest> {
+  protected get schema() {
+    return z.object({
+      provider: z.string().min(1),
+      code: z.string().min(1),
+      state: z.string().min(1).optional(),
+      redirectUri: z.string().url().optional(),
+    });
+  }
+}

package/koala-nest/src/application/auth/oauth2/scalar-token/scalar-oauth-token.handler.ts

@@ -0,0 +1,35 @@
+import { OAuthExchangeCodeHandler } from '@/application/auth/oauth2/exchange-code/exchange-code.handler';
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { AuthTokenResponse } from '@/application/auth/common/auth-token.response';
+import { ScalarTokenBody } from './scalar-token.types';
+import { BadRequestException, Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ScalarOAuthTokenHandler extends RequestHandlerBase<
+  ScalarTokenBody,
+  AuthTokenResponse
+> {
+  constructor(private readonly exchangeCode: OAuthExchangeCodeHandler) {
+    super();
+  }
+
+  async handle(body: ScalarTokenBody): Promise<AuthTokenResponse> {
+    const provider = body.provider?.trim();
+    const code = (body.code ?? body.ssoCode)?.trim();
+    const state = body.state?.trim();
+    const redirectUri = body.redirect_uri ?? body.redirectUri;
+
+    if (!provider || !code) {
+      throw new BadRequestException(
+        'Campos provider e code (ou ssoCode) são obrigatórios',
+      );
+    }
+
+    return this.exchangeCode.handle({
+      provider,
+      code,
+      state: state || undefined,
+      redirectUri,
+    });
+  }
+}

package/koala-nest/src/application/auth/oauth2/scalar-token/scalar-token.types.ts

@@ -0,0 +1 @@
+export type ScalarTokenBody = Record<string, string | undefined>;

package/koala-nest/src/application/auth/refresh-token/refresh-token.handler.ts

@@ -0,0 +1,26 @@
+import { ILoggedUserInfoService } from '@/domain/services/ilogged-user-info.service';
+import { IJwtTokenService } from '@/domain/auth/services/iauth.service';
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { AuthTokenResponse } from '@/application/auth/common/auth-token.response';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class RefreshTokenHandler extends RequestHandlerBase<
+  void,
+  AuthTokenResponse
+> {
+  constructor(
+    private readonly jwtTokenService: IJwtTokenService,
+    private readonly loggedUserInfo: ILoggedUserInfoService,
+  ) {
+    super();
+  }
+
+  handle(): Promise<AuthTokenResponse> {
+    const user = this.loggedUserInfo.getUser();
+
+    return Promise.resolve(
+      this.jwtTokenService.signTokenPair({ sub: user.sub }),
+    );
+  }
+}

package/koala-nest/src/application/auth/user-info/user-info.handler.ts

@@ -0,0 +1,30 @@
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { ILoggedUserInfoService } from '@/domain/services/ilogged-user-info.service';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { UserInfoResponse } from './user-info.response';
+
+@Injectable()
+export class UserInfoHandler extends RequestHandlerBase<
+  void,
+  UserInfoResponse
+> {
+  constructor(private readonly loggedUserInfo: ILoggedUserInfoService) {
+    super();
+  }
+
+  handle(): Promise<UserInfoResponse> {
+    const user = this.loggedUserInfo.getUser();
+
+    if (!user.name || !user.profile || !user.email || !user.login) {
+      throw new NotFoundException('User not found');
+    }
+
+    return Promise.resolve({
+      id: user.sub,
+      name: user.name,
+      email: user.email,
+      login: user.login,
+      profile: user.profile,
+    });
+  }
+}

package/koala-nest/src/application/auth/user-info/user-info.response.ts

@@ -0,0 +1,20 @@
+import { AuthProfile } from '@/core/auth/auth-profile.enum';
+import { ApiPropertyEnum } from '@/host/decorators/api-property-enum.decorator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class UserInfoResponse {
+  @ApiProperty()
+  id: string;
+
+  @ApiProperty()
+  name: string;
+
+  @ApiProperty()
+  email: string;
+
+  @ApiProperty()
+  login: string;
+
+  @ApiPropertyEnum({ enum: AuthProfile })
+  profile: AuthProfile;
+}

package/koala-nest/src/application/common/created-registre.response.ts

@@ -0,0 +1,20 @@
+import { AutoMap } from '@/core/tools/mapping';
+import { ApiProperty } from '@nestjs/swagger';
+
+abstract class CreatedRegistreResponseBase<TId> {
+  @ApiProperty()
+  @AutoMap()
+  id: TId;
+}
+
+export abstract class CreatedRegistreWithUUIDResponse extends CreatedRegistreResponseBase<string> {
+  @ApiProperty({ type: 'string', format: 'uuid' })
+  @AutoMap()
+  declare id: string;
+}
+
+export abstract class CreatedRegistreWithIdResponse extends CreatedRegistreResponseBase<number> {
+  @ApiProperty({ type: 'integer', format: 'int32' })
+  @AutoMap()
+  declare id: number;
+}

package/koala-nest/src/application/common/pagination.request.ts

@@ -0,0 +1,41 @@
+import { QUERY_FILTER_PARAMS } from '@/core/constants/query-params';
+import { AutoMap } from '@/core/tools/mapping';
+import type { QueryDirectionType } from '@/core/types';
+import { ApiProperty } from '@nestjs/swagger';
+
+export type PaginatedRequestProps<T extends PaginationRequest> = Omit<
+  { [K in keyof T as T[K] extends Function ? never : K]: T[K] },
+  '_id'
+>;
+
+export class PaginationRequest {
+  @ApiProperty({
+    required: false,
+    format: 'int32',
+    default: QUERY_FILTER_PARAMS.page,
+  })
+  @AutoMap()
+  page?: number = QUERY_FILTER_PARAMS.page;
+
+  @ApiProperty({
+    required: false,
+    format: 'int32',
+    default: QUERY_FILTER_PARAMS.limit,
+  })
+  @AutoMap()
+  limit?: number = QUERY_FILTER_PARAMS.limit;
+
+  @ApiProperty({
+    required: false,
+  })
+  @AutoMap()
+  orderBy?: string;
+
+  @ApiProperty({
+    required: false,
+    enum: ['asc', 'desc'],
+    default: QUERY_FILTER_PARAMS.direction,
+  })
+  @AutoMap()
+  direction?: QueryDirectionType = QUERY_FILTER_PARAMS.direction;
+}

package/koala-nest/src/application/common/request-handler.base.ts

@@ -0,0 +1,3 @@
+export abstract class RequestHandlerBase<TRequest, TResponse> {
+  abstract handle(req: TRequest): Promise<TResponse>;
+}

package/koala-nest/src/application/common/request-validator.base.ts

@@ -0,0 +1,33 @@
+import { ZodType } from 'zod';
+
+export abstract class RequestValidatorBase<
+  TRequest extends Record<string, any>,
+> {
+  protected _request: Record<string, any>;
+
+  constructor(request: TRequest) {
+    this._request = { ...request };
+  }
+
+  validate(): TRequest {
+    Object.keys(this._request).forEach((key) => {
+      if (key.includes('[]')) {
+        const newKey = key.replace('[]', '');
+        const value = this._request[key];
+        this._request[newKey] =
+          typeof value === 'string' ? value.split(',') : value;
+        delete this._request[key];
+      }
+    });
+
+    const requestParsed = this.schema.safeParse(this._request);
+
+    if (requestParsed.success) {
+      return Object.assign({} as TRequest, requestParsed.data);
+    }
+
+    throw requestParsed.error;
+  }
+
+  protected abstract get schema(): ZodType;
+}

package/koala-nest/src/application/mapping/mapping.provider.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@nestjs/common';
+import { PersonMapper } from './person.mapper';
+
+@Injectable()
+export class MappingProvider {
+  constructor() {
+    PersonMapper.createMap();
+  }
+}

package/koala-nest/src/application/mapping/person.mapper.ts

@@ -0,0 +1,44 @@
+import { createMap } from '@/core/tools/mapping';
+import { PersonQueryDto } from '@/domain/dtos/person-query.dto';
+import { Person } from '@/domain/entities/person/person';
+import { PersonAddress } from '@/domain/entities/person/person-address';
+import { PersonContact } from '@/domain/entities/person/person-contact';
+import {
+  CreatePersonAddressRequest,
+  CreatePersonContactRequest,
+  CreatePersonRequest,
+} from '@/application/person/create/create-person.request';
+import { CreatePersonResponse } from '@/application/person/create/create-person.response';
+import { ReadManyPersonRequest } from '@/application/person/read-many/read-many-person.request';
+import {
+  ReadPersonAddressResponse,
+  ReadPersonContactResponse,
+  ReadPersonResponse,
+} from '@/application/person/read/read-person.response';
+import {
+  UpdatePersonAddressRequest,
+  UpdatePersonContactRequest,
+  UpdatePersonRequest,
+} from '@/application/person/update/update-person.request';
+import { ReadManyPersonResponseItem } from '@/application/person/read-many/read-many-person.response';
+
+export class PersonMapper {
+  static createMap() {
+    createMap(Person, CreatePersonResponse);
+
+    createMap(Person, ReadPersonResponse);
+    createMap(PersonAddress, ReadPersonAddressResponse);
+    createMap(PersonContact, ReadPersonContactResponse);
+
+    createMap(CreatePersonRequest, Person);
+    createMap(CreatePersonAddressRequest, PersonAddress);
+    createMap(CreatePersonContactRequest, PersonContact);
+
+    createMap(UpdatePersonRequest, Person);
+    createMap(UpdatePersonAddressRequest, PersonAddress);
+    createMap(UpdatePersonContactRequest, PersonContact);
+
+    createMap(ReadManyPersonRequest, PersonQueryDto);
+    createMap(Person, ReadManyPersonResponseItem);
+  }
+}

package/koala-nest/src/application/person/create/create-person.handler.ts

@@ -0,0 +1,34 @@
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { CreatePersonRequest } from './create-person.request';
+import { CreatePersonResponse } from './create-person.response';
+import { Injectable } from '@nestjs/common';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { AutoMapper } from '@/core/tools/mapping';
+import { Person } from '@/domain/entities/person/person';
+import { CreatePersonValidator } from './create-person.validator';
+import { ICacheService } from '@/domain/common/icache.service';
+import { invalidatePersonListCache } from '@/core/utils/person-list-cache';
+
+@Injectable()
+export class CreatePersonHandler extends RequestHandlerBase<
+  CreatePersonRequest,
+  CreatePersonResponse
+> {
+  constructor(
+    private readonly repository: IPersonRepository,
+    private readonly cache: ICacheService,
+  ) {
+    super();
+  }
+
+  async handle(req: CreatePersonRequest): Promise<CreatePersonResponse> {
+    const person = AutoMapper.map(
+      new CreatePersonValidator(req).validate(),
+      CreatePersonRequest,
+      Person,
+    );
+    const createdPerson = await this.repository.save(person);
+    await invalidatePersonListCache(this.cache);
+    return AutoMapper.map(createdPerson, Person, CreatePersonResponse);
+  }
+}

package/koala-nest/src/application/person/create/create-person.request.ts

@@ -0,0 +1,29 @@
+import { ObjectClass } from '@/core/base/object-class';
+import { AutoMap } from '@/core/tools/mapping';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class CreatePersonAddressRequest extends ObjectClass<CreatePersonAddressRequest> {
+  @ApiProperty({ example: '123 Main St' })
+  @AutoMap()
+  address: string;
+}
+
+export class CreatePersonContactRequest extends ObjectClass<CreatePersonContactRequest> {
+  @ApiProperty({ example: 'john.doe@example.com' })
+  @AutoMap()
+  contact: string;
+}
+
+export class CreatePersonRequest extends ObjectClass<CreatePersonRequest> {
+  @ApiProperty({ example: 'John Doe' })
+  @AutoMap()
+  name: string;
+
+  @ApiProperty({ type: CreatePersonAddressRequest })
+  @AutoMap()
+  address: CreatePersonAddressRequest;
+
+  @ApiProperty({ type: CreatePersonContactRequest, isArray: true })
+  @AutoMap({ type: () => CreatePersonContactRequest })
+  contacts: CreatePersonContactRequest[];
+}

package/koala-nest/src/application/person/create/create-person.response.ts

@@ -0,0 +1,3 @@
+import { CreatedRegistreWithIdResponse } from '@/application/common/created-registre.response';
+
+export class CreatePersonResponse extends CreatedRegistreWithIdResponse {}

package/koala-nest/src/application/person/create/create-person.validator.ts

@@ -0,0 +1,9 @@
+import { RequestValidatorBase } from '@/application/common/request-validator.base';
+import { personBodySchema } from '@/application/person/person.schemas';
+import { CreatePersonRequest } from './create-person.request';
+
+export class CreatePersonValidator extends RequestValidatorBase<CreatePersonRequest> {
+  protected get schema() {
+    return personBodySchema();
+  }
+}

package/koala-nest/src/application/person/delete/delete-person.handler.ts

@@ -0,0 +1,22 @@
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { findPersonOrThrow } from '@/application/person/find-person-or-throw';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { Injectable } from '@nestjs/common';
+import { ICacheService } from '@/domain/common/icache.service';
+import { invalidatePersonListCache } from '@/core/utils/person-list-cache';
+
+@Injectable()
+export class DeletePersonHandler extends RequestHandlerBase<number, void> {
+  constructor(
+    private readonly repository: IPersonRepository,
+    private readonly cache: ICacheService,
+  ) {
+    super();
+  }
+
+  async handle(id: number): Promise<void> {
+    const person = await findPersonOrThrow(this.repository, id);
+    await this.repository.delete(person);
+    await invalidatePersonListCache(this.cache);
+  }
+}

package/koala-nest/src/application/person/find-person-or-throw.ts

@@ -0,0 +1,16 @@
+import { Person } from '@/domain/entities/person/person';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { NotFoundException } from '@nestjs/common';
+
+export async function findPersonOrThrow(
+  repository: IPersonRepository,
+  id: number,
+): Promise<Person> {
+  const person = await repository.findById(id);
+
+  if (!person) {
+    throw new NotFoundException('Pessoa não encontrada');
+  }
+
+  return person;
+}