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

package/cjs/decorators/log-action.decorator.js

@@ -1,149 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "LogAction", {
-    enumerable: true,
-    get: function() {
-        return LogAction;
-    }
-});
-const _common = require("@nestjs/common");
-const _winstonloggerclass = require("../classes/winston.logger.class");
-const _loggermiddleware = require("../middlewares/logger.middleware");
-function createLoggerAdapter(className, moduleName) {
-    if (moduleName) {
-        const winstonLogger = (0, _winstonloggerclass.createModuleLogger)(moduleName);
-        return {
-            log: (level, message, meta)=>{
-                winstonLogger.log(level, message, {
-                    context: className,
-                    ...meta
-                });
-            },
-            error: (message, stack, meta)=>{
-                winstonLogger.error(message, {
-                    context: className,
-                    stack,
-                    ...meta
-                });
-            }
-        };
-    }
-    const nestLogger = new _common.Logger(className);
-    return {
-        log: (level, message, meta)=>{
-            nestLogger[level](message, meta);
-        },
-        error: (message, stack, meta)=>{
-            nestLogger.error(message, stack, meta);
-        }
-    };
-}
-function LogAction(options = {}) {
-    return function(target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const className = target.constructor.name;
-        const methodName = String(propertyKey);
-        descriptor.value = async function(...args) {
-            const startTime = Date.now();
-            // Resolve module: decorator option > instance property > undefined
-            const moduleName = options.module || this.moduleName;
-            const logger = createLoggerAdapter(className, moduleName);
-            const action = options.action || `${this.entityName || className}.${methodName}`;
-            const logLevel = options.logLevel || 'debug';
-            const context = {
-                requestId: (0, _loggermiddleware.getRequestId)(),
-                userId: (0, _loggermiddleware.getUserId)(),
-                tenantId: (0, _loggermiddleware.getTenantId)(),
-                companyId: (0, _loggermiddleware.getCompanyId)(),
-                method: methodName,
-                module: moduleName
-            };
-            const startMessage = `Executing action method "${action}"`;
-            const startContext = options.includeParams ? {
-                ...context,
-                params: sanitizeParams(args)
-            } : context;
-            logger.log(logLevel, startMessage, startContext);
-            try {
-                const result = await originalMethod.apply(this, args);
-                const duration = Date.now() - startTime;
-                const resultType = getResultType(result);
-                const successMessage = `Executed action method "${action}", returned result "${resultType}" in ${duration.toFixed(2)}ms.`;
-                const successContext = options.includeResult && result ? {
-                    ...context,
-                    duration: `${duration}ms`,
-                    resultType,
-                    resultPreview: getResultPreview(result)
-                } : {
-                    ...context,
-                    duration: `${duration}ms`,
-                    resultType
-                };
-                logger.log(logLevel, successMessage, successContext);
-                return result;
-            } catch (error) {
-                const duration = Date.now() - startTime;
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                logger.error(`Failed action method "${action}" after ${duration.toFixed(2)}ms: ${errorMessage}`, error instanceof Error ? error.stack : undefined, {
-                    ...context,
-                    duration: `${duration}ms`,
-                    error: errorMessage
-                });
-                throw error;
-            }
-        };
-        return descriptor;
-    };
-}
-function sanitizeParams(args) {
-    return args.map((arg)=>{
-        if (arg === null || arg === undefined) return arg;
-        if (typeof arg === 'object') {
-            const sanitized = {
-                ...arg
-            };
-            const sensitiveKeys = [
-                'password',
-                'secret',
-                'token',
-                'apiKey',
-                'authorization'
-            ];
-            for (const key of Object.keys(sanitized)){
-                if (sensitiveKeys.some((sk)=>key.toLowerCase().includes(sk))) {
-                    sanitized[key] = '[REDACTED]';
-                }
-            }
-            return sanitized;
-        }
-        return arg;
-    });
-}
-function getResultType(result) {
-    if (result === null) return 'null';
-    if (result === undefined) return 'undefined';
-    if (Array.isArray(result)) return `Array<${result.length} items>`;
-    if (typeof result === 'object') {
-        const name = result.constructor?.name;
-        return name && name !== 'Object' ? name : 'Object';
-    }
-    return typeof result;
-}
-function getResultPreview(result) {
-    if (Array.isArray(result)) {
-        return {
-            count: result.length,
-            sample: result.slice(0, 2)
-        };
-    }
-    if (typeof result === 'object' && result !== null) {
-        const keys = Object.keys(result).slice(0, 5);
-        return {
-            keys,
-            hasMore: Object.keys(result).length > 5
-        };
-    }
-    return result;
-}

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

