@flusys/nestjs-shared 6.0.2 → 6.1.0

package/fesm/decorators/require-permission.decorator.spec.js

@@ -0,0 +1,143 @@
+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);
+}
+import { Reflector } from '@nestjs/core';
+import { PERMISSIONS_KEY } from '../constants';
+import { RequireAnyPermission, RequirePermission, RequirePermissionLogic } from './require-permission.decorator';
+describe('permission decorators', ()=>{
+    const reflector = new Reflector();
+    describe('RequirePermission', ()=>{
+        it('should set metadata with AND operator for multiple permissions', ()=>{
+            let Controller = class Controller {
+                handler() {}
+            };
+            _ts_decorate([
+                RequirePermission('user.read', 'user.write'),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", void 0)
+            ], Controller.prototype, "handler", null);
+            const metadata = reflector.get(PERMISSIONS_KEY, Controller.prototype.handler);
+            expect(metadata).toEqual({
+                permissions: [
+                    'user.read',
+                    'user.write'
+                ],
+                operator: 'AND'
+            });
+        });
+        it('should set metadata for a single permission', ()=>{
+            let Controller = class Controller {
+                handler() {}
+            };
+            _ts_decorate([
+                RequirePermission('user.read'),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", void 0)
+            ], Controller.prototype, "handler", null);
+            const metadata = reflector.get(PERMISSIONS_KEY, Controller.prototype.handler);
+            expect(metadata).toEqual({
+                permissions: [
+                    'user.read'
+                ],
+                operator: 'AND'
+            });
+        });
+        it('should set metadata with an empty permissions array when called with no args', ()=>{
+            let Controller = class Controller {
+                handler() {}
+            };
+            _ts_decorate([
+                RequirePermission(),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", void 0)
+            ], Controller.prototype, "handler", null);
+            const metadata = reflector.get(PERMISSIONS_KEY, Controller.prototype.handler);
+            expect(metadata).toEqual({
+                permissions: [],
+                operator: 'AND'
+            });
+        });
+    });
+    describe('RequireAnyPermission', ()=>{
+        it('should set metadata with OR operator', ()=>{
+            let Controller = class Controller {
+                handler() {}
+            };
+            _ts_decorate([
+                RequireAnyPermission('admin', 'manager'),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", void 0)
+            ], Controller.prototype, "handler", null);
+            const metadata = reflector.get(PERMISSIONS_KEY, Controller.prototype.handler);
+            expect(metadata).toEqual({
+                permissions: [
+                    'admin',
+                    'manager'
+                ],
+                operator: 'OR'
+            });
+        });
+    });
+    describe('RequirePermissionLogic', ()=>{
+        it('should set metadata with a raw string permission', ()=>{
+            let Controller = class Controller {
+                handler() {}
+            };
+            _ts_decorate([
+                RequirePermissionLogic('users.read'),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", void 0)
+            ], Controller.prototype, "handler", null);
+            const metadata = reflector.get(PERMISSIONS_KEY, Controller.prototype.handler);
+            expect(metadata).toBe('users.read');
+        });
+        it('should set metadata with a complex logic tree', ()=>{
+            const logic = {
+                type: 'group',
+                operator: 'AND',
+                children: [
+                    {
+                        type: 'action',
+                        actionId: 'users.read'
+                    },
+                    {
+                        type: 'group',
+                        operator: 'OR',
+                        children: [
+                            {
+                                type: 'action',
+                                actionId: 'admin'
+                            },
+                            {
+                                type: 'action',
+                                actionId: 'manager'
+                            }
+                        ]
+                    }
+                ]
+            };
+            let Controller = class Controller {
+                handler() {}
+            };
+            _ts_decorate([
+                RequirePermissionLogic(logic),
+                _ts_metadata("design:type", Function),
+                _ts_metadata("design:paramtypes", []),
+                _ts_metadata("design:returntype", void 0)
+            ], Controller.prototype, "handler", null);
+            const metadata = reflector.get(PERMISSIONS_KEY, Controller.prototype.handler);
+            expect(metadata).toEqual(logic);
+        });
+    });
+});

package/fesm/exceptions/base-app.exception.spec.js

