@hedhog/admin 0.11.1 → 0.12.2

package/src/user/user.module.ts

@@ -1,18 +1,18 @@
-import { PaginationModule } from '@hedhog/pagination';
-import { PrismaModule } from '@hedhog/prisma';
-import { Module, forwardRef } from '@nestjs/common';
-import { UserController } from './user.controller';
-import { UserService } from './user.service';
-import { AuthModule } from '../auth/auth.module';
-
-@Module({
-  providers: [UserService],
-  exports: [UserService],
-  controllers: [UserController],
-  imports: [
-    forwardRef(() => AuthModule),
-    forwardRef(() => PrismaModule),
-    forwardRef(() => PaginationModule),
-  ],
-})
-export class UserModule {}
+import { PaginationModule } from '@hedhog/pagination';
+import { PrismaModule } from '@hedhog/prisma';
+import { Module, forwardRef } from '@nestjs/common';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+import { AuthModule } from '../auth/auth.module';
+
+@Module({
+  providers: [UserService],
+  exports: [UserService],
+  controllers: [UserController],
+  imports: [
+    forwardRef(() => AuthModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+})
+export class UserModule {}

package/src/user/user.service.spec.ts

@@ -1,294 +1,294 @@
-import {
-  PageOrderDirection,
-  PaginationDTO,
-  PaginationService,
-} from '@hedhog/pagination';
-import { PrismaService } from '@hedhog/prisma';
-import { BadRequestException } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
-import { genSalt, hash } from 'bcrypt';
-import { DeleteDTO } from '../dto/delete.dto';
-import { UpdateIdsDTO } from '../dto/update-ids.dto';
-import { SALT_ROUNDS } from './constants/user.constants';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
-import { UserService } from './user.service';
-
-jest.mock('bcrypt', () => ({
-  genSalt: jest.fn().mockResolvedValue('mockSalt'),
-  hash: jest.fn().mockResolvedValue('mockHashedPassword'),
-}));
-
-describe('UserService', () => {
-  let service: UserService;
-  let prismaService: PrismaService;
-  let paginationService: PaginationService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        UserService,
-        {
-          provide: PrismaService,
-          useValue: {
-            user: {
-              findUnique: jest.fn(),
-              create: jest.fn(),
-              update: jest.fn(),
-              deleteMany: jest.fn(),
-            },
-            role_user: {
-              deleteMany: jest.fn(),
-              createMany: jest.fn(),
-            },
-            createInsensitiveSearch: jest.fn(),
-          },
-        },
-        {
-          provide: PaginationService,
-          useValue: {
-            paginate: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    service = module.get<UserService>(UserService);
-    prismaService = module.get<PrismaService>(PrismaService);
-    paginationService = module.get<PaginationService>(PaginationService);
-  });
-
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
-
-  describe('listRoles', () => {
-    it('should return paginated role for a specific user', async () => {
-      const paginationParams: PaginationDTO = {
-        page: 1,
-        pageSize: 10,
-        search: '',
-        sortField: '',
-        sortOrder: PageOrderDirection.Asc,
-        fields: '',
-      };
-
-      const mockPaginatedRoles = {
-        data: [],
-        total: 10,
-        lastPage: 1,
-        page: 1,
-        prev: 0,
-        next: 2,
-        pageSize: 10,
-      };
-
-      jest
-        .spyOn(paginationService, 'paginate')
-        .mockResolvedValue(mockPaginatedRoles);
-
-      const result = await service.listRoles(1, paginationParams);
-
-      expect(paginationService.paginate).toHaveBeenCalledWith(
-        prismaService.role,
-        paginationParams,
-        {
-          include: {
-            role_user: {
-              where: { user_id: 1 },
-              select: { user_id: true, role_id: true },
-            },
-          },
-        },
-      );
-      expect(result).toEqual(mockPaginatedRoles);
-    });
-  });
-
-  describe('updateRoles', () => {
-    it('should update user role', async () => {
-      const updateIdsDTO: UpdateIdsDTO = { ids: [1, 2] };
-
-      jest
-        .spyOn(prismaService.role_user, 'deleteMany')
-        .mockResolvedValue({ count: 1 });
-      jest
-        .spyOn(prismaService.role_user, 'createMany')
-        .mockResolvedValue({ count: 2 });
-
-      await service.updateRoles(1, updateIdsDTO);
-
-      expect(prismaService.role_user.deleteMany).toHaveBeenCalledWith({
-        where: { user_id: 1 },
-      });
-      expect(prismaService.role_user.createMany).toHaveBeenCalledWith({
-        data: [
-          { user_id: 1, role_id: 1 },
-          { user_id: 1, role_id: 2 },
-        ],
-        skipDuplicates: true,
-      });
-    });
-  });
-  /*
-  describe('getUsers', () => {
-    it('should return paginated user', async () => {
-      const paginationParams: PaginationDTO = {
-        page: 1,
-        pageSize: 10,
-        search: '',
-        sortField: '',
-        sortOrder: PageOrderDirection.Asc,
-        fields: '',
-      };
-
-      const mockPaginatedUsers = {
-        data: [],
-        total: 10,
-        lastPage: 1,
-        page: 1,
-        prev: 0,
-        next: 2,
-        pageSize: 10,
-      };
-
-      jest.spyOn(prismaService, 'createInsensitiveSearch').mockReturnValue([]);
-      jest
-        .spyOn(paginationService, 'paginate')
-        .mockResolvedValue(mockPaginatedUsers);
-
-      const result = await service.getUsers(paginationParams);
-
-      expect(prismaService.createInsensitiveSearch).toHaveBeenCalledWith(
-        ['name', 'email'],
-        paginationParams,
-      );
-      expect(paginationService.paginate).toHaveBeenCalledWith(
-        prismaService.user,
-        paginationParams,
-        { where: { OR: [] } },
-      );
-      expect(result).toEqual(mockPaginatedUsers);
-    });
-  });
-*/
-  describe('get', () => {
-    it('should return a specific user by ID', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'user@email.com',
-        password: 'hashedpassword',
-        created_at: new Date(),
-        updated_at: new Date(),
-        multifactor_id: null,
-        code: null,
-      };
-      jest.spyOn(prismaService.user, 'findUnique').mockResolvedValue(mockUser);
-
-      const result = await service.get(1);
-
-      expect(prismaService.user.findUnique).toHaveBeenCalledWith({
-        where: { id: 1 },
-      });
-      expect(result).toEqual(mockUser);
-    });
-  });
-
-  describe('hashPassword', () => {
-    it('should hash the password correctly', async () => {
-      const password = 'plainPassword';
-      const result = await service.hashPassword(password);
-
-      expect(genSalt).toHaveBeenCalledWith(SALT_ROUNDS);
-      expect(hash).toHaveBeenCalledWith(password, 'mockSalt');
-      expect(result).toEqual('mockHashedPassword');
-    });
-  });
-
-  describe('create', () => {
-    it('should create a new user with hashed password', async () => {
-      const createDTO: CreateDTO = {
-        email: 'test@test.com',
-        name: 'Test User',
-        password: 'password123',
-      };
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'user@email.com',
-        password: 'hashedpassword',
-        created_at: new Date(),
-        updated_at: new Date(),
-        multifactor_id: null,
-        code: null,
-      };
-
-      jest.spyOn(prismaService.user, 'create').mockResolvedValue(mockUser);
-
-      const result = await service.create(createDTO);
-
-      expect(prismaService.user.create).toHaveBeenCalledWith({
-        data: {
-          email: createDTO.email,
-          name: createDTO.name,
-          password: 'mockHashedPassword',
-        },
-      });
-      expect(result).toEqual(mockUser);
-    });
-  });
-
-  describe('update', () => {
-    it('should update an existing user', async () => {
-      const updateDTO: UpdateDTO = { name: 'Updated User' };
-      const updateInput = { id: 1, data: updateDTO };
-      const mockUser = {
-        id: 1,
-        name: 'Updated User',
-        email: 'user@email.com',
-        password: 'hashedpassword',
-        created_at: new Date(),
-        updated_at: new Date(),
-        multifactor_id: null,
-        code: null,
-      };
-      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
-
-      const result = await service.update(updateInput);
-
-      expect(prismaService.user.update).toHaveBeenCalledWith({
-        where: { id: updateInput.id },
-        data: updateInput.data,
-      });
-      expect(result).toEqual(mockUser);
-    });
-  });
-
-  describe('delete', () => {
-    it('should throw an error if no ids are provided', async () => {
-      const deleteDTO: DeleteDTO = { ids: null };
-
-      await expect(service.delete(deleteDTO)).rejects.toThrow(
-        new BadRequestException('You must select at least one user to delete.'),
-      );
-    });
-
-    it('should delete user by ids', async () => {
-      const deleteDTO: DeleteDTO = { ids: [1, 2] };
-
-      jest
-        .spyOn(prismaService.user, 'deleteMany')
-        .mockResolvedValue({ count: 2 });
-
-      await service.delete(deleteDTO);
-
-      expect(prismaService.user.deleteMany).toHaveBeenCalledWith({
-        where: {
-          id: { in: deleteDTO.ids },
-          email: { not: { startsWith: 'root@' } },
-        },
-      });
-    });
-  });
-});
+import {
+  PageOrderDirection,
+  PaginationDTO,
+  PaginationService,
+} from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { BadRequestException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { genSalt, hash } from 'bcrypt';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { SALT_ROUNDS } from './constants/user.constants';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { UserService } from './user.service';
+
+jest.mock('bcrypt', () => ({
+  genSalt: jest.fn().mockResolvedValue('mockSalt'),
+  hash: jest.fn().mockResolvedValue('mockHashedPassword'),
+}));
+
+describe('UserService', () => {
+  let service: UserService;
+  let prismaService: PrismaService;
+  let paginationService: PaginationService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        UserService,
+        {
+          provide: PrismaService,
+          useValue: {
+            user: {
+              findUnique: jest.fn(),
+              create: jest.fn(),
+              update: jest.fn(),
+              deleteMany: jest.fn(),
+            },
+            role_user: {
+              deleteMany: jest.fn(),
+              createMany: jest.fn(),
+            },
+            createInsensitiveSearch: jest.fn(),
+          },
+        },
+        {
+          provide: PaginationService,
+          useValue: {
+            paginate: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<UserService>(UserService);
+    prismaService = module.get<PrismaService>(PrismaService);
+    paginationService = module.get<PaginationService>(PaginationService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('listRoles', () => {
+    it('should return paginated role for a specific user', async () => {
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+
+      const mockPaginatedRoles = {
+        data: [],
+        total: 10,
+        lastPage: 1,
+        page: 1,
+        prev: 0,
+        next: 2,
+        pageSize: 10,
+      };
+
+      jest
+        .spyOn(paginationService, 'paginate')
+        .mockResolvedValue(mockPaginatedRoles);
+
+      const result = await service.listRoles(1, paginationParams);
+
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.role,
+        paginationParams,
+        {
+          include: {
+            role_user: {
+              where: { user_id: 1 },
+              select: { user_id: true, role_id: true },
+            },
+          },
+        },
+      );
+      expect(result).toEqual(mockPaginatedRoles);
+    });
+  });
+
+  describe('updateRoles', () => {
+    it('should update user role', async () => {
+      const updateIdsDTO: UpdateIdsDTO = { ids: [1, 2] };
+
+      jest
+        .spyOn(prismaService.role_user, 'deleteMany')
+        .mockResolvedValue({ count: 1 });
+      jest
+        .spyOn(prismaService.role_user, 'createMany')
+        .mockResolvedValue({ count: 2 });
+
+      await service.updateRoles(1, updateIdsDTO);
+
+      expect(prismaService.role_user.deleteMany).toHaveBeenCalledWith({
+        where: { user_id: 1 },
+      });
+      expect(prismaService.role_user.createMany).toHaveBeenCalledWith({
+        data: [
+          { user_id: 1, role_id: 1 },
+          { user_id: 1, role_id: 2 },
+        ],
+        skipDuplicates: true,
+      });
+    });
+  });
+  /*
+  describe('getUsers', () => {
+    it('should return paginated user', async () => {
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 10,
+        search: '',
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      };
+
+      const mockPaginatedUsers = {
+        data: [],
+        total: 10,
+        lastPage: 1,
+        page: 1,
+        prev: 0,
+        next: 2,
+        pageSize: 10,
+      };
+
+      jest.spyOn(prismaService, 'createInsensitiveSearch').mockReturnValue([]);
+      jest
+        .spyOn(paginationService, 'paginate')
+        .mockResolvedValue(mockPaginatedUsers);
+
+      const result = await service.getUsers(paginationParams);
+
+      expect(prismaService.createInsensitiveSearch).toHaveBeenCalledWith(
+        ['name', 'email'],
+        paginationParams,
+      );
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.user,
+        paginationParams,
+        { where: { OR: [] } },
+      );
+      expect(result).toEqual(mockPaginatedUsers);
+    });
+  });
+*/
+  describe('get', () => {
+    it('should return a specific user by ID', async () => {
+      const mockUser = {
+        id: 1,
+        name: 'Test User',
+        email: 'user@email.com',
+        password: 'hashedpassword',
+        created_at: new Date(),
+        updated_at: new Date(),
+        multifactor_id: null,
+        code: null,
+      };
+      jest.spyOn(prismaService.user, 'findUnique').mockResolvedValue(mockUser);
+
+      const result = await service.get(1);
+
+      expect(prismaService.user.findUnique).toHaveBeenCalledWith({
+        where: { id: 1 },
+      });
+      expect(result).toEqual(mockUser);
+    });
+  });
+
+  describe('hashPassword', () => {
+    it('should hash the password correctly', async () => {
+      const password = 'plainPassword';
+      const result = await service.hashPassword(password);
+
+      expect(genSalt).toHaveBeenCalledWith(SALT_ROUNDS);
+      expect(hash).toHaveBeenCalledWith(password, 'mockSalt');
+      expect(result).toEqual('mockHashedPassword');
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new user with hashed password', async () => {
+      const createDTO: CreateDTO = {
+        email: 'test@test.com',
+        name: 'Test User',
+        password: 'password123',
+      };
+      const mockUser = {
+        id: 1,
+        name: 'Test User',
+        email: 'user@email.com',
+        password: 'hashedpassword',
+        created_at: new Date(),
+        updated_at: new Date(),
+        multifactor_id: null,
+        code: null,
+      };
+
+      jest.spyOn(prismaService.user, 'create').mockResolvedValue(mockUser);
+
+      const result = await service.create(createDTO);
+
+      expect(prismaService.user.create).toHaveBeenCalledWith({
+        data: {
+          email: createDTO.email,
+          name: createDTO.name,
+          password: 'mockHashedPassword',
+        },
+      });
+      expect(result).toEqual(mockUser);
+    });
+  });
+
+  describe('update', () => {
+    it('should update an existing user', async () => {
+      const updateDTO: UpdateDTO = { name: 'Updated User' };
+      const updateInput = { id: 1, data: updateDTO };
+      const mockUser = {
+        id: 1,
+        name: 'Updated User',
+        email: 'user@email.com',
+        password: 'hashedpassword',
+        created_at: new Date(),
+        updated_at: new Date(),
+        multifactor_id: null,
+        code: null,
+      };
+      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
+
+      const result = await service.update(updateInput);
+
+      expect(prismaService.user.update).toHaveBeenCalledWith({
+        where: { id: updateInput.id },
+        data: updateInput.data,
+      });
+      expect(result).toEqual(mockUser);
+    });
+  });
+
+  describe('delete', () => {
+    it('should throw an error if no ids are provided', async () => {
+      const deleteDTO: DeleteDTO = { ids: null };
+
+      await expect(service.delete(deleteDTO)).rejects.toThrow(
+        new BadRequestException('You must select at least one user to delete.'),
+      );
+    });
+
+    it('should delete user by ids', async () => {
+      const deleteDTO: DeleteDTO = { ids: [1, 2] };
+
+      jest
+        .spyOn(prismaService.user, 'deleteMany')
+        .mockResolvedValue({ count: 2 });
+
+      await service.delete(deleteDTO);
+
+      expect(prismaService.user.deleteMany).toHaveBeenCalledWith({
+        where: {
+          id: { in: deleteDTO.ids },
+          email: { not: { startsWith: 'root@' } },
+        },
+      });
+    });
+  });
+});