@flusys/nestjs-shared 7.1.0 → 8.0.0

package/fesm/filters/global-exception.filter.spec.js

@@ -1,436 +0,0 @@
-import { HttpException, HttpStatus, Logger } from '@nestjs/common';
-import { QueryFailedError } from 'typeorm';
-const mockGetRequestId = jest.fn();
-const mockGetUserId = jest.fn();
-const mockGetTenantId = jest.fn();
-const mockGetCompanyId = jest.fn();
-jest.mock('../middlewares/logger.middleware', ()=>({
-        getRequestId: (...args)=>mockGetRequestId(...args),
-        getUserId: (...args)=>mockGetUserId(...args),
-        getTenantId: (...args)=>mockGetTenantId(...args),
-        getCompanyId: (...args)=>mockGetCompanyId(...args)
-    }));
-import { GlobalExceptionFilter } from './global-exception.filter';
-import { BaseAppException, ConflictException } from '../exceptions/base-app.exception';
-import { ERROR_MESSAGES } from '../constants/message-keys';
-function makeQueryFailedError(driverError, message = 'db error') {
-    const err = new QueryFailedError('SELECT 1', [], new Error(message));
-    Object.assign(err, driverError);
-    return err;
-}
-describe('GlobalExceptionFilter', ()=>{
-    let filter;
-    let errorSpy;
-    let warnSpy;
-    let request;
-    let response;
-    let host;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        filter = new GlobalExceptionFilter();
-        errorSpy = jest.spyOn(Logger.prototype, 'error').mockImplementation(()=>undefined);
-        warnSpy = jest.spyOn(Logger.prototype, 'warn').mockImplementation(()=>undefined);
-        jest.spyOn(Logger.prototype, 'log').mockImplementation(()=>undefined);
-        mockGetRequestId.mockReturnValue(undefined);
-        mockGetUserId.mockReturnValue(undefined);
-        mockGetTenantId.mockReturnValue(undefined);
-        mockGetCompanyId.mockReturnValue(undefined);
-        request = {
-            headers: {},
-            method: 'GET',
-            originalUrl: '/api/users',
-            path: '/api/users'
-        };
-        response = {
-            status: jest.fn().mockReturnThis(),
-            json: jest.fn()
-        };
-        host = {
-            switchToHttp: ()=>({
-                    getRequest: ()=>request,
-                    getResponse: ()=>response
-                })
-        };
-    });
-    afterEach(()=>{
-        errorSpy.mockRestore();
-        warnSpy.mockRestore();
-    });
-    describe('request id resolution', ()=>{
-        it('should prefer the AsyncLocalStorage request id', ()=>{
-            mockGetRequestId.mockReturnValue('ctx-request-id');
-            request.headers['x-request-id'] = 'header-request-id';
-            filter.catch(new Error('boom'), host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload._meta.requestId).toBe('ctx-request-id');
-        });
-        it('should fall back to the x-request-id header', ()=>{
-            request.headers['x-request-id'] = 'header-request-id';
-            filter.catch(new Error('boom'), host);
-            expect(response.json.mock.calls[0][0]._meta.requestId).toBe('header-request-id');
-        });
-        it('should default to "no-request-id" when nothing is available', ()=>{
-            filter.catch(new Error('boom'), host);
-            expect(response.json.mock.calls[0][0]._meta.requestId).toBe('no-request-id');
-        });
-    });
-    describe('BaseAppException handling', ()=>{
-        it('should use the exception status, message, messageKey, and variables', ()=>{
-            const exception = new ConflictException('User', 'email');
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.CONFLICT);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload).toMatchObject({
-                success: false,
-                message: 'User with this email already exists',
-                messageKey: ERROR_MESSAGES.CONFLICT,
-                messageVariables: {
-                    entity: 'User',
-                    field: 'email'
-                }
-            });
-        });
-        it('should include validation errors when present', ()=>{
-            const exception = new BaseAppException({
-                message: 'Validation failed',
-                messageKey: ERROR_MESSAGES.VALIDATION,
-                status: HttpStatus.BAD_REQUEST,
-                errors: [
-                    {
-                        field: 'email',
-                        message: 'must be an email'
-                    }
-                ]
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.errors).toEqual([
-                {
-                    field: 'email',
-                    message: 'must be an email'
-                }
-            ]);
-        });
-    });
-    describe('HttpException handling', ()=>{
-        it('should use the string response body as the message', ()=>{
-            const exception = new HttpException('Not allowed', HttpStatus.FORBIDDEN);
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.FORBIDDEN);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Not allowed');
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.HTTP);
-        });
-        it('should convert an array of validation messages into structured errors', ()=>{
-            const exception = new HttpException({
-                message: [
-                    'email must be a valid email',
-                    'age must not be less than 0'
-                ]
-            }, HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Validation failed');
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.VALIDATION);
-            expect(payload.errors).toEqual([
-                {
-                    field: 'email',
-                    message: 'must be a valid email'
-                },
-                {
-                    field: 'age',
-                    message: 'must not be less than 0'
-                }
-            ]);
-        });
-        it('should fall back the message when a validation message has no spaces', ()=>{
-            const exception = new HttpException({
-                message: [
-                    'required'
-                ]
-            }, HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.errors).toEqual([
-                {
-                    field: 'required',
-                    message: 'required'
-                }
-            ]);
-        });
-        it('should use the object messageKey/messageVariables/errors when present', ()=>{
-            const exception = new HttpException({
-                message: 'Custom message',
-                messageKey: 'custom.key',
-                messageVariables: {
-                    foo: 'bar'
-                },
-                errors: [
-                    {
-                        field: 'x',
-                        message: 'y'
-                    }
-                ]
-            }, HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload).toMatchObject({
-                message: 'Custom message',
-                messageKey: 'custom.key',
-                messageVariables: {
-                    foo: 'bar'
-                },
-                errors: [
-                    {
-                        field: 'x',
-                        message: 'y'
-                    }
-                ]
-            });
-        });
-        it('should default to Unknown error/HTTP messageKey when the object has no message', ()=>{
-            const exception = new HttpException({}, HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Unknown error');
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.HTTP);
-        });
-        it('should handle a non-string/non-object response body', ()=>{
-            const exception = new HttpException(42, HttpStatus.BAD_REQUEST);
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Unknown error');
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.UNKNOWN);
-        });
-    });
-    describe('QueryFailedError handling', ()=>{
-        it('should map a postgres unique violation (23505) to a conflict', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23505',
-                    detail: 'Key (email)=(a@b.com) already exists.',
-                    table: 'users'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.CONFLICT);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.CONFLICT);
-            expect(payload.message).toContain('Email');
-        });
-        it('should map a mysql duplicate entry (ER_DUP_ENTRY) to a conflict using the sqlMessage key name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: 'ER_DUP_ENTRY',
-                    sqlMessage: "Duplicate entry 'a@b.com' for key 'users.email_UNIQUE'",
-                    table: 'users'
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.CONFLICT);
-        });
-        it('should map an mssql duplicate constraint (2627) to a conflict', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    number: 2627,
-                    table: 'users'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.CONFLICT);
-        });
-        it('should fall back to "record" when no table name is available for a duplicate', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23505'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].message).toContain('Record');
-        });
-        it('should map a foreign key violation (23503) to a bad request', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23503',
-                    detail: 'Key (company_id)=(x) is not present in table "companies".'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.BAD_REQUEST);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.DB_FOREIGN_KEY);
-            expect(payload.message).toContain('Company ID');
-        });
-        it('should map a mysql foreign key violation via errno 1452', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    errno: 1452,
-                    sqlMessage: 'Cannot add or update a child row: a foreign key constraint fails (FOREIGN KEY (`company_id`) ...)'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.DB_FOREIGN_KEY);
-        });
-        it('should map a not-null violation (23502) with the human-readable column name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23502',
-                    column: 'user_name'
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.DB_NOT_NULL);
-            expect(payload.message).toContain('User Name');
-        });
-        it('should map a mysql not-null violation using the sqlMessage column name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: 'ER_BAD_NULL_ERROR',
-                    sqlMessage: "Column 'user_name' cannot be null"
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.DB_NOT_NULL);
-        });
-        it('should map a postgres invalid input syntax error (22P02)', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '22P02',
-                    column: 'age'
-                }
-            }, 'invalid input syntax for type integer: "abc"');
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.DB_INVALID_INPUT);
-            expect(payload.message).toContain('integer');
-            expect(payload.message).toContain('Age');
-        });
-        it('should map a value-too-long error (22001)', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '22001',
-                    column: 'name'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.DB_VALUE_TOO_LONG);
-        });
-        it('should map a mysql data-too-long error using the sqlMessage column name', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: 'ER_DATA_TOO_LONG',
-                    sqlMessage: "Data too long for column 'name' at row 1"
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.DB_VALUE_TOO_LONG);
-            expect(payload.message).toContain('Name');
-        });
-        it('should map a check constraint violation (23514)', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '23514',
-                    table: 'orders',
-                    constraint: 'orders_total_check'
-                }
-            });
-            filter.catch(exception, host);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.DB_CHECK_CONSTRAINT);
-            expect(payload.messageVariables).toMatchObject({
-                constraint: 'orders_total_check'
-            });
-        });
-        it('should map a deadlock error (40P01) to service unavailable', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '40P01'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.SERVICE_UNAVAILABLE);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.DB_DEADLOCK);
-        });
-        it('should map a mysql deadlock via errno 1213', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    errno: 1213
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.DB_DEADLOCK);
-        });
-        it('should fall back to a generic 500 for an unrecognized db error code', ()=>{
-            const exception = makeQueryFailedError({
-                driverError: {
-                    code: '99999'
-                }
-            });
-            filter.catch(exception, host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.INTERNAL_SERVER_ERROR);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.INTERNAL);
-        });
-        it('should read driver fields directly when driverError is absent', ()=>{
-            const exception = makeQueryFailedError({
-                code: '23505',
-                table: 'users'
-            });
-            filter.catch(exception, host);
-            expect(response.json.mock.calls[0][0].messageKey).toBe(ERROR_MESSAGES.CONFLICT);
-        });
-    });
-    describe('unrecognized exceptions', ()=>{
-        it('should return a generic 500 for a plain Error', ()=>{
-            filter.catch(new Error('unexpected'), host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.INTERNAL_SERVER_ERROR);
-            const payload = response.json.mock.calls[0][0];
-            expect(payload.message).toBe('Internal server error');
-            expect(payload.messageKey).toBe(ERROR_MESSAGES.INTERNAL);
-        });
-        it('should return a generic 500 for a thrown non-Error value', ()=>{
-            filter.catch('just a string', host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.INTERNAL_SERVER_ERROR);
-        });
-        it('should return a generic 500 for undefined/null', ()=>{
-            filter.catch(undefined, host);
-            expect(response.status).toHaveBeenCalledWith(HttpStatus.INTERNAL_SERVER_ERROR);
-        });
-    });
-    describe('logging behavior', ()=>{
-        it('should log at error level with the stack trace for 5xx responses', ()=>{
-            const exception = new Error('unexpected');
-            filter.catch(exception, host);
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('500'), exception.stack, expect.objectContaining({
-                statusCode: HttpStatus.INTERNAL_SERVER_ERROR
-            }));
-            expect(warnSpy).not.toHaveBeenCalled();
-        });
-        it('should log at warn level without a stack trace for 4xx responses', ()=>{
-            const exception = new HttpException('Not allowed', HttpStatus.FORBIDDEN);
-            filter.catch(exception, host);
-            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('403'), expect.objectContaining({
-                statusCode: HttpStatus.FORBIDDEN
-            }));
-            expect(errorSpy).not.toHaveBeenCalled();
-        });
-        it('should include correlation context (userId/tenantId/companyId) in the log payload', ()=>{
-            mockGetUserId.mockReturnValue('user-1');
-            mockGetTenantId.mockReturnValue('tenant-1');
-            mockGetCompanyId.mockReturnValue('company-1');
-            filter.catch(new Error('unexpected'), host);
-            expect(errorSpy).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.objectContaining({
-                userId: 'user-1',
-                tenantId: 'tenant-1',
-                companyId: 'company-1'
-            }));
-        });
-    });
-    it('should always set the response status and JSON body once', ()=>{
-        filter.catch(new Error('boom'), host);
-        expect(response.status).toHaveBeenCalledTimes(1);
-        expect(response.json).toHaveBeenCalledTimes(1);
-    });
-});

