add auth

src/modules/auth/auth.controller.ts

@@ -0,0 +1,103 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  UseGuards,
+  Request,
+  Response,
+  NotFoundException,
+  UnauthorizedException,
+  BadRequestException,
+  Res,
+  HttpCode,
+} from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { RegistrationDto } from './dto/registration.dto';
+import { LocalAuthGuard } from './guards/local-auth.guard';
+import { UsersService } from '../users/services/users.service';
+import { JwtAuthGuard } from './guards/jwt-auth.guard';
+
+@Controller('auth')
+export class AuthController {
+  constructor(
+    private readonly authService: AuthService,
+    private readonly usersService: UsersService,
+  ) {}
+
+  @UseGuards(JwtAuthGuard)
+  @Get('me')
+  async getUserData(@Request() req) {
+    const userId = req.user.userId;
+    const user = await this.usersService.getUserById(userId);
+
+    if (!user) throw new UnauthorizedException();
+
+    return {
+      email: user.email,
+      name: user.name,
+      is: user.id,
+    };
+  }
+  @HttpCode(200)
+  @UseGuards(LocalAuthGuard)
+  @Post('login')
+  async login(@Request() req, @Res({ passthrough: true }) res) {
+    const userData = req.user.data;
+    res.cookie('refreshToken', userData.refreshToken, {
+      httpOnly: true,
+      secure: true,
+    });
+    return { accessToken: req.user.data.accessToken };
+  }
+  @HttpCode(201)
+  @Post('registration')
+  async registration(@Body() registrationData: RegistrationDto) {
+    return await this.usersService.createUser(
+      registrationData.name,
+      registrationData.password,
+      registrationData.email,
+    );
+  }
+
+  @Post('registration-confirmation')
+  async confirmRegistration(@Body('code') confirmationCode) {
+    const result = await this.authService.confirmEmail(confirmationCode);
+    if (!result) {
+      throw new NotFoundException();
+    }
+    return null;
+  }
+
+  @Post('registration-email-resending')
+  async resendRegistrationEmail(@Body('email') email: string) {
+    const isResented = await this.authService.resendCode(email);
+    if (!isResented)
+      throw new BadRequestException({
+        message: 'email already confirmed or such email not found',
+        field: 'email',
+      });
+    return null;
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Post('logout')
+  async logout(@Request() req) {
+    if (!req.cookie?.refreshToken) throw new UnauthorizedException();
+    await this.usersService.addRevokedToken(req.cookie.refreshToken);
+    return null;
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Post('refresh-token')
+  async refreshToken(@Request() req, @Response() res) {
+    if (!req.cookie?.refreshToken) throw new UnauthorizedException();
+    const userId = req.user.id;
+    const newTokens = this.authService.createJwtTokensPair(userId, null);
+    res.cookie('refreshToken', newTokens.refreshToken, {
+      httpOnly: true,
+      secure: true,
+    });
+    return { accessToken: newTokens.accessToken };
+  }
+}

src/modules/auth/auth.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { UsersModule } from '../users/users.module';
+import { LocalStrategy } from './strategies/local.strategy';
+
+@Module({
+  imports: [UsersModule],
+  controllers: [AuthController],
+  providers: [AuthService, LocalStrategy],
+})
+export class AuthModule {}

src/modules/auth/auth.service.ts

@@ -0,0 +1,88 @@
+import { Injectable } from '@nestjs/common';
+import { isAfter } from 'date-fns';
+import * as jwt from 'jsonwebtoken';
+import * as bcrypt from 'bcrypt';
+import { UsersRepository } from '../users/infrastructure/users.repository';
+import * as process from 'process';
+
+@Injectable()
+export class AuthService {
+  constructor(private usersRepository: UsersRepository) {}
+
+  createJwtTokensPair(userId: string, email: string | null) {
+    const accessSecretKey = process.env.ACCESS_JWT_SECRET_KEY;
+    const refreshSecretKey = process.env.REFRESH_JWT_SECRET_KEY;
+    const payload: { userId: string; date: Date; email: string | null } = {
+      userId,
+      date: new Date(),
+      email,
+    };
+    const accessToken = jwt.sign(payload, accessSecretKey, { expiresIn: '1d' });
+    const refreshToken = jwt.sign(payload, refreshSecretKey, {
+      expiresIn: '30d',
+    });
+    return {
+      accessToken,
+      refreshToken,
+    };
+  }
+
+  async checkCredentials(email: string, password: string) {
+    const user = await this.usersRepository.findUserByEmail(email);
+    if (!user /*|| !user.emailConfirmation.isConfirmed*/)
+      return {
+        resultCode: 1,
+        data: {
+          accessToken: null,
+          refreshToken: null,
+        },
+      };
+    const isPasswordValid = await this.isPasswordCorrect(
+      password,
+      user.password,
+    );
+    if (!isPasswordValid) {
+      return {
+        resultCode: 1,
+        data: {
+          token: {
+            accessToken: null,
+            refreshToken: null,
+          },
+        },
+      };
+    }
+    const tokensPair = this.createJwtTokensPair(user.id, user.email);
+    return {
+      resultCode: 0,
+      data: tokensPair,
+    };
+  }
+
+  private async isPasswordCorrect(password: string, hash: string) {
+    return bcrypt.compare(password, hash);
+  }
+
+  async confirmEmail(token: string): Promise<boolean> {
+    const user = await this.usersRepository.findUserByVerificationToken(token);
+    if (!user || user.isEmailVerified) return false;
+    const dbToken = user.verificationToken;
+    const isTokenExpired = isAfter(user.verificationTokenExpiry, new Date());
+    if (dbToken !== token || isTokenExpired) {
+      return false;
+    }
+
+    return await this.usersRepository.updateConfirmation(user.id);
+  }
+
+  async resendCode(email: string) {
+    const user = await this.usersRepository.findUserByEmail(email);
+    if (!user || user?.verification.isEmailVerified) return null;
+    const updatedUser = await this.usersRepository.updateVerificationToken(
+      user.id,
+    );
+    if (!updatedUser) return null;
+
+    return true;
+  }
+}

src/modules/auth/dto/registration.dto.ts

@@ -0,0 +1,10 @@
+import { IsEmail, Length } from 'class-validator';
+
+export class RegistrationDto {
+  @Length(3, 30)
+  name: string;
+  @Length(3, 30)
+  password: string;
+  @IsEmail()
+  email: string;
+}

src/modules/auth/dto/update-auth.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { RegistrationDto } from './registration.dto';
+
+export class UpdateAuthDto extends PartialType(RegistrationDto) {}

src/modules/auth/entities/auth.entity.ts

@@ -0,0 +1 @@
+export class Auth {}

src/modules/auth/guards/auth.guard.ts

@@ -0,0 +1,52 @@
+import {
+  BadRequestException,
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+import { UsersRepository } from '../../users/infrastructure/users.repository';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(private readonly usersRepository: UsersRepository) {}
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    if (!request.headers || !request.headers.authorization) {
+      throw new BadRequestException([{ message: 'No any auth headers' }]);
+    }
+    const authorizationData = request.headers.authorization.split(' ');
+    const token = authorizationData[1];
+    const tokenName = authorizationData[0];
+    if (tokenName != 'Bearer') {
+      throw new UnauthorizedException([
+        {
+          message: 'login or password invalid',
+        },
+      ]);
+    }
+    try {
+      const secretKey = process.env.JWT_SECRET_KEY;
+      const decoded: any = jwt.verify(token, secretKey!);
+      const user = await this.usersRepository.findUserById(decoded.userId);
+      if (!user) {
+        throw new NotFoundException([
+          {
+            field: 'token',
+            message: 'user not found',
+          },
+        ]);
+      }
+    } catch (e) {
+      console.log(e);
+      throw new UnauthorizedException([
+        {
+          message: 'login or password invalid',
+        },
+      ]);
+    }
+    return true;
+  }
+}

src/modules/auth/guards/base-auth.guard.ts

@@ -0,0 +1,29 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class BaseAuthGuard implements CanActivate {
+  canActivate(
+    context: ExecutionContext,
+  ): boolean | Promise<boolean> | Observable<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const exceptedAuthInput = 'Basic YWRtaW46cXdlcnR5';
+    if (!request.headers || !request.headers.authorization) {
+      throw new UnauthorizedException([{ message: 'No any auth headers' }]);
+    } else {
+      if (request.headers.authorization != exceptedAuthInput) {
+        throw new UnauthorizedException([
+          {
+            message: 'login or password invalid',
+          },
+        ]);
+      }
+    }
+    return true;
+  }
+}

