refactor: update user service to use Prisma client for database operations

Author: jhonattan

src/lib/utils.tests.ts

@@ -19,8 +19,8 @@ export const createTestUser = (overrides?: Partial<User>): User => ({
   name: null,
   password: null,
   isGuest: false,
-  createdAt: new Date().toISOString(),
-  updatedAt: new Date().toISOString(),
+  createdAt: new Date(),
+  updatedAt: new Date(),
   ...overrides,
 });
 

src/services/user.service.test.ts

@@ -6,15 +6,24 @@ import {
   createTestRequest,
   createTestUser,
 } from "@/lib/utils.tests";
-import * as userRepository from "@/repositories/user.repository";
 import { getSession } from "@/session.server";
+import { prisma } from "@/db/prisma";
+import type { User } from "generated/prisma/client";
 
 import * as userService from "./user.service";
 
 // Mocking dependencies for unit tests
 vi.mock("@/session.server");
-vi.mock("@/repositories/user.repository");
 vi.mock("@/lib/security");
+vi.mock("@/db/prisma", () => ({
+  prisma: {
+    user: {
+      update: vi.fn(),
+      findUnique: vi.fn(),
+      create: vi.fn(),
+    },
+  },
+}));
 
 describe("user service", () => {
   beforeEach(() => {
@@ -29,7 +38,7 @@ describe("user service", () => {
       const mockSession = createMockSession(updatedUser.id); // Simulate updated user ID in session
 
       // Mockeando las funciones que serán llamadas
-      vi.mocked(userRepository.updateUser).mockResolvedValue(updatedUser);
+      vi.mocked(prisma.user.update).mockResolvedValue(updatedUser);
       vi.mocked(getSession).mockResolvedValue(mockSession);
 
       // Llamando al servicio y verificando el resultado
@@ -51,6 +60,10 @@ describe("user service", () => {
       // Mockeando las funciones que serán llamadas
       vi.mocked(getSession).mockResolvedValue(mockSession);
       vi.mocked(hashPassword).mockResolvedValue("hashed-password");
+      vi.mocked(prisma.user.update).mockResolvedValue({
+        ...updatedUser,
+        password: "hashed-password",
+      });
 
       // Llamando al servicio y verificando el resultado
       await userService.updateUser(updatedUser, request);
@@ -88,15 +101,15 @@ describe("user service", () => {
       });
 
       // Mock repository function to return existing user
-      vi.mocked(userRepository.getUserByEmail).mockResolvedValue(existingUser);
+      vi.mocked(prisma.user.findUnique).mockResolvedValue(existingUser);
 
       // Call service function
       const result = await userService.getOrCreateUser(email);
 
       // Verify results
       expect(result).toEqual(existingUser);
-      expect(userRepository.getUserByEmail).toHaveBeenCalledWith(email);
-      expect(userRepository.createUser).not.toHaveBeenCalled();
+      expect(prisma.user.findUnique).toHaveBeenCalledWith({ where: { email } });
+      expect(prisma.user.create).not.toHaveBeenCalled();
     });
 
     it("should create a new guest user when email is not found", async () => {
@@ -107,21 +120,22 @@ describe("user service", () => {
         id: 20,
         isGuest: true,
       });
-      const createUserDTO = {
-        email,
-        password: null,
-        isGuest: true,
-        name: null,
-      };
       // Mock repository functions
-      vi.mocked(userRepository.getUserByEmail).mockResolvedValue(null);
-      vi.mocked(userRepository.createUser).mockResolvedValue(newUser);
+      vi.mocked(prisma.user.findUnique).mockResolvedValue(null);
+      vi.mocked(prisma.user.create).mockResolvedValue(newUser);
       // Call service function
       const result = await userService.getOrCreateUser(email);
       // Verify results
       expect(result).toEqual(newUser);
-      expect(userRepository.getUserByEmail).toHaveBeenCalledWith(email);
-      expect(userRepository.createUser).toHaveBeenCalledWith(createUserDTO);
+      expect(prisma.user.findUnique).toHaveBeenCalledWith({ where: { email } });
+      expect(prisma.user.create).toHaveBeenCalledWith({
+        data: {
+          email,
+          password: null,
+          isGuest: true,
+          name: null,
+        },
+      });
     });
   });
 });

src/services/user.service.ts

@@ -1,43 +1,48 @@
 import { hashPassword } from "@/lib/security";
-import type { User, AuthResponse, CreateUserDTO } from "@/models/user.model";
-import * as userRepository from "@/repositories/user.repository";
+import type { Prisma, User } from "generated/prisma/client";
+import { prisma } from "@/db/prisma";
 import { getSession } from "@/session.server";
 
 export async function updateUser(
   updatedUser: Partial<User>,
   request: Request
-): Promise<AuthResponse["user"]> {
+): Promise<User> {
   const session = await getSession(request.headers.get("Cookie"));
   const id = session.get("userId");
 
   if (!id) {
     throw new Error("User not authenticated");
   }
 
+  const data: Prisma.UserUpdateInput = { ...updatedUser };
+
   if (updatedUser.password) {
     const hashedPassword = await hashPassword(updatedUser.password);
-    updatedUser.password = hashedPassword;
+    data.password = hashedPassword;
   }
 
-  const userData = await userRepository.updateUser(id, updatedUser);
+  const userData = await prisma.user.update({
+    where: { id: typeof id === "number" ? id : Number(id) },
+    data,
+  });
 
   return userData;
 }
 
 export async function getOrCreateUser(email: string): Promise<User> {
-  const existingUser = await userRepository.getUserByEmail(email);
+  let existingUser = await prisma.user.findUnique({
+    where: { email },
+  });
 
   if (!existingUser) {
-    const newUser: CreateUserDTO = {
-      email,
-      password: null,
-      isGuest: true,
-      name: null,
-    };
-
-    const user = await userRepository.createUser(newUser);
-
-    return user;
+    existingUser = await prisma.user.create({
+      data: {
+        email,
+        password: null,
+        isGuest: true,
+        name: null,
+      },
+    });
   }
 
   return existingUser;