@ackplus/nest-auth 0.1.51 → 1.1.1

package/src/lib/core/services/auth-provider-registry.service.ts

@@ -0,0 +1,93 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { BaseAuthProvider } from '../providers/base-auth.provider';
+import { EmailAuthProvider } from '../providers/email-auth.provider';
+import { PhoneAuthProvider } from '../providers/phone-auth.provider';
+import { AppleAuthProvider } from '../providers/apple-auth.provider';
+import { GoogleAuthProvider } from '../providers/google-auth.provider';
+import { JwtAuthProvider } from '../providers/jwt-auth.provider';
+import { FacebookAuthProvider } from '../providers/facebook-auth.provider';
+import { GitHubAuthProvider } from '../providers/github-auth.provider';
+import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
+import { AuthConfigService } from './auth-config.service';
+
+@Injectable()
+export class AuthProviderRegistryService {
+    private providers: Map<string, BaseAuthProvider> = new Map();
+    private options: AuthModuleOptions;
+
+    constructor(
+        private readonly emailAuthProvider: EmailAuthProvider,
+        private readonly phoneAuthProvider: PhoneAuthProvider,
+        private readonly jwtAuthProvider: JwtAuthProvider,
+        private readonly googleAuthProvider: GoogleAuthProvider,
+        private readonly facebookAuthProvider: FacebookAuthProvider,
+        private readonly appleAuthProvider: AppleAuthProvider,
+        private readonly githubAuthProvider: GitHubAuthProvider,
+    ) {
+
+        this.options = AuthConfigService.getOptions();
+
+        this.registerDefaultProviders();
+    }
+
+    registerDefaultProviders() {
+        if (this.options.emailAuth?.enabled) {
+            this.registerProvider(this.emailAuthProvider);
+        }
+        if (this.options.phoneAuth?.enabled) {
+            this.registerProvider(this.phoneAuthProvider);
+        }
+        if (this.options.jwt) {
+            this.registerProvider(this.jwtAuthProvider);
+        }
+        if (this.options.google) {
+            this.registerProvider(this.googleAuthProvider);
+        }
+        if (this.options.facebook) {
+            this.registerProvider(this.facebookAuthProvider);
+        }
+        if (this.options.apple) {
+            this.registerProvider(this.appleAuthProvider);
+        }
+        if (this.options.github) {
+            this.registerProvider(this.githubAuthProvider);
+        }
+    }
+
+    /**
+     * Register a provider
+     */
+    registerProvider(provider: BaseAuthProvider): void {
+        this.providers.set(provider.providerName, provider);
+    }
+
+    /**
+     * Get a provider by ID
+     */
+    getProvider(providerName: string): BaseAuthProvider | undefined {
+        return this.providers.get(providerName);
+    }
+
+    /**
+     * Get all registered providers
+     */
+    getAllProviders(): BaseAuthProvider[] {
+        return Array.from(this.providers.values());
+    }
+
+    /**
+     * Get all enabled providers
+     */
+    getEnabledProviders(): BaseAuthProvider[] {
+        return this.getAllProviders().filter(provider =>
+            'enabled' in provider ? provider.enabled : true
+        );
+    }
+
+    /**
+     * Check if a provider is registered
+     */
+    hasProvider(providerName: string): boolean {
+        return this.providers.has(providerName);
+    }
+}

package/src/lib/core/services/{debug-logger.service.js → debug-logger.service.ts}

