@hedhog/admin 0.0.121 → 0.0.123

package/src/route/route.service.spec.ts

@@ -1,300 +1,300 @@
-import {
-  PageOrderDirection,
-  PaginationDTO,
-  PaginationService,
-} from '@hedhog/pagination';
-import { PrismaService } from '@hedhog/prisma';
-import { Test, TestingModule } from '@nestjs/testing';
-import { DeleteDTO } from '../dto/delete.dto';
-import { UpdateIdsDTO } from '../dto/update-ids.dto';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
-import { RouteService } from './route.service';
-
-describe('RouteService', () => {
-  let service: RouteService;
-  let prismaService: PrismaService;
-  let paginationService: PaginationService;
-
-  const mockPrismaService = {
-    route: {
-      findUnique: jest.fn(),
-      create: jest.fn(),
-      update: jest.fn(),
-      deleteMany: jest.fn(),
-    },
-    role_route: {
-      deleteMany: jest.fn(),
-      createMany: jest.fn(),
-    },
-    route_screens: {
-      deleteMany: jest.fn(),
-      createMany: jest.fn(),
-    },
-    createInsensitiveSearch: jest.fn(),
-  };
-
-  const mockPaginationService = {
-    paginate: jest.fn(),
-  };
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        RouteService,
-        { provide: PrismaService, useValue: mockPrismaService },
-        { provide: PaginationService, useValue: mockPaginationService },
-      ],
-    }).compile();
-
-    service = module.get<RouteService>(RouteService);
-    prismaService = module.get<PrismaService>(PrismaService);
-    paginationService = module.get<PaginationService>(PaginationService);
-  });
-
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
-  /*
-  describe('getRoutes', () => {
-    it('should paginate route', async () => {
-      const paginationParams: PaginationDTO = {
-        page: 1,
-        pageSize: 10,
-        search: '',
-        sortField: '',
-        sortOrder: PageOrderDirection.Asc,
-        fields: '',
-      };
-      const result = { data: [], total: 0 };
-
-      mockPrismaService.createInsensitiveSearch.mockReturnValue([]);
-      mockPaginationService.paginate.mockResolvedValue(result);
-
-      const res = await service.getRoutes(paginationParams);
-
-      expect(mockPrismaService.createInsensitiveSearch).toHaveBeenCalledWith(
-        ['url', 'method'],
-        paginationParams,
-      );
-      expect(mockPaginationService.paginate).toHaveBeenCalledWith(
-        mockPrismaService.route,
-        paginationParams,
-        { where: { OR: [] } },
-      );
-      expect(res).toEqual(result);
-    });
-  });
-*/
-  /*
-  describe('getRouteById', () => {
-    it('should return a route by ID', async () => {
-      const routeId = 1;
-      const route = { id: routeId, url: '/test', method: 'GET' };
-
-      mockPrismaService.route.findUnique.mockResolvedValue(route);
-
-      const res = await service.getRouteById(routeId);
-
-      expect(mockPrismaService.route.findUnique).toHaveBeenCalledWith({
-        where: { id: routeId },
-      });
-      expect(res).toEqual(route);
-    });
-  });*/
-
-  describe('create', () => {
-    it('should create a new route', async () => {
-      const createDto: CreateDTO = { url: '/test', method: 'GET' };
-      const route = { id: 1, ...createDto };
-
-      mockPrismaService.route.create.mockResolvedValue(route);
-
-      const res = await service.create(createDto);
-
-      expect(mockPrismaService.route.create).toHaveBeenCalledWith({
-        data: createDto,
-      });
-      expect(res).toEqual(route);
-    });
-  });
-
-  describe('update', () => {
-    it('should update a route', async () => {
-      const updateDto: UpdateDTO = { url: '/updated', method: 'POST' };
-      const routeId = 1;
-      const updatedRoute = { id: routeId, ...updateDto };
-
-      mockPrismaService.route.update.mockResolvedValue(updatedRoute);
-
-      const res = await service.update({ id: routeId, data: updateDto });
-
-      expect(mockPrismaService.route.update).toHaveBeenCalledWith({
-        where: { id: routeId },
-        data: updateDto,
-      });
-      expect(res).toEqual(updatedRoute);
-    });
-  });
-
-  describe('delete', () => {
-    it('should delete route by ids', async () => {
-      const deleteDto: DeleteDTO = { ids: [1, 2] };
-      const result = { count: 2 };
-
-      mockPrismaService.route.deleteMany.mockResolvedValue(result);
-
-      const res = await service.delete(deleteDto);
-
-      expect(mockPrismaService.route.deleteMany).toHaveBeenCalledWith({
-        where: { id: { in: deleteDto.ids } },
-      });
-      expect(res).toEqual(result);
-    });
-  });
-
-  describe('updateRoles', () => {
-    it('should update role for a route', async () => {
-      const routeId = 1;
-      const updateIdsDto: UpdateIdsDTO = { ids: [1, 2] };
-      const result = { count: 2 };
-
-      mockPrismaService.role_route.deleteMany.mockResolvedValue({});
-      mockPrismaService.role_route.createMany.mockResolvedValue(result);
-
-      const res = await service.updateRoles(routeId, updateIdsDto);
-
-      expect(mockPrismaService.role_route.deleteMany).toHaveBeenCalledWith({
-        where: { route_id: routeId },
-      });
-      expect(mockPrismaService.role_route.createMany).toHaveBeenCalledWith({
-        data: updateIdsDto.ids.map((roleId) => ({
-          role_id: roleId,
-          route_id: routeId,
-        })),
-        skipDuplicates: true,
-      });
-      expect(res).toEqual(result);
-    });
-  });
-
-  describe('updateScreens', () => {
-    it('should update screens for a route', async () => {
-      const routeId = 1;
-      const updateIdsDto: UpdateIdsDTO = { ids: [1, 2] };
-      const result = { count: 2 };
-
-      mockPrismaService.route_screens.deleteMany.mockResolvedValue({});
-      mockPrismaService.route_screens.createMany.mockResolvedValue(result);
-
-      const res = await service.updateScreens(routeId, updateIdsDto);
-
-      expect(mockPrismaService.route_screens.deleteMany).toHaveBeenCalledWith({
-        where: { route_id: routeId },
-      });
-      expect(mockPrismaService.route_screens.createMany).toHaveBeenCalledWith({
-        data: updateIdsDto.ids.map((screenId) => ({
-          screen_id: screenId,
-          route_id: routeId,
-        })),
-        skipDuplicates: true,
-      });
-      expect(res).toEqual(result);
-    });
-  });
-
-  describe('listRoles', () => {
-    it('should call paginate method with correct parameters', async () => {
-      const locale = 'en';
-      const routeId = 1;
-      const paginationParams: PaginationDTO = {
-        page: 1,
-        pageSize: 10,
-        search: '',
-        sortField: '',
-        sortOrder: PageOrderDirection.Asc,
-        fields: '',
-      };
-
-      paginationService.paginate = jest.fn().mockResolvedValue({
-        data: [],
-        total: 0,
-      });
-
-      await service.listRoles(locale, routeId, paginationParams);
-
-      expect(paginationService.paginate).toHaveBeenCalledWith(
-        prismaService.role,
-        paginationParams,
-        {
-          include: {
-            role_locale: {
-              where: {
-                locale: { code: locale },
-              },
-              select: {
-                name: true,
-                description: true,
-              },
-            },
-            role_route: {
-              where: { route_id: routeId },
-              select: {
-                route_id: true,
-                role_id: true,
-              },
-            },
-          },
-        },
-        'role_locale',
-      );
-    });
-  });
-
-  describe('listScreens', () => {
-    it('should call paginate method with correct parameters', async () => {
-      const locale = 'en';
-      const routeId = 1;
-      const paginationParams: PaginationDTO = {
-        page: 1,
-        pageSize: 10,
-        search: '',
-        sortField: '',
-        sortOrder: PageOrderDirection.Asc,
-        fields: '',
-      };
-
-      paginationService.paginate = jest.fn().mockResolvedValue({
-        data: [],
-        total: 0,
-      });
-
-      await service.listScreens(locale, routeId, paginationParams);
-
-      expect(paginationService.paginate).toHaveBeenCalledWith(
-        prismaService.screens,
-        paginationParams,
-        {
-          include: {
-            screen_locale: {
-              where: {
-                locale: { code: locale },
-              },
-              select: {
-                name: true,
-              },
-            },
-            route_screens: {
-              where: { route_id: routeId },
-              select: {
-                route_id: true,
-                screen_id: true,
-              },
-            },
-          },
-        },
-        'screen_locale',
-      );
-    });
-  });
-});
+// import {
+//   PageOrderDirection,
+//   PaginationDTO,
+//   PaginationService,
+// } from '@hedhog/pagination';
+// import { PrismaService } from '@hedhog/prisma';
+// import { Test, TestingModule } from '@nestjs/testing';
+// import { DeleteDTO } from '../dto/delete.dto';
+// import { UpdateIdsDTO } from '../dto/update-ids.dto';
+// import { CreateDTO } from './dto/create.dto';
+// import { UpdateDTO } from './dto/update.dto';
+// import { RouteService } from './route.service';
+
+// describe('RouteService', () => {
+//   let service: RouteService;
+//   let prismaService: PrismaService;
+//   let paginationService: PaginationService;
+
+//   const mockPrismaService = {
+//     route: {
+//       findUnique: jest.fn(),
+//       create: jest.fn(),
+//       update: jest.fn(),
+//       deleteMany: jest.fn(),
+//     },
+//     role_route: {
+//       deleteMany: jest.fn(),
+//       createMany: jest.fn(),
+//     },
+//     route_screens: {
+//       deleteMany: jest.fn(),
+//       createMany: jest.fn(),
+//     },
+//     createInsensitiveSearch: jest.fn(),
+//   };
+
+//   const mockPaginationService = {
+//     paginate: jest.fn(),
+//   };
+
+//   beforeEach(async () => {
+//     const module: TestingModule = await Test.createTestingModule({
+//       providers: [
+//         RouteService,
+//         { provide: PrismaService, useValue: mockPrismaService },
+//         { provide: PaginationService, useValue: mockPaginationService },
+//       ],
+//     }).compile();
+
+//     service = module.get<RouteService>(RouteService);
+//     prismaService = module.get<PrismaService>(PrismaService);
+//     paginationService = module.get<PaginationService>(PaginationService);
+//   });
+
+//   it('should be defined', () => {
+//     expect(service).toBeDefined();
+//   });
+//   /*
+//   describe('getRoutes', () => {
+//     it('should paginate route', async () => {
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+//       const result = { data: [], total: 0 };
+
+//       mockPrismaService.createInsensitiveSearch.mockReturnValue([]);
+//       mockPaginationService.paginate.mockResolvedValue(result);
+
+//       const res = await service.getRoutes(paginationParams);
+
+//       expect(mockPrismaService.createInsensitiveSearch).toHaveBeenCalledWith(
+//         ['url', 'method'],
+//         paginationParams,
+//       );
+//       expect(mockPaginationService.paginate).toHaveBeenCalledWith(
+//         mockPrismaService.route,
+//         paginationParams,
+//         { where: { OR: [] } },
+//       );
+//       expect(res).toEqual(result);
+//     });
+//   });
+// */
+//   /*
+//   describe('getRouteById', () => {
+//     it('should return a route by ID', async () => {
+//       const routeId = 1;
+//       const route = { id: routeId, url: '/test', method: 'GET' };
+
+//       mockPrismaService.route.findUnique.mockResolvedValue(route);
+
+//       const res = await service.getRouteById(routeId);
+
+//       expect(mockPrismaService.route.findUnique).toHaveBeenCalledWith({
+//         where: { id: routeId },
+//       });
+//       expect(res).toEqual(route);
+//     });
+//   });*/
+
+//   describe('create', () => {
+//     it('should create a new route', async () => {
+//       const createDto: CreateDTO = { url: '/test', method: 'GET' };
+//       const route = { id: 1, ...createDto };
+
+//       mockPrismaService.route.create.mockResolvedValue(route);
+
+//       const res = await service.create(createDto);
+
+//       expect(mockPrismaService.route.create).toHaveBeenCalledWith({
+//         data: createDto,
+//       });
+//       expect(res).toEqual(route);
+//     });
+//   });
+
+//   describe('update', () => {
+//     it('should update a route', async () => {
+//       const updateDto: UpdateDTO = { url: '/updated', method: 'POST' };
+//       const routeId = 1;
+//       const updatedRoute = { id: routeId, ...updateDto };
+
+//       mockPrismaService.route.update.mockResolvedValue(updatedRoute);
+
+//       const res = await service.update({ id: routeId, data: updateDto });
+
+//       expect(mockPrismaService.route.update).toHaveBeenCalledWith({
+//         where: { id: routeId },
+//         data: updateDto,
+//       });
+//       expect(res).toEqual(updatedRoute);
+//     });
+//   });
+
+//   describe('delete', () => {
+//     it('should delete route by ids', async () => {
+//       const deleteDto: DeleteDTO = { ids: [1, 2] };
+//       const result = { count: 2 };
+
+//       mockPrismaService.route.deleteMany.mockResolvedValue(result);
+
+//       const res = await service.delete(deleteDto);
+
+//       expect(mockPrismaService.route.deleteMany).toHaveBeenCalledWith({
+//         where: { id: { in: deleteDto.ids } },
+//       });
+//       expect(res).toEqual(result);
+//     });
+//   });
+
+//   describe('updateRoles', () => {
+//     it('should update role for a route', async () => {
+//       const routeId = 1;
+//       const updateIdsDto: UpdateIdsDTO = { ids: [1, 2] };
+//       const result = { count: 2 };
+
+//       mockPrismaService.role_route.deleteMany.mockResolvedValue({});
+//       mockPrismaService.role_route.createMany.mockResolvedValue(result);
+
+//       const res = await service.updateRoles(routeId, updateIdsDto);
+
+//       expect(mockPrismaService.role_route.deleteMany).toHaveBeenCalledWith({
+//         where: { route_id: routeId },
+//       });
+//       expect(mockPrismaService.role_route.createMany).toHaveBeenCalledWith({
+//         data: updateIdsDto.ids.map((roleId) => ({
+//           role_id: roleId,
+//           route_id: routeId,
+//         })),
+//         skipDuplicates: true,
+//       });
+//       expect(res).toEqual(result);
+//     });
+//   });
+
+//   describe('updateScreens', () => {
+//     it('should update screens for a route', async () => {
+//       const routeId = 1;
+//       const updateIdsDto: UpdateIdsDTO = { ids: [1, 2] };
+//       const result = { count: 2 };
+
+//       mockPrismaService.route_screens.deleteMany.mockResolvedValue({});
+//       mockPrismaService.route_screens.createMany.mockResolvedValue(result);
+
+//       const res = await service.updateScreens(routeId, updateIdsDto);
+
+//       expect(mockPrismaService.route_screens.deleteMany).toHaveBeenCalledWith({
+//         where: { route_id: routeId },
+//       });
+//       expect(mockPrismaService.route_screens.createMany).toHaveBeenCalledWith({
+//         data: updateIdsDto.ids.map((screenId) => ({
+//           screen_id: screenId,
+//           route_id: routeId,
+//         })),
+//         skipDuplicates: true,
+//       });
+//       expect(res).toEqual(result);
+//     });
+//   });
+
+//   describe('listRoles', () => {
+//     it('should call paginate method with correct parameters', async () => {
+//       const locale = 'en';
+//       const routeId = 1;
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+
+//       paginationService.paginate = jest.fn().mockResolvedValue({
+//         data: [],
+//         total: 0,
+//       });
+
+//       await service.listRoles(locale, routeId, paginationParams);
+
+//       expect(paginationService.paginate).toHaveBeenCalledWith(
+//         prismaService.role,
+//         paginationParams,
+//         {
+//           include: {
+//             role_locale: {
+//               where: {
+//                 locale: { code: locale },
+//               },
+//               select: {
+//                 name: true,
+//                 description: true,
+//               },
+//             },
+//             role_route: {
+//               where: { route_id: routeId },
+//               select: {
+//                 route_id: true,
+//                 role_id: true,
+//               },
+//             },
+//           },
+//         },
+//         'role_locale',
+//       );
+//     });
+//   });
+
+//   describe('listScreens', () => {
+//     it('should call paginate method with correct parameters', async () => {
+//       const locale = 'en';
+//       const routeId = 1;
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+
+//       paginationService.paginate = jest.fn().mockResolvedValue({
+//         data: [],
+//         total: 0,
+//       });
+
+//       await service.listScreens(locale, routeId, paginationParams);
+
+//       expect(paginationService.paginate).toHaveBeenCalledWith(
+//         prismaService.screens,
+//         paginationParams,
+//         {
+//           include: {
+//             screen_locale: {
+//               where: {
+//                 locale: { code: locale },
+//               },
+//               select: {
+//                 name: true,
+//               },
+//             },
+//             route_screens: {
+//               where: { route_id: routeId },
+//               select: {
+//                 route_id: true,
+//                 screen_id: true,
+//               },
+//             },
+//           },
+//         },
+//         'screen_locale',
+//       );
+//     });
+//   });
+// });

