new authorization

src/modules/authentication/interface/grpc-controllers/add-username.grpc.controller.ts

@@ -0,0 +1,49 @@
+import {
+  AggregateID,
+  IdResponse,
+  RpcExceptionCode,
+  RpcValidationPipe,
+} from '@mobicoop/ddd-library';
+import { Controller, UsePipes } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
+import { GrpcMethod, RpcException } from '@nestjs/microservices';
+import { UsernameAlreadyExistsException } from '@modules/authentication/core/domain/authentication.errors';
+import { AddUsernameRequestDto } from './dtos/add-username.request.dto';
+import { AddUsernameCommand } from '@modules/authentication/core/application/commands/add-usernames/add-username.command';
+
+@UsePipes(
+  new RpcValidationPipe({
+    whitelist: true,
+    forbidUnknownValues: false,
+  }),
+)
+@Controller()
+export class AddUsernameGrpcController {
+  constructor(private readonly commandBus: CommandBus) {}
+
+  @GrpcMethod('AuthenticationService', 'AddUsername')
+  async addUsername(data: AddUsernameRequestDto): Promise<IdResponse> {
+    try {
+      const aggregateID: AggregateID = await this.commandBus.execute(
+        new AddUsernameCommand({
+          userId: data.userId,
+          username: {
+            name: data.name,
+            type: data.type,
+          },
+        }),
+      );
+      return new IdResponse(aggregateID);
+    } catch (error: any) {
+      if (error instanceof UsernameAlreadyExistsException)
+        throw new RpcException({
+          code: RpcExceptionCode.ALREADY_EXISTS,
+          message: error.message,
+        });
+      throw new RpcException({
+        code: RpcExceptionCode.UNKNOWN,
+        message: error.message,
+      });
+    }
+  }
+}

src/modules/authentication/interface/grpc-controllers/authentication.proto

@@ -0,0 +1,45 @@
+syntax = "proto3";
+
+package authentication;
+
+service AuthenticationService {
+  rpc Validate(AuthenticationByUsernamePassword) returns (Id);
+  rpc Create(Authentication) returns (Id);
+  rpc AddUsername(Username) returns (Id);
+  rpc UpdatePassword(Password) returns (Id);
+  rpc UpdateUsername(Username) returns (Id);
+  rpc DeleteUsername(Username) returns (Id);
+  rpc Delete(UserId) returns (Empty);
+}
+
+message AuthenticationByUsernamePassword {
+  string username = 1;
+  string password = 2;
+}
+
+message Authentication {
+  string userId = 1;
+  repeated Username usernames = 2;
+  string password = 3;
+}
+
+message Password {
+  string userId = 1;
+  string password = 2;
+}
+
+message Username {
+  string userId = 1;
+  string name = 2;
+  string type = 3;
+}
+
+message Id {
+  string id = 1;
+}
+
+message UserId {
+  string userId = 1;
+}
+
+message Empty {}

src/modules/authentication/interface/grpc-controllers/create-authentication.grpc.controller.ts

@@ -0,0 +1,43 @@
+import {
+  AggregateID,
+  IdResponse,
+  RpcExceptionCode,
+  RpcValidationPipe,
+} from '@mobicoop/ddd-library';
+import { Controller, UsePipes } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
+import { GrpcMethod, RpcException } from '@nestjs/microservices';
+import { CreateAuthenticationRequestDto } from './dtos/create-authentication.request.dto';
+import { CreateAuthenticationCommand } from '@modules/authentication/core/application/commands/create-authentication/create-authentication.command';
+import { AuthenticationAlreadyExistsException } from '@modules/authentication/core/domain/authentication.errors';
+
+@UsePipes(
+  new RpcValidationPipe({
+    whitelist: true,
+    forbidUnknownValues: false,
+  }),
+)
+@Controller()
+export class CreateAuthenticationGrpcController {
+  constructor(private readonly commandBus: CommandBus) {}
+
+  @GrpcMethod('AuthenticationService', 'Create')
+  async create(data: CreateAuthenticationRequestDto): Promise<IdResponse> {
+    try {
+      const aggregateID: AggregateID = await this.commandBus.execute(
+        new CreateAuthenticationCommand(data),
+      );
+      return new IdResponse(aggregateID);
+    } catch (error: any) {
+      if (error instanceof AuthenticationAlreadyExistsException)
+        throw new RpcException({
+          code: RpcExceptionCode.ALREADY_EXISTS,
+          message: error.message,
+        });
+      throw new RpcException({
+        code: RpcExceptionCode.UNKNOWN,
+        message: error.message,
+      });
+    }
+  }
+}

