@flusys/nestjs-auth 6.0.2 → 6.1.1

package/cjs/helpers/auth-response.mapper.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get toBranchInfo () {
+        return toBranchInfo;
+    },
+    get toCompanyInfo () {
+        return toCompanyInfo;
+    },
+    get toUserInfo () {
+        return toUserInfo;
+    }
+});
+function toUserInfo(user) {
+    return {
+        id: user.id,
+        email: user.email,
+        name: user.name ?? undefined,
+        phone: user.phone ?? null,
+        profilePictureId: user.profilePictureId ?? null
+    };
+}
+function toCompanyInfo(company) {
+    return {
+        id: company.id,
+        name: company.name,
+        slug: company.slug,
+        logoId: company.logoId ?? null
+    };
+}
+function toBranchInfo(branch) {
+    return {
+        id: branch.id,
+        name: branch.name,
+        slug: branch.slug,
+        logoId: branch.logoId ?? null
+    };
+}

package/cjs/helpers/auth-response.mapper.spec.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _authresponsemapper = require("./auth-response.mapper");
+function buildUser(overrides = {}) {
+    return {
+        id: 'user-uuid-1',
+        email: 'user@example.com',
+        name: 'Test User',
+        phone: null,
+        profilePictureId: null,
+        isActive: true,
+        emailVerified: false,
+        phoneVerified: false,
+        lastLoginAt: null,
+        additionalFields: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        password: null,
+        ...overrides
+    };
+}
+function buildCompany(overrides = {}) {
+    return {
+        id: 'company-uuid-1',
+        name: 'Acme Corp',
+        slug: 'acme-corp',
+        logoId: null,
+        readOnly: false,
+        address: null,
+        phone: null,
+        email: null,
+        website: null,
+        serial: null,
+        isActive: true,
+        settings: null,
+        additionalFields: null,
+        branches: [],
+        ...overrides
+    };
+}
+function buildBranch(overrides = {}) {
+    return {
+        id: 'branch-uuid-1',
+        name: 'Main Branch',
+        slug: 'main-branch',
+        logoId: null,
+        readOnly: false,
+        address: null,
+        phone: null,
+        email: null,
+        serial: null,
+        isActive: true,
+        additionalFields: null,
+        parentId: null,
+        parent: null,
+        children: [],
+        companyId: 'company-uuid-1',
+        company: buildCompany(),
+        ...overrides
+    };
+}
+describe('auth-response.mapper', ()=>{
+    describe('toUserInfo', ()=>{
+        it('maps all user fields', ()=>{
+            const user = buildUser({
+                name: 'John Doe',
+                phone: '+123',
+                profilePictureId: 'pic-1'
+            });
+            const result = (0, _authresponsemapper.toUserInfo)(user);
+            expect(result).toEqual({
+                id: 'user-uuid-1',
+                email: 'user@example.com',
+                name: 'John Doe',
+                phone: '+123',
+                profilePictureId: 'pic-1'
+            });
+        });
+        it('defaults name to undefined and nullable fields to null when absent', ()=>{
+            const user = buildUser({
+                name: null,
+                phone: null,
+                profilePictureId: null
+            });
+            const result = (0, _authresponsemapper.toUserInfo)(user);
+            expect(result.name).toBeUndefined();
+            expect(result.phone).toBeNull();
+            expect(result.profilePictureId).toBeNull();
+        });
+    });
+    describe('toCompanyInfo', ()=>{
+        it('maps all company fields', ()=>{
+            const company = buildCompany({
+                logoId: 'logo-1'
+            });
+            const result = (0, _authresponsemapper.toCompanyInfo)(company);
+            expect(result).toEqual({
+                id: 'company-uuid-1',
+                name: 'Acme Corp',
+                slug: 'acme-corp',
+                logoId: 'logo-1'
+            });
+        });
+        it('defaults logoId to null when absent', ()=>{
+            const company = buildCompany({
+                logoId: null
+            });
+            const result = (0, _authresponsemapper.toCompanyInfo)(company);
+            expect(result.logoId).toBeNull();
+        });
+    });
+    describe('toBranchInfo', ()=>{
+        it('maps all branch fields', ()=>{
+            const branch = buildBranch({
+                logoId: 'logo-2'
+            });
+            const result = (0, _authresponsemapper.toBranchInfo)(branch);
+            expect(result).toEqual({
+                id: 'branch-uuid-1',
+                name: 'Main Branch',
+                slug: 'main-branch',
+                logoId: 'logo-2'
+            });
+        });
+        it('defaults logoId to null when absent', ()=>{
+            const branch = buildBranch({
+                logoId: null
+            });
+            const result = (0, _authresponsemapper.toBranchInfo)(branch);
+            expect(result.logoId).toBeNull();
+        });
+    });
+});

