@ackplus/nest-auth 1.1.1 → 1.1.2

package/src/lib/auth/guards/{auth.guard.ts → auth.guard.js}

@@ -1,18 +1,18 @@
-import { Injectable, CanActivate, ExecutionContext, UnauthorizedException, ForbiddenException } from '@nestjs/common';
-import { UNAUTHORIZED_EXCEPTION_CODE } from '../../auth.constants';
-import { Reflector } from '@nestjs/core';
-import { Request, Response } from 'express';
-import { JwtService } from '../../core/services/jwt.service';
-import { SessionManagerService } from '../../session/services/session-manager.service';
-import { AccessKeyService } from '../../user/services/access-key.service';
-import { JWTTokenPayload } from '../../core/interfaces/token-payload.interface';
-import { SKIP_MFA_KEY } from '../../core/decorators/skip-mfa.decorator';
-import { PERMISSIONS_KEY } from '../../core/decorators/permissions.decorator';
-import { ROLES_KEY } from '../../core/decorators/role.decorator';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestAuthAuthGuard = exports.OPTIONAL_AUTH_KEY = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const auth_constants_1 = require("../../auth.constants");
+const core_1 = require("@nestjs/core");
+const jwt_service_1 = require("../../core/services/jwt.service");
+const session_manager_service_1 = require("../../session/services/session-manager.service");
+const access_key_service_1 = require("../../user/services/access-key.service");
+const skip_mfa_decorator_1 = require("../../core/decorators/skip-mfa.decorator");
+const permissions_decorator_1 = require("../../core/decorators/permissions.decorator");
+const role_decorator_1 = require("../../core/decorators/role.decorator");
 // Key for optional auth metadata
-export const OPTIONAL_AUTH_KEY = 'optional_auth';
-
+exports.OPTIONAL_AUTH_KEY = 'optional_auth';
 /**
  * NestAuthAuthGuard
  *
@@ -27,59 +27,53 @@ export const OPTIONAL_AUTH_KEY = 'optional_auth';
  *
  * Note: For automatic token refresh, enable RefreshTokenInterceptor globally.
  */