package/fesm/filters/index.js

@@ -1 +0,0 @@
-export * from './global-exception.filter';

package/fesm/guards/jwt-auth.guard.js

@@ -1,65 +0,0 @@
-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 { AUTH_MESSAGES, IS_PUBLIC_KEY } from '../constants';
-import { Inject, Injectable, UnauthorizedException } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { AuthGuard } from '@nestjs/passport';
-export class JwtAuthGuard extends AuthGuard('jwt') {
-    canActivate(context) {
-        // Check if route is marked as public
-        const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [
-            context.getHandler(),
-            context.getClass()
-        ]);
-        if (isPublic) {
-            return true;
-        }
-        return super.canActivate(context);
-    }
-    handleRequest(err, user) {
-        if (err || !user) {
-            throw err || new UnauthorizedException({
-                message: 'Invalid or expired token',
-                messageKey: AUTH_MESSAGES.TOKEN_INVALID
-            });
-        }
-        return user;
-    }
-    // NOTE: @Inject(Reflector) required for bundled code - external classes need explicit injection
-    constructor(reflector){
-        super(), _define_property(this, "reflector", void 0), this.reflector = reflector;
-    }
-}
-JwtAuthGuard = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(Reflector)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Reflector === "undefined" ? Object : Reflector
-    ])
-], JwtAuthGuard);