package/cjs/helpers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./auth-response.mapper"), exports);
+_export_star(require("./token.helper"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/cjs/helpers/token.helper.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generateTokens () {
+        return generateTokens;
+    },
+    get parseExpiryToMs () {
+        return parseExpiryToMs;
+    }
+});
+function generateTokens(jwtService, authConfig, payload) {
+    const accessToken = jwtService.sign({
+        ...payload,
+        type: 'access'
+    }, {
+        secret: authConfig.getJwtSecret(),
+        expiresIn: authConfig.getJwtExpiration(),
+        algorithm: 'HS256'
+    });
+    const refreshToken = jwtService.sign({
+        ...payload,
+        type: 'refresh'
+    }, {
+        secret: authConfig.getRefreshTokenSecret(),
+        expiresIn: authConfig.getRefreshTokenExpiration(),
+        algorithm: 'HS256'
+    });
+    return {
+        accessToken,
+        refreshToken
+    };
+}
+function parseExpiryToMs(expiry) {
+    const match = expiry.match(/^(\d+)([smhd])$/);
+    if (!match) return 7 * 24 * 60 * 60 * 1000;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch(unit){
+        case 's':
+            return value * 1000;
+        case 'm':
+            return value * 60 * 1000;
+        case 'h':
+            return value * 60 * 60 * 1000;
+        case 'd':
+            return value * 24 * 60 * 60 * 1000;
+        default:
+            return 7 * 24 * 60 * 60 * 1000;
+    }
+}