@@ -1,353 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _logactiondecorator = require("./log-action.decorator");
-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);
-}
-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()
-    }));
-describe('LogAction', ()=>{
-    let nestLoggerWarnSpy;
-    let nestLoggerDebugSpy;
-    let nestLoggerErrorSpy;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        nestLoggerWarnSpy = jest.spyOn(_common.Logger.prototype, 'warn').mockImplementation(()=>undefined);
-        nestLoggerDebugSpy = jest.spyOn(_common.Logger.prototype, 'debug').mockImplementation(()=>undefined);
-        nestLoggerErrorSpy = jest.spyOn(_common.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([
-            (0, _logactiondecorator.LogAction)(),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", [
-                String
-            ]),
-            _ts_metadata("design:returntype", Promise)
-        ], Service.prototype, "doWork", null);
-        _ts_decorate([
-            (0, _logactiondecorator.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([
-            (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.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([
-                (0, _logactiondecorator.LogAction)(),
-                _ts_metadata("design:type", Function),
-                _ts_metadata("design:paramtypes", []),
-                _ts_metadata("design:returntype", Promise)
-            ], Service.prototype, "returnsNull", null);
-            _ts_decorate([
-                (0, _logactiondecorator.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/cjs/decorators/on-domain-event.decorator.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "OnDomainEvent", {
-    enumerable: true,
-    get: function() {
-        return OnDomainEvent;
-    }
-});
-const _common = require("@nestjs/common");
-const _constants = require("../constants");
-const OnDomainEvent = (...patterns)=>(0, _common.SetMetadata)(_constants.DOMAIN_EVENT_HANDLER_KEY, patterns);

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

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _constants = require("../constants");
-const _ondomaineventdecorator = require("./on-domain-event.decorator");
-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);
-}
-let TestConsumer = class TestConsumer {
-    handleCreated() {}
-    handleDeleted() {}
-    handlePlain() {}
-};
-_ts_decorate([
-    (0, _ondomaineventdecorator.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([
-    (0, _ondomaineventdecorator.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(_constants.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(_constants.DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handleDeleted);
-        expect(patterns).toEqual([
-            'auth.*.deleted',
-            'iam.*.deleted'
-        ]);
-    });
-    it('should leave undecorated methods without metadata', ()=>{
-        expect(Reflect.getMetadata(_constants.DOMAIN_EVENT_HANDLER_KEY, TestConsumer.prototype.handlePlain)).toBeUndefined();
-    });
-});

package/cjs/decorators/public.decorator.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Public", {
-    enumerable: true,
-    get: function() {
-        return Public;
-    }
-});
-const _common = require("@nestjs/common");
-const _constants = require("../constants");
-const Public = ()=>(0, _common.SetMetadata)(_constants.IS_PUBLIC_KEY, true);

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

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _core = require("@nestjs/core");
-const _constants = require("../constants");
-const _publicdecorator = require("./public.decorator");
-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);
-}
-describe('Public', ()=>{
-    it('should set the IS_PUBLIC_KEY metadata to true on a method', ()=>{
-        let TestController = class TestController {
-            handler() {}
-        };
-        _ts_decorate([
-            (0, _publicdecorator.Public)(),
-            _ts_metadata("design:type", Function),
-            _ts_metadata("design:paramtypes", []),
-            _ts_metadata("design:returntype", void 0)
-        ], TestController.prototype, "handler", null);
-        const reflector = new _core.Reflector();
-        const metadata = reflector.get(_constants.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([
-            (0, _publicdecorator.Public)()
-        ], TestController);
-        const reflector = new _core.Reflector();
-        const metadata = reflector.get(_constants.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 _core.Reflector();
-        const metadata = reflector.get(_constants.IS_PUBLIC_KEY, TestController.prototype.handler);
-        expect(metadata).toBeUndefined();
-    });
-});

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

@@ -1,32 +0,0 @@
-"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 RequireAnyPermission () {
-        return RequireAnyPermission;
-    },
-    get RequirePermission () {
-        return RequirePermission;
-    },
-    get RequirePermissionLogic () {
-        return RequirePermissionLogic;
-    }
-});
-const _common = require("@nestjs/common");
-const _constants = require("../constants");
-const RequirePermission = (...permissions)=>(0, _common.SetMetadata)(_constants.PERMISSIONS_KEY, {
-        permissions,
-        operator: 'AND'
-    });
-const RequireAnyPermission = (...permissions)=>(0, _common.SetMetadata)(_constants.PERMISSIONS_KEY, {
-        permissions,
-        operator: 'OR'
-    });
-const RequirePermissionLogic = (logic)=>(0, _common.SetMetadata)(_constants.PERMISSIONS_KEY, logic);