@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/decorators/log-action.decorator.spec.js

@@ -1,349 +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);
-}
-import { Logger } from '@nestjs/common';
-const mockWinstonLogger = {
-    log: jest.fn(),
-    error: jest.fn()
-};
-const createModuleLoggerMock = jest.fn((..._args)=>mockWinstonLogger);
-jest.mock('../classes/winston.logger.class', ()=>({
-        createModuleLogger: (...args)=>createModuleLoggerMock(...args)
-    }));
-const getRequestIdMock = jest.fn(()=>'req-1');
-const getUserIdMock = jest.fn(()=>'user-1');
-const getTenantIdMock = jest.fn(()=>'tenant-1');
-const getCompanyIdMock = jest.fn(()=>'company-1');
-jest.mock('../middlewares/logger.middleware', ()=>({
-        getRequestId: ()=>getRequestIdMock(),
-        getUserId: ()=>getUserIdMock(),
-        getTenantId: ()=>getTenantIdMock(),
-        getCompanyId: ()=>getCompanyIdMock()
-    }));
-import { LogAction } from './log-action.decorator';
-describe('LogAction', ()=>{
-    let nestLoggerWarnSpy;
-    let nestLoggerDebugSpy;
-    let nestLoggerErrorSpy;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        nestLoggerWarnSpy = jest.spyOn(Logger.prototype, 'warn').mockImplementation(()=>undefined);
-        nestLoggerDebugSpy = jest.spyOn(Logger.prototype, 'debug').mockImplementation(()=>undefined);
-        nestLoggerErrorSpy = jest.spyOn(Logger.prototype, 'error').mockImplementation(()=>undefined);
-    });
-    afterEach(()=>{
-        jest.restoreAllMocks();
-    });
-    describe('using the Nest Logger (no moduleName)', ()=>{
-        let Service = class Service {
-            async doWork(value) {
-                return `done:${value}`;
-            }
-            async fail() {
-                throw new Error('boom');
-            }
-            constructor(){
-                _define_property(this, "entityName", 'product');
-            }
-        };
-        _ts_decorate([
-            LogAction(),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", [
-                String
-            ]),
-            _ts_metadata("design:returntype", Promise)
-        ], Service.prototype, "doWork", null);
-        _ts_decorate([
-            LogAction(),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", Promise)
-        ], Service.prototype, "fail", null);
-        it('should log a debug start/success message and return the original result', async ()=>{
-            const service = new Service();
-            const result = await service.doWork('x');
-            expect(result).toBe('done:x');
-            expect(nestLoggerDebugSpy).toHaveBeenCalledTimes(2);
-            const [startMessage] = nestLoggerDebugSpy.mock.calls[0];
-            expect(startMessage).toContain('Executing action method "product.doWork"');
-            const [successMessage] = nestLoggerDebugSpy.mock.calls[1];
-            expect(successMessage).toContain('Executed action method "product.doWork"');
-        });
-        it('should log and rethrow the original error on failure', async ()=>{
-            const service = new Service();
-            await expect(service.fail()).rejects.toThrow('boom');
-            expect(nestLoggerErrorSpy).toHaveBeenCalledTimes(1);
-            const [message, stack] = nestLoggerErrorSpy.mock.calls[0];
-            expect(message).toContain('Failed action method "product.fail"');
-            expect(message).toContain('boom');
-            expect(stack).toEqual(expect.any(String));
-        });
-    });
-    describe('using the Winston module logger (moduleName resolved from instance property)', ()=>{
-        let Service = class Service {
-            async doWork() {
-                return {
-                    id: '1'
-                };
-            }
-            constructor(){
-                _define_property(this, "entityName", 'product');
-                _define_property(this, "moduleName", 'catalog');
-            }
-        };
-        _ts_decorate([
-            LogAction(),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", Promise)
-        ], Service.prototype, "doWork", null);
-        it('should resolve the module logger via createModuleLogger(moduleName)', async ()=>{
-            const service = new Service();
-            await service.doWork();
-            expect(createModuleLoggerMock).toHaveBeenCalledWith('catalog');
-            expect(mockWinstonLogger.log).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('options', ()=>{
-        it('should use a custom action name when provided', async ()=>{
-            let Service = class Service {
-                async doWork() {
-                    return 'ok';
-                }
-            };
-            _ts_decorate([
-                LogAction({
-                    action: 'custom.action'
-                }),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork();
-            const [startMessage] = nestLoggerDebugSpy.mock.calls[0];
-            expect(startMessage).toContain('"custom.action"');
-        });
-        it('should prefer decorator module option over instance moduleName', async ()=>{
-            let Service = class Service {
-                async doWork() {
-                    return 'ok';
-                }
-                constructor(){
-                    _define_property(this, "moduleName", 'instance-module');
-                }
-            };
-            _ts_decorate([
-                LogAction({
-                    module: 'decorator-module'
-                }),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork();
-            expect(createModuleLoggerMock).toHaveBeenCalledWith('decorator-module');
-        });
-        it('should use the custom logLevel', async ()=>{
-            let Service = class Service {
-                async doWork() {
-                    return 'ok';
-                }
-            };
-            _ts_decorate([
-                LogAction({
-                    logLevel: 'warn'
-                }),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork();
-            // logLevel routes to the matching Logger method (nestLogger.warn), not nestLogger.log
-            expect(nestLoggerWarnSpy).toHaveBeenCalledTimes(2);
-            expect(nestLoggerDebugSpy).not.toHaveBeenCalled();
-        });
-        it('should redact sensitive keys from params when includeParams is true', async ()=>{
-            let Service = class Service {
-                async doWork(_dto) {
-                    return 'ok';
-                }
-            };
-            _ts_decorate([
-                LogAction({
-                    includeParams: true
-                }),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", [
-                    typeof Record === "undefined" ? Object : Record
-                ]),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork({
-                email: 'a@b.com',
-                password: 'secret',
-                token: 'abc'
-            });
-            const [, startContext] = nestLoggerDebugSpy.mock.calls[0];
-            expect(startContext.params[0]).toEqual({
-                email: 'a@b.com',
-                password: '[REDACTED]',
-                token: '[REDACTED]'
-            });
-        });
-        it('should pass through null/undefined/primitive args unchanged when sanitizing params', async ()=>{
-            let Service = class Service {
-                async doWork(_a, _b, _c) {
-                    return 'ok';
-                }
-            };
-            _ts_decorate([
-                LogAction({
-                    includeParams: true
-                }),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", [
-                    Object,
-                    Object,
-                    Object
-                ]),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork(null, undefined, 'plain-string');
-            const [, startContext] = nestLoggerDebugSpy.mock.calls[0];
-            expect(startContext.params).toEqual([
-                null,
-                undefined,
-                'plain-string'
-            ]);
-        });
-        it('should include a result preview when includeResult is true and result is an array', async ()=>{
-            let Service = class Service {
-                async doWork() {
-                    return [
-                        1,
-                        2,
-                        3
-                    ];
-                }
-            };
-            _ts_decorate([
-                LogAction({
-                    includeResult: true
-                }),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork();
-            const [, successContext] = nestLoggerDebugSpy.mock.calls[1];
-            expect(successContext.resultType).toBe('Array<3 items>');
-            expect(successContext.resultPreview).toEqual({
-                count: 3,
-                sample: [
-                    1,
-                    2
-                ]
-            });
-        });
-        it('should include a keys-preview when includeResult is true and result is an object', async ()=>{
-            let Service = class Service {
-                async doWork() {
-                    return {
-                        a: 1,
-                        b: 2,
-                        c: 3,
-                        d: 4,
-                        e: 5,
-                        f: 6
-                    };
-                }
-            };
-            _ts_decorate([
-                LogAction({
-                    includeResult: true
-                }),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork();
-            const [, successContext] = nestLoggerDebugSpy.mock.calls[1];
-            expect(successContext.resultPreview).toEqual({
-                keys: [
-                    'a',
-                    'b',
-                    'c',
-                    'd',
-                    'e',
-                    'f'
-                ].slice(0, 5),
-                hasMore: true
-            });
-        });
-        it('should not attach a result preview when includeResult is false', async ()=>{
-            let Service = class Service {
-                async doWork() {
-                    return {
-                        a: 1
-                    };
-                }
-            };
-            _ts_decorate([
-                LogAction(),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "doWork", null);
-            await new Service().doWork();
-            const [, successContext] = nestLoggerDebugSpy.mock.calls[1];
-            expect(successContext.resultPreview).toBeUndefined();
-        });
-        it('should report resultType "null" and "undefined" correctly', async ()=>{
-            let Service = class Service {
-                async returnsNull() {
-                    return null;
-                }
-                async returnsUndefined() {
-                    return undefined;
-                }
-            };
-            _ts_decorate([
-                LogAction(),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "returnsNull", null);
-            _ts_decorate([
-                LogAction(),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "returnsUndefined", null);
-            const service = new Service();
-            await service.returnsNull();
-            await service.returnsUndefined();
-            expect(nestLoggerDebugSpy.mock.calls[1][1].resultType).toBe('null');
-            expect(nestLoggerDebugSpy.mock.calls[3][1].resultType).toBe('undefined');
-        });
-    });
-});

package/fesm/decorators/on-domain-event.decorator.js

@@ -1,10 +0,0 @@
-import { SetMetadata } from '@nestjs/common';
-import { DOMAIN_EVENT_HANDLER_KEY } from '../constants';
-/**
- * Marks a provider method as a domain event consumer.
- *
- * `*` matches one segment, `**` (or `#`) matches the rest:
- *   `@OnDomainEvent('storage.folder.created')`
- *   `@OnDomainEvent('auth.*.updated')`
- *   `@OnDomainEvent('**')`
- */ export const OnDomainEvent = (...patterns)=>SetMetadata(DOMAIN_EVENT_HANDLER_KEY, patterns);

package/fesm/decorators/on-domain-event.decorator.spec.js

@@ -1,46 +0,0 @@
-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 { DOMAIN_EVENT_HANDLER_KEY } from '../constants';
-import { OnDomainEvent } from './on-domain-event.decorator';
-let TestConsumer = class TestConsumer {
-    handleCreated() {}
-    handleDeleted() {}
-    handlePlain() {}
-};
-_ts_decorate([
-    OnDomainEvent('storage.folder.created'),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", []),
-    _ts_metadata("design:returntype", void 0)
-], TestConsumer.prototype, "handleCreated", null);
-_ts_decorate([
-    OnDomainEvent('auth.*.deleted', 'iam.*.deleted'),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", []),
-    _ts_metadata("design:returntype", void 0)
-], TestConsumer.prototype, "handleDeleted", null);
-describe('OnDomainEvent', ()=>{
-    it('should attach a single pattern as metadata', ()=>{
-        const patterns = Reflect.getMetadata(DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handleCreated);
-        expect(patterns).toEqual([
-            'storage.folder.created'
-        ]);
-    });
-    it('should attach every pattern passed to the decorator', ()=>{
-        const patterns = Reflect.getMetadata(DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handleDeleted);
-        expect(patterns).toEqual([
-            'auth.*.deleted',
-            'iam.*.deleted'
-        ]);
-    });
-    it('should leave undecorated methods without metadata', ()=>{
-        expect(Reflect.getMetadata(DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handlePlain)).toBeUndefined();
-    });
-});

package/fesm/decorators/public.decorator.js

@@ -1,20 +0,0 @@
-import { SetMetadata } from '@nestjs/common';
-import { IS_PUBLIC_KEY } from '../constants';
-/**
- * Decorator to mark routes as public (skip authentication)
- *
- * Use this on controller methods or entire controllers to bypass
- * JWT authentication guards.
- *
- * @example
- * // Skip auth for a single route
- * @Public()
- * @Post('login')
- * login() { }
- *
- * @example
- * // Skip auth for entire controller
- * @Public()
- * @Controller('public')
- * export class PublicController { }
- */ export const Public = ()=>SetMetadata(IS_PUBLIC_KEY, true);

package/fesm/decorators/public.decorator.spec.js

@@ -1,46 +0,0 @@
-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 { IS_PUBLIC_KEY } from '../constants';
-import { Public } from './public.decorator';
-describe('Public', ()=>{
-    it('should set the IS_PUBLIC_KEY metadata to true on a method', ()=>{
-        let TestController = class TestController {
-            handler() {}
-        };
-        _ts_decorate([
-            Public(),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", void 0)
-        ], TestController.prototype, "handler", null);
-        const reflector = new Reflector();
-        const metadata = reflector.get(IS_PUBLIC_KEY, TestController.prototype.handler);
-        expect(metadata).toBe(true);
-    });
-    it('should set the IS_PUBLIC_KEY metadata to true on a class', ()=>{
-        let TestController = class TestController {
-        };
-        TestController = _ts_decorate([
-            Public()
-        ], TestController);
-        const reflector = new Reflector();
-        const metadata = reflector.get(IS_PUBLIC_KEY, TestController);
-        expect(metadata).toBe(true);
-    });
-    it('should not set metadata on a handler that does not use the decorator', ()=>{
-        let TestController = class TestController {
-            handler() {}
-        };
-        const reflector = new Reflector();
-        const metadata = reflector.get(IS_PUBLIC_KEY, TestController.prototype.handler);
-        expect(metadata).toBeUndefined();
-    });
-});

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

@@ -1,27 +0,0 @@
-import { SetMetadata } from '@nestjs/common';
-import { PERMISSIONS_KEY } from '../constants';
-/** Require ALL permissions (AND logic) - most secure pattern */ export const RequirePermission = (...permissions)=>SetMetadata(PERMISSIONS_KEY, {
-        permissions,
-        operator: 'AND'
-    });
-/** Require ANY permission (OR logic) - use carefully */ export const RequireAnyPermission = (...permissions)=>SetMetadata(PERMISSIONS_KEY, {
-        permissions,
-        operator: 'OR'
-    });
-/**
- * Require complex permission logic using ILogicNode tree
- * @example
- * // Single permission
- * @RequirePermissionLogic('users.read')
- * @example
- * // Complex: users.read AND (admin OR manager)
- * @RequirePermissionLogic({
- *   type: 'group', operator: 'AND', children: [
- *     { type: 'action', actionId: 'users.read' },
- *     { type: 'group', operator: 'OR', children: [
- *       { type: 'action', actionId: 'admin' },
- *       { type: 'action', actionId: 'manager' },
- *     ]},
- *   ],
- * })
- */ export const RequirePermissionLogic = (logic)=>SetMetadata(PERMISSIONS_KEY, logic);

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

@@ -1,143 +0,0 @@
-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);
-        });
-    });
-});