@flusys/nestjs-shared 6.0.2 → 6.1.0

package/fesm/guards/permission.guard.spec.js

@@ -0,0 +1,354 @@
+import { UnauthorizedException } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { AUTH_MESSAGES, IS_PUBLIC_KEY, PERMISSIONS_KEY } from '../constants';
+import { InsufficientPermissionsException, NoPermissionsFoundException, PermissionSystemUnavailableException } from '../exceptions/permission.exception';
+import { PermissionGuard } from './permission.guard';
+function buildContext(request) {
+    return {
+        getHandler: ()=>({}),
+        getClass: ()=>({}),
+        switchToHttp: ()=>({
+                getRequest: ()=>request
+            })
+    };
+}
+describe('PermissionGuard', ()=>{
+    let reflector;
+    let cache;
+    let getAllAndOverrideMock;
+    beforeEach(()=>{
+        reflector = new Reflector();
+        cache = {
+            get: jest.fn(),
+            set: jest.fn(),
+            del: jest.fn()
+        };
+        getAllAndOverrideMock = jest.fn();
+        jest.spyOn(reflector, 'getAllAndOverride').mockImplementation(getAllAndOverrideMock);
+    });
+    function mockMetadata(isPublic, permissionConfig) {
+        getAllAndOverrideMock.mockImplementation((key)=>{
+            if (key === IS_PUBLIC_KEY) return isPublic;
+            if (key === PERMISSIONS_KEY) return permissionConfig;
+            return undefined;
+        });
+    }
+    describe('public routes and missing permission metadata', ()=>{
+        it('should allow access when the route is public', async ()=>{
+            mockMetadata(true, undefined);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({}))).resolves.toBe(true);
+        });
+        it('should allow access when no permission metadata is set', async ()=>{
+            mockMetadata(false, undefined);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+    });
+    describe('authentication requirement', ()=>{
+        it('should throw UnauthorizedException when there is no user on the request', async ()=>{
+            mockMetadata(false, 'user.read');
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({}))).rejects.toMatchObject({
+                constructor: UnauthorizedException
+            });
+            try {
+                await guard.canActivate(buildContext({}));
+            } catch (error) {
+                expect(error.getResponse()).toMatchObject({
+                    messageKey: AUTH_MESSAGES.TOKEN_REQUIRED
+                });
+            }
+        });
+    });
+    describe('cache availability', ()=>{
+        it('should throw PermissionSystemUnavailableException when no cache is injected', async ()=>{
+            mockMetadata(false, 'user.read');
+            const guard = new PermissionGuard(reflector, undefined);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(PermissionSystemUnavailableException);
+        });
+    });
+    describe('permission resolution', ()=>{
+        it('should throw NoPermissionsFoundException when the user has no cached permissions', async ()=>{
+            mockMetadata(false, 'user.read');
+            cache.get.mockResolvedValue(undefined);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(NoPermissionsFoundException);
+        });
+        it('should throw NoPermissionsFoundException when the cached permission array is empty', async ()=>{
+            mockMetadata(false, 'user.read');
+            cache.get.mockResolvedValue([]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(NoPermissionsFoundException);
+        });
+        it('should allow access for a single string permission that the user has', async ()=>{
+            mockMetadata(false, 'user.read');
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should throw InsufficientPermissionsException for a single string permission the user lacks', async ()=>{
+            mockMetadata(false, 'user.write');
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(InsufficientPermissionsException);
+        });
+        it('should support a wildcard "*" permission granting everything', async ()=>{
+            mockMetadata(false, 'anything.here');
+            cache.get.mockResolvedValue([
+                '*'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should support a namespaced wildcard like "user.*"', async ()=>{
+            mockMetadata(false, 'user.delete');
+            cache.get.mockResolvedValue([
+                'user.*'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should evaluate an array of permissions as AND logic', async ()=>{
+            mockMetadata(false, [
+                'user.read',
+                'user.write'
+            ]);
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(InsufficientPermissionsException);
+        });
+        it('should pass an array of permissions when the user has all of them', async ()=>{
+            mockMetadata(false, [
+                'user.read',
+                'user.write'
+            ]);
+            cache.get.mockResolvedValue([
+                'user.read',
+                'user.write'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should return true for an empty permission array (no-op logic node)', async ()=>{
+            mockMetadata(false, []);
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should evaluate SimplePermissionConfig with OR operator', async ()=>{
+            mockMetadata(false, {
+                permissions: [
+                    'admin',
+                    'manager'
+                ],
+                operator: 'OR'
+            });
+            cache.get.mockResolvedValue([
+                'manager'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should reject SimplePermissionConfig with OR operator when none match', async ()=>{
+            mockMetadata(false, {
+                permissions: [
+                    'admin',
+                    'manager'
+                ],
+                operator: 'OR'
+            });
+            cache.get.mockResolvedValue([
+                'guest'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(InsufficientPermissionsException);
+        });
+        it('should return true for SimplePermissionConfig with an empty permissions array', async ()=>{
+            mockMetadata(false, {
+                permissions: [],
+                operator: 'AND'
+            });
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should evaluate a nested ILogicNode tree (AND of action + OR group)', async ()=>{
+            mockMetadata(false, {
+                type: 'group',
+                operator: 'AND',
+                children: [
+                    {
+                        type: 'action',
+                        actionId: 'users.read'
+                    },
+                    {
+                        type: 'group',
+                        operator: 'OR',
+                        children: [
+                            {
+                                type: 'action',
+                                actionId: 'admin'
+                            },
+                            {
+                                type: 'action',
+                                actionId: 'manager'
+                            }
+                        ]
+                    }
+                ]
+            });
+            cache.get.mockResolvedValue([
+                'users.read',
+                'manager'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should fail-closed on a group node with no children', async ()=>{
+            mockMetadata(false, {
+                type: 'group',
+                operator: 'AND',
+                children: []
+            });
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(InsufficientPermissionsException);
+        });
+        it('should read backendCodes from an object-shaped cache value', async ()=>{
+            mockMetadata(false, 'user.read');
+            cache.get.mockResolvedValue({
+                backendCodes: [
+                    'user.read'
+                ]
+            });
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).resolves.toBe(true);
+        });
+        it('should treat an object-shaped cache value with no backendCodes as no permissions', async ()=>{
+            mockMetadata(false, 'user.read');
+            cache.get.mockResolvedValue({});
+            const guard = new PermissionGuard(reflector, cache);
+            await expect(guard.canActivate(buildContext({
+                user: {
+                    id: 'u1'
+                }
+            }))).rejects.toBeInstanceOf(NoPermissionsFoundException);
+        });
+    });
+    describe('company-scoped cache key', ()=>{
+        it('should include companyId/branchId in the cache lookup when company feature is enabled', async ()=>{
+            mockMetadata(false, 'user.read');
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache, {
+                enableCompanyFeature: true
+            });
+            await guard.canActivate(buildContext({
+                user: {
+                    id: 'u1',
+                    companyId: 'c1',
+                    branchId: 'b1'
+                }
+            }));
+            expect(cache.get).toHaveBeenCalledWith(expect.stringContaining('company:c1:branch:b1:user:u1'));
+        });
+        it('should fall back to the user-scoped cache key when company feature is disabled', async ()=>{
+            mockMetadata(false, 'user.read');
+            cache.get.mockResolvedValue([
+                'user.read'
+            ]);
+            const guard = new PermissionGuard(reflector, cache);
+            await guard.canActivate(buildContext({
+                user: {
+                    id: 'u1',
+                    companyId: 'c1',
+                    branchId: 'b1'
+                }
+            }));
+            expect(cache.get).toHaveBeenCalledWith(expect.stringContaining(':user:u1'));
+            expect(cache.get).toHaveBeenCalledWith(expect.not.stringContaining('company'));
+        });
+    });
+});

package/fesm/interceptors/delete-empty-id-from-body.interceptor.spec.js

@@ -0,0 +1,103 @@
+import { of } from 'rxjs';
+import { DeleteEmptyIdFromBodyInterceptor } from './delete-empty-id-from-body.interceptor';
+function buildContext(body) {
+    const request = {
+        body
+    };
+    const context = {
+        switchToHttp: ()=>({
+                getRequest: ()=>request
+            })
+    };
+    return {
+        context,
+        request
+    };
+}
+function buildCallHandler() {
+    return {
+        handle: jest.fn().mockReturnValue(of('next-result'))
+    };
+}
+describe('DeleteEmptyIdFromBodyInterceptor', ()=>{
+    let interceptor;
+    beforeEach(()=>{
+        interceptor = new DeleteEmptyIdFromBodyInterceptor();
+    });
+    it('should delete an empty-string id on a single object body', ()=>{
+        const { context, request } = buildContext({
+            id: '',
+            name: 'Product'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            name: 'Product'
+        });
+    });
+    it('should delete a null id on a single object body', ()=>{
+        const { context, request } = buildContext({
+            id: null,
+            name: 'Product'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            name: 'Product'
+        });
+    });
+    it('should keep a truthy id on a single object body', ()=>{
+        const { context, request } = buildContext({
+            id: 'uuid-1',
+            name: 'Product'
+        });
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual({
+            id: 'uuid-1',
+            name: 'Product'
+        });
+    });
+    it('should strip empty ids from each item in an array body', ()=>{
+        const { context, request } = buildContext([
+            {
+                id: '',
+                name: 'A'
+            },
+            {
+                id: 'uuid-2',
+                name: 'B'
+            },
+            {
+                id: null,
+                name: 'C'
+            }
+        ]);
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toEqual([
+            {
+                name: 'A'
+            },
+            {
+                id: 'uuid-2',
+                name: 'B'
+            },
+            {
+                name: 'C'
+            }
+        ]);
+    });
+    it('should leave a null body untouched', ()=>{
+        const { context, request } = buildContext(null);
+        interceptor.intercept(context, buildCallHandler());
+        expect(request.body).toBeNull();
+    });
+    it('should call next.handle() and return its observable', (done)=>{
+        const { context } = buildContext({
+            id: ''
+        });
+        const callHandler = buildCallHandler();
+        interceptor.intercept(context, callHandler).subscribe((value)=>{
+            expect(value).toBe('next-result');
+            expect(callHandler.handle).toHaveBeenCalled();
+            done();
+        });
+    });
+});

package/fesm/interceptors/idempotency.interceptor.spec.js

@@ -0,0 +1,112 @@
+import { ConflictException } from '@nestjs/common';
+import { of } from 'rxjs';
+import { IDEMPOTENCY_CACHE_PREFIX, IDEMPOTENCY_KEY_HEADER } from '../constants';
+import { IdempotencyInterceptor } from './idempotency.interceptor';
+function buildContext(headers = {}) {
+    const request = {
+        headers
+    };
+    return {
+        switchToHttp: ()=>({
+                getRequest: ()=>request
+            })
+    };
+}
+function buildCallHandler(response = {
+    success: true
+}) {
+    return {
+        handle: jest.fn().mockReturnValue(of(response))
+    };
+}
+describe('IdempotencyInterceptor', ()=>{
+    let cache;
+    beforeEach(()=>{
+        cache = {
+            get: jest.fn(),
+            set: jest.fn(),
+            del: jest.fn()
+        };
+    });
+    it('should skip idempotency handling when no cache is injected', async ()=>{
+        const interceptor = new IdempotencyInterceptor(undefined);
+        const callHandler = buildCallHandler('raw-result');
+        const result$ = await interceptor.intercept(buildContext({
+            [IDEMPOTENCY_KEY_HEADER]: 'key-1'
+        }), callHandler);
+        await new Promise((resolve)=>{
+            result$.subscribe((value)=>{
+                expect(value).toBe('raw-result');
+                resolve();
+            });
+        });
+        expect(callHandler.handle).toHaveBeenCalled();
+    });
+    it('should skip idempotency handling when no idempotency key header is provided', async ()=>{
+        const interceptor = new IdempotencyInterceptor(cache);
+        const callHandler = buildCallHandler('raw-result');
+        const result$ = await interceptor.intercept(buildContext({}), callHandler);
+        await new Promise((resolve)=>{
+            result$.subscribe((value)=>{
+                expect(value).toBe('raw-result');
+                resolve();
+            });
+        });
+        expect(cache.get).not.toHaveBeenCalled();
+    });
+    it('should process and cache the response when the key is new', async ()=>{
+        cache.get.mockResolvedValue(undefined);
+        const interceptor = new IdempotencyInterceptor(cache);
+        const callHandler = buildCallHandler({
+            success: true,
+            data: 'X'
+        });
+        const result$ = await interceptor.intercept(buildContext({
+            [IDEMPOTENCY_KEY_HEADER]: 'key-1'
+        }), callHandler);
+        const cacheKey = `${IDEMPOTENCY_CACHE_PREFIX}:key-1`;
+        expect(cache.set).toHaveBeenCalledWith(cacheKey, '__PROCESSING__', 24 * 60 * 60 * 1000);
+        await new Promise((resolve)=>{
+            result$.subscribe((value)=>{
+                expect(value).toEqual({
+                    success: true,
+                    data: 'X'
+                });
+                resolve();
+            });
+        });
+        // Allow the tap() side-effect microtask to flush
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(cache.set).toHaveBeenCalledWith(cacheKey, {
+            success: true,
+            data: 'X'
+        }, 24 * 60 * 60 * 1000);
+    });
+    it('should return the cached response when the key already has a completed result', async ()=>{
+        const cachedResponse = {
+            success: true,
+            data: 'cached'
+        };
+        cache.get.mockResolvedValue(cachedResponse);
+        const interceptor = new IdempotencyInterceptor(cache);
+        const callHandler = buildCallHandler();
+        const result$ = await interceptor.intercept(buildContext({
+            [IDEMPOTENCY_KEY_HEADER]: 'key-1'
+        }), callHandler);
+        await new Promise((resolve)=>{
+            result$.subscribe((value)=>{
+                expect(value).toEqual(cachedResponse);
+                resolve();
+            });
+        });
+        expect(callHandler.handle).not.toHaveBeenCalled();
+    });
+    it('should throw ConflictException when the key is still marked as processing', async ()=>{
+        cache.get.mockResolvedValue('__PROCESSING__');
+        const interceptor = new IdempotencyInterceptor(cache);
+        await expect(interceptor.intercept(buildContext({
+            [IDEMPOTENCY_KEY_HEADER]: 'key-1'
+        }), buildCallHandler())).rejects.toBeInstanceOf(ConflictException);
+    });
+});

package/fesm/interceptors/response-meta.interceptor.spec.js

@@ -0,0 +1,85 @@
+import { of } from 'rxjs';
+import { REQUEST_ID_HEADER } from '../constants';
+import { ResponseMetaInterceptor } from './response-meta.interceptor';
+function buildContext(headers = {}) {
+    const request = {
+        headers
+    };
+    const context = {
+        switchToHttp: ()=>({
+                getRequest: ()=>request
+            })
+    };
+    return {
+        context,
+        request
+    };
+}
+function buildCallHandler(response) {
+    return {
+        handle: jest.fn().mockReturnValue(of(response))
+    };
+}
+describe('ResponseMetaInterceptor', ()=>{
+    let interceptor;
+    beforeEach(()=>{
+        interceptor = new ResponseMetaInterceptor();
+    });
+    it('should attach _meta to a response object with a success field', (done)=>{
+        const { context } = buildContext();
+        interceptor.intercept(context, buildCallHandler({
+            success: true,
+            data: {}
+        })).subscribe((result)=>{
+            expect(result.success).toBe(true);
+            expect(result._meta).toMatchObject({
+                requestId: expect.stringMatching(/^req_/),
+                timestamp: expect.any(String),
+                responseTime: expect.any(Number)
+            });
+            done();
+        });
+    });
+    it('should use the existing x-request-id header instead of generating one', (done)=>{
+        const { context } = buildContext({
+            [REQUEST_ID_HEADER]: 'existing-id'
+        });
+        interceptor.intercept(context, buildCallHandler({
+            success: true
+        })).subscribe((result)=>{
+            expect(result._meta.requestId).toBe('existing-id');
+            done();
+        });
+    });
+    it('should set request.requestId as a side effect', ()=>{
+        const { context, request } = buildContext();
+        interceptor.intercept(context, buildCallHandler({
+            success: true
+        })).subscribe();
+        expect(request.requestId).toEqual(expect.stringMatching(/^req_/));
+    });
+    it('should not modify a response without a "success" field', (done)=>{
+        const { context } = buildContext();
+        const response = {
+            data: 'raw'
+        };
+        interceptor.intercept(context, buildCallHandler(response)).subscribe((result)=>{
+            expect(result).toBe(response);
+            done();
+        });
+    });
+    it('should not modify a primitive response', (done)=>{
+        const { context } = buildContext();
+        interceptor.intercept(context, buildCallHandler('plain-string')).subscribe((result)=>{
+            expect(result).toBe('plain-string');
+            done();
+        });
+    });
+    it('should not modify a null response', (done)=>{
+        const { context } = buildContext();
+        interceptor.intercept(context, buildCallHandler(null)).subscribe((result)=>{
+            expect(result).toBeNull();
+            done();
+        });
+    });
+});