@hichchi/nest-auth 0.0.2 → 0.0.3

package/services/auth.service.js

@@ -1,20 +1,23 @@
+"use strict";
 // noinspection JSUnusedGlobalSymbols,ExceptionCaughtLocallyJS
 var AuthService_1;
-import { __decorate, __metadata, __param } from "tslib";
-import { BadRequestException, ForbiddenException, HttpException, Inject, Injectable, InternalServerErrorException, NotFoundException, UnauthorizedException, } from "@nestjs/common";
-import { compareSync, hashSync } from "bcrypt";
-import { JsonWebTokenError, TokenExpiredError } from "@nestjs/jwt";
-import { LoggerService } from "@hichchi/nest-core";
-import { AUTH_OPTIONS, USER_SERVICE } from "../tokens";
-import { UserCacheService } from "./user-cache.service";
-import { JwtTokenService } from "./jwt-token.service";
-import { v4 as uuid } from "uuid";
-import { TokenVerifyService } from "./token-verify.service";
-import { generateAuthUser } from "../utils";
-import { randomBytes, randomInt } from "crypto";
-import { AuthErrors, AuthField, AuthMethod, AuthProvider, AuthSuccessResponses, } from "@hichchi/nest-connector/auth";
-import { DEFAULT_SALT_ROUNDS, DEFAULT_VERIFY_TOKEN_LENGTH, Errors, SECOND_IN_MS, SuccessResponseDto, } from "@hichchi/nest-connector";
-import { ACCESS_TOKEN_COOKIE_NAME, REFRESH_TOKEN_COOKIE_NAME } from "../constants";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const bcrypt_1 = require("bcrypt");
+const jwt_1 = require("@nestjs/jwt");
+const nest_core_1 = require("@hichchi/nest-core");
+const tokens_1 = require("../tokens");
+const user_cache_service_1 = require("./user-cache.service");
+const jwt_token_service_1 = require("./jwt-token.service");
+const uuid_1 = require("uuid");
+const token_verify_service_1 = require("./token-verify.service");
+const utils_1 = require("../utils");
+const crypto_1 = require("crypto");
+const auth_1 = require("@hichchi/nest-connector/auth");
+const nest_connector_1 = require("@hichchi/nest-connector");
+const constants_1 = require("../constants");
 /**
  * Core authentication service that provides comprehensive identity management functionality.
  *
@@ -115,8 +118,8 @@ let AuthService = AuthService_1 = class AuthService {
      * @see {@link DEFAULT_VERIFY_TOKEN_LENGTH} Default length constant for verification tokens
      * @see {@link VerifyToken} Type representing verification tokens
      */
