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

package/cjs/classes/winston.logger.class.js

@@ -1,274 +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 createModuleLogger () {
-        return createModuleLogger;
-    },
-    get instance () {
-        return instance;
-    }
-});
-const _config = require("@flusys/nestjs-core/config");
-const _fs = require("fs");
-const _path = require("path");
-const _winston = require("winston");
-const _winstondailyrotatefile = /*#__PURE__*/ _interop_require_wildcard(require("winston-daily-rotate-file"));
-const _winstontransport = /*#__PURE__*/ _interop_require_wildcard(require("winston-transport"));
-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 _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-const Transport = _winstontransport.default || _winstontransport;
-const DailyRotateFile = _winstondailyrotatefile.default || _winstondailyrotatefile;
-// Configuration
-const logConfig = _config.envConfig.getLogConfig();
-const LOG_DIR = logConfig.dir;
-const LOG_LEVEL = logConfig.level;
-const LOG_MAX_SIZE = logConfig.maxSize;
-const LOG_MAX_FILES = logConfig.maxFiles;
-const USE_TENANT_MODE = _config.envConfig.useTenantMode();
-// Ensure logs directory exists
-if (!(0, _fs.existsSync)(LOG_DIR)) {
-    (0, _fs.mkdirSync)(LOG_DIR, {
-        recursive: true
-    });
-}
-// Custom Formats
-/**
- * Custom format for structured logging (production)
- * Multi-line format:
- * - Line 1: Timestamp
- * - Line 2: Log Level
- * - Line 3: [RequestId]
- * - Line 4: Empty
- * - Line 5+: Message with context
- */ const LEVEL_MAP = {
-    error: 'Error',
-    warn: 'Warning',
-    info: 'Information',
-    debug: 'Debug',
-    verbose: 'Verbose'
-};
-const LOG_SEPARATOR = '─'.repeat(80);
-const structuredFormat = _winston.format.printf(({ timestamp, level, message, context, requestId, userId, tenantId, companyId, method, url, path, statusCode, duration, stack, ...metadata })=>{
-    const reqId = requestId || 'no-request-id';
-    const levelFormatted = LEVEL_MAP[level] || level.charAt(0).toUpperCase() + level.slice(1);
-    const contextParts = [];
-    if (context) contextParts.push(`Context: ${context}`);
-    if (method && (path || url)) contextParts.push(`Endpoint: ${method} ${path || url}`);
-    if (statusCode) contextParts.push(`Status: ${statusCode}`);
-    if (duration) contextParts.push(`Duration: ${duration}`);
-    if (userId) contextParts.push(`UserId: ${userId}`);
-    if (tenantId) contextParts.push(`TenantId: ${tenantId}`);
-    if (companyId) contextParts.push(`CompanyId: ${companyId}`);
-    let content = message;
-    if (contextParts.length > 0) {
-        content = `${contextParts.join(' | ')}\n${message}`;
-    }
-    const metaKeys = Object.keys(metadata).filter((k)=>k !== 'splat');
-    if (metaKeys.length > 0) {
-        const metaStr = JSON.stringify(metaKeys.reduce((acc, k)=>({
-                ...acc,
-                [k]: metadata[k]
-            }), {}));
-        content += `\nMetadata: ${metaStr}`;
-    }
-    if (stack) {
-        content += `\nStack: ${stack}`;
-    }
-    return `${LOG_SEPARATOR}\n${timestamp} | ${levelFormatted} | [${reqId}]\n${content}`;
-});
-// Transports
-/**
- * Daily rotating file transport for all logs
- */ const combinedRotateTransport = new DailyRotateFile({
-    filename: `${LOG_DIR}/combined-%DATE%.log`,
-    datePattern: 'YYYY-MM-DD',
-    zippedArchive: true,
-    maxSize: LOG_MAX_SIZE,
-    maxFiles: LOG_MAX_FILES,
-    level: LOG_LEVEL
-});
-/**
- * Daily rotating file transport for error logs only
- */ const errorRotateTransport = new DailyRotateFile({
-    filename: `${LOG_DIR}/error-%DATE%.log`,
-    datePattern: 'YYYY-MM-DD',
-    zippedArchive: true,
-    maxSize: LOG_MAX_SIZE,
-    maxFiles: LOG_MAX_FILES,
-    level: 'error'
-});
-// Transport Caches
-const moduleTransportCache = new Map();
-const tenantTransportCache = new Map();
-function getCachedTransport(cache, name) {
-    const cached = cache.get(name);
-    if (cached) return cached;
-    const logDir = (0, _path.join)(LOG_DIR, name);
-    if (!(0, _fs.existsSync)(logDir)) {
-        (0, _fs.mkdirSync)(logDir, {
-            recursive: true
-        });
-    }
-    const transport = new DailyRotateFile({
-        filename: `${logDir}/combined-%DATE%.log`,
-        datePattern: 'YYYY-MM-DD',
-        zippedArchive: true,
-        maxSize: LOG_MAX_SIZE,
-        maxFiles: LOG_MAX_FILES,
-        level: LOG_LEVEL
-    });
-    cache.set(name, transport);
-    return transport;
-}
-const getModuleTransport = (name)=>getCachedTransport(moduleTransportCache, name);
-const getTenantTransport = (name)=>getCachedTransport(tenantTransportCache, name);
-let TenantAwareTransport = class TenantAwareTransport extends Transport {
-    log(info, callback) {
-        setImmediate(()=>this.emit('logged', info));
-        const tenantId = info.tenantId || info.metadata?.tenantId;
-        const transport = USE_TENANT_MODE && tenantId ? getTenantTransport(tenantId) : this.defaultTransport;
-        transport.log(info, callback);
-    }
-    constructor(defaultTransport){
-        super(), _define_property(this, "defaultTransport", void 0), this.defaultTransport = defaultTransport;
-    }
-};
-const tenantAwareCombinedTransport = new TenantAwareTransport(combinedRotateTransport);
-const consoleTransport = new _winston.transports.Console({
-    level: LOG_LEVEL,
-    format: _winston.format.combine(_winston.format.colorize({
-        all: true
-    }), _winston.format.timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss'
-    }), _winston.format.errors({
-        stack: true
-    }), structuredFormat)
-});
-// Logger Instances
-/**
- * Development logger configuration
- * - Console output with colors
- * - Human-readable format
- * - Debug level by default
- */ const devLogger = (0, _winston.createLogger)({
-    level: LOG_LEVEL,
-    format: _winston.format.combine(_winston.format.timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss'
-    }), _winston.format.errors({
-        stack: true
-    })),
-    transports: [
-        consoleTransport
-    ],
-    exitOnError: false
-});
-/**
- * Production logger configuration
- * - File-based logging with rotation
- * - JSON structured format
- * - Separate error log file
- * - Compressed old logs
- * - Tenant-aware routing (when USE_TENANT_MODE=true)
- */ const prodLogger = (0, _winston.createLogger)({
-    level: LOG_LEVEL,
-    format: _winston.format.combine(_winston.format.timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss.SSS'
-    }), _winston.format.errors({
-        stack: true
-    }), structuredFormat),
-    transports: [
-        tenantAwareCombinedTransport,
-        errorRotateTransport
-    ],
-    exitOnError: false
-});
-const instance = _config.envConfig.isProduction() ? prodLogger : devLogger;
-/**
- * Module logger cache to avoid creating multiple loggers for the same module
- */ const moduleLoggerCache = new Map();
-function createModuleLogger(moduleName) {
-    // In dev mode, use global console logger
-    if (!_config.envConfig.isProduction()) {
-        return devLogger;
-    }
-    // Check cache first
-    if (moduleLoggerCache.has(moduleName)) {
-        return moduleLoggerCache.get(moduleName);
-    }
-    // Create module-specific logger for production
-    const moduleLogger = (0, _winston.createLogger)({
-        level: LOG_LEVEL,
-        format: _winston.format.combine(_winston.format.timestamp({
-            format: 'YYYY-MM-DD HH:mm:ss.SSS'
-        }), _winston.format.errors({
-            stack: true
-        }), structuredFormat),
-        transports: [
-            getModuleTransport(moduleName),
-            errorRotateTransport
-        ],
-        exitOnError: false
-    });
-    moduleLoggerCache.set(moduleName, moduleLogger);
-    return moduleLogger;
-}