@@ -1,31 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DebugLoggerService = exports.DebugLogLevel = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const auth_config_service_1 = require("./auth-config.service");
-var DebugLogLevel;
-(function (DebugLogLevel) {
-    DebugLogLevel["ERROR"] = "error";
-    DebugLogLevel["WARN"] = "warn";
-    DebugLogLevel["INFO"] = "info";
-    DebugLogLevel["DEBUG"] = "debug";
-    DebugLogLevel["VERBOSE"] = "verbose";
-})(DebugLogLevel || (exports.DebugLogLevel = DebugLogLevel = {}));
-let DebugLoggerService = class DebugLoggerService {
-    constructor(authConfig) {
-        this.authConfig = authConfig;
-        this.logger = new common_1.Logger('NestAuth');
-        this.config = {
-            enabled: false,
-            level: DebugLogLevel.VERBOSE,
-            prefix: '[NestAuth]',
-            includeTimestamp: true,
-            includeContext: true
-        };
+import { Injectable, Logger } from '@nestjs/common';
+import { AuthConfigService } from './auth-config.service';
+
+export enum DebugLogLevel {
+    ERROR = 'error',
+    WARN = 'warn',
+    INFO = 'info',
+    DEBUG = 'debug',
+    VERBOSE = 'verbose'
+}
+
+export interface DebugLogOptions {
+    enabled?: boolean;
+    level?: DebugLogLevel;
+    prefix?: string;
+    includeTimestamp?: boolean;
+    includeContext?: boolean;
+}
+
+@Injectable()
+export class DebugLoggerService {
+    private readonly logger = new Logger('NestAuth');
+    private config: DebugLogOptions = {
+        enabled: false,
+        level: DebugLogLevel.VERBOSE,
+        prefix: '[NestAuth]',
+        includeTimestamp: true,
+        includeContext: true
+    };
+
+    constructor(private readonly authConfig: AuthConfigService) {
         this.updateConfig();
     }
-    updateConfig() {
+
+    private updateConfig(): void {
         const authOptions = this.authConfig.getConfig();
         if (authOptions.debug) {
             this.config = {
@@ -34,9 +41,10 @@ let DebugLoggerService = class DebugLoggerService {
             };
         }
     }
-    shouldLog(level) {
-        if (!this.config.enabled)
-            return false;
+
+    private shouldLog(level: DebugLogLevel): boolean {
+        if (!this.config.enabled) return false;
+
         const levels = [
             DebugLogLevel.ERROR,
             DebugLogLevel.WARN,
@@ -44,113 +52,138 @@ let DebugLoggerService = class DebugLoggerService {
             DebugLogLevel.DEBUG,
             DebugLogLevel.VERBOSE
         ];
+
         const currentLevelIndex = levels.indexOf(this.config.level);
         const requestedLevelIndex = levels.indexOf(level);
+
         return requestedLevelIndex <= currentLevelIndex;
     }
-    formatMessage(message, context, data) {
+
+    private formatMessage(message: string, context?: string, data?: any): string {
         let formattedMessage = '';
+
         if (this.config.prefix) {
             formattedMessage += `${this.config.prefix} `;
         }
+
         if (this.config.includeTimestamp) {
             formattedMessage += `[${new Date().toISOString()}] `;
         }
+
         if (this.config.includeContext && context) {
             formattedMessage += `[${context}] `;
         }
+
         formattedMessage += message;
+
         if (data) {
             formattedMessage += ` | Data: ${JSON.stringify(data, null, 2)}`;
         }
+
         return formattedMessage;
     }
-    error(message, context, data, trace) {
+
+    error(message: string, context?: string, data?: any, trace?: string): void {
         if (this.shouldLog(DebugLogLevel.ERROR)) {
             this.logger.error(this.formatMessage(message, context, data), trace);
         }
     }
-    warn(message, context, data) {
+
+    warn(message: string, context?: string, data?: any): void {
         if (this.shouldLog(DebugLogLevel.WARN)) {
             this.logger.warn(this.formatMessage(message, context, data));
         }
     }
-    info(message, context, data) {
+
+    info(message: string, context?: string, data?: any): void {
         if (this.shouldLog(DebugLogLevel.INFO)) {
             this.logger.log(this.formatMessage(message, context, data));
         }
     }
-    debug(message, context, data) {
+
+    debug(message: string, context?: string, data?: any): void {
         if (this.shouldLog(DebugLogLevel.DEBUG)) {
             this.logger.debug(this.formatMessage(message, context, data));
         }
     }
-    verbose(message, context, data) {
+
+    verbose(message: string, context?: string, data?: any): void {
         if (this.shouldLog(DebugLogLevel.VERBOSE)) {
             this.logger.verbose(this.formatMessage(message, context, data));
         }
     }
-    logUserOperation(operation, userId, data) {
+
+    // Convenience methods for specific operations
+    logUserOperation(operation: string, userId?: string, data?: any): void {
         this.debug(`User Operation: ${operation}`, 'UserService', {
             userId,
             operation,
             ...data
         });
     }
-    logAuthOperation(operation, providerId, userId, data) {
+
+    logAuthOperation(operation: string, providerName?: string, userId?: string, data?: any): void {
         this.debug(`Auth Operation: ${operation}`, 'AuthService', {
             operation,
-            providerId,
+            providerName,
             userId,
             ...data
         });
     }
-    logRoleOperation(operation, roleId, data) {
+
+    logRoleOperation(operation: string, roleId?: string, data?: any): void {
         this.debug(`Role Operation: ${operation}`, 'RoleService', {
             operation,
             roleId,
             ...data
         });
     }
-    logTenantOperation(operation, tenantId, data) {
+
+    logTenantOperation(operation: string, tenantId?: string, data?: any): void {
         this.debug(`Tenant Operation: ${operation}`, 'TenantService', {
             operation,
             tenantId,
             ...data
         });
     }
-    logSessionOperation(operation, sessionId, data) {
+
+    logSessionOperation(operation: string, sessionId?: string, data?: any): void {
         this.debug(`Session Operation: ${operation}`, 'SessionService', {
             operation,
             sessionId,
             ...data
         });
     }
-    logPermissionOperation(operation, permissionId, data) {
+
+    logPermissionOperation(operation: string, permissionId?: string, data?: any): void {
         this.debug(`Permission Operation: ${operation}`, 'PermissionService', {
             operation,
             permissionId,
             ...data
         });
     }
-    logError(error, context, additionalData) {
-        this.error(`Error in ${context}: ${error.message}`, context, {
-            error: error.name,
-            message: error.message,
-            stack: error.stack,
-            ...additionalData
-        }, error.stack);
-    }
-    logFunctionEntry(functionName, context, params) {
+
+    // Method to log errors with full context
+    logError(error: Error, context: string, additionalData?: any): void {
+        this.error(
+            `Error in ${context}: ${error.message}`,
+            context,
+            {
+                error: error.name,
+                message: error.message,
+                stack: error.stack,
+                ...additionalData
+            },
+            error.stack
+        );
+    }
+
+    // Method to log function entry/exit for detailed debugging
+    logFunctionEntry(functionName: string, context: string, params?: any): void {
         this.verbose(`Entering function: ${functionName}`, context, { params });
     }
-    logFunctionExit(functionName, context, result) {
+
+    logFunctionExit(functionName: string, context: string, result?: any): void {
         this.verbose(`Exiting function: ${functionName}`, context, { result });
     }
-};
-exports.DebugLoggerService = DebugLoggerService;
-exports.DebugLoggerService = DebugLoggerService = tslib_1.__decorate([
-    (0, common_1.Injectable)(),
-    tslib_1.__metadata("design:paramtypes", [auth_config_service_1.AuthConfigService])
-], DebugLoggerService);
-//# sourceMappingURL=debug-logger.service.js.map
+}

package/src/lib/core/services/initialization.service.ts

@@ -0,0 +1,29 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { TenantService } from '../../tenant/services/tenant.service';
+import { AuthConfigService } from './auth-config.service';
+
+@Injectable()
+export class InitializationService implements OnModuleInit {
+    constructor(
+        private readonly tenantService: TenantService,
+        private readonly authConfig: AuthConfigService,
+    ) { }
+
+    async onModuleInit() {
+        // Initialize default tenant if configured
+        await this.initializeDefaultTenant();
+    }
+
+    private async initializeDefaultTenant(): Promise<void> {
+        try {
+            const config = this.authConfig.getConfig();
+
+            if (config.defaultTenant) {
+                await this.tenantService.initializeDefaultTenant();
+            }
+        } catch (error) {
+            // Log the error but don't fail module initialization
+            console.error('Failed to initialize default tenant:', error);
+        }
+    }
+}

package/src/lib/core/services/jwt.service.ts

@@ -0,0 +1,137 @@
+import { Injectable } from '@nestjs/common';
+import jwt from 'jsonwebtoken';
+import { AuthModuleOptions } from '../../core/interfaces/auth-module-options.interface';
+import { JWTTokenPayload } from '../../core/interfaces/token-payload.interface';
+import ms from 'ms';
+import { AuthConfigService } from './auth-config.service';
+
+
+@Injectable()
+export class JwtService {
+
+    private options: AuthModuleOptions;
+
+    constructor() {
+        this.options = AuthConfigService.getOptions();
+    }
+
+    async generateAccessToken(payload: Partial<JWTTokenPayload>): Promise<string> {
+        return new Promise((resolve, reject) => {
+            jwt.sign(
+                {
+                    ...payload,
+                    type: 'access',
+                    exp: Math.floor(Date.now() / 1000) + ms(this.options.session.sessionExpiry),
+                    iat: Math.floor(Date.now() / 1000),
+                },
+                this.options.jwt.secret,
+                (err, token) => {
+                    if (err) reject(err);
+                    else resolve(token);
+                },
+            );
+        });
+    }
+
+    async generateRefreshToken(payload: Partial<JWTTokenPayload>): Promise<string> {
+        return new Promise((resolve, reject) => {
+            jwt.sign(
+                {
+                    ...payload,
+                    type: 'refresh',
+                    exp: Math.floor(Date.now() / 1000) + ms(this.options.session.refreshTokenExpiry),
+                    iat: Math.floor(Date.now() / 1000),
+                },
+                this.options.jwt.secret,
+                (err, token) => {
+                    if (err) reject(err);
+                    else resolve(token);
+                },
+            );
+        });
+    }
+
+    async verifyToken(token: string): Promise<JWTTokenPayload> {
+        return new Promise((resolve, reject) => {
+            jwt.verify(
+                token,
+                this.options.jwt.secret,
+                (err, decoded) => {
+                    if (err) reject(err);
+                    else resolve(decoded as JWTTokenPayload);
+                },
+            );
+        });
+    }
+
+    async generateTokens(payload: Partial<JWTTokenPayload>): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }> {
+        const [accessToken, refreshToken] = await Promise.all([
+            this.generateAccessToken(payload),
+            this.generateRefreshToken(payload),
+        ]);
+
+        return {
+            accessToken,
+            refreshToken,
+        };
+    }
+
+    updateToken(token: string, payload: Partial<JWTTokenPayload>): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const decoded = this.decodeToken(token);
+            if (!decoded) reject(new Error('Invalid token'));
+            else {
+                jwt.sign({ ...decoded, ...payload }, this.options.jwt.secret, { expiresIn: this.options.session.sessionExpiry }, (err, token) => {
+                    if (err) reject(err);
+                    else resolve(token);
+                });
+            }
+        });
+    }
+
+    decodeToken(token: string): JWTTokenPayload | null {
+        try {
+            return jwt.decode(token) as JWTTokenPayload;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    getConfig(): AuthModuleOptions {
+        return this.options;
+    }
+
+    async generatePasswordResetToken(payload: { userId: string; passwordHashPrefix: string; type: string }): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const expiresIn = this.options.passwordResetTokenExpiresIn || '1h';
+            jwt.sign(
+                {
+                    ...payload,
+                    exp: Math.floor(Date.now() / 1000) + ms(expiresIn),
+                    iat: Math.floor(Date.now() / 1000),
+                },
+                this.options.jwt.secret,
+                (err, token) => {
+                    if (err) reject(err);
+                    else resolve(token);
+                },
+            );
+        });
+    }
+
+    async verifyPasswordResetToken(token: string): Promise<any> {
+        return new Promise((resolve, reject) => {
+            jwt.verify(
+                token,
+                this.options.jwt.secret,
+                (err, decoded) => {
+                    if (err) reject(err);
+                    else resolve(decoded);
+                },
+            );
+        });
+    }
+}

package/src/lib/nest-auth.module.ts

@@ -0,0 +1,152 @@
+import { Module, DynamicModule, MiddlewareConsumer, Provider } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { AuthModuleAsyncOptions, AuthModuleOptions, AuthModuleOptionsFactory } from './core/interfaces/auth-module-options.interface';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+import { RequestContextMiddleware } from './request-context/request-context.middleware';
+import { AuthModule } from './auth/auth.module';
+import { UserModule } from './user/user.module';
+import { RoleModule } from './role/role.module';
+import { SessionModule } from './session/session.module';
+import { TenantModule } from './tenant/tenant.module';
+import { CoreModule } from './core/core.module';
+import { AuthConfigService } from './core/services/auth-config.service';
+import { RefreshTokenInterceptor } from './auth/interceptors/refresh-token.interceptor';
+import { NEST_AUTH_ASYNC_OPTIONS_PROVIDER } from './auth.constants';
+import { AdminConsoleModule } from './admin-console/admin-console.module';
+
+
+@Module({})
+export class NestAuthModule {
+  static forRoot(options: AuthModuleOptions): DynamicModule {
+    const mergedOptions = this.getOptions(options);
+
+    // Set options in static service
+    AuthConfigService.setOptions(mergedOptions);
+
+    // Conditionally add refresh token interceptor (enabled by default)
+    const providers: Provider[] = [];
+    if (mergedOptions.enableAutoRefresh !== false) {
+      providers.push({
+        provide: APP_INTERCEPTOR,
+        useClass: RefreshTokenInterceptor,
+      });
+    }
+
+    return {
+      module: NestAuthModule,
+      global: mergedOptions.isGlobal,
+      imports: [
+        EventEmitterModule,
+        CoreModule,
+        AuthModule,
+        TenantModule,
+        UserModule,
+        RoleModule,
+        SessionModule,
+        AdminConsoleModule,
+      ],
+      providers,
+      exports: [
+        CoreModule,
+        AuthModule,
+        TenantModule,
+        UserModule,
+        RoleModule,
+        SessionModule,
+        AdminConsoleModule,
+      ],
+    };
+  }
+
+  static forRootAsync(options: AuthModuleAsyncOptions): DynamicModule {
+    const asyncProviders = this.createAsyncProviders(options);
+
+    // Add refresh token interceptor provider (enabled by default)
+    const providers: Provider[] = [...asyncProviders];
+    if (options.enableAutoRefresh !== false) {
+      providers.push({
+        provide: APP_INTERCEPTOR,
+        useClass: RefreshTokenInterceptor,
+      });
+    }
+
+    return {
+      module: NestAuthModule,
+      global: options.isGlobal,
+      imports: [
+        EventEmitterModule,
+        CoreModule,
+        AuthModule,
+        TenantModule,
+        UserModule,
+        RoleModule,
+        SessionModule,
+        ...(options.imports || []),
+      ],
+      providers,
+      exports: [
+        CoreModule,
+        AuthModule,
+        TenantModule,
+        UserModule,
+        RoleModule,
+        SessionModule,
+      ],
+    };
+  }
+
+  private static createAsyncProviders(options: AuthModuleAsyncOptions): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+
+    if (options.useClass) {
+      return [
+        this.createAsyncOptionsProvider(options),
+        {
+          provide: options.useClass,
+          useClass: options.useClass,
+        },
+      ];
+    }
+
+    return [];
+  }
+
+  private static createAsyncOptionsProvider(options: AuthModuleAsyncOptions): Provider {
+    if (options.useFactory) {
+      return {
+        provide: NEST_AUTH_ASYNC_OPTIONS_PROVIDER,
+        useFactory: async (...args: any[]) => {
+          const userOptions = await options.useFactory(...args);
+          const mergedOptions = this.getOptions(userOptions);
+          AuthConfigService.setOptions(mergedOptions);
+          return mergedOptions;
+        },
+        inject: options.inject || [],
+      };
+    }
+
+    return {
+      provide: NEST_AUTH_ASYNC_OPTIONS_PROVIDER,
+      useFactory: async (optionsFactory: AuthModuleOptionsFactory) => {
+        const userOptions = await optionsFactory.createAuthModuleOptions();
+        const mergedOptions = this.getOptions(userOptions);
+        AuthConfigService.setOptions(mergedOptions);
+        return mergedOptions;
+      },
+      inject: [options.useExisting || options.useClass!],
+    };
+  }
+
+  private static getOptions(options: AuthModuleOptions): AuthModuleOptions {
+    const deepmerge = require('deepmerge');
+    // Use default options from AuthConfigService - single source of truth
+    const defaultOptions = AuthConfigService.getDefaultOptions();
+    return deepmerge(defaultOptions, options);
+  }
+
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(RequestContextMiddleware).forRoutes('auth/*');
+  }
+}