@@ -0,0 +1,153 @@
+import { HttpStatus } from '@nestjs/common';
+import { ERROR_MESSAGES } from '../constants/message-keys';
+import { BaseAppException, ConflictException, ForbiddenException, InternalServerException, NotFoundException, ServiceUnavailableException, UnauthorizedException, ValidationException } from './base-app.exception';
+describe('BaseAppException', ()=>{
+    it('should default status to BAD_REQUEST when not provided', ()=>{
+        const exception = new BaseAppException({
+            message: 'oops'
+        });
+        expect(exception.getStatus()).toBe(HttpStatus.BAD_REQUEST);
+    });
+    it('should default messageKey to ERROR_MESSAGES.GENERIC when not provided', ()=>{
+        const exception = new BaseAppException({
+            message: 'oops'
+        });
+        expect(exception.messageKey).toBe(ERROR_MESSAGES.GENERIC);
+    });
+    it('should use the provided status, messageKey, messageVariables, errors, and metadata', ()=>{
+        const errors = [
+            {
+                field: 'name',
+                message: 'required'
+            }
+        ];
+        const exception = new BaseAppException({
+            message: 'Invalid',
+            messageKey: 'custom.key',
+            messageVariables: {
+                foo: 'bar'
+            },
+            status: HttpStatus.UNPROCESSABLE_ENTITY,
+            errors,
+            metadata: {
+                extra: true
+            }
+        });
+        expect(exception.getStatus()).toBe(HttpStatus.UNPROCESSABLE_ENTITY);
+        expect(exception.messageKey).toBe('custom.key');
+        expect(exception.messageVariables).toEqual({
+            foo: 'bar'
+        });
+        expect(exception.errors).toEqual(errors);
+        expect(exception.metadata).toEqual({
+            extra: true
+        });
+    });
+    it('should build an HttpException response body with success:false', ()=>{
+        const exception = new BaseAppException({
+            message: 'oops',
+            messageKey: 'k'
+        });
+        expect(exception.getResponse()).toEqual({
+            success: false,
+            message: 'oops',
+            messageKey: 'k',
+            messageVariables: undefined,
+            errors: undefined
+        });
+    });
+    describe('NotFoundException', ()=>{
+        it('should build a message with id when id is provided', ()=>{
+            const exception = new NotFoundException('User', 'uuid-1');
+            expect(exception.getStatus()).toBe(HttpStatus.NOT_FOUND);
+            expect(exception.message).toBe('User with id "uuid-1" not found');
+            expect(exception.messageKey).toBe(ERROR_MESSAGES.NOT_FOUND);
+            expect(exception.metadata).toEqual({
+                entity: 'User',
+                id: 'uuid-1'
+            });
+        });
+        it('should build a message without id when id is omitted', ()=>{
+            const exception = new NotFoundException('User');
+            expect(exception.message).toBe('User not found');
+        });
+    });
+    describe('ValidationException', ()=>{
+        it('should carry the validation errors and BAD_REQUEST status', ()=>{
+            const errors = [
+                {
+                    field: 'email',
+                    message: 'invalid format'
+                }
+            ];
+            const exception = new ValidationException(errors);
+            expect(exception.getStatus()).toBe(HttpStatus.BAD_REQUEST);
+            expect(exception.messageKey).toBe(ERROR_MESSAGES.VALIDATION);
+            expect(exception.errors).toEqual(errors);
+        });
+    });
+    describe('UnauthorizedException', ()=>{
+        it('should use the default message when none is provided', ()=>{
+            const exception = new UnauthorizedException();
+            expect(exception.getStatus()).toBe(HttpStatus.UNAUTHORIZED);
+            expect(exception.message).toBe('Unauthorized access');
+            expect(exception.messageKey).toBe(ERROR_MESSAGES.UNAUTHORIZED);
+        });
+        it('should use a custom message when provided', ()=>{
+            const exception = new UnauthorizedException('Custom message');
+            expect(exception.message).toBe('Custom message');
+        });
+    });
+    describe('ForbiddenException', ()=>{
+        it('should default to "Access forbidden"', ()=>{
+            const exception = new ForbiddenException();
+            expect(exception.getStatus()).toBe(HttpStatus.FORBIDDEN);
+            expect(exception.message).toBe('Access forbidden');
+            expect(exception.messageKey).toBe(ERROR_MESSAGES.FORBIDDEN);
+        });
+    });
+    describe('ConflictException', ()=>{
+        it('should include the field in the message and metadata when provided', ()=>{
+            const exception = new ConflictException('User', 'email');
+            expect(exception.getStatus()).toBe(HttpStatus.CONFLICT);
+            expect(exception.message).toBe('User with this email already exists');
+            expect(exception.messageVariables).toEqual({
+                entity: 'User',
+                field: 'email'
+            });
+            expect(exception.metadata).toEqual({
+                entity: 'User',
+                field: 'email'
+            });
+        });
+        it('should omit the field when not provided', ()=>{
+            const exception = new ConflictException('User');
+            expect(exception.message).toBe('User already exists');
+            expect(exception.messageVariables).toEqual({
+                entity: 'User'
+            });
+        });
+    });
+    describe('InternalServerException', ()=>{
+        it('should default to "Internal server error"', ()=>{
+            const exception = new InternalServerException();
+            expect(exception.getStatus()).toBe(HttpStatus.INTERNAL_SERVER_ERROR);
+            expect(exception.message).toBe('Internal server error');
+            expect(exception.messageKey).toBe(ERROR_MESSAGES.INTERNAL);
+        });
+    });
+    describe('ServiceUnavailableException', ()=>{
+        it('should build a message including the service name', ()=>{
+            const exception = new ServiceUnavailableException('Email');
+            expect(exception.getStatus()).toBe(HttpStatus.SERVICE_UNAVAILABLE);
+            expect(exception.message).toBe('Email is temporarily unavailable');
+            expect(exception.messageKey).toBe(ERROR_MESSAGES.SERVICE_UNAVAILABLE);
+            expect(exception.messageVariables).toEqual({
+                service: 'Email'
+            });
+            expect(exception.metadata).toEqual({
+                service: 'Email'
+            });
+        });
+    });
+});