package/fesm/guards/jwt-auth.guard.spec.js

@@ -1,71 +0,0 @@
-import { UnauthorizedException } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { AuthGuard } from '@nestjs/passport';
-import { AUTH_MESSAGES, IS_PUBLIC_KEY } from '../constants';
-import { JwtAuthGuard } from './jwt-auth.guard';
-function buildContext() {
-    return {
-        getHandler: ()=>({}),
-        getClass: ()=>({})
-    };
-}
-describe('JwtAuthGuard', ()=>{
-    let reflector;
-    let guard;
-    let superCanActivateSpy;
-    beforeEach(()=>{
-        reflector = new Reflector();
-        guard = new JwtAuthGuard(reflector);
-        superCanActivateSpy = jest.spyOn(AuthGuard('jwt').prototype, 'canActivate').mockReturnValue(true);
-    });
-    afterEach(()=>{
-        jest.restoreAllMocks();
-    });
-    describe('canActivate', ()=>{
-        it('should allow access without invoking the parent guard when the route is public', ()=>{
-            jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(true);
-            const result = guard.canActivate(buildContext());
-            expect(result).toBe(true);
-            expect(superCanActivateSpy).not.toHaveBeenCalled();
-        });
-        it('should check IS_PUBLIC_KEY metadata on both handler and class', ()=>{
-            const getAllAndOverrideSpy = jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(false);
-            const ctx = buildContext();
-            guard.canActivate(ctx);
-            expect(getAllAndOverrideSpy).toHaveBeenCalledWith(IS_PUBLIC_KEY, [
-                ctx.getHandler(),
-                ctx.getClass()
-            ]);
-        });
-        it('should delegate to the parent AuthGuard when the route is not public', ()=>{
-            jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(false);
-            const result = guard.canActivate(buildContext());
-            expect(result).toBe(true);
-            expect(superCanActivateSpy).toHaveBeenCalled();
-        });
-    });
-    describe('handleRequest', ()=>{
-        it('should return the user when authentication succeeds', ()=>{
-            const user = {
-                id: 'user-1'
-            };
-            expect(guard.handleRequest(null, user)).toBe(user);
-        });
-        it('should throw the original error when one is provided', ()=>{
-            const err = new Error('strategy failure');
-            expect(()=>guard.handleRequest(err, null)).toThrow(err);
-        });
-        it('should throw UnauthorizedException with AUTH_MESSAGES.TOKEN_INVALID when no error but no user', ()=>{
-            try {
-                guard.handleRequest(null, null);
-                fail('expected to throw');
-            } catch (error) {
-                expect(error).toBeInstanceOf(UnauthorizedException);
-                expect(error.getResponse()).toMatchObject({
-                    message: 'Invalid or expired token',
-                    messageKey: AUTH_MESSAGES.TOKEN_INVALID
-                });
-            }
-        });
-    });
-});