-    static generateVerifyToken(length = DEFAULT_VERIFY_TOKEN_LENGTH) {
-        return randomBytes(length).toString("hex");
+    static generateVerifyToken(length = nest_connector_1.DEFAULT_VERIFY_TOKEN_LENGTH) {
+        return (0, crypto_1.randomBytes)(length).toString("hex");
     }
     /**
      * Generates a cryptographically secure random password with strong complexity requirements.
@@ -159,7 +162,7 @@ let AuthService = AuthService_1 = class AuthService {
         const symbols = "!@#$%&*";
         const allCharacters = uppercase + lowercase + numbers + symbols;
         const getRandomSecureIndex = (max) => {
-            return randomInt(0, max);
+            return (0, crypto_1.randomInt)(0, max);
         };
         let password = "";
         password += uppercase[getRandomSecureIndex(uppercase.length)];
@@ -211,7 +214,7 @@ let AuthService = AuthService_1 = class AuthService {
      * @see {@link verifyHash} Companion method for verifying passwords against hashes
      */
     static generateHash(password) {
-        return hashSync(password, DEFAULT_SALT_ROUNDS);
+        return (0, bcrypt_1.hashSync)(password, nest_connector_1.DEFAULT_SALT_ROUNDS);
     }
     /**
      * Securely verifies a plain text password against a bcrypt hash.
@@ -248,7 +251,7 @@ let AuthService = AuthService_1 = class AuthService {
      * @see {@link generateHash} Companion method for generating password hashes
      */
     static verifyHash(password, hash) {
-        return compareSync(password, hash);
+        return (0, bcrypt_1.compareSync)(password, hash);
     }
     /**
      * Authenticate a user with username/email and password
@@ -285,30 +288,30 @@ let AuthService = AuthService_1 = class AuthService {
      * @see {@link LocalStrategy} Strategy that uses this method to authenticate users
      */
     async authenticate(request, username, password, subdomain) {
-        const INVALID_CREDS = this.options.authField === AuthField.EMAIL
-            ? AuthErrors.AUTH_401_INVALID_EMAIL_PASSWORD
-            : AuthErrors.AUTH_401_INVALID_USERNAME_PASSWORD;
+        const INVALID_CREDS = this.options.authField === auth_1.AuthField.EMAIL
+            ? auth_1.AuthErrors.AUTH_401_INVALID_EMAIL_PASSWORD
+            : auth_1.AuthErrors.AUTH_401_INVALID_USERNAME_PASSWORD;
         try {
-            const user = this.options.authField === AuthField.USERNAME && this.userService.getUserByUsername
+            const user = this.options.authField === auth_1.AuthField.USERNAME && this.userService.getUserByUsername
                 ? await this.userService.getUserByUsername(username, subdomain)
-                : this.options.authField === AuthField.EMAIL
+                : this.options.authField === auth_1.AuthField.EMAIL
                     ? await this.userService.getUserByEmail(username, subdomain)
-                    : this.options.authField === AuthField.BOTH && this.userService.getUserByUsernameOrEmail
+                    : this.options.authField === auth_1.AuthField.BOTH && this.userService.getUserByUsernameOrEmail
                         ? await this.userService.getUserByUsernameOrEmail(username, subdomain)
                         : Boolean(this.options.authField) && this.userService.getUserByAuthField
                             ? await this.userService.getUserByAuthField(username, subdomain)
                             : null;
             if (!user) {
-                throw new UnauthorizedException(INVALID_CREDS);
+                throw new common_1.UnauthorizedException(INVALID_CREDS);
             }
             if (!user.password) {
-                throw new ForbiddenException(AuthErrors.AUTH_401_NOT_LOCAL);
+                throw new common_1.ForbiddenException(auth_1.AuthErrors.AUTH_401_NOT_LOCAL);
             }
             if (!AuthService_1.verifyHash(password, user.password)) {
-                throw new UnauthorizedException(INVALID_CREDS);
+                throw new common_1.UnauthorizedException(INVALID_CREDS);
             }
             if (this.options.checkEmailVerified && !user.emailVerified) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_EMAIL_NOT_VERIFIED);
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_EMAIL_NOT_VERIFIED);
             }
             // if (user.status === Status.PENDING) {
             //     return await Promise.reject(new ForbiddenException(AuthErrors.AUTH_403_PENDING));