src/modules/auth/guards/jwt-auth.guard.ts

@@ -0,0 +1,25 @@
+import {
+  ExecutionContext,
+  Injectable,
+  UsePipes,
+  ValidationPipe,
+} from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {
+  constructor() {
+    super();
+  }
+  @UsePipes(new ValidationPipe())
+  validateLoginDto(): void {}
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const req = context.switchToHttp().getRequest();
+
+    const res: boolean = await (super.canActivate(context) as Promise<boolean>);
+    if (!res) return false;
+
+    // check DTO
+    return res;
+  }
+}

src/modules/auth/guards/local-auth.guard.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class LocalAuthGuard extends AuthGuard('local') {}

src/modules/auth/strategies/jwt.strategy.ts

@@ -0,0 +1,21 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { AppSettings } from '../../../settings/app-settings';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    @Inject(AppSettings.name) private readonly appSettings: AppSettings,
+  ) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: true,
+      secretOrKey: appSettings.auth.ACCESS_JWT_SECRET_KEY,
+    });
+  }
+
+  async validate(payload: any) {
+    return { userId: payload.userId };
+  }
+}

src/modules/auth/strategies/local.strategy.ts

@@ -0,0 +1,21 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy } from 'passport-local';
+import { AuthService } from '../auth.service';
+
+@Injectable()
+export class LocalStrategy extends PassportStrategy(Strategy) {
+  constructor(private readonly authService: AuthService) {
+    super({
+      usernameField: 'login',
+    });
+  }
+
+  async validate(login: string, password: string): Promise<any> {
+    const user = await this.authService.checkCredentials(login, password);
+    if (user.resultCode === 1) {
+      throw new UnauthorizedException();
+    }
+    return user;
+  }
+}