package/cjs/classes/winston.logger.class.spec.js

@@ -1,330 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-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;
-}
-const mockExistsSync = jest.fn();
-const mockMkdirSync = jest.fn();
-jest.mock('fs', ()=>({
-        existsSync: (...args)=>mockExistsSync(...args),
-        mkdirSync: (...args)=>mockMkdirSync(...args)
-    }));
-const mockGetLogConfig = jest.fn();
-const mockUseTenantMode = jest.fn();
-const mockIsProduction = jest.fn();
-jest.mock('@flusys/nestjs-core/config', ()=>({
-        envConfig: {
-            getLogConfig: (...args)=>mockGetLogConfig(...args),
-            useTenantMode: (...args)=>mockUseTenantMode(...args),
-            isProduction: (...args)=>mockIsProduction(...args)
-        }
-    }));
-const { EventEmitter } = require('events');
-let FakeDailyRotateFile = class FakeDailyRotateFile extends EventEmitter {
-    constructor(options){
-        super(), _define_property(this, "options", void 0), _define_property(this, "log", jest.fn((_info, callback)=>callback?.()));
-        this.options = options;
-    }
-};
-jest.mock('winston-daily-rotate-file', ()=>({
-        __esModule: true,
-        default: FakeDailyRotateFile
-    }));
-let capturedPrintf;
-jest.mock('winston', ()=>{
-    const actual = jest.requireActual('winston');
-    // winston's `format` export exposes its sub-formatters (colorize, combine, printf, ...)
-    // as non-enumerable getters, so a plain object spread silently drops them. Delegate through
-    // the prototype chain instead and only shadow `printf` to capture the formatter callback.
-    const realPrintf = actual.format.printf;
-    const mockFormat = Object.create(actual.format);
-    Object.defineProperty(mockFormat, 'printf', {
-        value: (fn)=>{
-            capturedPrintf = fn;
-            return realPrintf(fn);
-        }
-    });
-    return {
-        ...actual,
-        format: mockFormat
-    };
-});
-describe('winston.logger.class', ()=>{
-    let consoleErrorSpy;
-    beforeEach(()=>{
-        jest.resetModules();
-        jest.clearAllMocks();
-        // FakeDailyRotateFile isn't a real winston-transport instance, so winston logs a
-        // harmless "legacy transport" deprecation warning via console.error on each createLogger call.
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(()=>undefined);
-        mockExistsSync.mockReturnValue(true);
-        mockGetLogConfig.mockReturnValue({
-            dir: 'logs',
-            level: 'debug',
-            maxSize: '20m',
-            maxFiles: '14d',
-            disableHttpLogging: false
-        });
-        mockUseTenantMode.mockReturnValue(false);
-    });
-    afterEach(()=>{
-        consoleErrorSpy.mockRestore();
-    });
-    it('should create the log directory when it does not exist', ()=>{
-        mockExistsSync.mockReturnValue(false);
-        mockIsProduction.mockReturnValue(false);
-        require('./winston.logger.class');
-        expect(mockMkdirSync).toHaveBeenCalledWith('logs', {
-            recursive: true
-        });
-    });
-    it('should not attempt to create the log directory when it already exists', ()=>{
-        mockExistsSync.mockReturnValue(true);
-        mockIsProduction.mockReturnValue(false);
-        require('./winston.logger.class');
-        expect(mockMkdirSync).not.toHaveBeenCalledWith('logs', {
-            recursive: true
-        });
-    });
-    it('should export a dev (console-based) instance when not in production', ()=>{
-        mockIsProduction.mockReturnValue(false);
-        const { instance } = require('./winston.logger.class');
-        expect(instance).toBeDefined();
-        expect(typeof instance.log).toBe('function');
-    });
-    it('should export a prod (file-rotation-based) instance when in production', ()=>{
-        mockIsProduction.mockReturnValue(true);
-        const { instance } = require('./winston.logger.class');
-        expect(instance).toBeDefined();
-        expect(typeof instance.log).toBe('function');
-    });
-    describe('createModuleLogger', ()=>{
-        it('should return the shared dev logger instance in non-production mode', ()=>{
-            mockIsProduction.mockReturnValue(false);
-            const { createModuleLogger, instance } = require('./winston.logger.class');
-            expect(createModuleLogger('auth')).toBe(instance);
-            expect(createModuleLogger('iam')).toBe(instance);
-        });
-        it('should create a distinct, cached logger per module in production mode', ()=>{
-            mockIsProduction.mockReturnValue(true);
-            const { createModuleLogger } = require('./winston.logger.class');
-            const authLogger1 = createModuleLogger('auth');
-            const authLogger2 = createModuleLogger('auth');
-            const iamLogger = createModuleLogger('iam');
-            expect(authLogger1).toBe(authLogger2);
-            expect(authLogger1).not.toBe(iamLogger);
-        });
-        it('should create the module-specific log directory on first use in production mode', ()=>{
-            mockIsProduction.mockReturnValue(true);
-            mockExistsSync.mockImplementation((p)=>p === 'logs');
-            const { createModuleLogger } = require('./winston.logger.class');
-            createModuleLogger('storage');
-            expect(mockMkdirSync).toHaveBeenCalledWith(expect.stringContaining('storage'), {
-                recursive: true
-            });
-        });
-        it('should not recreate the module directory or transport on subsequent calls', ()=>{
-            mockIsProduction.mockReturnValue(true);
-            mockExistsSync.mockReturnValue(true);
-            const { createModuleLogger } = require('./winston.logger.class');
-            createModuleLogger('storage');
-            const mkdirCallsAfterFirst = mockMkdirSync.mock.calls.length;
-            createModuleLogger('storage');
-            expect(mockMkdirSync.mock.calls.length).toBe(mkdirCallsAfterFirst);
-        });
-    });
-    describe('structuredFormat (captured printf callback)', ()=>{
-        beforeEach(()=>{
-            mockIsProduction.mockReturnValue(true);
-            capturedPrintf = undefined;
-            require('./winston.logger.class');
-        });
-        it('should capture the printf formatter', ()=>{
-            expect(capturedPrintf).toBeInstanceOf(Function);
-        });
-        it('should default the request id when absent and map known levels', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'error',
-                message: 'boom'
-            });
-            expect(out).toContain('[no-request-id]');
-            expect(out).toContain('Error');
-        });
-        it('should use the provided requestId and title-case unknown levels', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'silly',
-                message: 'x',
-                requestId: 'req-1'
-            });
-            expect(out).toContain('[req-1]');
-            expect(out).toContain('Silly');
-        });
-        it('should render context, endpoint, status, duration and user/tenant/company parts', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'info',
-                message: 'handled',
-                context: 'AuthService',
-                method: 'POST',
-                path: '/login',
-                statusCode: 200,
-                duration: '12ms',
-                userId: 'u1',
-                tenantId: 't1',
-                companyId: 'c1'
-            });
-            expect(out).toContain('Context: AuthService');
-            expect(out).toContain('Endpoint: POST /login');
-            expect(out).toContain('Status: 200');
-            expect(out).toContain('Duration: 12ms');
-            expect(out).toContain('UserId: u1');
-            expect(out).toContain('TenantId: t1');
-            expect(out).toContain('CompanyId: c1');
-            expect(out).toContain('handled');
-        });
-        it('should fall back to `url` for the endpoint line when `path` is absent', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'info',
-                message: 'm',
-                method: 'GET',
-                url: '/legacy'
-            });
-            expect(out).toContain('Endpoint: GET /legacy');
-        });
-        it('should omit the endpoint line entirely when method has no path or url', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'info',
-                message: 'm',
-                method: 'GET'
-            });
-            expect(out).not.toContain('Endpoint:');
-        });
-        it('should append remaining metadata as JSON, excluding the `splat` key', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'info',
-                message: 'm',
-                splat: [
-                    'ignored'
-                ],
-                orderId: 'o1',
-                amount: 50
-            });
-            expect(out).toContain('Metadata: {"orderId":"o1","amount":50}');
-            expect(out).not.toContain('ignored');
-        });
-        it('should omit the Metadata line when no extra metadata remains', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'info',
-                message: 'm',
-                splat: []
-            });
-            expect(out).not.toContain('Metadata:');
-        });
-        it('should append the stack trace when present', ()=>{
-            const out = capturedPrintf({
-                timestamp: 'T',
-                level: 'error',
-                message: 'crashed',
-                stack: 'Error: crashed\n    at foo.ts:1:1'
-            });
-            expect(out).toContain('Stack: Error: crashed');
-        });
-    });
-    describe('TenantAwareTransport routing', ()=>{
-        it('should route to the default transport when tenant mode is disabled', ()=>{
-            mockIsProduction.mockReturnValue(true);
-            mockUseTenantMode.mockReturnValue(false);
-            const { instance } = require('./winston.logger.class');
-            const tenantAwareTransport = instance.transports[0];
-            const defaultTransport = tenantAwareTransport.defaultTransport;
-            const logSpy = jest.spyOn(defaultTransport, 'log');
-            const cb = jest.fn();
-            tenantAwareTransport.log({
-                level: 'info',
-                message: 'x',
-                tenantId: 't1'
-            }, cb);
-            expect(logSpy).toHaveBeenCalled();
-        });
-        it('should route to the default transport when tenant mode is enabled but no tenantId is present', ()=>{
-            mockIsProduction.mockReturnValue(true);
-            mockUseTenantMode.mockReturnValue(true);
-            const { instance } = require('./winston.logger.class');
-            const tenantAwareTransport = instance.transports[0];
-            const defaultTransport = tenantAwareTransport.defaultTransport;
-            const logSpy = jest.spyOn(defaultTransport, 'log');
-            const cb = jest.fn();
-            tenantAwareTransport.log({
-                level: 'info',
-                message: 'x'
-            }, cb);
-            expect(logSpy).toHaveBeenCalled();
-        });
-        it('should route to a tenant-specific transport when tenant mode is enabled and tenantId is present', ()=>{
-            mockIsProduction.mockReturnValue(true);
-            mockUseTenantMode.mockReturnValue(true);
-            mockExistsSync.mockReturnValue(true);
-            const { instance } = require('./winston.logger.class');
-            const tenantAwareTransport = instance.transports[0];
-            const defaultTransport = tenantAwareTransport.defaultTransport;
-            const defaultLogSpy = jest.spyOn(defaultTransport, 'log');
-            const cb = jest.fn();
-            tenantAwareTransport.log({
-                level: 'info',
-                message: 'x',
-                tenantId: 'tenant-a'
-            }, cb);
-            expect(defaultLogSpy).not.toHaveBeenCalled();
-        });
-        it('should read tenantId from nested `metadata.tenantId` when top-level tenantId is absent', ()=>{
-            mockIsProduction.mockReturnValue(true);
-            mockUseTenantMode.mockReturnValue(true);
-            mockExistsSync.mockReturnValue(true);
-            const { instance } = require('./winston.logger.class');
-            const tenantAwareTransport = instance.transports[0];
-            const defaultTransport = tenantAwareTransport.defaultTransport;
-            const defaultLogSpy = jest.spyOn(defaultTransport, 'log');
-            const cb = jest.fn();
-            tenantAwareTransport.log({
-                level: 'info',
-                message: 'x',
-                metadata: {
-                    tenantId: 'tenant-b'
-                }
-            }, cb);
-            expect(defaultLogSpy).not.toHaveBeenCalled();
-        });
-        it('should re-emit "logged" so winston can track transport completion', (done)=>{
-            mockIsProduction.mockReturnValue(true);
-            mockUseTenantMode.mockReturnValue(false);
-            const { instance } = require('./winston.logger.class');
-            const tenantAwareTransport = instance.transports[0];
-            tenantAwareTransport.once('logged', (info)=>{
-                expect(info.message).toBe('done-check');
-                done();
-            });
-            tenantAwareTransport.log({
-                level: 'info',
-                message: 'done-check'
-            }, jest.fn());
-        });
-    });
-});

