@hedhog/admin 0.12.1 → 0.12.3

package/frontend/user/components/update-panel.tsx.ejs

@@ -0,0 +1,64 @@
+import FormPanel, { FormPanelRef } from "@/components/panels/form-panel";
+import { Overlay } from "@/components/custom/overlay";
+import { TabPanel } from "@/components/panels/tab-panel";
+import { useUserGet, useUserUpdate } from "@/features/admin/user";
+import useEffectAfterFirstUpdate from "@/hooks/use-effect-after-first-update";
+import { User } from "@/types/models";
+import { useState, forwardRef, useImperativeHandle, useRef } from "react";
+import { useTranslation } from "react-i18next";
+import { IconEdit, IconPlus, IconTrash } from "@tabler/icons-react";
+
+export type UserUpdatePanelProps = {
+  data: User;
+  onUpdated?: (data: User) => void;
+};
+
+const UserUpdatePanel = forwardRef(
+  ({ data, onUpdated }: UserUpdatePanelProps, ref) => {
+    const { t } = useTranslation(["actions", "fields", "translations"]);
+    const { data: item, isLoading } = useUserGet(data.id as number);
+    const { mutate: userUpdate } = useUserUpdate();
+    const formRef = useRef<FormPanelRef>(null);
+
+    useEffectAfterFirstUpdate(() => {
+      if (item && formRef.current) {
+        formRef.current.setValuesFromItem(item);
+      }
+    }, [item]);
+
+    useImperativeHandle(ref, () => ({}));
+
+    return (
+      <TabPanel
+        activeTabIndex={0}
+        tabs={[
+          {
+            title: t("details", { ns: "actions" }),
+            children: (
+              <Overlay loading={isLoading}>
+                <FormPanel
+                  ref={formRef}
+                  fields={[]}
+                  button={{ text: t("save", { ns: "actions" }) }}
+                  onSubmit={(data) => {
+                    userUpdate({
+                      id: data.id,
+                      data,
+                    });
+                    if (typeof onUpdated === "function") {
+                      onUpdated(data);
+                    }
+                  }}
+                />
+              </Overlay>
+            ),
+          },
+        ]}
+      />
+    );
+  },
+);
+
+UserUpdatePanel.displayName = "UserUpdatePanel";
+
+export default UserUpdatePanel;

package/frontend/user/locales/en/admin.user.json

@@ -0,0 +1,11 @@
+{
+  "create": "Create user",
+  "createText": "Fill the user informations.",
+  "createTooltip": "Create new user",
+  "delete": "Delete user",
+  "deleteText": "Are you sure to delete these user?",
+  "deleteTooltip": "Delete the selected user",
+  "edit": "Edit user",
+  "editText": "View and edit user information.",
+  "editTooltip": "Edit the selected user"
+}

package/frontend/user/locales/pt/admin.user.json

@@ -0,0 +1,11 @@
+{
+  "create": "Criar usuário",
+  "createText": "Preencha as informações do usuário.",
+  "createTooltip": "Criar novo usuário",
+  "delete": "Excluir usuário",
+  "deleteText": "Você tem certeza que deseja excluir esses usuários?",
+  "deleteTooltip": "Excluir o usuário selecionado",
+  "edit": "Editar usuário",
+  "editText": "Visualizar e editar informações do usuário.",
+  "editTooltip": "Editar o usuário selecionado"
+}

package/frontend/user/react-query/handlers.ts.ejs

@@ -0,0 +1,28 @@
+import { useDefaultMutation } from "@/hooks/use-default-mutation";
+import { useQuery } from "@tanstack/react-query";
+import { requests } from "./requests";
+
+const scope = "user";
+
+export function useUserCreate() {
+  const { userCreate } = requests();
+  return useDefaultMutation(scope, "create", userCreate);
+}
+
+export function useUserDelete() {
+  const { userDelete } = requests();
+  return useDefaultMutation(scope, "delete", userDelete);
+}
+
+export function useUserUpdate() {
+  const { userUpdate } = requests();
+  return useDefaultMutation(scope, "update", userUpdate);
+}
+
+export function useUserGet(id: number) {
+  const { userGet } = requests();
+  return useQuery({
+    queryKey: [scope, "get"],
+    queryFn: () => userGet(id),
+  });
+}

package/frontend/user/react-query/requests.ts.ejs

