add findAllUsers

src/repository/user.repository.ts

@@ -1,11 +1,11 @@
 import { Injectable } from '@nestjs/common';
 import { PrismaClient, User } from '@prisma/client';
 import { PrismaService } from '../prisma/service/prisma.service';
 import { Prisma } from '@prisma/client';
 
 @Injectable()
 export class UserRepository {
-  constructor(private db: PrismaService) {}
+  constructor(private db: PrismaService) { }
 
   async getUserByEmail(email: string): Promise<User> {
     return this.db.user.findUnique({ where: { email: email } });
@@ -34,4 +34,26 @@
       },
     });
   }
+
+  async getAllUsers(): Promise<object[]> {
+    return this.db.user.findMany({
+      select: {
+        id: true,
+        firstName: true,
+        lastName: true,
+        email: true,
+        phoneNumber: true,
+        role: true,
+        password: false,
+        refreshToken: false,
+        status: true
+      }
+    });
+  }
+
+  exclude<Key extends keyof User>(user: User, keys: Key[]): Omit<User, Key> {
+    return Object.fromEntries(
+      Object.entries(user).filter(([key]) => !keys.includes(key as Key)),
+    ) as Omit<User, Key>;
+  }
 }

src/user/user.controller.spec.ts

@@ -1,12 +1,18 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { UserController } from './user.controller';
+import { UserService } from './user.service';
 
 describe('UserController', () => {
   let controller: UserController;
-
+  const mockUserService = {
+    findUserById: jest.fn(),
+    update: jest.fn(),
+    exclude: jest.fn(),
+  };
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [UserController],
+      providers: [{ provide: UserService, useValue: mockUserService }]
     }).compile();
 
     controller = module.get<UserController>(UserController);

src/user/user.controller.ts

@@ -3,11 +3,11 @@ import { UserService } from './user.service';
 
 @Controller('user')
 export class UserController {
-  constructor(private userService: UserService) {}
+  constructor(private userService: UserService) { }
 
   @Get()
   findAllUsers() {
-    return null;
+    return this.userService.findAllUsers();
   }
 
   @Patch('ban/:userId')

src/user/user.module.ts

@@ -1,9 +1,12 @@
 import { Module } from '@nestjs/common';
 import { UserController } from './user.controller';
 import { UserService } from './user.service';
+import { UserRepository } from 'src/repository/user.repository';
+import { PrismaModule } from 'src/prisma/prisma.module';
 
 @Module({
+  imports: [PrismaModule],
   controllers: [UserController],
-  providers: [UserService]
+  providers: [UserService, UserRepository]
 })
-export class UserModule {}
+export class UserModule { }

src/user/user.service.spec.ts

@@ -1,12 +1,21 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { UserService } from './user.service';
+import { UserRepository } from '../repository/user.repository';
 
 describe('UserService', () => {
   let service: UserService;
+  const mockUserRepository = {
+    findUserById: jest.fn(),
+    update: jest.fn(),
+    exclude: jest.fn(),
+  };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [UserService],
+      providers: [UserService, {
+        provide: UserRepository,
+        useValue: mockUserRepository,
+      },],
     }).compile();
 
     service = module.get<UserService>(UserService);

src/user/user.service.ts

@@ -1,12 +1,18 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
 import { UserRepository } from '../repository/user.repository';
 
 @Injectable()
 export class UserService {
-  constructor(private userRepo: UserRepository) {}
+  constructor(private userRepo: UserRepository) { }
 
   findAllUsers() {
-    return null;
+    try {
+      const allUsers = this.userRepo.getAllUsers();
+      return allUsers;
+    } catch (e) {
+      console.log(e);
+      throw InternalServerErrorException;
+    }
   }
 
   banUser() {
@@ -17,3 +23,7 @@
     return null;
   }
 }
+function exclude(allUsers: Promise<{ id: string; createdAt: Date; updatedAt: Date; firstName: string; lastName: string; email: string; phoneNumber: string; password: string; role: import(".prisma/client").$Enums.Role; refreshToken: string; }[]>) {
+  throw new Error('Function not implemented.');
+}
+