@ackplus/nest-auth 1.1.1 → 1.1.5

package/src/lib/session/services/{session-manager.service.ts → session-manager.service.js}

@@ -1,178 +1,140 @@
-import { Injectable, UnauthorizedException, Inject } from '@nestjs/common';
-import { ISessionRepository } from '../interfaces/session-repository.interface';
-import { NestAuthSession } from '../entities/session.entity';
-import { SessionPayload } from '../../core/interfaces/token-payload.interface';
-import { AuthModuleOptions } from '../../core/interfaces/auth-module-options.interface';
-import { AuthConfigService } from '../../core/services/auth-config.service';
-import { RequestContext } from '../../request-context/request-context';
-import { NestAuthUser } from '../../user/entities/user.entity';
-import { v4 as uuidv4 } from 'uuid';
-import ms from 'ms';
-
-export const SESSION_REPOSITORY = 'SESSION_REPOSITORY';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManagerService = exports.SESSION_REPOSITORY = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const auth_config_service_1 = require("../../core/services/auth-config.service");
+const request_context_1 = require("../../request-context/request-context");
+const uuid_1 = require("uuid");
+const ms_1 = tslib_1.__importDefault(require("ms"));
+exports.SESSION_REPOSITORY = 'SESSION_REPOSITORY';
 /**
  * High-level session manager
  * Handles session lifecycle using repository pattern
  */