@@ -0,0 +1,55 @@
+import { useApp } from "@/hooks/use-app";
+import { Delete, PaginationParams, PaginationResult } from "@/types";
+import { User } from "@/types/models";
+import { HttpMethod } from "@/types/http-method";
+
+export function requests() {
+  const { request } = useApp();
+
+  const userList = async (params: PaginationParams) => {
+    return request<PaginationResult<User>>({
+      url: "/user",
+      params,
+    }).then((res) => res.data);
+  };
+
+  const userGet = async (id: number) => {
+    return request<User>({
+      url: `/user/${id}`,
+    }).then((res) => res.data);
+  };
+
+  const userCreate = async (params: { data: User }) => {
+    const { data } = params;
+    return request<User>({
+      url: "/user",
+      method: HttpMethod.POST,
+      data: data,
+    }).then((res) => res.data);
+  };
+
+  const userDelete = async (ids: number[]) => {
+    return request<Delete>({
+      url: "/user",
+      data: { ids },
+      method: HttpMethod.DELETE,
+    }).then((res) => res.data);
+  };
+
+  const userUpdate = async (params: { id: number; data: User }) => {
+    const { id, data } = params;
+    return request<User>({
+      url: `/user/${id}`,
+      method: HttpMethod.PATCH,
+      data: data,
+    }).then((res) => res.data);
+  };
+
+  return {
+    userCreate,
+    userUpdate,
+    userDelete,
+    userList,
+    userGet,
+  };
+}

package/package.json

@@ -1,43 +1,43 @@
-{
-  "name": "@hedhog/admin",
-  "version": "0.12.1",
-  "private": false,
-  "main": "dist/index.js",
-  "scripts": {
-    "clean": "rimraf ./dist",
-    "prebuild": "npm run clean",
-    "build": "tsc --project tsconfig.production.json && npm version patch",
-    "prod": "npm run build && npm publish --access public"
-  },
-  "file": [
-    "dist/**/*",
-    "src/entities/**/*.ts",
-    "src/migrations/**/*.ts",
-    "src/**/*.ejs",
-    "hedhog.yaml"
-  ],
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "description": "",
-  "devDependencies": {
-    "@hedhog/locale": "^0.7.8",
-    "@hedhog/mail": "^0.7.6",
-    "@hedhog/pagination": "^0.7.4",
-    "@hedhog/prisma": "^0.7.6",
-    "@hedhog/setting": "^0.7.9",
-    "@hedhog/utils": "^0.0.28",
-    "@nestjs/mapped-types": "^2.0.5",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.1.3"
-  },
-  "peerDependencies": {
-    "@hedhog/locale": "latest",
-    "@hedhog/mail": "latest",
-    "@hedhog/pagination": "latest",
-    "@hedhog/prisma": "latest",
-    "@hedhog/setting": "latest",
-    "@hedhog/utils": "latest",
-    "@nestjs/jwt": "latest"
-  }
-}
+{
+  "name": "@hedhog/admin",
+  "version": "0.12.3",
+  "private": false,
+  "main": "dist/index.js",
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "prebuild": "npm run clean",
+    "build": "tsc --project tsconfig.production.json && npm version patch",
+    "prod": "npm run build && npm publish --access public"
+  },
+  "file": [
+    "dist/**/*",
+    "src/entities/**/*.ts",
+    "src/migrations/**/*.ts",
+    "src/**/*.ejs",
+    "hedhog.yaml"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "devDependencies": {
+    "@hedhog/locale": "^0.17.1",
+    "@hedhog/mail": "^0.17.1",
+    "@hedhog/pagination": "^0.17.1",
+    "@hedhog/prisma": "^0.17.1",
+    "@hedhog/setting": "^0.12.2",
+    "@hedhog/utils": "^0.0.28",
+    "@nestjs/mapped-types": "^2.0.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.3"
+  },
+  "peerDependencies": {
+    "@hedhog/locale": "latest",
+    "@hedhog/mail": "latest",
+    "@hedhog/pagination": "latest",
+    "@hedhog/prisma": "latest",
+    "@hedhog/setting": "latest",
+    "@hedhog/utils": "latest",
+    "@nestjs/jwt": "latest"
+  }
+}

package/src/auth/auth.service.spec.ts