src/modules/core/validation/notification.ts

@@ -0,0 +1,69 @@
+import { IEvent } from '@nestjs/cqrs';
+
+export class ResultNotification<T = null> {
+  constructor(data: T | null = null) {
+    this.data = data;
+  }
+
+  extensions: NotificationExtension[] = [];
+  code = 0;
+  data: T | null = null;
+
+  hasError() {
+    return this.code !== 0;
+  }
+
+  addError(
+    message: string,
+    key: string | null = null,
+    code: number | null = null,
+  ) {
+    this.code = code ?? 1;
+    this.extensions.push(new NotificationExtension(message, key));
+  }
+
+  addData(data: T) {
+    this.data = data;
+  }
+}
+
+export class NotificationExtension {
+  constructor(public message: string, public key: string | null) {}
+}
+
+export class DomainResultNotification<
+  TData = null,
+> extends ResultNotification<TData> {
+  public events: IEvent[] = [];
+  addEvents(...events: IEvent[]) {
+    this.events = [...this.events, ...events];
+  }
+
+  static create<T>(
+    mainNotification: DomainResultNotification<T>,
+    ...otherNotifications: DomainResultNotification[]
+  ) {
+    const domainResultNotification = new DomainResultNotification<T>();
+
+    if (!!mainNotification.data) {
+      domainResultNotification.addData(mainNotification.data);
+    }
+    domainResultNotification.events = mainNotification.events;
+
+    mainNotification.extensions.forEach((e) => {
+      domainResultNotification.addError(e.message, e.key);
+    });
+
+    otherNotifications.forEach((n) => {
+      domainResultNotification.events = [
+        ...domainResultNotification.events,
+        ...n.events,
+      ];
+      n.extensions.forEach((e) => {
+        domainResultNotification.addError(e.message, e.key);
+      });
+    });
+
+    return domainResultNotification;
+  }
+}