package/fesm/guards/optional-jwt-auth.guard.js

@@ -1,57 +0,0 @@
-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 { Inject, Injectable } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { AuthGuard } from '@nestjs/passport';
-import { IS_PUBLIC_KEY } from '../constants';
-export class OptionalJwtGuard extends AuthGuard('jwt') {
-    canActivate(context) {
-        const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [
-            context.getHandler(),
-            context.getClass()
-        ]);
-        if (isPublic) {
-            return true;
-        }
-        return super.canActivate(context);
-    }
-    handleRequest(_err, user) {
-        return user || undefined;
-    }
-    constructor(reflector){
-        super(), _define_property(this, "reflector", void 0), this.reflector = reflector;
-    }
-}
-OptionalJwtGuard = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(Reflector)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Reflector === "undefined" ? Object : Reflector
-    ])
-], OptionalJwtGuard);

package/fesm/guards/optional-jwt-auth.guard.spec.js

@@ -1,51 +0,0 @@
-import { Reflector } from '@nestjs/core';
-import { AuthGuard } from '@nestjs/passport';
-import { OptionalJwtGuard } from './optional-jwt-auth.guard';
-function buildContext() {
-    return {
-        getHandler: ()=>({}),
-        getClass: ()=>({})
-    };
-}
-describe('OptionalJwtGuard', ()=>{
-    let reflector;
-    let guard;
-    let superCanActivateSpy;
-    beforeEach(()=>{
-        reflector = new Reflector();
-        guard = new OptionalJwtGuard(reflector);
-        superCanActivateSpy = jest.spyOn(AuthGuard('jwt').prototype, 'canActivate').mockReturnValue(true);
-    });
-    afterEach(()=>{
-        jest.restoreAllMocks();
-    });
-    describe('canActivate', ()=>{
-        it('should allow access without invoking the parent guard when the route is public', ()=>{
-            jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(true);
-            expect(guard.canActivate(buildContext())).toBe(true);
-            expect(superCanActivateSpy).not.toHaveBeenCalled();
-        });
-        it('should delegate to the parent AuthGuard when the route is not public', ()=>{
-            jest.spyOn(reflector, 'getAllAndOverride').mockReturnValue(false);
-            expect(guard.canActivate(buildContext())).toBe(true);
-            expect(superCanActivateSpy).toHaveBeenCalled();
-        });
-    });
-    describe('handleRequest', ()=>{
-        it('should return the user when present', ()=>{
-            const user = {
-                id: 'user-1'
-            };
-            expect(guard.handleRequest(null, user)).toBe(user);
-        });
-        it('should return undefined (not throw) when there is an error', ()=>{
-            expect(guard.handleRequest(new Error('token expired'), null)).toBeUndefined();
-        });
-        it('should return undefined when there is no user and no error', ()=>{
-            expect(guard.handleRequest(null, null)).toBeUndefined();
-        });
-        it('should return undefined for a falsy user value', ()=>{
-            expect(guard.handleRequest(null, false)).toBeUndefined();
-        });
-    });
-});