@@ -318,20 +321,20 @@ let AuthService = AuthService_1 = class AuthService {
             // }
             const tokenResponse = this.generateTokens(user);
             const cacheUser = await this.updateCacheUser(user, tokenResponse);
-            const authUser = generateAuthUser(cacheUser, tokenResponse.accessToken);
+            const authUser = (0, utils_1.generateAuthUser)(cacheUser, tokenResponse.accessToken);
             await this.userService
                 .onAuthenticate?.(request, authUser)
-                .catch(callbackError => LoggerService.error("Error in onAuthenticate success callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onAuthenticate success callback:", callbackError));
             return authUser;
         }
         catch (error) {
             await this.userService
                 .onAuthenticate?.(request, undefined, error)
-                .catch(callbackError => LoggerService.error("Error in onAuthenticate error callback:", callbackError));
-            if (!(error instanceof HttpException)) {
-                LoggerService.error(error);
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onAuthenticate error callback:", callbackError));
+            if (!(error instanceof common_1.HttpException)) {
+                nest_core_1.LoggerService.error(error);
             }
-            throw new UnauthorizedException(INVALID_CREDS);
+            throw new common_1.UnauthorizedException(INVALID_CREDS);
         }
     }
     /**
@@ -383,28 +386,28 @@ let AuthService = AuthService_1 = class AuthService {
             if (!cacheUser ||
                 !cacheUser.sessions?.length ||
                 !cacheUser.sessions?.find(session => session.accessToken === accessToken)) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_INVALID_TOKEN);
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_INVALID_TOKEN);
             }
-            const authUser = generateAuthUser(cacheUser, accessToken);
+            const authUser = (0, utils_1.generateAuthUser)(cacheUser, accessToken);
             await this.userService
                 .onAuthenticateJWT?.(request, authUser)
-                .catch(callbackError => LoggerService.error("Error in onAuthenticateJWT success callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onAuthenticateJWT success callback:", callbackError));
             return authUser;
         }
         catch (error) {
             await this.userService
                 .onAuthenticateJWT?.(request, undefined, error)
-                .catch(callbackError => LoggerService.error("Error in onAuthenticateJWT error callback:", callbackError));
-            if (error instanceof TokenExpiredError) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_EXPIRED_TOKEN);
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onAuthenticateJWT error callback:", callbackError));
+            if (error instanceof jwt_1.TokenExpiredError) {
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_EXPIRED_TOKEN);
             }
-            else if (error instanceof JsonWebTokenError) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_INVALID_TOKEN);
+            else if (error instanceof jwt_1.JsonWebTokenError) {
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_INVALID_TOKEN);
             }
-            else if (error instanceof HttpException) {
+            else if (error instanceof common_1.HttpException) {
                 throw error;
             }
-            throw new UnauthorizedException();
+            throw new common_1.UnauthorizedException();
         }
     }
     /**
@@ -452,7 +455,7 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async authenticateGoogle(request, profile, redirectUrl) {
         if (!("getUserByEmail" in this.userService)) {
-            throw new InternalServerErrorException(AuthErrors.AUTH_501_NOT_IMPLEMENTED);
+            throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_501_NOT_IMPLEMENTED);
         }
         try {
             let user = await this.userService.getUserByEmail(profile.email);
@@ -462,25 +465,25 @@ let AuthService = AuthService_1 = class AuthService {
                         firstName: profile.given_name,
                         lastName: profile.family_name,
                         email: profile.email,
-                    }, AuthProvider.GOOGLE, profile));
+                    }, auth_1.AuthProvider.GOOGLE, profile));
                 }
                 catch (error) {
-                    LoggerService.error(error);
-                    throw new UnauthorizedException(AuthErrors.AUTH_500_SIGN_UP);
+                    nest_core_1.LoggerService.error(error);
+                    throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_500_SIGN_UP);
                 }
             }
             const tokenResponse = this.generateTokens(user);
             const cacheUser = await this.updateCacheUser(user, tokenResponse, undefined, redirectUrl);
-            const authUser = generateAuthUser(cacheUser, tokenResponse.accessToken);
+            const authUser = (0, utils_1.generateAuthUser)(cacheUser, tokenResponse.accessToken);
             await this.userService
                 .onAuthenticateGoogle?.(request, authUser)
-                .catch(callbackError => LoggerService.error("Error in onAuthenticateGoogle success callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onAuthenticateGoogle success callback:", callbackError));
             return authUser;
         }
         catch (error) {
             await this.userService
                 .onAuthenticateGoogle?.(request, undefined, error)
-                .catch(callbackError => LoggerService.error("Error in onAuthenticateGoogle error callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onAuthenticateGoogle error callback:", callbackError));
             throw error;
         }
     }
@@ -523,11 +526,11 @@ let AuthService = AuthService_1 = class AuthService {
         const jwtPayload = this.jwtTokenService.verifyAccessToken(accessToken);
         const user = await this.userService.getUserById(jwtPayload.sub);
         if (!user) {
-            return Promise.reject(new UnauthorizedException(AuthErrors.AUTH_401_SOCIAL_SIGN_IN));
+            return Promise.reject(new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_SOCIAL_SIGN_IN));
         }
         const tokenResponse = this.generateTokens(user);
         const cacheUser = await this.updateCacheUser(user, tokenResponse);
-        const authUser = generateAuthUser(cacheUser, accessToken);
+        const authUser = (0, utils_1.generateAuthUser)(cacheUser, accessToken);
         return this.signIn(request, authUser, res);
     }
     /**
@@ -561,14 +564,14 @@ let AuthService = AuthService_1 = class AuthService {
             }
             await this.userService
                 .onGetUserByToken?.(request, user.id)
-                .catch(callbackError => LoggerService.error("Error in onGetUserByToken success callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onGetUserByToken success callback:", callbackError));
             return user;
         }
         catch (error) {
             await this.userService
                 .onGetUserByToken?.(request, undefined, error)
-                .catch(callbackError => LoggerService.error("Error in onGetUserByToken error callback:", callbackError));
-            LoggerService.error(error);
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onGetUserByToken error callback:", callbackError));
+            nest_core_1.LoggerService.error(error);
             return null;
         }
     }
@@ -669,7 +672,7 @@ let AuthService = AuthService_1 = class AuthService {
                 cacheUser.sessions = cacheUser.sessions.filter(session => session.refreshToken !== oldRefreshToken);
             }
             cacheUser.sessions.push({
-                sessionId: uuid(),
+                sessionId: (0, uuid_1.v4)(),
                 accessToken: tokenResponse.accessToken,
                 refreshToken: tokenResponse.refreshToken,
                 frontendUrl,
@@ -678,7 +681,7 @@ let AuthService = AuthService_1 = class AuthService {
         else {
             cacheUser.sessions = [
                 {
-                    sessionId: uuid(),
+                    sessionId: (0, uuid_1.v4)(),
                     accessToken: tokenResponse.accessToken,
                     refreshToken: tokenResponse.refreshToken,
                     frontendUrl,
@@ -729,16 +732,16 @@ let AuthService = AuthService_1 = class AuthService {
      * @see {@link AuthOptions.cookies} Configuration for cookie settings
      */
     setAuthCookies(response, tokenResponse) {
-        if (this.options.authMethod === AuthMethod.COOKIE && this.options.cookies) {
-            response.cookie(ACCESS_TOKEN_COOKIE_NAME, tokenResponse.accessToken, {
-                maxAge: this.options.jwt.expiresIn * SECOND_IN_MS,
+        if (this.options.authMethod === auth_1.AuthMethod.COOKIE && this.options.cookies) {
+            response.cookie(constants_1.ACCESS_TOKEN_COOKIE_NAME, tokenResponse.accessToken, {
+                maxAge: this.options.jwt.expiresIn * nest_connector_1.SECOND_IN_MS,
                 httpOnly: true,
                 sameSite: this.options.cookies.sameSite,
                 secure: this.options.cookies.secure,
                 signed: true,
             });
-            response.cookie(REFRESH_TOKEN_COOKIE_NAME, tokenResponse.refreshToken, {
-                maxAge: this.options.jwt.refreshExpiresIn * SECOND_IN_MS,
+            response.cookie(constants_1.REFRESH_TOKEN_COOKIE_NAME, tokenResponse.refreshToken, {
+                maxAge: this.options.jwt.refreshExpiresIn * nest_connector_1.SECOND_IN_MS,
                 httpOnly: true,
                 sameSite: this.options.cookies.sameSite,
                 secure: this.options.cookies.secure,
@@ -778,21 +781,21 @@ let AuthService = AuthService_1 = class AuthService {
         try {
             const { password: rawPass, ...rest } = signUpDto;
             const password = AuthService_1.generateHash(rawPass);
-            const user = await this.userService.signUpUser({ ...rest, password }, AuthProvider.LOCAL);
+            const user = await this.userService.signUpUser({ ...rest, password }, auth_1.AuthProvider.LOCAL);
             if (!user) {
-                throw new InternalServerErrorException(AuthErrors.AUTH_500_SIGN_UP);
+                throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500_SIGN_UP);
             }
             await this.sendVerificationEmail(user);
             user.password = null;
             await this.userService
                 .onSignUp?.(request, user.id)
-                .catch(callbackError => LoggerService.error("Error in onSignUp success callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onSignUp success callback:", callbackError));
             return user;
         }
         catch (error) {
             await this.userService
                 .onSignUp?.(request, undefined, error)
-                .catch(callbackError => LoggerService.error("Error in onSignUp error callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onSignUp error callback:", callbackError));
             throw error;
         }
     }
@@ -830,7 +833,7 @@ let AuthService = AuthService_1 = class AuthService {
         try {
             const user = await this.userService.getUserById(authUser.id);
             if (!user) {
-                throw new NotFoundException(AuthErrors.AUTH_401_UNKNOWN);
+                throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_401_UNKNOWN);
             }
             const { sessionId, accessToken, refreshToken } = authUser;
             const tokenResponse = {
@@ -842,7 +845,7 @@ let AuthService = AuthService_1 = class AuthService {
             this.setAuthCookies(res, tokenResponse);
             await this.userService
                 .onSignIn?.(req, authUser)
-                .catch(callbackError => LoggerService.error("Error in onSignIn success callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onSignIn success callback:", callbackError));
             return {
                 ...tokenResponse,
                 sessionId,
@@ -852,7 +855,7 @@ let AuthService = AuthService_1 = class AuthService {
         catch (error) {
             await this.userService
                 .onSignIn?.(req, authUser, error)
-                .catch(callbackError => LoggerService.error("Error in onSignIn error callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onSignIn error callback:", callbackError));
             throw error;
         }
     }
@@ -885,17 +888,17 @@ let AuthService = AuthService_1 = class AuthService {
         try {
             const user = await this.userService.getUserById(authUser.id);
             if (!user) {
-                throw new NotFoundException(AuthErrors.AUTH_401_UNKNOWN);
+                throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_401_UNKNOWN);
             }
             await this.userService
                 .onGetCurrentUser?.(request, authUser)
-                .catch(callbackError => LoggerService.error("Error in onGetCurrentUser success callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onGetCurrentUser success callback:", callbackError));
             return { ...user, password: null };
         }
         catch (error) {
             await this.userService
                 .onGetCurrentUser?.(request, authUser, error)
-                .catch(callbackError => LoggerService.error("Error in onGetCurrentUser error callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onGetCurrentUser error callback:", callbackError));
             throw error;
         }
     }
@@ -941,28 +944,28 @@ let AuthService = AuthService_1 = class AuthService {
             const { sub } = this.jwtTokenService.verifyRefreshToken(token);
             const user = await this.userService.getUserById(sub);
             if (!user) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_INVALID_REFRESH_TOKEN);
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_INVALID_REFRESH_TOKEN);
             }
             const tokenResponse = this.generateTokens(user);
             const cacheUser = await this.updateCacheUser(user, tokenResponse, token);
-            const authUser = generateAuthUser(cacheUser, tokenResponse.accessToken);
+            const authUser = (0, utils_1.generateAuthUser)(cacheUser, tokenResponse.accessToken);
             this.setAuthCookies(response, tokenResponse);
             await this.userService
                 .onRefreshTokens?.(request, authUser)
-                .catch(callbackError => LoggerService.error("Error in onRefreshTokens callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onRefreshTokens callback:", callbackError));
             return tokenResponse;
         }
         catch (error) {
-            if (error instanceof TokenExpiredError) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_EXPIRED_REFRESH_TOKEN);
+            if (error instanceof jwt_1.TokenExpiredError) {
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_EXPIRED_REFRESH_TOKEN);
             }
-            else if (error instanceof JsonWebTokenError) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_INVALID_REFRESH_TOKEN);
+            else if (error instanceof jwt_1.JsonWebTokenError) {
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_INVALID_REFRESH_TOKEN);
             }
-            else if (error instanceof HttpException) {
+            else if (error instanceof common_1.HttpException) {
                 throw error;
             }
-            throw new UnauthorizedException();
+            throw new common_1.UnauthorizedException();
         }
     }
     /**
@@ -1007,7 +1010,7 @@ let AuthService = AuthService_1 = class AuthService {
         try {
             const user = await this.userService.getUserById(authUser.id);
             if (!user) {
-                throw new UnauthorizedException(AuthErrors.AUTH_401_UNKNOWN);
+                throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_UNKNOWN);
             }
             if (user?.password) {
                 const { oldPassword, newPassword } = updatePasswordDto;
@@ -1016,21 +1019,24 @@ let AuthService = AuthService_1 = class AuthService {
                     const user = await this.userService.updateUserById(authUser.id, { password }, {
                         id: authUser.id,
                     });
+                    if (!user) {
+                        throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500_CHANGE_PASSWORD);
+                    }
                     user.password = null;
                     // Success callback with error logging
                     await this.userService
                         .onChangePassword?.(request, authUser)
-                        .catch(callbackError => LoggerService.error("Error in onChangePassword success callback:", callbackError));
+                        .catch(callbackError => nest_core_1.LoggerService.error("Error in onChangePassword success callback:", callbackError));
                     return user;
                 }
-                throw new NotFoundException(AuthErrors.AUTH_401_INVALID_PASSWORD);
+                throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_401_INVALID_PASSWORD);
             }
-            throw new ForbiddenException(AuthErrors.AUTH_401_NOT_LOCAL);
+            throw new common_1.ForbiddenException(auth_1.AuthErrors.AUTH_401_NOT_LOCAL);
         }
         catch (error) {
             await this.userService
                 .onChangePassword?.(request, authUser, error)
-                .catch(callbackError => LoggerService.error("Error in onChangePassword error callback:", callbackError));
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onChangePassword error callback:", callbackError));
             throw error;
         }
     }
@@ -1066,7 +1072,7 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async sendVerificationEmail(user) {
         if (!this.userService.sendVerificationEmail) {
-            throw new NotFoundException(Errors.ERROR_404_NOT_IMPLEMENTED);
+            throw new common_1.NotFoundException(nest_connector_1.Errors.ERROR_404_NOT_IMPLEMENTED);
         }
         try {
             const token = AuthService_1.generateVerifyToken();
@@ -1074,10 +1080,10 @@ let AuthService = AuthService_1 = class AuthService {
             await this.userService.sendVerificationEmail(user.id, token);
         }
         catch (error) {
-            if (error instanceof HttpException) {
+            if (error instanceof common_1.HttpException) {
                 throw error;
             }
-            throw new InternalServerErrorException(AuthErrors.AUTH_500_SEND_EMAIL_VERIFICATION);
+            throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500_SEND_EMAIL_VERIFICATION);
         }
     }
     /**
@@ -1119,20 +1125,20 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async resendEmailVerification(request, resendEmailVerifyDto) {
         if (!("getUserByEmail" in this.userService) || !this.userService.sendVerificationEmail) {
-            throw new NotFoundException(Errors.ERROR_404_NOT_IMPLEMENTED);
+            throw new common_1.NotFoundException(nest_connector_1.Errors.ERROR_404_NOT_IMPLEMENTED);
         }
         const user = await this.userService.getUserByEmail(resendEmailVerifyDto.email);
         if (user) {
             if (user.emailVerified) {
-                throw new BadRequestException(AuthErrors.AUTH_400_EMAIL_ALREADY_VERIFIED);
+                throw new common_1.BadRequestException(auth_1.AuthErrors.AUTH_400_EMAIL_ALREADY_VERIFIED);
             }
             await this.sendVerificationEmail(user);
             await this.userService
                 .onResendVerificationEmail?.(request, user.id)
-                .catch(callbackError => LoggerService.error("Error in onResendVerificationEmail callback:", callbackError));
-            return new SuccessResponseDto(AuthSuccessResponses.AUTH_200_EMAIL_VERIFICATION_SENT);
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onResendVerificationEmail callback:", callbackError));
+            return new nest_connector_1.SuccessResponseDto(auth_1.AuthSuccessResponses.AUTH_200_EMAIL_VERIFICATION_SENT);
         }
-        throw new NotFoundException(AuthErrors.AUTH_404_EMAIL);
+        throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_404_EMAIL);
     }
     /**
      * Verify a user's email address using a verification token
@@ -1172,7 +1178,7 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async verifyEmail(request, emailVerifyDto) {
         if (!this.userService.sendVerificationEmail) {
-            throw new NotFoundException(Errors.ERROR_404_NOT_IMPLEMENTED);
+            throw new common_1.NotFoundException(nest_connector_1.Errors.ERROR_404_NOT_IMPLEMENTED);
         }
         try {
             const userId = await this.tokenVerifyService.getUserIdByEmailVerifyToken(emailVerifyDto.token);
@@ -1184,16 +1190,16 @@ let AuthService = AuthService_1 = class AuthService {
                 // Success callback with error logging
                 await this.userService
                     .onVerifyEmail?.(request, userId, true)
-                    .catch(callbackError => LoggerService.error("Error in onVerifyEmail success callback:", callbackError));
+                    .catch(callbackError => nest_core_1.LoggerService.error("Error in onVerifyEmail success callback:", callbackError));
                 return true;
             }
             return false;
         }
         catch (error) {
-            if (error instanceof HttpException) {
+            if (error instanceof common_1.HttpException) {
                 throw error;
             }
-            throw new InternalServerErrorException(AuthErrors.AUTH_500_VERIFY_EMAIL);
+            throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500_VERIFY_EMAIL);
         }
     }
     /**
@@ -1236,15 +1242,15 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async requestPasswordReset(request, requestResetDto) {
         if (!("getUserByEmail" in this.userService) || !this.userService.sendPasswordResetEmail) {
-            throw new NotFoundException(Errors.ERROR_404_NOT_IMPLEMENTED);
+            throw new common_1.NotFoundException(nest_connector_1.Errors.ERROR_404_NOT_IMPLEMENTED);
         }
         try {
             const user = await this.userService.getUserByEmail(requestResetDto.email);
             if (!user) {
-                throw new NotFoundException(AuthErrors.AUTH_404_EMAIL);
+                throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_404_EMAIL);
             }
             if (!user.email) {
-                throw new InternalServerErrorException(AuthErrors.AUTH_500);
+                throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500);
             }
             const token = AuthService_1.generateVerifyToken();
             const setToken = await this.tokenVerifyService.savePasswordResetToken(user.id, token);
@@ -1253,16 +1259,16 @@ let AuthService = AuthService_1 = class AuthService {
                 // Success callback with error logging
                 await this.userService
                     .onRequestPasswordReset?.(request, user.id)
-                    .catch(callbackError => LoggerService.error("Error in onRequestPasswordReset callback:", callbackError));
-                return new SuccessResponseDto(AuthSuccessResponses.AUTH_200_PASSWORD_RESET_EMAIL_SENT);
+                    .catch(callbackError => nest_core_1.LoggerService.error("Error in onRequestPasswordReset callback:", callbackError));
+                return new nest_connector_1.SuccessResponseDto(auth_1.AuthSuccessResponses.AUTH_200_PASSWORD_RESET_EMAIL_SENT);
             }
-            throw new InternalServerErrorException(AuthErrors.AUTH_500_REQUEST_PASSWORD_RESET);
+            throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500_REQUEST_PASSWORD_RESET);
         }
         catch (error) {
-            if (error instanceof HttpException) {
+            if (error instanceof common_1.HttpException) {
                 throw error;
             }
-            throw new InternalServerErrorException(AuthErrors.AUTH_500_REQUEST_PASSWORD_RESET);
+            throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500_REQUEST_PASSWORD_RESET);
         }
     }
     /**
@@ -1309,16 +1315,16 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async verifyResetPasswordToken(request, verifyDto) {
         if (!("getUserByEmail" in this.userService) || !this.userService.sendPasswordResetEmail) {
-            throw new NotFoundException(Errors.ERROR_404_NOT_IMPLEMENTED);
+            throw new common_1.NotFoundException(nest_connector_1.Errors.ERROR_404_NOT_IMPLEMENTED);
         }
         const userId = await this.tokenVerifyService.getUserIdByPasswordResetToken(verifyDto.token);
         if (userId) {
             await this.userService
                 .onVerifyResetPasswordToken?.(request, userId)
-                .catch(callbackError => LoggerService.error("Error in onVerifyResetPasswordToken callback:", callbackError));
-            return new SuccessResponseDto(AuthSuccessResponses.AUTH_200_PASSWORD_RESET_TOKEN_VALID);
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onVerifyResetPasswordToken callback:", callbackError));
+            return new nest_connector_1.SuccessResponseDto(auth_1.AuthSuccessResponses.AUTH_200_PASSWORD_RESET_TOKEN_VALID);
         }
-        throw new UnauthorizedException(AuthErrors.AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN);
+        throw new common_1.UnauthorizedException(auth_1.AuthErrors.AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN);
     }
     /**
      * Reset a user's password using a reset token
@@ -1370,32 +1376,32 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async resetPassword(request, resetPasswordDto) {
         if (!("getUserByEmail" in this.userService) || !this.userService.sendPasswordResetEmail) {
-            throw new NotFoundException(Errors.ERROR_404_NOT_IMPLEMENTED);
+            throw new common_1.NotFoundException(nest_connector_1.Errors.ERROR_404_NOT_IMPLEMENTED);
         }
         try {
             const { token, password } = resetPasswordDto;
             const userId = await this.tokenVerifyService.getUserIdByPasswordResetToken(token);
             if (!userId) {
-                throw new NotFoundException(AuthErrors.AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN);
+                throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_401_EXPIRED_OR_INVALID_PASSWORD_RESET_TOKEN);
             }
             const hash = AuthService_1.generateHash(password);
             const user = await this.userService.updateUserById(userId, { password: hash }, {
                 id: userId,
             });
             if (!user) {
-                throw new NotFoundException(AuthErrors.AUTH_500_PASSWORD_RESET);
+                throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_500_PASSWORD_RESET);
             }
             await this.tokenVerifyService.clearPasswordResetTokenByUserId(userId);
             await this.userService
                 .onResetPassword?.(request, userId)
-                .catch(callbackError => LoggerService.error("Error in onResetPassword callback:", callbackError));
-            return new SuccessResponseDto(AuthSuccessResponses.AUTH_200_PASSWORD_RESET_SUCCESS);
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onResetPassword callback:", callbackError));
+            return new nest_connector_1.SuccessResponseDto(auth_1.AuthSuccessResponses.AUTH_200_PASSWORD_RESET_SUCCESS);
         }
         catch (error) {
-            if (error instanceof HttpException) {
+            if (error instanceof common_1.HttpException) {
                 throw error;
             }
-            throw new NotFoundException(AuthErrors.AUTH_500_PASSWORD_RESET);
+            throw new common_1.NotFoundException(auth_1.AuthErrors.AUTH_500_PASSWORD_RESET);
         }
     }
     /**
@@ -1436,15 +1442,15 @@ let AuthService = AuthService_1 = class AuthService {
      */
     async signOut(request, authUser, response) {
         try {
-            if (this.options.authMethod === AuthMethod.COOKIE && this.options.cookies) {
-                response.cookie(ACCESS_TOKEN_COOKIE_NAME, "", {
+            if (this.options.authMethod === auth_1.AuthMethod.COOKIE && this.options.cookies) {
+                response.cookie(constants_1.ACCESS_TOKEN_COOKIE_NAME, "", {
                     maxAge: 0,
                     httpOnly: true,
                     sameSite: this.options.cookies.sameSite,
                     secure: this.options.cookies.secure,
                     signed: true,
                 });
-                response.cookie(REFRESH_TOKEN_COOKIE_NAME, "", {
+                response.cookie(constants_1.REFRESH_TOKEN_COOKIE_NAME, "", {
                     maxAge: 0,
                     httpOnly: true,
                     sameSite: this.options.cookies.sameSite,
@@ -1473,27 +1479,27 @@ let AuthService = AuthService_1 = class AuthService {
             }
             await this.userService
                 .onSignOut?.(request, authUser)
-                .catch(callbackError => LoggerService.error("Error in onSignOut success callback:", callbackError));
-            return new SuccessResponseDto(AuthSuccessResponses.AUTH_200_SIGNED_OUT);
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onSignOut success callback:", callbackError));
+            return new nest_connector_1.SuccessResponseDto(auth_1.AuthSuccessResponses.AUTH_200_SIGNED_OUT);
         }
         catch (error) {
             await this.userService
                 .onSignOut?.(request, authUser, error)
-                .catch(callbackError => LoggerService.error("Error in onSignOut error callback:", callbackError));
-            if (error instanceof HttpException) {
+                .catch(callbackError => nest_core_1.LoggerService.error("Error in onSignOut error callback:", callbackError));
+            if (error instanceof common_1.HttpException) {
                 throw error;
             }
-            throw new InternalServerErrorException(AuthErrors.AUTH_500_SIGN_UP);
+            throw new common_1.InternalServerErrorException(auth_1.AuthErrors.AUTH_500_SIGN_UP);
         }
     }
 };
-AuthService = AuthService_1 = __decorate([
-    Injectable(),
-    __param(0, Inject(AUTH_OPTIONS)),
-    __param(1, Inject(USER_SERVICE)),
-    __metadata("design:paramtypes", [Object, Object, JwtTokenService,
-        UserCacheService,
-        TokenVerifyService])
+exports.AuthService = AuthService;
+exports.AuthService = AuthService = AuthService_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Inject)(tokens_1.AUTH_OPTIONS)),
+    tslib_1.__param(1, (0, common_1.Inject)(tokens_1.USER_SERVICE)),
+    tslib_1.__metadata("design:paramtypes", [Object, Object, jwt_token_service_1.JwtTokenService,
+        user_cache_service_1.UserCacheService,
+        token_verify_service_1.TokenVerifyService])
 ], AuthService);
-export { AuthService };
 //# sourceMappingURL=auth.service.js.map