src/modules/core/validation/validation.utils.ts

@@ -0,0 +1,58 @@
+import { DomainResultNotification, ResultNotification } from './notification';
+import { validateOrReject } from 'class-validator';
+import { IEvent } from '@nestjs/cqrs';
+import {
+  validationErrorsMapper,
+  ValidationPipeErrorType,
+} from '../../../settings/pipes-setup';
+
+export class DomainError extends Error {
+  constructor(message: string, public resultNotification: ResultNotification) {
+    super(message);
+  }
+}
+
+export const validateEntityOrThrow = async (entity: any) => {
+  try {
+    await validateOrReject(entity);
+  } catch (errors) {
+    const resultNotification: ResultNotification = mapErrorsToNotification(
+      validationErrorsMapper.mapValidationErrorArrayToValidationPipeErrorTypeArray(
+        errors,
+      ),
+    );
+
+    throw new DomainError('domain entity validation error', resultNotification);
+  }
+};
+
+export const validateEntity = async <T extends object>(
+  entity: T,
+  events: IEvent[],
+): Promise<DomainResultNotification<T>> => {
+  try {
+    await validateOrReject(entity);
+  } catch (errors) {
+    const resultNotification: DomainResultNotification<T> =
+      mapErrorsToNotification<T>(
+        validationErrorsMapper.mapValidationErrorArrayToValidationPipeErrorTypeArray(
+          errors,
+        ),
+      );
+    resultNotification.addData(entity);
+    resultNotification.addEvents(...events);
+    return resultNotification;
+  }
+  const domainResultNotification = new DomainResultNotification<T>(entity);
+  domainResultNotification.addEvents(...events);
+
+  return domainResultNotification;
+};
+
+export function mapErrorsToNotification<T>(errors: ValidationPipeErrorType[]) {
+  const resultNotification = new DomainResultNotification<T>();
+  errors.forEach((item: ValidationPipeErrorType) =>
+    resultNotification.addError(item.message, item.field, 1),
+  );
+  return resultNotification;
+}

src/modules/users/api/users.controller.ts

@@ -0,0 +1,47 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  NotFoundException,
+  Param,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import { UsersService } from '../services/users.service';
+import { CreateUserDto } from '../dto/create-user.dto';
+import { Pagination } from '../../../infrastructure/common/pagination.service';
+import { BaseAuthGuard } from '../../auth/guards/base-auth.guard';
+
+@Controller('users')
+export class UsersController {
+  constructor(private usersService: UsersService) {}
+
+  @Get()
+  async findAll(@Query() query) {
+    const { page, pageSize, searchNameTerm } =
+      Pagination.getPaginationData(query);
+    const users = await this.usersService.getUsers(
+      page,
+      pageSize,
+      searchNameTerm,
+    );
+    if (!users) throw new NotFoundException('Users not found');
+    return users;
+  }
+  //@UseGuards(BaseAuthGuard)
+  @Post()
+  async create(@Body() createUserDto: CreateUserDto) {
+    return await this.usersService.createUser(
+      createUserDto.login,
+      createUserDto.password,
+      createUserDto.email,
+    );
+  }
+  @UseGuards(BaseAuthGuard)
+  @Delete(':id')
+  async remove(@Param('id') id: string) {
+    return await this.usersService.deleteUserById(id);
+  }
+}