package/cjs/helpers/token.helper.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _tokenhelper = require("./token.helper");
+describe('token.helper', ()=>{
+    describe('generateTokens', ()=>{
+        let mockJwtService;
+        let mockAuthConfig;
+        beforeEach(()=>{
+            mockJwtService = {
+                sign: jest.fn()
+            };
+            mockAuthConfig = {
+                getJwtSecret: jest.fn().mockReturnValue('jwt-secret'),
+                getJwtExpiration: jest.fn().mockReturnValue('1h'),
+                getRefreshTokenSecret: jest.fn().mockReturnValue('refresh-secret'),
+                getRefreshTokenExpiration: jest.fn().mockReturnValue('7d')
+            };
+        });
+        it('signs an access token and a refresh token with distinct secrets', ()=>{
+            mockJwtService.sign.mockReturnValueOnce('access-token-value').mockReturnValueOnce('refresh-token-value');
+            const result = (0, _tokenhelper.generateTokens)(mockJwtService, mockAuthConfig, {
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'access'
+            });
+            expect(result).toEqual({
+                accessToken: 'access-token-value',
+                refreshToken: 'refresh-token-value'
+            });
+            expect(mockJwtService.sign).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'access'
+            }), expect.objectContaining({
+                secret: 'jwt-secret',
+                expiresIn: '1h',
+                algorithm: 'HS256'
+            }));
+            expect(mockJwtService.sign).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'refresh'
+            }), expect.objectContaining({
+                secret: 'refresh-secret',
+                expiresIn: '7d',
+                algorithm: 'HS256'
+            }));
+        });
+        it('includes companyId and branchId in the signed payload when provided', ()=>{
+            mockJwtService.sign.mockReturnValue('token');
+            (0, _tokenhelper.generateTokens)(mockJwtService, mockAuthConfig, {
+                id: 'user-1',
+                email: 'user@example.com',
+                type: 'access',
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            });
+            expect(mockJwtService.sign).toHaveBeenCalledWith(expect.objectContaining({
+                companyId: 'company-1',
+                branchId: 'branch-1'
+            }), expect.anything());
+        });
+    });
+    describe('parseExpiryToMs', ()=>{
+        it('parses seconds', ()=>{
+            expect((0, _tokenhelper.parseExpiryToMs)('30s')).toBe(30 * 1000);
+        });
+        it('parses minutes', ()=>{
+            expect((0, _tokenhelper.parseExpiryToMs)('15m')).toBe(15 * 60 * 1000);
+        });
+        it('parses hours', ()=>{
+            expect((0, _tokenhelper.parseExpiryToMs)('2h')).toBe(2 * 60 * 60 * 1000);
+        });
+        it('parses days', ()=>{
+            expect((0, _tokenhelper.parseExpiryToMs)('7d')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+        it('falls back to 7 days for an unparsable value', ()=>{
+            expect((0, _tokenhelper.parseExpiryToMs)('not-a-duration')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+        it('falls back to 7 days for an unknown unit', ()=>{
+            expect((0, _tokenhelper.parseExpiryToMs)('5y')).toBe(7 * 24 * 60 * 60 * 1000);
+        });
+    });
+});

package/cjs/index.js

@@ -8,6 +8,7 @@ _export_star(require("./docs"), exports);
 _export_star(require("./dtos"), exports);
 _export_star(require("./entities"), exports);
 _export_star(require("./enums"), exports);
+_export_star(require("./helpers"), exports);
 _export_star(require("./interceptors"), exports);
 _export_star(require("./interfaces"), exports);
 _export_star(require("./modules"), exports);

package/cjs/interceptors/clear-token.interceptor.spec.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _rxjs = require("rxjs");
+const _cleartokeninterceptor = require("./clear-token.interceptor");
+const _config = require("../config");
+function buildContext(req, res) {
+    return {
+        switchToHttp: ()=>({
+                getRequest: ()=>req,
+                getResponse: ()=>res
+            })
+    };
+}
+function buildCallHandler(value) {
+    return {
+        handle: ()=>(0, _rxjs.of)(value)
+    };
+}
+describe('ClearToken', ()=>{
+    let mockAuthConfig;
+    beforeEach(()=>{
+        mockAuthConfig = {
+            getRefreshTokenCookieName: jest.fn().mockReturnValue('custom_refresh_token')
+        };
+    });
+    it('clears the cookie for a browser request', (done)=>{
+        const interceptor = new _cleartokeninterceptor.ClearToken(mockAuthConfig);
+        const clearCookie = jest.fn();
+        const req = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 Chrome/1.0'
+            }
+        };
+        const res = {
+            clearCookie
+        };
+        interceptor.intercept(buildContext(req, res), buildCallHandler({
+            success: true
+        })).subscribe((result)=>{
+            expect(clearCookie).toHaveBeenCalledWith('custom_refresh_token', expect.objectContaining({
+                httpOnly: true,
+                path: '/'
+            }));
+            expect(result).toEqual({
+                success: true
+            });
+            done();
+        });
+    });
+    it('does not clear the cookie for a non-browser (API) request', (done)=>{
+        const interceptor = new _cleartokeninterceptor.ClearToken(mockAuthConfig);
+        const clearCookie = jest.fn();
+        const req = {
+            headers: {
+                'user-agent': 'PostmanRuntime/7.0'
+            }
+        };
+        const res = {
+            clearCookie
+        };
+        interceptor.intercept(buildContext(req, res), buildCallHandler({
+            success: true
+        })).subscribe(()=>{
+            expect(clearCookie).not.toHaveBeenCalled();
+            done();
+        });
+    });
+    it('falls back to the default cookie name when authConfig is unavailable', (done)=>{
+        const interceptor = new _cleartokeninterceptor.ClearToken(undefined);
+        const clearCookie = jest.fn();
+        const req = {
+            headers: {
+                'user-agent': 'Mozilla/5.0 Chrome/1.0'
+            }
+        };
+        const res = {
+            clearCookie
+        };
+        interceptor.intercept(buildContext(req, res), buildCallHandler({
+            success: true
+        })).subscribe(()=>{
+            expect(clearCookie).toHaveBeenCalledWith(_config.DEFAULT_COOKIE_NAME, expect.anything());
+            done();
+        });
+    });
+    it('passes through the emitted value unchanged', (done)=>{
+        const interceptor = new _cleartokeninterceptor.ClearToken(mockAuthConfig);
+        const req = {
+            headers: {
+                'user-agent': 'PostmanRuntime/7.0'
+            }
+        };
+        const res = {
+            clearCookie: jest.fn()
+        };
+        const payload = {
+            success: true,
+            message: 'Logged out successfully'
+        };
+        interceptor.intercept(buildContext(req, res), buildCallHandler(payload)).subscribe((result)=>{
+            expect(result).toBe(payload);
+            done();
+        });
+    });
+});

package/cjs/interceptors/set-token.interceptor.spec.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _rxjs = require("rxjs");
+const _settokeninterceptor = require("./set-token.interceptor");
+const _config = require("../config");
+function buildContext(req, res) {
+    return {
+        switchToHttp: ()=>({
+                getRequest: ()=>req,
+                getResponse: ()=>res
+            })
+    };
+}
+function buildCallHandler(value) {
+    return {
+        handle: ()=>(0, _rxjs.of)(value)
+    };
+}
+const browserReq = {
+    headers: {
+        'user-agent': 'Mozilla/5.0 Chrome/1.0'
+    }
+};
+const apiReq = {
+    headers: {
+        'user-agent': 'PostmanRuntime/7.0'
+    }
+};
+describe('SetToken', ()=>{
+    let mockAuthConfig;
+    beforeEach(()=>{
+        mockAuthConfig = {
+            getRefreshTokenCookieName: jest.fn().mockReturnValue('custom_refresh_token'),
+            getRefreshTokenExpiration: jest.fn().mockReturnValue('7d')
+        };
+    });
+    it('sets a refresh token cookie and strips refreshToken from data for browser requests', (done)=>{
+        const interceptor = new _settokeninterceptor.SetToken(mockAuthConfig);
+        const cookie = jest.fn();
+        const res = {
+            cookie
+        };
+        const payload = {
+            success: true,
+            data: {
+                accessToken: 'access-1',
+                refreshToken: 'refresh-1',
+                user: {
+                    id: 'u1'
+                }
+            }
+        };
+        interceptor.intercept(buildContext(browserReq, res), buildCallHandler(payload)).subscribe((result)=>{
+            expect(cookie).toHaveBeenCalledWith('custom_refresh_token', 'refresh-1', expect.objectContaining({
+                httpOnly: true,
+                path: '/'
+            }));
+            expect(result).toEqual({
+                success: true,
+                data: {
+                    accessToken: 'access-1',
+                    user: {
+                        id: 'u1'
+                    }
+                }
+            });
+            expect(result.data.refreshToken).toBeUndefined();
+            done();
+        });
+    });
+    it('does not set a cookie or modify data for non-browser (API) requests', (done)=>{
+        const interceptor = new _settokeninterceptor.SetToken(mockAuthConfig);
+        const cookie = jest.fn();
+        const res = {
+            cookie
+        };
+        const payload = {
+            success: true,
+            data: {
+                accessToken: 'access-1',
+                refreshToken: 'refresh-1'
+            }
+        };
+        interceptor.intercept(buildContext(apiReq, res), buildCallHandler(payload)).subscribe((result)=>{
+            expect(cookie).not.toHaveBeenCalled();
+            expect(result).toBe(payload);
+            done();
+        });
+    });
+    it('passes through non-object values unchanged', (done)=>{
+        const interceptor = new _settokeninterceptor.SetToken(mockAuthConfig);
+        const res = {
+            cookie: jest.fn()
+        };
+        interceptor.intercept(buildContext(browserReq, res), buildCallHandler('plain-string')).subscribe((result)=>{
+            expect(result).toBe('plain-string');
+            done();
+        });
+    });
+    it('passes through null values unchanged', (done)=>{
+        const interceptor = new _settokeninterceptor.SetToken(mockAuthConfig);
+        const res = {
+            cookie: jest.fn()
+        };
+        interceptor.intercept(buildContext(browserReq, res), buildCallHandler(null)).subscribe((result)=>{
+            expect(result).toBeNull();
+            done();
+        });
+    });
+    it('passes through values without a refreshToken in data unchanged', (done)=>{
+        const interceptor = new _settokeninterceptor.SetToken(mockAuthConfig);
+        const cookie = jest.fn();
+        const res = {
+            cookie
+        };
+        const payload = {
+            success: true,
+            data: {
+                accessToken: 'access-1'
+            }
+        };
+        interceptor.intercept(buildContext(browserReq, res), buildCallHandler(payload)).subscribe((result)=>{
+            expect(cookie).not.toHaveBeenCalled();
+            expect(result).toBe(payload);
+            done();
+        });
+    });
+    it('falls back to the default cookie name when authConfig is unavailable', (done)=>{
+        const interceptor = new _settokeninterceptor.SetToken(undefined);
+        const cookie = jest.fn();
+        const res = {
+            cookie
+        };
+        const payload = {
+            data: {
+                refreshToken: 'refresh-1'
+            }
+        };
+        interceptor.intercept(buildContext(browserReq, res), buildCallHandler(payload)).subscribe(()=>{
+            expect(cookie).toHaveBeenCalledWith(_config.DEFAULT_COOKIE_NAME, 'refresh-1', expect.anything());
+            done();
+        });
+    });
+    it('throws PayloadTooLargeException when the refresh token exceeds the max cookie size', (done)=>{
+        const interceptor = new _settokeninterceptor.SetToken(mockAuthConfig);
+        const res = {
+            cookie: jest.fn()
+        };
+        const oversizedToken = 'a'.repeat(4000);
+        const payload = {
+            data: {
+                refreshToken: oversizedToken
+            }
+        };
+        interceptor.intercept(buildContext(browserReq, res), buildCallHandler(payload)).subscribe({
+            error: (err)=>{
+                expect(err).toBeInstanceOf(_common.PayloadTooLargeException);
+                done();
+            }
+        });
+    });
+});