auth

src/modules/auth/services/tokens.service.ts

@@ -1,18 +1,18 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { EntityManager } from '@mikro-orm/postgresql';
-import { LockMode } from '@mikro-orm/core';
 import { Injectable, Logger, UnauthorizedException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import dayjs from 'dayjs';
-
+import { RefreshTokenType } from '../interfaces/IToken-payload';
 import { AuthMessage } from '../../../common/enums/message.enum';
-import { RefreshToken, RefreshTokenType } from '../entities/refresh-token.entity';
+import { RefreshToken } from '../entities/refresh-token.entity';
 import { IAdminTokenPayload, ITokenPayload } from '../interfaces/IToken-payload';
-import { Restaurant } from 'src/modules/restaurants/entities/restaurant.entity';
+
 
 @Injectable()
 export class TokensService {
+
   private readonly logger = new Logger(TokensService.name);
   constructor(
     private readonly configService: ConfigService,
@@ -22,24 +22,22 @@ export class TokensService {
 
   async generateAccessAndRefreshToken(
     ownerId: string,
-    : string,
     isAdmin: boolean,
-    slug: string,
     em?: EntityManager,
   ) {
     const refreshExpire = this.configService.getOrThrow<number>('REFRESH_TOKEN_EXPIRE');
     const accessExpire = this.configService.getOrThrow<number>('JWT_EXPIRATION_TIME');
 
     const payload: ITokenPayload | IAdminTokenPayload = isAdmin
-      ? { adminId: ownerId, : }
-      : { userId: ownerId, : , slug };
+      ? { adminId: ownerId, }
+      : { userId: ownerId };
 
     const accessToken = await this.generateAccessToken(payload, accessExpire);
     const refreshToken = this.generateRefreshToken();
     const type = isAdmin ? RefreshTokenType.ADMIN : RefreshTokenType.USER;
 
     // Only pass em if it's a transaction manager (not this.em), otherwise pass undefined to trigger flush
-    await this.storeRefreshToken(ownerId, , refreshToken, type, em);
+    await this.storeRefreshToken(ownerId, refreshToken, type, em);
 
     return {
       accessToken: { token: accessToken, expire: dayjs().add(accessExpire, 'seconds').valueOf() },
@@ -48,15 +46,11 @@ export class TokensService {
   }
 
   private generateAccessToken(payload: ITokenPayload | IAdminTokenPayload, expiresIn: number) {
-    // Ensure expiresIn is passed as a string with time unit for reliability
-    // JWT library accepts: number (seconds) or string with unit (e.g., "3600s", "1h")
-    // Using string format is more explicit and prevents unit confusion
     return this.jwtService.signAsync(payload, { expiresIn: `${expiresIn}s` });
   }
 
   async storeRefreshToken(
     ownerId: string,
-    : string,
     refreshToken: string,
     type: RefreshTokenType,
     em?: EntityManager,
@@ -70,76 +64,69 @@ export class TokensService {
     const token = entityManager.create(RefreshToken, {
       hashedToken,
       ownerId,
-      ,
       type,
       expiresAt,
     });
 
-  if(em) {
-    // Within transaction, just persist (flush will be called by transaction)
-    entityManager.persist(token);
-  } else {
-  // Outside transaction, persist and flush immediately
-  await entityManager.persistAndFlush(token);
-}
+    if (em) {
+      // Within transaction, just persist (flush will be called by transaction)
+      entityManager.persist(token);
+    } else {
+      // Outside transaction, persist and flush immediately
+      await entityManager.persistAndFlush(token);
+    }
   }
 
   async refreshToken(oldRefreshToken: string) {
-  const hashedToken = this.hashToken(oldRefreshToken);
+    const hashedToken = this.hashToken(oldRefreshToken);
 
-  // Use transaction to ensure atomicity and prevent race conditions
-  return this.em.transactional(async em => {
-    // Lock the token row to prevent concurrent refresh attempts
-    // Using pessimistic write lock (FOR UPDATE) to prevent race conditions
-    const token = await em.findOne(RefreshToken, { hashedToken }, { lockMode: LockMode.PESSIMISTIC_WRITE });
+    return this.em.transactional(async em => {
 
-    if (!token) {
-      throw new UnauthorizedException(AuthMessage.INVALID_REFRESH_TOKEN);
-    }
+      const token = await em.findOne(RefreshToken, { hashedToken });
 
-    // Check expiration
-    if (dayjs(token.expiresAt).isBefore(dayjs())) {
-      em.remove(token);
-      await em.flush();
-      throw new UnauthorizedException(AuthMessage.REFRESH_TOKEN_EXPIRED);
-    }
+      if (!token) {
+        throw new UnauthorizedException(AuthMessage.INVALID_REFRESH_TOKEN);
+      }
 
-    // Store token data before removal
-    const ownerId = token.ownerId;
-    const  = token.;
-    const isAdmin = token.type === RefreshTokenType.ADMIN;
+      // Check expiration
+      if (dayjs(token.expiresAt).isBefore(dayjs())) {
+        em.remove(token);
+        await em.flush();
+        throw new UnauthorizedException(AuthMessage.REFRESH_TOKEN_EXPIRED);
+      }
 
-    // Verify restaurant still exists
-    const restaurant = await em.findOne(Restaurant, { id:  });
-    if (!restaurant) {
-      throw new UnauthorizedException(AuthMessage.INVALID_REFRESH_TOKEN);
-    }
+      // Store token data before removal
+      const ownerId = token.ownerId;
+      const isAdmin = token.type === RefreshTokenType.ADMIN;
 
-    try {
-      // Generate new tokens first (before removing old token)
-      // Pass the transaction EntityManager to ensure operations are within the transaction
-      const tokens = await this.generateAccessAndRefreshToken(ownerId, restaurant.id, isAdmin, restaurant.slug, em);
 
-      // Remove old token only after new token is created
-      em.remove(token);
+      try {
+        // Generate new tokens first (before removing old token)
+        // Pass the transaction EntityManager to ensure operations are within the transaction
+        const tokens = await this.generateAccessAndRefreshToken(ownerId, isAdmin, em);
 
-      // Persist changes atomically
-      await em.flush();
+        // Remove old token only after new token is created
+        em.remove(token);
 
-      return tokens;
-    } catch (error) {
-      this.logger.error('Failed to generate new tokens after refresh', error);
-      // Transaction will rollback automatically, preserving the old token
-      throw new UnauthorizedException('Failed to refresh token');
-    }
-  });
-}
+        // Persist changes atomically
+        await em.flush();
+
+        return tokens;
+      } catch (error) {
+        this.logger.error('Failed to generate new tokens after refresh', error);
+        // Transaction will rollback automatically, preserving the old token
+        throw new UnauthorizedException('Failed to refresh token');
+      }
+    });
+  }
 
   private generateRefreshToken() {
-  return randomBytes(32).toString('hex');
-}
+    return randomBytes(32).toString('hex');
+  }
 
   private hashToken(token: string): string {
-  return createHash('sha256').update(token).digest('hex');
-}
+    return createHash('sha256').update(token).digest('hex');
+  }
+
 }
+