src/modules/users/dto/create-user.dto.ts

@@ -0,0 +1,10 @@
+import { Length, Matches } from 'class-validator';
+
+export class CreateUserDto {
+  @Length(3, 10)
+  login: string;
+  @Length(6, 20)
+  password: string;
+  @Matches(/^[\w-.]+@([\w-]+\.)+[\w-]{2,4}$/)
+  email: string;
+}

src/modules/users/dto/update-user.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateUserDto } from './create-user.dto';
+
+export class UpdateUserDto extends PartialType(CreateUserDto) {}

src/modules/users/infrastructure/users.repository.ts

@@ -0,0 +1,164 @@
+import {
+  CreateUserInput,
+  EntityWithPaginationType,
+  User,
+  UserViewType,
+  VerificationWithUser,
+} from '../../../types/types';
+import { Injectable } from '@nestjs/common';
+import { addHours } from 'date-fns';
+import { IUsersRepository } from '../services/users.service';
+import { v4 as uuidv4 } from 'uuid';
+import { PrismaService } from '../../../prisma.service';
+
+@Injectable()
+export class UsersRepository implements IUsersRepository {
+  constructor(private prisma: PrismaService) {}
+
+  async getUsers(
+    currentPage: number,
+    itemsPerPage: number,
+    searchNameTerm: string,
+  ): Promise<EntityWithPaginationType<UserViewType>> {
+    const where = {
+      name: {
+        search: searchNameTerm,
+      },
+    };
+    const [totalItems, users] = await this.prisma.$transaction([
+      this.prisma.user.count({ where }),
+      this.prisma.user.findMany({
+        where,
+        skip: (currentPage - 1) * itemsPerPage,
+        take: itemsPerPage,
+      }),
+    ]);
+
+    console.log(users, 'usersFromBase');
+    const totalPages = Math.ceil(totalItems / itemsPerPage);
+    const usersView = users.map((u) => ({
+      id: u.id,
+      name: u.name,
+      email: u.email,
+    }));
+    console.log(usersView, 'users---');
+    return {
+      totalPages,
+      currentPage,
+      itemsPerPage,
+      totalItems,
+      items: usersView,
+    };
+  }
+
+  async createUser(newUser: CreateUserInput): Promise<User | null> {
+    return await this.prisma.user.create({
+      data: {
+        email: newUser.email,
+        password: newUser.password,
+        name: newUser.name,
+        verification: {
+          create: {
+            verificationToken: newUser.verificationToken,
+            verificationTokenExpiry: newUser.verificationTokenExpiry,
+          },
+        },
+      },
+      include: {
+        verification: true,
+      },
+    });
+  }
+
+  async deleteUserById(id: string): Promise<boolean> {
+    const result = await this.prisma.user.delete({
+      where: {
+        id,
+      },
+    });
+    return result.isDeleted;
+  }
+
+  async findUserById(id: string): Promise<User | null> {
+    const user = await this.prisma.user.findUnique({ where: { id } });
+    if (!user) {
+      return null;
+    }
+
+    return user;
+  }
+
+  async findUserByEmail(email: string): Promise<User | null> {
+    const user = await this.prisma.user.findUnique({
+      where: { email },
+      include: { verification: true },
+    });
+
+    if (!user) {
+      return null;
+    }
+    return user;
+  }
+
+  async findUserByVerificationToken(
+    token: string,
+  ): Promise<VerificationWithUser | null> {
+    const verification = await this.prisma.verification.findUnique({
+      where: {
+        verificationToken: token,
+      },
+      include: {
+        user: true,
+      },
+    });
+    if (!verification) {
+      return null;
+    }
+    return verification;
+  }
+
+  async updateConfirmation(id: string) {
+    const result = await this.prisma.verification.update({
+      where: {
+        userId: id,
+      },
+      data: {
+        isEmailVerified: true,
+      },
+    });
+    return result.isEmailVerified;
+  }
+
+  async updateVerificationToken(id: string) {
+    return await this.prisma.verification.update({
+      where: {
+        userId: id,
+      },
+      data: {
+        verificationToken: uuidv4(),
+        verificationTokenExpiry: addHours(new Date(), 24),
+      },
+      include: {
+        user: true,
+      },
+    });
+  }
+
+  async revokeToken(id: string, token: string): Promise<User | null> {
+    const revokedToken = await this.prisma.accessToken.update({
+      where: {
+        token: token,
+      },
+      data: {
+        isRevoked: true,
+      },
+      include: {
+        user: true,
+      },
+    });
+    if (!revokedToken.user) {
+      return null;
+    }
+    return revokedToken.user;
+  }
+}

