Added missing entities( zoneEffect, zoneEventTile, zoneEventTileTeleport, zoneObject)

src/services/userService.ts

@@ -1,12 +1,13 @@
 import bcrypt from 'bcryptjs'
 import UserRepository from '#repositories/userRepository'
 import PasswordResetTokenRepository from '#repositories/passwordResetTokenRepository'
-import prisma from '#utilities/prisma'
-import { User } from '@prisma/client'
 import config from '#utilities/config'
 import NodeMailer from 'nodemailer'
 import { httpLogger } from '#utilities/logger'
-import PasswordResetTokenService from './passwordResetTokenService'
+import PasswordResetTokenService from './passwordResetTokenService' // @TODO: Correctly implement this
+import { User } from '#entities/user'
+import { Database } from '#utilities/database'
+import { PasswordResetToken } from '#entities/passwordResetToken'
 
 /**
  * User service
@@ -14,11 +15,6 @@ import PasswordResetTokenService from './passwordResetTokenService'
  * @class UserService
  */
 class UserService {
-  /**
-   * Login user
-   * @param username
-   * @param password
-   */
   async login(username: string, password: string): Promise<boolean | User> {
     try {
       const user = await UserRepository.getByUsername(username)
@@ -39,43 +35,31 @@ class UserService {
     }
   }
 
-  /**
-   * Register user
-   * @param username
-   * @param email
-   * @param password
-   */
   async register(username: string, email: string, password: string): Promise<boolean | User> {
     try {
-      const user = await UserRepository.getByUsername(username)
-      if (user) {
-        return false
-      }
+      // Check existing users
+      const [userByName, userByEmail] = await Promise.all([UserRepository.getByUsername(username), UserRepository.getByEmail(email)])
 
-      const userByEmail = await UserRepository.getByEmail(email)
-      if (userByEmail) {
-        httpLogger.error(`User already exists: ${email}`)
+      if (userByName || userByEmail) {
+        httpLogger.error(`User already exists: ${userByEmail ? email : username}`)
         return false
       }
 
       const hashedPassword = await bcrypt.hash(password, 10)
-      return prisma.user.create({
-        data: {
-          username,
-          email,
-          password: hashedPassword
-        }
-      })
+
+      const newUser = new User()
+      newUser.username = username
+      newUser.email = email
+      newUser.password = hashedPassword
+      await Database.save(newUser)
+
+      return newUser
     } catch (error: any) {
       httpLogger.error(`Error registering user: ${error instanceof Error ? error.message : String(error)}`)
       return false
     }
   }
 
-  /**
-   * Reset password
-   * @param email
-   */
   async requestPasswordReset(email: string): Promise<boolean> {
     try {
       const user = await UserRepository.getByEmail(email)
@@ -86,24 +70,20 @@ class UserService {
 
       // Check if password reset has been requested recently
       if (latestToken) {
-        const tokenExpiryDate = new Date(Date.now() - 24 * 60 * 60 * 1000) // 24 hours
+        const tokenExpiryDate = new Date(Date.now() - 24 * 60 * 60 * 1000)
         const isTokenExpired = latestToken.createdAt < tokenExpiryDate
 
         if (!isTokenExpired) return false
 
-        await prisma.passwordResetToken.delete({
-          where: {
-            id: latestToken.id
-          }
-        })
+        // Delete existing token using MikroORM
+        await Database.delete(latestToken)
       }
 
-      await prisma.passwordResetToken.create({
-        data: {
-          userId: user.id,
-          token: token
-        }
-      })
+      // Create new token using MikroORM
+      const passwordResetToken = new PasswordResetToken()
+      passwordResetToken.user = user
+      passwordResetToken.token = token
+      await Database.save(passwordResetToken)
 
       const transporter = NodeMailer.createTransport({
         host: config.SMTP_HOST,
@@ -119,8 +99,8 @@ class UserService {
         from: config.SMTP_USER,
         to: email,
         subject: 'Reset your password',
-        text: 'A password reset has been requested, reset your password here: ' + config.CLIENT_URL + '#' + token, // Plain text body
-        html: "<p>A password reset has been requested, reset your password here: <a href='" + config.CLIENT_URL + '#' + token + "'>" + config.CLIENT_URL + '#' + token + '</a></p>' // Html body
+        text: `A password reset has been requested, reset your password here: ${config.CLIENT_URL}#${token}`,
+        html: `<p>A password reset has been requested, reset your password here: <a href="${config.CLIENT_URL}#${token}">${config.CLIENT_URL}#${token}</a></p>`
       })
 
       return true
@@ -130,11 +110,6 @@ class UserService {
     }
   }
 
-  /**
-   * Set new password
-   * @param urlToken
-   * @param password
-   */
   async resetPassword(urlToken: string, password: string): Promise<boolean> {
     try {
       const tokenData = await PasswordResetTokenRepository.getByToken(urlToken)
@@ -143,16 +118,19 @@ class UserService {
       }
 
       const hashedPassword = await bcrypt.hash(password, 10)
-      await prisma.user.update({
-        where: { id: tokenData.userId },
-        data: {
-          password: hashedPassword
-        }
-      })
+
+      // Update user password using MikroORM
+      const orm = await Database.getInstance()
+      const em = orm.em.fork()
+      const user = await em.findOne(User, { id: tokenData.userId })
+
+      if (!user) return false
+
+      user.password = hashedPassword
+      await em.persistAndFlush(user)
 
       // Delete the token
-      const passwordResetTokenService = new PasswordResetTokenService()
-      await passwordResetTokenService.delete(urlToken)
+      await em.removeAndFlush(tokenData)
 
       return true
     } catch (error: any) {