package/fesm/exceptions/permission.exception.spec.js

@@ -0,0 +1,78 @@
+import { ForbiddenException, InternalServerErrorException } from '@nestjs/common';
+import { ERROR_MESSAGES } from '../constants/message-keys';
+import { InsufficientPermissionsException, NoPermissionsFoundException, PermissionSystemUnavailableException } from './permission.exception';
+describe('permission exceptions', ()=>{
+    describe('PermissionSystemUnavailableException', ()=>{
+        it('should be an InternalServerErrorException with the expected response body', ()=>{
+            const exception = new PermissionSystemUnavailableException();
+            expect(exception).toBeInstanceOf(InternalServerErrorException);
+            expect(exception.getResponse()).toMatchObject({
+                success: false,
+                message: 'Permission system temporarily unavailable',
+                messageKey: ERROR_MESSAGES.PERMISSION_SYSTEM_UNAVAILABLE
+            });
+        });
+    });
+    describe('InsufficientPermissionsException', ()=>{
+        it('should default to AND operator and matching messageKey', ()=>{
+            const exception = new InsufficientPermissionsException([
+                'user.create',
+                'user.update'
+            ]);
+            expect(exception).toBeInstanceOf(ForbiddenException);
+            expect(exception.getResponse()).toMatchObject({
+                success: false,
+                message: 'Insufficient permissions',
+                messageKey: ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS,
+                messageVariables: {
+                    permissions: 'user.create, user.update'
+                },
+                missingPermissions: [
+                    'user.create',
+                    'user.update'
+                ],
+                operator: 'AND'
+            });
+        });
+        it('should use the OR messageKey when operator is OR', ()=>{
+            const exception = new InsufficientPermissionsException([
+                'admin',
+                'manager'
+            ], 'OR');
+            expect(exception.getResponse()).toMatchObject({
+                messageKey: ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS_OR,
+                operator: 'OR'
+            });
+        });
+        it('should join a single missing permission without a separator', ()=>{
+            const exception = new InsufficientPermissionsException([
+                'user.create'
+            ]);
+            expect(exception.getResponse()).toMatchObject({
+                messageVariables: {
+                    permissions: 'user.create'
+                }
+            });
+        });
+        it('should handle an empty missing-permissions list', ()=>{
+            const exception = new InsufficientPermissionsException([]);
+            expect(exception.getResponse()).toMatchObject({
+                messageVariables: {
+                    permissions: ''
+                },
+                missingPermissions: []
+            });
+        });
+    });
+    describe('NoPermissionsFoundException', ()=>{
+        it('should be a ForbiddenException with the expected response body', ()=>{
+            const exception = new NoPermissionsFoundException();
+            expect(exception).toBeInstanceOf(ForbiddenException);
+            expect(exception.getResponse()).toMatchObject({
+                success: false,
+                message: 'No permissions found',
+                messageKey: ERROR_MESSAGES.NO_PERMISSIONS_FOUND
+            });
+        });
+    });
+});