src/modules/authentication/interface/grpc-controllers/delete-authentication.grpc.controller.ts

@@ -0,0 +1,45 @@
+import {
+  DatabaseErrorException,
+  NotFoundException,
+  RpcExceptionCode,
+  RpcValidationPipe,
+} from '@mobicoop/ddd-library';
+import { Controller, UsePipes } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
+import { GrpcMethod, RpcException } from '@nestjs/microservices';
+import { DeleteAuthenticationCommand } from '@modules/authentication/core/application/commands/delete-authentication/delete-authentication.command';
+import { DeleteAuthenticationRequestDto } from './dtos/delete-authentication.request.dto';
+
+@UsePipes(
+  new RpcValidationPipe({
+    whitelist: true,
+    forbidUnknownValues: false,
+  }),
+)
+@Controller()
+export class DeleteAuthenticationGrpcController {
+  constructor(private readonly commandBus: CommandBus) {}
+
+  @GrpcMethod('AuthenticationService', 'Delete')
+  async delete(data: DeleteAuthenticationRequestDto): Promise<void> {
+    try {
+      await this.commandBus.execute(new DeleteAuthenticationCommand(data));
+    } catch (error: any) {
+      if (error instanceof NotFoundException)
+        throw new RpcException({
+          code: RpcExceptionCode.NOT_FOUND,
+          message: error.message,
+        });
+
+      if (error instanceof DatabaseErrorException)
+        throw new RpcException({
+          code: RpcExceptionCode.INTERNAL,
+          message: error.message,
+        });
+      throw new RpcException({
+        code: RpcExceptionCode.UNKNOWN,
+        message: error.message,
+      });
+    }
+  }
+}

src/modules/authentication/interface/grpc-controllers/dtos/add-username.request.dto.ts

@@ -0,0 +1,8 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+import { UsernameDto } from './username.dto';
+
+export class AddUsernameRequestDto extends UsernameDto {
+  @IsString()
+  @IsNotEmpty()
+  userId: string;
+}

src/modules/authentication/interface/grpc-controllers/dtos/create-authentication.request.dto.ts

@@ -0,0 +1,25 @@
+import { Type } from 'class-transformer';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsNotEmpty,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import { UsernameDto } from './username.dto';
+
+export class CreateAuthenticationRequestDto {
+  @IsString()
+  @IsNotEmpty()
+  userId: string;
+
+  @Type(() => UsernameDto)
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  usernames: UsernameDto[];
+
+  @IsString()
+  @IsNotEmpty()
+  password: string;
+}

src/modules/authentication/interface/grpc-controllers/dtos/delete-authentication.request.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class DeleteAuthenticationRequestDto {
+  @IsString()
+  @IsNotEmpty()
+  userId: string;
+}

src/modules/authentication/interface/grpc-controllers/dtos/username.dto.ts

@@ -0,0 +1,16 @@
+import { Type } from '@modules/authentication/core/domain/username.types';
+import { IsEnum, IsNotEmpty, IsString } from 'class-validator';
+import { IsValidUsername } from './validators/decorators/is-valid-username.decorator';
+
+export class UsernameDto {
+  @IsString()
+  @IsNotEmpty()
+  @IsValidUsername({
+    message: 'Invalid username',
+  })
+  name: string;
+
+  @IsEnum(Type)
+  @IsNotEmpty()
+  type: Type;
+}

src/modules/authentication/interface/grpc-controllers/dtos/validators/decorators/is-valid-username.decorator.ts

@@ -0,0 +1,32 @@
+import { Type } from '@modules/authentication/core/domain/username.types';
+import {
+  registerDecorator,
+  ValidationOptions,
+  ValidationArguments,
+  isEmail,
+  isPhoneNumber,
+} from 'class-validator';
+
+export function IsValidUsername(validationOptions?: ValidationOptions) {
+  return function (object: any, propertyName: string) {
+    registerDecorator({
+      name: 'isValidUsername',
+      target: object.constructor,
+      propertyName: propertyName,
+      options: validationOptions,
+      validator: {
+        validate(value: any, args: ValidationArguments) {
+          const usernameType: Type = args.object['type'];
+          switch (usernameType) {
+            case Type.PHONE:
+              return isPhoneNumber(value);
+            case Type.EMAIL:
+              return isEmail(value);
+            default:
+              return false;
+          }
+        },
+      },
+    });
+  };
+}