src/modules/users/services/users.service.ts

@@ -0,0 +1,87 @@
+import { v4 as uuidv4 } from 'uuid';
+import {
+  CreateUserInput,
+  EntityWithPaginationType,
+  User,
+  UserViewType,
+} from '../../../types/types';
+import { addHours } from 'date-fns';
+import { Injectable } from '@nestjs/common';
+import jwt from 'jsonwebtoken';
+import { UsersRepository } from '../infrastructure/users.repository';
+import * as bcrypt from 'bcrypt';
+
+@Injectable()
+export class UsersService {
+  constructor(private usersRepository: UsersRepository) {}
+
+  async getUsers(page: number, pageSize: number, searchNameTerm: string) {
+    return await this.usersRepository.getUsers(page, pageSize, searchNameTerm);
+  }
+
+  async getUserById(id: string) {
+    return await this.usersRepository.findUserById(id);
+  }
+
+  async createUser(
+    name: string,
+    password: string,
+    email: string,
+  ): Promise<UserViewType | null> {
+    const passwordHash = await this._generateHash(password);
+    const newUser: CreateUserInput = {
+      name: name || email.split('@')[0],
+      email: email,
+      password: passwordHash,
+      verificationToken: uuidv4(),
+      verificationTokenExpiry: addHours(new Date(), 24),
+      isEmailVerified: false,
+    };
+    const createdUser = await this.usersRepository.createUser(newUser);
+    if (!createdUser) {
+      return null;
+    }
+
+    return {
+      id: createdUser.id,
+      name: createdUser.name,
+      email: createdUser.email,
+    };
+  }
+
+  async deleteUserById(id: string): Promise<boolean> {
+    return await this.usersRepository.deleteUserById(id);
+  }
+
+  async addRevokedToken(token: string) {
+    const secretKey = process.env.JWT_SECRET_KEY;
+    if (!secretKey) throw new Error('JWT_SECRET_KEY is not defined');
+
+    try {
+      const decoded: any = jwt.verify(token, secretKey);
+      return this.usersRepository.revokeToken(decoded.userId, token);
+    } catch (e) {
+      console.log('Decoding error: e');
+      return null;
+    }
+  }
+  private async _generateHash(password: string) {
+    return await bcrypt.hash(password, 10);
+  }
+}
+
+export interface IUsersRepository {
+  getUsers(
+    page: number,
+    pageSize: number,
+    searchNameTerm: string,
+  ): Promise<EntityWithPaginationType<UserViewType>>;
+
+  createUser(newUser: CreateUserInput): Promise<User | null>;
+
+  deleteUserById(id: string): Promise<boolean>;
+
+  findUserById(id: string): Promise<User | null>;
+
+  revokeToken(id: string, token: string): Promise<User | null>;
+}

src/modules/users/users.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { UsersService } from './services/users.service';
+import { UsersController } from './api/users.controller';
+import { UsersRepository } from './infrastructure/users.repository';
+
+@Module({
+  controllers: [UsersController],
+  providers: [UsersService, UsersRepository],
+  exports: [UsersRepository, UsersService],
+})
+export class UsersModule {}