package/cjs/constants/index.js

@@ -1,88 +0,0 @@
-// Metadata keys
-"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 CACHE_INSTANCE () {
-        return CACHE_INSTANCE;
-    },
-    get CLIENT_TYPE_HEADER () {
-        return CLIENT_TYPE_HEADER;
-    },
-    get DEFAULT_EVENT_EXCHANGE () {
-        return DEFAULT_EVENT_EXCHANGE;
-    },
-    get DEFAULT_EVENT_SERVICE_NAME () {
-        return DEFAULT_EVENT_SERVICE_NAME;
-    },
-    get DEFAULT_EVENT_TOPIC () {
-        return DEFAULT_EVENT_TOPIC;
-    },
-    get DOMAIN_EVENT_HANDLER_KEY () {
-        return DOMAIN_EVENT_HANDLER_KEY;
-    },
-    get EVENT_BUS_INSTANCE () {
-        return EVENT_BUS_INSTANCE;
-    },
-    get EVENT_BUS_MODULE_OPTIONS () {
-        return EVENT_BUS_MODULE_OPTIONS;
-    },
-    get IDEMPOTENCY_CACHE_PREFIX () {
-        return IDEMPOTENCY_CACHE_PREFIX;
-    },
-    get IDEMPOTENCY_KEY_HEADER () {
-        return IDEMPOTENCY_KEY_HEADER;
-    },
-    get IS_PUBLIC_KEY () {
-        return IS_PUBLIC_KEY;
-    },
-    get PERMISSIONS_CACHE_PREFIX () {
-        return PERMISSIONS_CACHE_PREFIX;
-    },
-    get PERMISSIONS_KEY () {
-        return PERMISSIONS_KEY;
-    },
-    get PERMISSION_GUARD_CONFIG () {
-        return PERMISSION_GUARD_CONFIG;
-    },
-    get REQUEST_ID_HEADER () {
-        return REQUEST_ID_HEADER;
-    }
-});
-_export_star(require("./permissions"), exports);
-_export_star(require("./message-keys"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-const IS_PUBLIC_KEY = 'isPublic';
-const PERMISSIONS_KEY = 'permissions';
-const DOMAIN_EVENT_HANDLER_KEY = 'domainEventHandler';
-const CACHE_INSTANCE = 'CACHE_INSTANCE';
-const PERMISSION_GUARD_CONFIG = 'PERMISSION_GUARD_CONFIG';
-const EVENT_BUS_INSTANCE = 'EVENT_BUS_INSTANCE';
-const EVENT_BUS_MODULE_OPTIONS = 'EVENT_BUS_MODULE_OPTIONS';
-const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
-const REQUEST_ID_HEADER = 'x-request-id';
-const CLIENT_TYPE_HEADER = 'x-client-type';
-const PERMISSIONS_CACHE_PREFIX = 'my-permissions';
-const IDEMPOTENCY_CACHE_PREFIX = 'idempotency';
-const DEFAULT_EVENT_EXCHANGE = 'flusys.events';
-const DEFAULT_EVENT_TOPIC = 'flusys.domain-events';
-const DEFAULT_EVENT_SERVICE_NAME = 'flusys';