@flusys/nestjs-auth 1.0.1 → 1.1.0

package/fesm/controllers/authentication.controller.js

@@ -34,26 +34,16 @@ import { ApiBearerAuth, ApiBody, ApiExtraModels, ApiHeader, ApiOperation, ApiRes
 import { SkipThrottle, Throttle } from '@nestjs/throttler';
 import { Request } from 'express';
 import { DEFAULT_COOKIE_NAME } from '../config';
-import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
 import { ClearToken } from '../interceptors/clear-token.interceptor';
 import { SetToken } from '../interceptors/set-token.interceptor';
 import { AuthConfigService } from '../services/auth-config.service';
-import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export class AuthenticationController {
     buildAuthUrl(req, path) {
         const frontendUrl = this.authConfig?.getFrontendUrl();
         return frontendUrl ? `${frontendUrl}${path}` : `${req.protocol}://${req.get('host')}${path}`;
     }
-    get emailService() {
-        if (!this.authEmailService) {
-            throw new Error('Email service is not configured');
-        }
-        return this.authEmailService;
-    }
-    get isEmailEnabled() {
-        return !!this.authEmailService;
-    }
     async login(loginDto) {
         const result = await this.authService.login(loginDto.email, loginDto.password);
         if ('requiresEmailVerification' in result) {
@@ -99,56 +89,11 @@ export class AuthenticationController {
             message: 'Password changed successfully'
         };
     }
-    async forgotPassword(req, dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.emailService.forgotPassword(dto.email, this.buildAuthUrl(req, '/auth/reset-password'));
-    }
-    async resetPassword(dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.emailService.resetPassword(dto.token, dto.newPassword);
-    }
-    async resendVerification(req, dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.emailService.resendVerificationEmail(dto.email, this.buildAuthUrl(req, '/auth/verify-email'));
-    }
-    /** Verify email - Verify email using token. Handles both pending registration and existing user verification. */ async verifyEmail(dto) {
-        if (!this.isEmailEnabled) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        const result = await this.emailService.verifyEmail(dto.token);
-        if (result.type === 'pending') {
-            return this.authService.createUserFromPendingRegistration(result.pending);
-        }
-        return {
-            success: true,
-            message: result.message
-        };
-    }
-    constructor(authService, authConfig, authEmailService){
+    constructor(authService, authConfig){
         _define_property(this, "authService", void 0);
         _define_property(this, "authConfig", void 0);
-        _define_property(this, "authEmailService", void 0);
         this.authService = authService;
         this.authConfig = authConfig;
-        this.authEmailService = authEmailService;
     }
 }
 _ts_decorate([
@@ -427,131 +372,15 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], AuthenticationController.prototype, "changePassword", null);
-_ts_decorate([
-    Post('forgot-password'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    ApiOperation({
-        summary: 'Request password reset email'
-    }),
-    ApiBody({
-        type: ForgotPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ForgotPasswordDto === "undefined" ? Object : ForgotPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "forgotPassword", null);
-_ts_decorate([
-    Post('reset-password'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 5,
-            ttl: 900000
-        }
-    }),
-    ApiOperation({
-        summary: 'Reset password using token'
-    }),
-    ApiBody({
-        type: ResetPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ResetPasswordDto === "undefined" ? Object : ResetPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "resetPassword", null);
-_ts_decorate([
-    Post('resend-verification'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 3,
-            ttl: 300000
-        }
-    }),
-    ApiOperation({
-        summary: 'Resend email verification link'
-    }),
-    ApiBody({
-        type: ResendVerificationDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ResendVerificationDto === "undefined" ? Object : ResendVerificationDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "resendVerification", null);
-_ts_decorate([
-    Post('verify-email'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 10,
-            ttl: 60000
-        }
-    }),
-    UseInterceptors(SetToken),
-    ApiOperation({
-        summary: 'Verify email using token'
-    }),
-    ApiBody({
-        type: VerifyEmailDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: RegistrationResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof VerifyEmailDto === "undefined" ? Object : VerifyEmailDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "verifyEmail", null);
 AuthenticationController = _ts_decorate([
     ApiTags('Authentication'),
     Controller('auth'),
     _ts_param(0, Inject(AuthenticationService)),
     _ts_param(1, Optional()),
     _ts_param(1, Inject(AuthConfigService)),
-    _ts_param(2, Optional()),
-    _ts_param(2, Inject(AuthEmailService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof AuthenticationService === "undefined" ? Object : AuthenticationService,
-        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
-        typeof AuthEmailService === "undefined" ? Object : AuthEmailService
+        typeof AuthConfigService === "undefined" ? Object : AuthConfigService
     ])
 ], AuthenticationController);

package/fesm/controllers/email-verification.controller.js

@@ -0,0 +1,210 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
+import { BadRequestException, Body, Controller, HttpCode, HttpStatus, Inject, Post, Req, UseInterceptors } from '@nestjs/common';
+import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { Throttle } from '@nestjs/throttler';
+import { Request } from 'express';
+import { ForgotPasswordDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
+import { SetToken } from '../interceptors/set-token.interceptor';
+import { AuthConfigService } from '../services/auth-config.service';
+import { AuthDataSourceProvider } from '../services/auth-datasource.provider';
+import { AuthEmailService } from '../services/auth-email.service';
+import { AuthenticationService } from '../services/authentication.service';
+export class EmailVerificationController {
+    ensureEmailVerificationEnabled() {
+        if (!this.dataSourceProvider.isEmailVerificationEnabled()) {
+            throw new BadRequestException('Email verification is not enabled for this tenant');
+        }
+    }
+    buildAuthUrl(req, path) {
+        const frontendUrl = this.authConfig.getFrontendUrl();
+        return frontendUrl ? `${frontendUrl}${path}` : `${req.protocol}://${req.get('host')}${path}`;
+    }
+    async forgotPassword(req, dto) {
+        this.ensureEmailVerificationEnabled();
+        return this.authEmailService.forgotPassword(dto.email, this.buildAuthUrl(req, '/auth/reset-password'));
+    }
+    async resetPassword(dto) {
+        this.ensureEmailVerificationEnabled();
+        return this.authEmailService.resetPassword(dto.token, dto.newPassword);
+    }
+    async resendVerification(req, dto) {
+        this.ensureEmailVerificationEnabled();
+        return this.authEmailService.resendVerificationEmail(dto.email, this.buildAuthUrl(req, '/auth/verify-email'));
+    }
+    async verifyEmail(dto) {
+        this.ensureEmailVerificationEnabled();
+        const result = await this.authEmailService.verifyEmail(dto.token);
+        if (result.type === 'pending') {
+            return this.authService.createUserFromPendingRegistration(result.pending);
+        }
+        return {
+            success: true,
+            message: result.message
+        };
+    }
+    constructor(authService, authEmailService, authConfig, dataSourceProvider){
+        _define_property(this, "authService", void 0);
+        _define_property(this, "authEmailService", void 0);
+        _define_property(this, "authConfig", void 0);
+        _define_property(this, "dataSourceProvider", void 0);
+        this.authService = authService;
+        this.authEmailService = authEmailService;
+        this.authConfig = authConfig;
+        this.dataSourceProvider = dataSourceProvider;
+    }
+}
+_ts_decorate([
+    Post('forgot-password'),
+    HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 3,
+            ttl: 300000
+        }
+    }),
+    ApiOperation({
+        summary: 'Request password reset email'
+    }),
+    ApiBody({
+        type: ForgotPasswordDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: MessageResponseDto
+    }),
+    _ts_param(0, Req()),
+    _ts_param(1, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Request === "undefined" ? Object : Request,
+        typeof ForgotPasswordDto === "undefined" ? Object : ForgotPasswordDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EmailVerificationController.prototype, "forgotPassword", null);
+_ts_decorate([
+    Post('reset-password'),
+    HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 5,
+            ttl: 900000
+        }
+    }),
+    ApiOperation({
+        summary: 'Reset password using token'
+    }),
+    ApiBody({
+        type: ResetPasswordDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: MessageResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ResetPasswordDto === "undefined" ? Object : ResetPasswordDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EmailVerificationController.prototype, "resetPassword", null);
+_ts_decorate([
+    Post('resend-verification'),
+    HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 3,
+            ttl: 300000
+        }
+    }),
+    ApiOperation({
+        summary: 'Resend email verification link'
+    }),
+    ApiBody({
+        type: ResendVerificationDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: MessageResponseDto
+    }),
+    _ts_param(0, Req()),
+    _ts_param(1, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Request === "undefined" ? Object : Request,
+        typeof ResendVerificationDto === "undefined" ? Object : ResendVerificationDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EmailVerificationController.prototype, "resendVerification", null);
+_ts_decorate([
+    Post('verify-email'),
+    HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 10,
+            ttl: 60000
+        }
+    }),
+    UseInterceptors(SetToken),
+    ApiOperation({
+        summary: 'Verify email using token'
+    }),
+    ApiBody({
+        type: VerifyEmailDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: MessageResponseDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: RegistrationResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof VerifyEmailDto === "undefined" ? Object : VerifyEmailDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EmailVerificationController.prototype, "verifyEmail", null);
+EmailVerificationController = _ts_decorate([
+    ApiTags('Authentication'),
+    Controller('auth'),
+    _ts_param(0, Inject(AuthenticationService)),
+    _ts_param(1, Inject(AuthEmailService)),
+    _ts_param(2, Inject(AuthConfigService)),
+    _ts_param(3, Inject(AuthDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof AuthenticationService === "undefined" ? Object : AuthenticationService,
+        typeof AuthEmailService === "undefined" ? Object : AuthEmailService,
+        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
+        typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider
+    ])
+], EmailVerificationController);

package/fesm/controllers/index.js

@@ -1,5 +1,6 @@
 export * from './authentication.controller';
 export * from './company-selection.controller';
+export * from './email-verification.controller';
 export * from './user.controller';
 export * from './company.controller';
 export * from './branch.controller';

package/fesm/entities/index.js

@@ -10,20 +10,28 @@ import { PendingRegistration } from './pending-registration.entity';
 import { UserCompanyPermission } from './user-company-permission.entity';
 import { User } from './user.entity';
 import { UserToken } from './user-token.entity';
-export const CoreEntities = [
+const BaseEntities = [
     User,
-    UserToken,
+    UserToken
+];
+const EmailEntities = [
     PendingRegistration
 ];
-export const CompanyEntities = [
+const CompanyEntities = [
     Company,
     CompanyBranch,
     UserCompanyPermission
 ];
-export const AllEntities = [
-    ...CoreEntities,
-    ...CompanyEntities
-];
-export function getEntitiesByConfig(enableCompanyFeature) {
-    return enableCompanyFeature ? AllEntities : CoreEntities;
+export function getEntitiesByConfig(config) {
+    const { enableCompanyFeature = false, enableEmailVerification = true } = config;
+    const entities = [
+        ...BaseEntities
+    ];
+    if (enableEmailVerification) {
+        entities.push(...EmailEntities);
+    }
+    if (enableCompanyFeature) {
+        entities.push(...CompanyEntities);
+    }
+    return entities;
 }

package/fesm/modules/auth.module.js

@@ -10,8 +10,8 @@ import { JwtModule } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
 import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { AUTH_MODULE_OPTIONS } from '../config/auth.constants';
-import { AuthenticationController, BranchController, CompanyController, CompanySelectionController, UserController, UserPermissionController } from '../controllers';
-import { Company, CompanyBranch, User, UserCompanyPermission } from '../entities';
+import { AuthenticationController, BranchController, CompanyController, CompanySelectionController, EmailVerificationController, UserController, UserPermissionController } from '../controllers';
+import { getEntitiesByConfig } from '../entities';
 import { ClearToken } from '../interceptors/clear-token.interceptor';
 import { SetToken } from '../interceptors/set-token.interceptor';
 import { AuthEmailService, AuthenticationService, BranchService, CompanySelectionSessionService, CompanyService, UserPermissionService, UserService } from '../services';
@@ -36,9 +36,9 @@ export class AuthModule {
             ...options.providers ?? []
         ], options.imports);
     }
-    /** Build the dynamic module with shared logic */ static buildModule(options, providers, externalImports = []) {
+    static buildModule(options, providers, externalImports = []) {
         const { global = false, includeController = true, bootstrapAppConfig } = options;
-        const enableCompanyFeature = bootstrapAppConfig?.enableCompanyFeature ?? false;
+        const featureFlags = this.getFeatureFlags(bootstrapAppConfig);
         return {
             module: AuthModule,
             global,
@@ -46,15 +46,21 @@ export class AuthModule {
                 ...externalImports,
                 ...this.buildImports()
             ],
-            controllers: this.buildControllers(includeController, enableCompanyFeature),
+            controllers: this.buildControllers(includeController, featureFlags),
             providers: [
                 ...providers,
-                ...this.buildProviders(enableCompanyFeature)
+                ...this.buildProviders(featureFlags)
             ],
-            exports: this.buildExports(enableCompanyFeature)
+            exports: this.buildExports(featureFlags)
         };
     }
-    /** Common module imports */ static buildImports() {
+    static getFeatureFlags(bootstrapAppConfig) {
+        return {
+            enableCompanyFeature: bootstrapAppConfig?.enableCompanyFeature ?? false,
+            enableEmailVerification: bootstrapAppConfig?.enableEmailVerification ?? true
+        };
+    }
+    static buildImports() {
         return [
             PassportModule.register({
                 defaultStrategy: 'jwt'
@@ -64,35 +70,40 @@ export class AuthModule {
             UtilsModule
         ];
     }
-    /** Build controllers based on feature flags */ static buildControllers(includeController, enableCompanyFeature) {
+    static buildControllers(includeController, flags) {
         if (!includeController) return [];
         const controllers = [
             AuthenticationController,
             UserController
         ];
-        if (enableCompanyFeature) {
+        if (flags.enableEmailVerification) {
+            controllers.push(EmailVerificationController);
+        }
+        if (flags.enableCompanyFeature) {
             controllers.push(CompanySelectionController, CompanyController, BranchController, UserPermissionController);
         }
         return controllers;
     }
-    /** Core providers (without AUTH_MODULE_OPTIONS - that's added separately) */ static buildProviders(enableCompanyFeature) {
+    static buildProviders(flags) {
         const providers = [
             AuthConfigService,
             AuthDataSourceProvider,
             JwtStrategy,
             JwtAuthGuard,
             AuthenticationService,
-            AuthEmailService,
             SetToken,
             ClearToken,
             UserService
         ];
-        if (enableCompanyFeature) {
+        if (flags.enableEmailVerification) {
+            providers.push(AuthEmailService);
+        }
+        if (flags.enableCompanyFeature) {
             providers.push(CompanySelectionSessionService, CompanyService, BranchService, UserPermissionService);
         }
         return providers;
     }
-    /** Build module exports */ static buildExports(enableCompanyFeature) {
+    static buildExports(flags) {
         const exports = [
             PassportModule,
             AUTH_MODULE_OPTIONS,
@@ -101,15 +112,17 @@ export class AuthModule {
             JwtStrategy,
             JwtAuthGuard,
             AuthenticationService,
-            AuthEmailService,
             UserService
         ];
-        if (enableCompanyFeature) {
+        if (flags.enableEmailVerification) {
+            exports.push(AuthEmailService);
+        }
+        if (flags.enableCompanyFeature) {
             exports.push(CompanySelectionSessionService, CompanyService, BranchService, UserPermissionService);
         }
         return exports;
     }
-    /** Create async providers for forRootAsync */ static createAsyncProviders(options) {
+    static createAsyncProviders(options) {
         const staticOptions = {
             global: options.global,
             includeController: options.includeController,
@@ -166,15 +179,11 @@ export class AuthModule {
             }
         ];
     }
-    /** Get auth entities based on feature flags */ static getEntities(enableCompanyFeature = false) {
-        return enableCompanyFeature ? [
-            User,
-            Company,
-            CompanyBranch,
-            UserCompanyPermission
-        ] : [
-            User
-        ];
+    static getEntities(config) {
+        return getEntitiesByConfig({
+            enableCompanyFeature: config.enableCompanyFeature ?? false,
+            enableEmailVerification: config.enableEmailVerification ?? true
+        });
     }
 }
 AuthModule = _ts_decorate([

package/fesm/services/auth-config.service.js

@@ -25,6 +25,7 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
+import { envConfig } from '@flusys/nestjs-core/config';
 import { Inject, Injectable, InternalServerErrorException, Logger, Optional } from '@nestjs/common';
 import { AUTH_MODULE_OPTIONS } from '../config/auth.constants';
 import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
@@ -40,21 +41,24 @@ export class AuthConfigService {
     isCompanyFeatureEnabled() {
         return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
     }
+    isEmailVerificationEnabled() {
+        return this.options.bootstrapAppConfig?.enableEmailVerification ?? true;
+    }
     // JWT Configuration
-    /** Get JWT secret key */ getJwtSecret() {
+    getJwtSecret() {
         if (!this.config.jwtSecret) {
             throw new InternalServerErrorException('[AuthModule] JWT_SECRET is required - set via environment or module config');
         }
         return this.config.jwtSecret;
     }
-    /** Get JWT expiration time */ getJwtExpiration() {
+    getJwtExpiration() {
         return this.config.jwtExpiration ?? '1h';
     }
-    /** Get refresh token secret key */ getRefreshTokenSecret() {
+    getRefreshTokenSecret() {
         if (this.config.refreshTokenSecret) {
             return this.config.refreshTokenSecret;
         }
-        if (process.env.NODE_ENV === 'production') {
+        if (envConfig.isProduction()) {
             throw new InternalServerErrorException('[AuthModule] REFRESH_TOKEN_SECRET is required in production - ' + 'using the same secret for access and refresh tokens is a security risk');
         }
         if (!this.refreshTokenSecretWarned) {
@@ -63,14 +67,14 @@ export class AuthConfigService {
         }
         return this.getJwtSecret();
     }
-    /** Get refresh token expiration time */ getRefreshTokenExpiration() {
+    getRefreshTokenExpiration() {
         return this.config.refreshTokenExpiration ?? '7d';
     }
-    /** Get refresh token cookie name */ getRefreshTokenCookieName() {
+    getRefreshTokenCookieName() {
         return this.config.refreshTokenCookieName ?? 'fsn_refresh_token';
     }
     // Frontend Configuration
-    /** Get frontend URL for email links */ getFrontendUrl() {
+    getFrontendUrl() {
         return this.config.frontendUrl;
     }
     constructor(injectedOptions){