package/src/screen/dto/create.dto.ts

@@ -1,18 +1,10 @@
 import { IsNotEmpty, IsString } from 'class-validator';
 
 export class CreateDTO {
-  @IsString({ message: 'O nome deve ser uma string' })
-  @IsNotEmpty({ message: 'O nome é obrigatório.' })
-  name: string;
-
   @IsString({ message: 'O slug deve ser uma string' })
   @IsNotEmpty({ message: 'O slug é obrigatório.' })
   slug: string;
 
-  @IsString({ message: 'A descrição deve ser uma string' })
-  @IsNotEmpty({ message: 'A descrição é obrigatória.' })
-  description: string;
-
   @IsString({ message: 'O ícone deve ser uma string' })
   @IsNotEmpty({ message: 'A descrição é obrigatória.' })
   icon?: string;

package/src/screen/screen.controller.ts

@@ -14,7 +14,7 @@ import {
 import { DeleteDTO } from '../dto/delete.dto';
 import { UpdateIdsDTO } from '../dto/update-ids.dto';
 import { Locale } from '@hedhog/locale';
-import { Role } from '@hedhog/utils';
+import { Role } from '@hedhog/core';
 import { CreateDTO } from './dto/create.dto';
 import { UpdateDTO } from './dto/update.dto';
 import { ScreenService } from './screen.service';