-@Injectable()
-export class SessionManagerService {
-    private options: AuthModuleOptions;
-    private readonly maxSessionsPerUser: number;
-    private readonly slidingExpiration: boolean;
-
-    constructor(
-        @Inject(SESSION_REPOSITORY)
-        private readonly repository: ISessionRepository,
-    ) {
-        this.options = AuthConfigService.getOptions();
+let SessionManagerService = class SessionManagerService {
+    constructor(repository) {
+        this.repository = repository;
+        this.options = auth_config_service_1.AuthConfigService.getOptions();
         this.maxSessionsPerUser = this.options.session?.maxSessionsPerUser || 10;
         this.slidingExpiration = this.options.session?.slidingExpiration ?? true;
     }
-
     /**
      * Create a new session
      */
-    async createSession(payload: {
-        userId: string;
-        refreshToken?: string;
-        data?: any;
-        userAgent?: string;
-        deviceName?: string;
-        ipAddress?: string;
-    }): Promise<NestAuthSession> {
+    async createSession(payload) {
         const { userId, refreshToken, data, userAgent, deviceName, ipAddress } = payload;
-
         // Check max sessions limit
         await this.enforceMaxSessions(userId);
-
-        const sessionPayload: SessionPayload = {
-            id: uuidv4(),
+        const sessionPayload = {
+            id: (0, uuid_1.v4)(),
             userId,
             refreshToken: refreshToken || '',
             data: data || {},
             expiresAt: this.calculateExpiration(),
-            userAgent: userAgent || RequestContext.currentRequest()?.headers['user-agent'] || 'Unknown',
-            deviceName: deviceName || RequestContext.getDeviceInfo().deviceName,
-            ipAddress: ipAddress || RequestContext.getDeviceInfo().ipAddress,
+            userAgent: userAgent || request_context_1.RequestContext.currentRequest()?.headers['user-agent'] || 'Unknown',
+            deviceName: deviceName || request_context_1.RequestContext.getDeviceInfo().deviceName,
+            ipAddress: ipAddress || request_context_1.RequestContext.getDeviceInfo().ipAddress,
             lastActive: new Date(),
         };
-
         return await this.repository.create(sessionPayload);
     }
-
     /**
      * Get session by ID and optionally refresh it
      */
-    async getSession(sessionId: string, refreshSession = true): Promise<NestAuthSession> {
+    async getSession(sessionId, refreshSession = true) {
         const session = await this.repository.findById(sessionId);
-
         if (!session) {
-            throw new UnauthorizedException('Session not found');
+            throw new common_1.UnauthorizedException('Session not found');
         }
-
         // Check if expired
         if (this.isExpired(session)) {
             await this.repository.delete(sessionId);
-            throw new UnauthorizedException('Session expired');
+            throw new common_1.UnauthorizedException('Session expired');
         }
-
         // Update last active if sliding expiration enabled
         if (refreshSession && this.slidingExpiration) {
             await this.repository.updateLastActive(sessionId);
         }
-
         return session;
     }
-
     /**
      * Get all sessions for a user
      */
-    async getUserSessions(userId: string): Promise<NestAuthSession[]> {
+    async getUserSessions(userId) {
         return await this.repository.findByUserId(userId);
     }
-
     /**
      * Get active sessions for a user
      */
-    async getActiveSessions(userId: string): Promise<NestAuthSession[]> {
+    async getActiveSessions(userId) {
         return await this.repository.findActiveByUserId(userId);
     }
-
     /**
      * Update session data
      */
-    async updateSession(sessionId: string, updates: Partial<NestAuthSession>): Promise<NestAuthSession> {
+    async updateSession(sessionId, updates) {
         return await this.repository.update(sessionId, updates);
     }
-
     /**
      * Revoke (delete) a session
      */
-    async revokeSession(sessionId: string): Promise<void> {
+    async revokeSession(sessionId) {
         await this.repository.delete(sessionId);
     }
-
     /**
      * Revoke all sessions for a user
      */
-    async revokeAllUserSessions(userId: string): Promise<void> {
+    async revokeAllUserSessions(userId) {
         await this.repository.deleteByUserId(userId);
     }
-
     /**
      * Revoke all sessions except the current one
      */
-    async revokeOtherSessions(userId: string, currentSessionId: string): Promise<void> {
+    async revokeOtherSessions(userId, currentSessionId) {
         const sessions = await this.repository.findByUserId(userId);
-
         for (const session of sessions) {
             if (session.id !== currentSessionId) {
                 await this.repository.delete(session.id);
             }
         }
     }
-
     /**
      * Clean up expired sessions
      */
-    async cleanupExpiredSessions(): Promise<number> {
+    async cleanupExpiredSessions() {
         return await this.repository.deleteExpired();
     }
-
     /**
      * Extend session expiration
      */
-    async extendSession(sessionId: string, duration?: string): Promise<NestAuthSession> {
+    async extendSession(sessionId, duration) {
         const expiresAt = this.calculateExpiration(duration);
-        return await this.repository.update(sessionId, { expiresAt } as any);
+        return await this.repository.update(sessionId, { expiresAt });
     }
-
     /**
      * Validate session and return it if valid
      */
-    async validateSession(sessionId: string): Promise<NestAuthSession | null> {
+    async validateSession(sessionId) {
         try {
             return await this.getSession(sessionId, true);
-        } catch {
+        }
+        catch {
             return null;
         }
     }
-
     /**
      * Check if user has reached max sessions limit
      */
-    async hasReachedMaxSessions(userId: string): Promise<boolean> {
+    async hasReachedMaxSessions(userId) {
         const count = await this.repository.countActiveByUserId(userId);
         return count >= this.maxSessionsPerUser;
     }
-
     /**
      * Enforce max sessions per user by removing oldest sessions
      */
-    private async enforceMaxSessions(userId: string): Promise<void> {
+    async enforceMaxSessions(userId) {
         const activeSessions = await this.repository.findActiveByUserId(userId);
-
         if (activeSessions.length >= this.maxSessionsPerUser) {
             // Sort by lastActive (oldest first)
             const sorted = activeSessions.sort((a, b) => {
@@ -180,7 +142,6 @@ export class SessionManagerService {
                 const bTime = b.lastActive?.getTime() || 0;
                 return aTime - bTime;
             });
-
             // Remove oldest session(s)
             const toRemove = sorted.slice(0, activeSessions.length - this.maxSessionsPerUser + 1);
             for (const session of toRemove) {
@@ -188,39 +149,34 @@ export class SessionManagerService {
             }
         }
     }
-
     /**
      * Calculate session expiration date
      */
-    private calculateExpiration(duration?: string): Date {
+    calculateExpiration(duration) {
         const expiryDuration = duration || this.options.session?.sessionExpiry || '7d';
-        const milliseconds = ms(expiryDuration);
+        const milliseconds = (0, ms_1.default)(expiryDuration);
         return new Date(Date.now() + milliseconds);
     }
-
     /**
      * Check if session is expired
      */
-    private isExpired(session: NestAuthSession): boolean {
-        if (!session.expiresAt) return false;
+    isExpired(session) {
+        if (!session.expiresAt)
+            return false;
         return new Date() > new Date(session.expiresAt);
     }
-
     /**
      * Create session from user (helper method from old BaseSessionService)
      * For backward compatibility with AuthService
      */
-    async createSessionFromUser(user: NestAuthUser, extraData: { isMfaVerified?: boolean } = {}): Promise<NestAuthSession> {
-        const { deviceName, ipAddress, browser } = RequestContext.getDeviceInfo();
+    async createSessionFromUser(user, extraData = {}) {
+        const { deviceName, ipAddress, browser } = request_context_1.RequestContext.getDeviceInfo();
         const { isMfaVerified = false } = extraData;
-
         if (!user) {
-            throw new UnauthorizedException('User not found');
+            throw new common_1.UnauthorizedException('User not found');
         }
-
         const roles = await user.getRoles();
         const permissions = await user.getPermissions();
-
         // Create session using createSession method
         return await this.createSession({
             userId: user.id,
@@ -235,12 +191,11 @@ export class SessionManagerService {
             deviceName,
         });
     }
-
     /**
      * Create new session from existing session (for refresh)
      * For backward compatibility with AuthService
      */
-    async createSessionFromSession(session: NestAuthSession): Promise<NestAuthSession> {
+    async createSessionFromSession(session) {
         return await this.createSession({
             userId: session.userId,
             refreshToken: session.refreshToken,
@@ -250,12 +205,17 @@ export class SessionManagerService {
             ipAddress: session.ipAddress,
         });
     }
-
     /**
      * Get current active sessions for a user
      * For backward compatibility with AuthService
      */
-    async getCurrentSessions(userId: string): Promise<NestAuthSession[]> {
+    async getCurrentSessions(userId) {
         return await this.getActiveSessions(userId);
     }
-}
+};
+exports.SessionManagerService = SessionManagerService;
+exports.SessionManagerService = SessionManagerService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Inject)(exports.SESSION_REPOSITORY)),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], SessionManagerService);

package/src/lib/session/session.module.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Session Module
+ *
+ * DEFAULT: Uses TypeORM (Database) for session storage
+ * OPTIONAL: Can use Redis if configured (requires ioredis packages)
+ */
+export declare class SessionModule {
+    /**
+     * Create Redis repository instance
+     * Only called if Redis storage is configured
+     */
+    private static createRedisRepository;
+}
+//# sourceMappingURL=session.module.d.ts.map

package/src/lib/session/session.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.module.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-auth/src/lib/session/session.module.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,qBA0Ca,aAAa;IACtB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;CAsCvC"}

package/src/lib/session/session.module.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const session_entity_1 = require("./entities/session.entity");
+const session_manager_service_1 = require("./services/session-manager.service");
+const typeorm_session_repository_1 = require("./repositories/typeorm-session.repository");
+const memory_session_repository_1 = require("./repositories/memory-session.repository");
+const core_module_1 = require("../core/core.module");
+const session_options_interface_1 = require("../core/interfaces/session-options.interface");
+const auth_config_service_1 = require("../core/services/auth-config.service");
+/**
+ * Session Module
+ *
+ * DEFAULT: Uses TypeORM (Database) for session storage
+ * OPTIONAL: Can use Redis if configured (requires ioredis packages)
+ */
+let SessionModule = class SessionModule {
+    /**
+     * Create Redis repository instance
+     * Only called if Redis storage is configured
+     */
+    static createRedisRepository(redisUrl) {
+        let RedisSessionRepository;
+        let ioredisModule;
+        let redisClient;
+        // Try to load Redis modules
+        try {
+            // Lazy load Redis repository
+            RedisSessionRepository = require('./repositories/redis-session.repository').RedisSessionRepository;
+            ioredisModule = require('@nestjs-modules/ioredis');
+            const Redis = require('ioredis').default || require('ioredis');
+            // Create Redis client
+            if (redisUrl) {
+                redisClient = new Redis(redisUrl);
+            }
+            else {
+                redisClient = new Redis(); // Uses default localhost:6379
+            }
+            // Return repository instance
+            return new RedisSessionRepository(redisClient);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('Cannot find module')) {
+                throw new Error('❌ Redis session storage is configured but packages are not installed.\n' +
+                    '   Install them with: npm install ioredis @nestjs-modules/ioredis\n' +
+                    '   Or change session.storageType to SessionStorageType.DATABASE');
+            }
+            throw new Error(`❌ Failed to initialize Redis session storage: ${errorMessage}\n` +
+                '   Make sure Redis server is running and accessible.');
+        }
+    }
+};
+exports.SessionModule = SessionModule;
+exports.SessionModule = SessionModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        imports: [
+            typeorm_1.TypeOrmModule.forFeature([session_entity_1.NestAuthSession]),
+            (0, common_1.forwardRef)(() => core_module_1.CoreModule),
+        ],
+        providers: [
+            // Repository implementations
+            typeorm_session_repository_1.TypeORMSessionRepository,
+            memory_session_repository_1.MemorySessionRepository,
+            // Session Repository Provider (dynamically chooses storage)
+            {
+                provide: session_manager_service_1.SESSION_REPOSITORY,
+                useFactory: (typeormRepo) => {
+                    const config = auth_config_service_1.AuthConfigService.getOptions();
+                    const storageType = config.session?.storageType || session_options_interface_1.SessionStorageType.DATABASE;
+                    // Handle Redis storage
+                    if (storageType === session_options_interface_1.SessionStorageType.REDIS) {
+                        return SessionModule.createRedisRepository(config.session?.redisUrl);
+                    }
+                    if (storageType === session_options_interface_1.SessionStorageType.MEMORY) {
+                        return new memory_session_repository_1.MemorySessionRepository();
+                    }
+                    // Default to database storage
+                    return typeormRepo;
+                },
+                inject: [typeorm_session_repository_1.TypeORMSessionRepository],
+            },
+            // Session Manager
+            session_manager_service_1.SessionManagerService,
+        ],
+        exports: [
+            session_manager_service_1.SESSION_REPOSITORY,
+            session_manager_service_1.SessionManagerService,
+            typeorm_session_repository_1.TypeORMSessionRepository,
+            memory_session_repository_1.MemorySessionRepository,
+        ],
+    })
+], SessionModule);

package/src/lib/session/utils/session.util.d.ts

@@ -0,0 +1,73 @@
+import { NestAuthSession } from '../entities/session.entity';
+/**
+ * Session utility functions
+ */
+export declare class SessionUtil {
+    /**
+     * Extract session metadata (device, location, etc.)
+     */
+    static extractMetadata(session: NestAuthSession): {
+        device: string;
+        ip: string;
+        location?: string;
+        browser?: string;
+        os?: string;
+    };
+    /**
+     * Calculate remaining session time
+     */
+    static getRemainingTime(session: NestAuthSession): {
+        milliseconds: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        formatted: string;
+    };
+    /**
+     * Check if session is about to expire (within threshold)
+     */
+    static isExpiringSoon(session: NestAuthSession, thresholdMs?: number): boolean;
+    /**
+     * Check if session is expired
+     */
+    static isExpired(session: NestAuthSession): boolean;
+    /**
+     * Check if session is active (not expired)
+     */
+    static isActive(session: NestAuthSession): boolean;
+    /**
+     * Format session for display
+     */
+    static formatForDisplay(session: NestAuthSession): {
+        id: string;
+        device: string;
+        ipAddress: string;
+        lastActive: string;
+        expiresAt: string;
+        isActive: boolean;
+        isCurrent?: boolean;
+    };
+    /**
+     * Sanitize session data (remove sensitive information)
+     */
+    static sanitize(session: NestAuthSession): Partial<NestAuthSession>;
+    /**
+     * Compare two sessions
+     */
+    static isSameDevice(session1: NestAuthSession, session2: NestAuthSession): boolean;
+    /**
+     * Get session age
+     */
+    static getAge(session: NestAuthSession): {
+        milliseconds: number;
+        formatted: string;
+    };
+    /**
+     * Get idle time (time since last activity)
+     */
+    static getIdleTime(session: NestAuthSession): {
+        milliseconds: number;
+        formatted: string;
+    };
+}
+//# sourceMappingURL=session.util.d.ts.map

package/src/lib/session/utils/session.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.util.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nest-auth/src/lib/session/utils/session.util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAI7D;;GAEG;AACH,qBAAa,WAAW;IACpB;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG;QAC9C,MAAM,EAAE,MAAM,CAAC;QACf,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,EAAE,CAAC,EAAE,MAAM,CAAC;KACf;IAQD;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG;QAC/C,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;KACrB;IA4BD;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,WAAW,GAAE,MAAsB,GAAG,OAAO;IAK7F;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO;IAKnD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO;IAIlD;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG;QAC/C,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,OAAO,CAAC;KACvB;IAeD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAKnE;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAE,eAAe,GAAG,OAAO;IAQlF;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,GAAG;QACrC,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KACrB;IAYD;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG;QAC1C,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KACrB;CAWJ"}