@hedhog/admin 0.12.1 → 0.12.3

package/src/auth/auth.service.ts

@@ -26,7 +26,7 @@ export class AuthService {
     private readonly jwt: JwtService,
     @Inject(forwardRef(() => MailService))
     private readonly mail: MailService,
-  ) {}
+  ) { }
 
   async verifyToken(token: string) {
     return this.jwt.verifyAsync(token, {
@@ -52,7 +52,7 @@ export class AuthService {
   }
 
   async loginWithEmailAndPassword(email: string, password: string) {
-    const user = await this.prisma.user.findFirst({
+    const user = await (this.prisma as any).user.findFirst({
       where: {
         email,
       },
@@ -73,7 +73,7 @@ export class AuthService {
       if (user.multifactor_id === MultifactorType.EMAIL) {
         const code = this.generateRandomNumber();
 
-        await this.prisma.user.update({
+        await (this.prisma as any).user.update({
           where: {
             id: user.id,
           },
@@ -117,7 +117,7 @@ export class AuthService {
     subject?: string;
     body?: string;
   }) {
-    const user = await this.prisma.user.findFirst({
+    const user = await (this.prisma as any).user.findFirst({
       where: {
         email,
       },
@@ -136,7 +136,7 @@ export class AuthService {
 
     const code = this.jwt.sign(payload);
 
-    await this.prisma.user.update({
+    await (this.prisma as any).user.update({
       where: {
         id: user.id,
       },
@@ -171,7 +171,7 @@ export class AuthService {
 
     const { id } = this.jwt.decode(code) as User;
 
-    const user = await this.prisma.user.findFirst({
+    const user = await (this.prisma as any).user.findFirst({
       where: {
         id,
         code,
@@ -182,7 +182,7 @@ export class AuthService {
       const salt = await genSalt();
       const password = await hash(confirmNewPassword, salt);
 
-      await this.prisma.user.update({
+      await (this.prisma as any).user.update({
         where: {
           id: user.id,
         },
@@ -201,7 +201,7 @@ export class AuthService {
   async otp({ token, code }: OtpDTO) {
     const data = this.jwt.decode(token);
 
-    const user = await this.prisma.user.findFirst({
+    const user = await (this.prisma as any).user.findFirst({
       where: {
         id: data['id'],
         code: String(code),
@@ -212,7 +212,7 @@ export class AuthService {
       throw new NotFoundException('Invalid code');
     }
 
-    await this.prisma.user.update({
+    await (this.prisma as any).user.update({
       where: {
         id: user.id,
       },
@@ -229,6 +229,6 @@ export class AuthService {
   }
 
   verify(id: number) {
-    return this.prisma.user.findUnique({ where: { id } });
+    return (this.prisma as any).user.findUnique({ where: { id } });
   }
 }

package/src/menu/menu.service.ts

@@ -20,16 +20,16 @@ export class MenuService {
     private readonly prismaService: PrismaService,
     @Inject(forwardRef(() => PaginationService))
     private readonly paginationService: PaginationService,
-  ) {}
+  ) { }
 
   async updateScreens(menuId: number, data: UpdateIdsDTO) {
-    await this.prismaService.menu_screen.deleteMany({
+    await (this.prismaService as any).menu_screen.deleteMany({
       where: {
         menu_id: menuId,
       },
     });
 
-    return this.prismaService.menu_screen.createMany({
+    return (this.prismaService as any).menu_screen.createMany({
       data: data.ids.map((screenId) => ({
         menu_id: menuId,
         screen_id: screenId,
@@ -38,13 +38,13 @@ export class MenuService {
     });
   }
   async updateRoles(menuId: number, data: UpdateIdsDTO) {
-    await this.prismaService.role_menu.deleteMany({
+    await (this.prismaService as any).role_menu.deleteMany({
       where: {
         menu_id: menuId,
       },
     });
 
-    return this.prismaService.role_menu.createMany({
+    return (this.prismaService as any).role_menu.createMany({
       data: data.ids.map((roleId) => ({
         menu_id: menuId,
         role_id: roleId,
@@ -58,7 +58,7 @@ export class MenuService {
     paginationParams: PaginationDTO,
   ) {
     return this.paginationService.paginate(
-      this.prismaService.screen,
+      (this.prismaService as any).screen,
       paginationParams,
       {
         include: {
@@ -92,7 +92,7 @@ export class MenuService {
     paginationParams: PaginationDTO,
   ) {
     return this.paginationService.paginate(
-      this.prismaService.role,
+      (this.prismaService as any).role,
       paginationParams,
       {
         include: {
@@ -127,7 +127,7 @@ export class MenuService {
       menuId = null;
     }
 
-    let menu = (await this.prismaService.menu.findMany({
+    let menu = (await (this.prismaService as any).menu.findMany({
       where: {
         menu_id: menuId,
         role_menu: {
@@ -174,13 +174,13 @@ export class MenuService {
 
   async list(locale: string, paginationParams: PaginationDTO) {
     const fields = ['url', 'icon'];
-    const OR = this.prismaService.createInsensitiveSearch(
+    const OR = (this.prismaService as any).createInsensitiveSearch(
       fields,
       paginationParams,
     );
 
     return this.paginationService.paginate(
-      this.prismaService.menu,
+      (this.prismaService as any).menu,
       paginationParams,
       {
         where: {
@@ -204,19 +204,19 @@ export class MenuService {
   }
 
   async get(menuId: number) {
-    return this.prismaService.menu.findUnique({
+    return (this.prismaService as any).menu.findUnique({
       where: { id: menuId },
     });
   }
 
   async create({ slug, url, icon, order, menuId }: CreateDTO) {
-    return this.prismaService.menu.create({
+    return (this.prismaService as any).menu.create({
       data: { slug, url, icon, order, menu_id: menuId },
     });
   }
 
   async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.prismaService.menu.update({
+    return (this.prismaService as any).menu.update({
       where: { id },
       data,
     });
@@ -229,7 +229,7 @@ export class MenuService {
       );
     }
 
-    return this.prismaService.menu.deleteMany({
+    return (this.prismaService as any).menu.deleteMany({
       where: {
         id: {
           in: ids,
@@ -239,7 +239,7 @@ export class MenuService {
   }
 
   async updateOrder({ ids }: OrderDTO): Promise<void> {
-    const count = await this.prismaService.menu.count({
+    const count = await (this.prismaService as any).menu.count({
       where: {
         id: {
           in: ids,
@@ -253,7 +253,7 @@ export class MenuService {
 
     await Promise.all(
       ids.map((id, index) =>
-        this.prismaService.menu.update({
+        (this.prismaService as any).menu.update({
           where: { id },
           data: { order: index + 1 },
         }),

package/src/role/guards/role.guard.ts

@@ -19,7 +19,7 @@ export class RoleGuard implements CanActivate {
     private reflector: Reflector,
     @Inject(forwardRef(() => PrismaService))
     private readonly prisma: PrismaService,
-  ) {}
+  ) { }
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
     const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
@@ -95,7 +95,7 @@ export class RoleGuard implements CanActivate {
 
     console.log({ fullPath, httpMethod });
 
-    const route = await this.prisma.route.count({
+    const route = await (this.prisma as any).route.count({
       where: {
         method: httpMethod,
         url: fullPath,

package/src/role/role.service.ts

@@ -22,16 +22,16 @@ export class RoleService {
     private readonly paginationService: PaginationService,
     @Inject(forwardRef(() => LocaleService))
     private readonly localeService: LocaleService,
-  ) {}
+  ) { }
 
   async updateUsers(roleId: number, { ids }: UpdateIdsDTO) {
-    await this.prismaService.role_user.deleteMany({
+    await (this.prismaService as any).role_user.deleteMany({
       where: {
         role_id: roleId,
       },
     });
 
-    return this.prismaService.role_user.createMany({
+    return (this.prismaService as any).role_user.createMany({
       data: ids.map((userId) => ({
         role_id: roleId,
         user_id: userId,
@@ -41,13 +41,13 @@ export class RoleService {
   }
 
   async updateScreens(roleId: number, data: UpdateIdsDTO) {
-    await this.prismaService.role_screen.deleteMany({
+    await (this.prismaService as any).role_screen.deleteMany({
       where: {
         role_id: roleId,
       },
     });
 
-    return this.prismaService.role_screen.createMany({
+    return (this.prismaService as any).role_screen.createMany({
       data: data.ids.map((screenId) => ({
         role_id: roleId,
         screen_id: screenId,
@@ -57,13 +57,13 @@ export class RoleService {
   }
 
   async updateRoutes(roleId: number, data: UpdateIdsDTO) {
-    await this.prismaService.role_route.deleteMany({
+    await (this.prismaService as any).role_route.deleteMany({
       where: {
         role_id: roleId,
       },
     });
 
-    return this.prismaService.role_route.createMany({
+    return (this.prismaService as any).role_route.createMany({
       data: data.ids.map((routeId) => ({
         role_id: roleId,
         route_id: routeId,
@@ -73,13 +73,13 @@ export class RoleService {
   }
 
   async updateMenus(roleId: number, data: UpdateIdsDTO) {
-    await this.prismaService.role_menu.deleteMany({
+    await (this.prismaService as any).role_menu.deleteMany({
       where: {
         role_id: roleId,
       },
     });
 
-    return this.prismaService.role_menu.createMany({
+    return (this.prismaService as any).role_menu.createMany({
       data: data.ids.map((menuId) => ({
         role_id: roleId,
         menu_id: menuId,
@@ -90,7 +90,7 @@ export class RoleService {
 
   async listUsers(roleId: number, paginationParams: PaginationDTO) {
     return this.paginationService.paginate(
-      this.prismaService.user,
+      (this.prismaService as any).user,
       paginationParams,
       {
         include: {
@@ -114,7 +114,7 @@ export class RoleService {
     paginationParams: PaginationDTO,
   ) {
     return this.paginationService.paginate(
-      this.prismaService.menu,
+      (this.prismaService as any).menu,
       paginationParams,
       {
         include: {
@@ -145,7 +145,7 @@ export class RoleService {
 
   async listRoutes(roleId: number, paginationParams: PaginationDTO) {
     return this.paginationService.paginate(
-      this.prismaService.route,
+      (this.prismaService as any).route,
       paginationParams,
       {
         include: {
@@ -169,7 +169,7 @@ export class RoleService {
     paginationParams: PaginationDTO,
   ) {
     return this.paginationService.paginate(
-      this.prismaService.screen,
+      (this.prismaService as any).screen,
       paginationParams,
       {
         include: {
@@ -201,13 +201,13 @@ export class RoleService {
   async list(locale: string, paginationParams: PaginationDTO) {
     const fields = [];
 
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
+    const OR: any[] = (this.prismaService as any).createInsensitiveSearch(
       fields,
       paginationParams,
     );
 
     return this.paginationService.paginate(
-      this.prismaService.role,
+      (this.prismaService as any).role,
       paginationParams,
       {
         where: {
@@ -235,7 +235,7 @@ export class RoleService {
     return getWithLocale(
       locale,
       'role_locale',
-      await this.prismaService.role.findUnique({
+      await (this.prismaService as any).role.findUnique({
         where: { id: roleId },
         include: {
           role_locale: {
@@ -278,7 +278,7 @@ export class RoleService {
       );
     }
 
-    return this.prismaService.role.deleteMany({
+    return (this.prismaService as any).role.deleteMany({
       where: {
         id: {
           in: ids,

package/src/route/route.service.ts

@@ -13,18 +13,18 @@ export class RouteService {
     private readonly prismaService: PrismaService,
     @Inject(forwardRef(() => PaginationService))
     private readonly paginationService: PaginationService,
-  ) {}
+  ) { }
 
   async list(paginationParams: PaginationDTO) {
     const fields = ['url', 'method'];
 
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
+    const OR: any[] = (this.prismaService as any).createInsensitiveSearch(
       fields,
       paginationParams,
     );
 
     return this.paginationService.paginate(
-      this.prismaService.route,
+      (this.prismaService as any).route,
       paginationParams,
       {
         where: {
@@ -35,22 +35,22 @@ export class RouteService {
   }
 
   async get(routeId: number) {
-    return this.prismaService.route.findUnique({ where: { id: routeId } });
+    return (this.prismaService as any).route.findUnique({ where: { id: routeId } });
   }
 
   async create({ url, method }: CreateDTO) {
-    return this.prismaService.route.create({ data: { url, method } });
+    return (this.prismaService as any).route.create({ data: { url, method } });
   }
 
   async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.prismaService.route.update({
+    return (this.prismaService as any).route.update({
       where: { id },
       data,
     });
   }
 
   async delete({ ids }: DeleteDTO) {
-    return this.prismaService.route.deleteMany({
+    return (this.prismaService as any).route.deleteMany({
       where: {
         id: {
           in: ids,
@@ -65,7 +65,7 @@ export class RouteService {
     paginationParams: PaginationDTO,
   ) {
     return this.paginationService.paginate(
-      this.prismaService.role,
+      (this.prismaService as any).role,
       paginationParams,
       {
         include: {
@@ -96,13 +96,13 @@ export class RouteService {
   }
 
   async updateRoles(routeId: number, data: UpdateIdsDTO) {
-    await this.prismaService.role_route.deleteMany({
+    await (this.prismaService as any).role_route.deleteMany({
       where: {
         route_id: routeId,
       },
     });
 
-    return this.prismaService.role_route.createMany({
+    return (this.prismaService as any).role_route.createMany({
       data: data.ids.map((roleId) => ({
         role_id: roleId,
         route_id: routeId,
@@ -117,7 +117,7 @@ export class RouteService {
     paginationParams: PaginationDTO,
   ) {
     return this.paginationService.paginate(
-      this.prismaService.screen,
+      (this.prismaService as any).screen,
       paginationParams,
       {
         include: {
@@ -147,13 +147,13 @@ export class RouteService {
   }
 
   async updateScreens(routeId: number, data: UpdateIdsDTO) {
-    await this.prismaService.route_screen.deleteMany({
+    await (this.prismaService as any).route_screen.deleteMany({
       where: {
         route_id: routeId,
       },
     });
 
-    return this.prismaService.route_screen.createMany({
+    return (this.prismaService as any).route_screen.createMany({
       data: data.ids.map((screenId) => ({
         screen_id: screenId,
         route_id: routeId,

package/src/screen/screen.service.ts

@@ -18,16 +18,16 @@ export class ScreenService {
     private readonly prismaService: PrismaService,
     @Inject(forwardRef(() => PaginationService))
     private readonly paginationService: PaginationService,
-  ) {}
+  ) { }
 
   async updateRoles(screenId: number, data: UpdateIdsDTO) {
-    await this.prismaService.role_screen.deleteMany({
+    await (this.prismaService as any).role_screen.deleteMany({
       where: {
         screen_id: screenId,
       },
     });
 
-    return this.prismaService.role_screen.createMany({
+    return (this.prismaService as any).role_screen.createMany({
       data: data.ids.map((roleId) => ({
         screen_id: screenId,
         role_id: roleId,
@@ -37,7 +37,7 @@ export class ScreenService {
   }
   async updateRoutes(screenId: number, { ids }: UpdateIdsDTO) {
     ids = (
-      await this.prismaService.route.findMany({
+      await (this.prismaService as any).route.findMany({
         where: {
           id: {
             in: ids,
@@ -49,13 +49,13 @@ export class ScreenService {
       })
     ).map((route) => route.id);
 
-    await this.prismaService.route_screen.deleteMany({
+    await (this.prismaService as any).route_screen.deleteMany({
       where: {
         screen_id: screenId,
       },
     });
 
-    return this.prismaService.route_screen.createMany({
+    return (this.prismaService as any).route_screen.createMany({
       data: ids.map((routeId) => ({
         screen_id: screenId,
         route_id: routeId,
@@ -65,7 +65,7 @@ export class ScreenService {
   }
   async listRoutes(screenId: number, paginationParams: PaginationDTO) {
     return this.paginationService.paginate(
-      this.prismaService.route,
+      (this.prismaService as any).route,
       paginationParams,
       {
         include: {
@@ -89,7 +89,7 @@ export class ScreenService {
     paginationParams: PaginationDTO,
   ) {
     return this.paginationService.paginate(
-      this.prismaService.role,
+      (this.prismaService as any).role,
       paginationParams,
       {
         include: {
@@ -109,13 +109,13 @@ export class ScreenService {
 
   async list(locale: string, paginationParams: PaginationDTO) {
     const fields = ['slug', 'icon'];
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
+    const OR: any[] = (this.prismaService as any).createInsensitiveSearch(
       fields,
       paginationParams,
     );
 
     const result = await this.paginationService.paginate(
-      this.prismaService.screen,
+      (this.prismaService as any).screen,
       paginationParams,
       {
         where: {
@@ -142,11 +142,11 @@ export class ScreenService {
   }
 
   async get(screenId: number) {
-    return this.prismaService.screen.findUnique({ where: { id: screenId } });
+    return (this.prismaService as any).screen.findUnique({ where: { id: screenId } });
   }
 
   async create({ slug, icon }: CreateDTO) {
-    return this.prismaService.screen.create({
+    return (this.prismaService as any).screen.create({
       data: {
         slug,
         icon,
@@ -155,7 +155,7 @@ export class ScreenService {
   }
 
   async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.prismaService.screen.update({
+    return (this.prismaService as any).screen.update({
       where: { id },
       data,
     });
@@ -168,7 +168,7 @@ export class ScreenService {
       );
     }
 
-    return this.prismaService.screen.deleteMany({
+    return (this.prismaService as any).screen.deleteMany({
       where: {
         id: {
           in: ids,