-@Injectable()
-export class NestAuthAuthGuard implements CanActivate {
-    constructor(
-        private reflector: Reflector,
-        private jwtService: JwtService,
-        private sessionManager: SessionManagerService,
-        private accessKeyService: AccessKeyService,
-    ) { }
-
-    async canActivate(context: ExecutionContext): Promise<boolean> {
-        const request = context.switchToHttp().getRequest<Request>() as any;
-        const response = context.switchToHttp().getResponse<Response>();
-
+let NestAuthAuthGuard = class NestAuthAuthGuard {
+    constructor(reflector, jwtService, sessionManager, accessKeyService) {
+        this.reflector = reflector;
+        this.jwtService = jwtService;
+        this.sessionManager = sessionManager;
+        this.accessKeyService = accessKeyService;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
         // Check if authentication is optional
-        const isOptional = this.reflector.getAllAndOverride<boolean>(OPTIONAL_AUTH_KEY, [
+        const isOptional = this.reflector.getAllAndOverride(exports.OPTIONAL_AUTH_KEY, [
             context.getHandler(),
             context.getClass(),
         ]);
-
         // Initialize request properties
         request.user = null;
         request.session = null;
         request.accessKey = null;
         request.authType = null;
-
         const authHeader = request.headers.authorization;
-
         // If no auth header
         if (!authHeader) {
             if (isOptional) {
                 // Optional auth: allow request to proceed without user data
                 return true;
-            } else {
+            }
+            else {
                 // Required auth: throw error
-                throw new UnauthorizedException({
+                throw new common_1.UnauthorizedException({
                     message: 'No authentication provided',
                     code: 'NO_AUTH'
                 });
             }
         }
-
         const [type, token] = authHeader.split(' ');
         if (!type || !token) {
             if (isOptional) {
                 return true;
-            } else {
-                throw new UnauthorizedException({
+            }
+            else {
+                throw new common_1.UnauthorizedException({
                     message: 'Invalid authentication format',
                     code: 'INVALID_AUTH_FORMAT'
                 });
             }
         }
-
         // Handle authentication
         let isAuthenticated = false;
         try {
@@ -94,95 +88,93 @@ export class NestAuthAuthGuard implements CanActivate {
                     if (isOptional) {
                         // Invalid auth type, but optional - proceed without user data
                         return true;
-                    } else {
-                        throw new UnauthorizedException({
+                    }
+                    else {
+                        throw new common_1.UnauthorizedException({
                             message: 'Invalid authentication type',
                             code: 'INVALID_AUTH_TYPE'
                         });
                     }
             }
-        } catch (error) {
+        }
+        catch (error) {
             if (isOptional) {
                 // If optional auth fails, silently proceed without user data
                 return true;
-            } else {
+            }
+            else {
                 // If required auth fails, re-throw the error
                 throw error;
             }
         }
-
         // If authentication failed and it's required, stop here
         if (!isAuthenticated && !isOptional) {
             return false;
         }
-
         // After successful authentication, check authorization (roles, permissions)
         // Only check authorization if user is authenticated
         if (isAuthenticated && request.user) {
             await this.checkAuthorization(context, request);
         }
-
         return true;
     }
-
-    private async handleJwtAuth(context: ExecutionContext, request: any, response: Response, token: string, isOptional: boolean = false): Promise<boolean> {
+    async handleJwtAuth(context, request, response, token, isOptional = false) {
         try {
             // Verify the JWT token
             const payload = await this.jwtService.verifyToken(token);
             request.user = payload;
             request.authType = 'jwt';
-
             // Verify session exists
-            const session = await this.sessionManager.getSession(payload.sessionId as string);
+            const session = await this.sessionManager.getSession(payload.sessionId);
             if (!session) {
                 if (isOptional) {
                     // Session not found but auth is optional - reset user data and continue
                     request.user = null;
                     request.authType = null;
                     return false;
-                } else {
-                    throw new UnauthorizedException({
+                }
+                else {
+                    throw new common_1.UnauthorizedException({
                         message: 'Session not found',
-                        code: UNAUTHORIZED_EXCEPTION_CODE
+                        code: auth_constants_1.UNAUTHORIZED_EXCEPTION_CODE
                     });
                 }
             }
-
             request.session = session;
-
             // Check MFA requirements
             await this.checkMfa(context, payload, isOptional);
             return true;
-        } catch (error) {
+        }
+        catch (error) {
             // Token verification failed
             // Note: Token refresh is handled by RefreshTokenInterceptor
             if (isOptional) {
                 // Auth is optional - continue without user data
                 return false;
-            } else {
-                throw new UnauthorizedException({
+            }
+            else {
+                throw new common_1.UnauthorizedException({
                     message: 'Invalid or expired token',
-                    code: UNAUTHORIZED_EXCEPTION_CODE
+                    code: auth_constants_1.UNAUTHORIZED_EXCEPTION_CODE
                 });
             }
         }
     }
-
-    private async handleApiKeyAuth(request: any, token: string, isOptional: boolean = false): Promise<boolean> {
+    async handleApiKeyAuth(request, token, isOptional = false) {
         // Split the token into public and private parts
         const [publicKey, privateKey] = token.split('.');
         if (!publicKey || !privateKey) {
             if (isOptional) {
                 // Invalid format but auth is optional - continue without user data
                 return false;
-            } else {
-                throw new UnauthorizedException({
+            }
+            else {
+                throw new common_1.UnauthorizedException({
                     message: 'Invalid API key format',
                     code: 'INVALID_API_KEY_FORMAT'
                 });
             }
         }
-
         try {
             // Validate API key pair
             const isValid = await this.accessKeyService.validateAccessKey(publicKey, privateKey);
@@ -190,197 +182,162 @@ export class NestAuthAuthGuard implements CanActivate {
                 if (isOptional) {
                     // Invalid API key but auth is optional - continue without user data
                     return false;
-                } else {
-                    throw new UnauthorizedException({
+                }
+                else {
+                    throw new common_1.UnauthorizedException({
                         message: 'Invalid API key',
                         code: 'INVALID_API_KEY'
                     });
                 }
             }
-
             // Get access key details
             const accessKey = await this.accessKeyService.getAccessKey(publicKey);
-
             // Update last used timestamp
             await this.accessKeyService.updateAccessKeyLastUsed(publicKey);
-
             // Attach user and access key to request
             request.user = accessKey.user;
             request.accessKey = accessKey;
             request.authType = 'api-key';
-
             return true;
-        } catch (error) {
+        }
+        catch (error) {
             if (isOptional) {
                 // API key validation failed but auth is optional - continue without user data
                 return false;
-            } else {
+            }
+            else {
                 throw error;
             }
         }
     }
-
-
-    private async checkMfa(context: ExecutionContext, payload: JWTTokenPayload, isOptional: boolean = false): Promise<void> {
+    async checkMfa(context, payload, isOptional = false) {
         // Check if MFA should be skipped
-        const skipMfa = this.reflector.getAllAndOverride<boolean>(SKIP_MFA_KEY, [
+        const skipMfa = this.reflector.getAllAndOverride(skip_mfa_decorator_1.SKIP_MFA_KEY, [
             context.getHandler(),
             context.getClass(),
         ]);
-
         // Get MFA status from token
         const isMfaEnabled = payload.isMfaEnabled;
         const isMfaVerified = payload.isMfaVerified;
-
         // If MFA is enabled and not verified, and route is not marked to skip MFA, require MFA verification
         if (isMfaEnabled && !isMfaVerified && !skipMfa) {
             if (isOptional) {
                 // MFA required but auth is optional - this creates a conflict
                 // In this case, we should not set user data since MFA is not verified
                 throw new Error('MFA verification required - cannot proceed with optional auth');
-            } else {
-                throw new UnauthorizedException({
+            }
+            else {
+                throw new common_1.UnauthorizedException({
                     message: 'Multi-factor authentication is required',
-                    code: UNAUTHORIZED_EXCEPTION_CODE
+                    code: auth_constants_1.UNAUTHORIZED_EXCEPTION_CODE
                 });
             }
         }
     }
-
     /**
      * Check authorization (roles, permissions) after successful authentication
      */
-    private async checkAuthorization(context: ExecutionContext, request: Request): Promise<void> {
+    async checkAuthorization(context, request) {
         // Get required permissions and roles from decorators
         const requiredPermissions = this.getRequiredPermissions(context);
         const requiredRoles = this.getRequiredRoles(context);
-
         // If no authorization requirements, allow access
         if (!requiredPermissions.length && !requiredRoles.length) {
             return;
         }
-
         const user = request.user;
-
         // Check if user exists
         if (!user) {
-            throw new ForbiddenException('Access denied: User not authenticated');
+            throw new common_1.ForbiddenException('Access denied: User not authenticated');
         }
-
         // Check roles if required
         if (requiredRoles.length > 0) {
             this.checkRoles(user, requiredRoles);
         }
-
         // Check permissions if required
         if (requiredPermissions.length > 0) {
             this.checkPermissions(user, requiredPermissions);
         }
     }
-
     /**
      * Get required permissions from decorator
      */
-    private getRequiredPermissions(context: ExecutionContext): string[] {
-        let permissions = this.reflector.getAllAndOverride<string[] | string>(
-            PERMISSIONS_KEY,
-            [context.getHandler(), context.getClass()],
-        );
-
+    getRequiredPermissions(context) {
+        let permissions = this.reflector.getAllAndOverride(permissions_decorator_1.PERMISSIONS_KEY, [context.getHandler(), context.getClass()]);
         if (!permissions) {
             return [];
         }
-
         // Normalize to array
         return typeof permissions === 'string' ? [permissions] : permissions;
     }
-
     /**
      * Get required roles from decorator
      */
-    private getRequiredRoles(context: ExecutionContext): string[] {
-        let roles = this.reflector.getAllAndOverride<string[] | string>(
-            ROLES_KEY,
-            [context.getHandler(), context.getClass()],
-        );
-
+    getRequiredRoles(context) {
+        let roles = this.reflector.getAllAndOverride(role_decorator_1.ROLES_KEY, [context.getHandler(), context.getClass()]);
         if (!roles) {
             return [];
         }
-
         // Normalize to array
         return typeof roles === 'string' ? [roles] : roles;
     }
-
     /**
      * Check if user has required roles
      */
-    private checkRoles(user: any, requiredRoles: string[]): void {
+    checkRoles(user, requiredRoles) {
         if (!user.roles || !Array.isArray(user.roles)) {
-            throw new ForbiddenException('Access denied: No roles assigned');
+            throw new common_1.ForbiddenException('Access denied: No roles assigned');
         }
-
         // Get active role names
         const userRoleNames = user.roles
             .filter(role => role.isActive)
             .map(role => role.name);
-
         // Check if user has all required roles
         const hasAllRoles = requiredRoles.every(role => userRoleNames.includes(role));
-
         if (!hasAllRoles) {
             const missingRoles = requiredRoles.filter(role => !userRoleNames.includes(role));
-            throw new ForbiddenException(
-                `Access denied: Missing required roles: ${missingRoles.join(', ')}`
-            );
+            throw new common_1.ForbiddenException(`Access denied: Missing required roles: ${missingRoles.join(', ')}`);
         }
     }
-
     /**
      * Check if user has required permissions
      */
-    private checkPermissions(user: any, requiredPermissions: string[]): void {
+    checkPermissions(user, requiredPermissions) {
         if (!user.roles || !Array.isArray(user.roles)) {
-            throw new ForbiddenException('Access denied: No roles assigned for permission check');
+            throw new common_1.ForbiddenException('Access denied: No roles assigned for permission check');
         }
-
         // Get all permissions from user's roles
         const userPermissions = this.getUserPermissions(user.roles);
-
         // Check if user has all required permissions
-        const hasAllPermissions = requiredPermissions.every(permission =>
-            userPermissions.includes(permission)
-        );
-
+        const hasAllPermissions = requiredPermissions.every(permission => userPermissions.includes(permission));
         if (!hasAllPermissions) {
-            const missingPermissions = requiredPermissions.filter(permission =>
-                !userPermissions.includes(permission)
-            );
-
-            throw new ForbiddenException(
-                `Access denied: Missing required permissions: ${missingPermissions.join(', ')}`
-            );
+            const missingPermissions = requiredPermissions.filter(permission => !userPermissions.includes(permission));
+            throw new common_1.ForbiddenException(`Access denied: Missing required permissions: ${missingPermissions.join(', ')}`);
         }
     }
-
     /**
      * Extract all permissions from user's roles
      */
-    private getUserPermissions(roles: any[]): string[] {
-        const permissions = new Set<string>();
-
+    getUserPermissions(roles) {
+        const permissions = new Set();
         roles.forEach(role => {
             // Skip inactive roles
             if (!role.isActive) {
                 return;
             }
-
             // Add permissions from this role
             if (role.permissions && Array.isArray(role.permissions)) {
                 role.permissions.forEach(permission => permissions.add(permission));
             }
         });
-
         return Array.from(permissions);
     }
-}
+};
+exports.NestAuthAuthGuard = NestAuthAuthGuard;
+exports.NestAuthAuthGuard = NestAuthAuthGuard = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [core_1.Reflector,
+        jwt_service_1.JwtService,
+        session_manager_service_1.SessionManagerService,
+        access_key_service_1.AccessKeyService])
+], NestAuthAuthGuard);

package/src/lib/auth/{index.ts → index.d.ts}

@@ -1,11 +1,6 @@
-// Guards
 export * from './guards/auth.guard';
 export { OPTIONAL_AUTH_KEY } from './guards/auth.guard';
-
-// Interceptors
 export * from './interceptors/refresh-token.interceptor';
-
-// Events
 export * from './events/logged-out-all.event';
 export * from './events/logged-out.event';
 export * from './events/password-reset-requested.event';
@@ -14,18 +9,12 @@ export * from './events/user-2fa-verified.event';
 export * from './events/user-logged-in.event';
 export * from './events/user-refresh-token.event';
 export * from './events/user-registered.event';
-
-// Services
 export * from './services/auth.service';
 export * from './services/cookie.service';
 export * from './services/mfa.service';
 export * from './services/client-config.service';
-
-// Controllers
 export * from './controllers/auth.controller';
 export * from './controllers/mfa.controller';
-
-// DTOs
 export * from './dto/requests/login.request.dto';
 export * from './dto/requests/signup.request.dto';
 export * from './dto/credentials/social-credentials.dto';
@@ -46,7 +35,6 @@ export * from './dto/responses/auth-cookie.response.dto';
 export * from './dto/responses/verify-otp.response.dto';
 export * from './dto/responses/mfa-status.response.dto';
 export * from './dto/responses/client-config.response.dto';
-
-// Entities
 export * from './entities/otp.entity';
 export * from './entities/mfa-secret.entity';
+//# sourceMappingURL=index.d.ts.map

package/src/lib/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-auth/src/lib/auth/index.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD,cAAc,0CAA0C,CAAC;AAGzD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yCAAyC,CAAC;AACxD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAG/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC;AAGjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAG7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,0CAA0C,CAAC;AACzD,cAAc,yCAAyC,CAAC;AACxD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,sDAAsD,CAAC;AACrE,cAAc,uDAAuD,CAAC;AACtE,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uCAAuC,CAAC;AACtD,cAAc,0CAA0C,CAAC;AACzD,cAAc,uCAAuC,CAAC;AACtD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,mCAAmC,CAAC;AAClD,cAAc,0CAA0C,CAAC;AACzD,cAAc,yCAAyC,CAAC;AACxD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAG3D,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC"}

package/src/lib/auth/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTIONAL_AUTH_KEY = void 0;
+const tslib_1 = require("tslib");
+// Guards
+tslib_1.__exportStar(require("./guards/auth.guard"), exports);
+var auth_guard_1 = require("./guards/auth.guard");
+Object.defineProperty(exports, "OPTIONAL_AUTH_KEY", { enumerable: true, get: function () { return auth_guard_1.OPTIONAL_AUTH_KEY; } });
+// Interceptors
+tslib_1.__exportStar(require("./interceptors/refresh-token.interceptor"), exports);
+// Events
+tslib_1.__exportStar(require("./events/logged-out-all.event"), exports);
+tslib_1.__exportStar(require("./events/logged-out.event"), exports);
+tslib_1.__exportStar(require("./events/password-reset-requested.event"), exports);
+tslib_1.__exportStar(require("./events/password-reset.event"), exports);
+tslib_1.__exportStar(require("./events/user-2fa-verified.event"), exports);
+tslib_1.__exportStar(require("./events/user-logged-in.event"), exports);
+tslib_1.__exportStar(require("./events/user-refresh-token.event"), exports);
+tslib_1.__exportStar(require("./events/user-registered.event"), exports);
+// Services
+tslib_1.__exportStar(require("./services/auth.service"), exports);
+tslib_1.__exportStar(require("./services/cookie.service"), exports);
+tslib_1.__exportStar(require("./services/mfa.service"), exports);
+tslib_1.__exportStar(require("./services/client-config.service"), exports);
+// Controllers
+tslib_1.__exportStar(require("./controllers/auth.controller"), exports);
+tslib_1.__exportStar(require("./controllers/mfa.controller"), exports);
+// DTOs
+tslib_1.__exportStar(require("./dto/requests/login.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/signup.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/credentials/social-credentials.dto"), exports);
+tslib_1.__exportStar(require("./dto/credentials/email-credentials.dto"), exports);
+tslib_1.__exportStar(require("./dto/credentials/phone-credentials.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/forgot-password.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/reset-password.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/reset-password-with-token.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/verify-forgot-password-otp-request-dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/send-mfa-code.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/change-password.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/toggle-mfa.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/refresh-token.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/verify-2fa.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/requests/verify-totp-setup.request.dto"), exports);
+tslib_1.__exportStar(require("./dto/responses/auth.response.dto"), exports);
+tslib_1.__exportStar(require("./dto/responses/auth-cookie.response.dto"), exports);
+tslib_1.__exportStar(require("./dto/responses/verify-otp.response.dto"), exports);
+tslib_1.__exportStar(require("./dto/responses/mfa-status.response.dto"), exports);
+tslib_1.__exportStar(require("./dto/responses/client-config.response.dto"), exports);
+// Entities
+tslib_1.__exportStar(require("./entities/otp.entity"), exports);
+tslib_1.__exportStar(require("./entities/mfa-secret.entity"), exports);

package/src/lib/auth/interceptors/refresh-token.interceptor.d.ts

@@ -0,0 +1,43 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { AuthService } from '../services/auth.service';
+import { CookieService } from '../services/cookie.service';
+import { JwtService } from '../../core/services/jwt.service';
+import { AuthConfigService } from '../../core/services/auth-config.service';
+/**
+ * RefreshTokenInterceptor
+ *
+ * Automatically handles token refresh when access token is expired.
+ * This interceptor runs before guards and catches token expiration errors,
+ * attempting to refresh the token transparently.
+ *
+ * Token delivery method (header vs cookie) respects the `accessTokenType` configuration:
+ * - If `accessTokenType: 'header'` (default): Updates Authorization header only
+ * - If `accessTokenType: 'cookie'`: Sets tokens in cookies
+ *
+ * Apply this globally to handle token refresh across your entire application.
+ *
+ * @example
+ * ```typescript
+ * // In AppModule or NestAuthModule configuration
+ * providers: [
+ *   {
+ *     provide: APP_INTERCEPTOR,
+ *     useClass: RefreshTokenInterceptor,
+ *   },
+ * ]
+ * ```
+ */
+export declare class RefreshTokenInterceptor implements NestInterceptor {
+    private readonly authService;
+    private readonly cookieService;
+    private readonly jwtService;
+    private readonly authConfig;
+    constructor(authService: AuthService, cookieService: CookieService, jwtService: JwtService, authConfig: AuthConfigService);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
+    /**
+     * Extract refresh token from cookies or headers
+     */
+    private extractRefreshToken;
+}
+//# sourceMappingURL=refresh-token.interceptor.d.ts.map

package/src/lib/auth/interceptors/refresh-token.interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh-token.interceptor.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nest-auth/src/lib/auth/interceptors/refresh-token.interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,eAAe,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAc,MAAM,MAAM,CAAC;AAG9C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAG5E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBACa,uBAAwB,YAAW,eAAe;IAEvD,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAHV,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,iBAAiB;IAG5C,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAuDvF;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAe9B"}