@@ -1,196 +1,196 @@
-import { MailService } from '@hedhog/mail';
-import { PrismaService } from '@hedhog/prisma';
-import { NotFoundException } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { Test, TestingModule } from '@nestjs/testing';
-import { compare } from 'bcrypt';
-import { AuthService } from './auth.service';
-
-jest.mock('bcrypt');
-
-describe('AuthService', () => {
-  let authService: AuthService;
-  let prismaService: PrismaService;
-  let jwtService: JwtService;
-  let mailService: MailService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        AuthService,
-        {
-          provide: PrismaService,
-          useValue: {
-            user: {
-              findFirst: jest.fn(),
-              update: jest.fn(),
-              findUnique: jest.fn(),
-            },
-          },
-        },
-        {
-          provide: JwtService,
-          useValue: {
-            sign: jest.fn(),
-            verifyAsync: jest.fn(),
-            decode: jest.fn(),
-          },
-        },
-        {
-          provide: MailService,
-          useValue: {
-            send: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    authService = module.get<AuthService>(AuthService);
-    prismaService = module.get<PrismaService>(PrismaService);
-    jwtService = module.get<JwtService>(JwtService);
-    mailService = module.get<MailService>(MailService);
-  });
-
-  it('should be defined', () => {
-    expect(authService).toBeDefined();
-  });
-
-  describe('loginWithEmailAndPassword', () => {
-    it('should throw NotFoundException if user is not found', async () => {
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
-
-      await expect(
-        authService.loginWithEmailAndPassword('test@example.com', 'password'),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should throw NotFoundException if password is invalid', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      (compare as jest.Mock).mockResolvedValue(false);
-
-      await expect(
-        authService.loginWithEmailAndPassword('test@example.com', 'password'),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should return a token if login is successful', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      (compare as jest.Mock).mockResolvedValue(true);
-      jest.spyOn(jwtService, 'sign').mockReturnValue('token');
-
-      const result = await authService.loginWithEmailAndPassword(
-        'test@example.com',
-        'password',
-      );
-
-      expect(result).toEqual({ token: 'token' });
-    });
-  });
-
-  describe('forget', () => {
-    it('should throw NotFoundException if user is not found', async () => {
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
-
-      await expect(
-        authService.forget({ email: 'test@example.com' }),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should update user with reset code and send email', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
-      jest
-        .spyOn(authService, 'generateRandomString')
-        .mockReturnValue('resetCode');
-
-      const result = await authService.forget({ email: 'test@example.com' });
-
-      expect(prismaService.user.update).toHaveBeenCalledWith({
-        where: { id: 1 },
-        data: { code: 'resetCode' },
-      });
-      expect(mailService.send).toHaveBeenCalledWith({
-        to: 'test@example.com',
-        subject: 'Reset password',
-        body: `Reset your password by clicking <a href="${process.env.FRONTEND_URL}/reset-password/resetCode">here</a>`,
-      });
-      expect(result).toEqual(true);
-    });
-  });
-
-  describe('otp', () => {
-    it('should throw NotFoundException if user with code is not found', async () => {
-      jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
-
-      await expect(
-        authService.otp({ token: 'token', code: 123456 }),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should return a token if otp is valid', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
-      jest.spyOn(jwtService, 'sign').mockReturnValue('newToken');
-
-      const result = await authService.otp({ token: 'token', code: 123456 });
-
-      expect(prismaService.user.update).toHaveBeenCalledWith({
-        where: { id: 1 },
-        data: { code: null },
-      });
-      expect(result).toEqual({ token: 'newToken' });
-    });
-  });
-
-  describe('verifyToken', () => {
-    it('should verify and return token data', async () => {
-      jest.spyOn(jwtService, 'verifyAsync').mockResolvedValue({ id: 1 });
-
-      const result = await authService.verifyToken('token');
-
-      expect(result).toEqual({ id: 1 });
-    });
-  });
-});
+// import { MailService } from '@hedhog/mail';
+// import { PrismaService } from '@hedhog/prisma';
+// import { NotFoundException } from '@nestjs/common';
+// import { JwtService } from '@nestjs/jwt';
+// import { Test, TestingModule } from '@nestjs/testing';
+// import { compare } from 'bcrypt';
+// import { AuthService } from './auth.service';
+
+// jest.mock('bcrypt');
+
+// describe('AuthService', () => {
+//   let authService: AuthService;
+//   let prismaService: PrismaService;
+//   let jwtService: JwtService;
+//   let mailService: MailService;
+
+//   beforeEach(async () => {
+//     const module: TestingModule = await Test.createTestingModule({
+//       providers: [
+//         AuthService,
+//         {
+//           provide: PrismaService,
+//           useValue: {
+//             user: {
+//               findFirst: jest.fn(),
+//               update: jest.fn(),
+//               findUnique: jest.fn(),
+//             },
+//           },
+//         },
+//         {
+//           provide: JwtService,
+//           useValue: {
+//             sign: jest.fn(),
+//             verifyAsync: jest.fn(),
+//             decode: jest.fn(),
+//           },
+//         },
+//         {
+//           provide: MailService,
+//           useValue: {
+//             send: jest.fn(),
+//           },
+//         },
+//       ],
+//     }).compile();
+
+//     authService = module.get<AuthService>(AuthService);
+//     prismaService = module.get<PrismaService>(PrismaService);
+//     jwtService = module.get<JwtService>(JwtService);
+//     mailService = module.get<MailService>(MailService);
+//   });
+
+//   it('should be defined', () => {
+//     expect(authService).toBeDefined();
+//   });
+
+//   describe('loginWithEmailAndPassword', () => {
+//     it('should throw NotFoundException if user is not found', async () => {
+//       jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
+
+//       await expect(
+//         authService.loginWithEmailAndPassword('test@example.com', 'password'),
+//       ).rejects.toThrow(NotFoundException);
+//     });
+
+//     it('should throw NotFoundException if password is invalid', async () => {
+//       const mockUser = {
+//         id: 1,
+//         name: 'Test User',
+//         email: 'test@example.com',
+//         password: 'hashedpassword',
+//         multifactor_id: null,
+//         code: null,
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//       };
+//       jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+//       (compare as jest.Mock).mockResolvedValue(false);
+
+//       await expect(
+//         authService.loginWithEmailAndPassword('test@example.com', 'password'),
+//       ).rejects.toThrow(NotFoundException);
+//     });
+
+//     it('should return a token if login is successful', async () => {
+//       const mockUser = {
+//         id: 1,
+//         name: 'Test User',
+//         email: 'test@example.com',
+//         password: 'hashedpassword',
+//         multifactor_id: null,
+//         code: null,
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//       };
+//       jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+//       (compare as jest.Mock).mockResolvedValue(true);
+//       jest.spyOn(jwtService, 'sign').mockReturnValue('token');
+
+//       const result = await authService.loginWithEmailAndPassword(
+//         'test@example.com',
+//         'password',
+//       );
+
+//       expect(result).toEqual({ token: 'token' });
+//     });
+//   });
+
+//   describe('forget', () => {
+//     it('should throw NotFoundException if user is not found', async () => {
+//       jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
+
+//       await expect(
+//         authService.forget({ email: 'test@example.com' }),
+//       ).rejects.toThrow(NotFoundException);
+//     });
+
+//     it('should update user with reset code and send email', async () => {
+//       const mockUser = {
+//         id: 1,
+//         name: 'Test User',
+//         email: 'test@example.com',
+//         password: 'hashedpassword',
+//         multifactor_id: null,
+//         code: null,
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//       };
+//       jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+//       jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
+//       jest
+//         .spyOn(authService, 'generateRandomString')
+//         .mockReturnValue('resetCode');
+
+//       const result = await authService.forget({ email: 'test@example.com' });
+
+//       expect(prismaService.user.update).toHaveBeenCalledWith({
+//         where: { id: 1 },
+//         data: { code: 'resetCode' },
+//       });
+//       expect(mailService.send).toHaveBeenCalledWith({
+//         to: 'test@example.com',
+//         subject: 'Reset password',
+//         body: `Reset your password by clicking <a href="${process.env.FRONTEND_URL}/reset-password/resetCode">here</a>`,
+//       });
+//       expect(result).toEqual(true);
+//     });
+//   });
+
+//   describe('otp', () => {
+//     it('should throw NotFoundException if user with code is not found', async () => {
+//       jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
+//       jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
+
+//       await expect(
+//         authService.otp({ token: 'token', code: 123456 }),
+//       ).rejects.toThrow(NotFoundException);
+//     });
+
+//     it('should return a token if otp is valid', async () => {
+//       const mockUser = {
+//         id: 1,
+//         name: 'Test User',
+//         email: 'test@example.com',
+//         password: 'hashedpassword',
+//         multifactor_id: null,
+//         code: null,
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//       };
+//       jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
+//       jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+//       jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
+//       jest.spyOn(jwtService, 'sign').mockReturnValue('newToken');
+
+//       const result = await authService.otp({ token: 'token', code: 123456 });
+
+//       expect(prismaService.user.update).toHaveBeenCalledWith({
+//         where: { id: 1 },
+//         data: { code: null },
+//       });
+//       expect(result).toEqual({ token: 'newToken' });
+//     });
+//   });
+
+//   describe('verifyToken', () => {
+//     it('should verify and return token data', async () => {
+//       jest.spyOn(jwtService, 'verifyAsync').mockResolvedValue({ id: 1 });
+
+//       const result = await authService.verifyToken('token');
+
+//       expect(result).toEqual({ id: 1 });
+//     });
+//   });
+// });