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

package/cjs/modules/event-bus/event-bus.module.spec.js

@@ -1,149 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _disabledeventbusclass = require("../../classes/disabled-event-bus.class");
-const _eventbusregistry = require("../../classes/event-bus.registry");
-const _hybrideventbusclass = require("../../classes/hybrid-event-bus.class");
-const _constants = require("../../constants");
-const _eventbusexplorer = require("./event-bus.explorer");
-const _eventbusmodule = require("./event-bus.module");
-function getBusProvider(providers) {
-    return providers.find((provider)=>provider.provide === _constants.EVENT_BUS_INSTANCE);
-}
-describe('EventBusModule', ()=>{
-    const originalFlag = process.env.ENABLE_DOMAIN_EVENTS;
-    afterEach(()=>{
-        _eventbusregistry.EventBusRegistry.reset();
-        if (originalFlag === undefined) {
-            delete process.env.ENABLE_DOMAIN_EVENTS;
-        } else {
-            process.env.ENABLE_DOMAIN_EVENTS = originalFlag;
-        }
-    });
-    describe('when enabled', ()=>{
-        it('should default to a global module', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: true
-            });
-            expect(dynamicModule.module).toBe(_eventbusmodule.EventBusModule);
-            expect(dynamicModule.global).toBe(true);
-        });
-        it('should respect global=false', ()=>{
-            expect(_eventbusmodule.EventBusModule.forRoot({
-                enabled: true,
-                global: false
-            }).global).toBe(false);
-        });
-        it('should export the bus instance and the module options', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: true
-            });
-            expect(dynamicModule.exports).toEqual([
-                _constants.EVENT_BUS_INSTANCE,
-                _constants.EVENT_BUS_MODULE_OPTIONS
-            ]);
-        });
-        it('should register the explorer so handlers get bound', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: true
-            });
-            expect(dynamicModule.providers).toContain(_eventbusexplorer.EventBusExplorer);
-        });
-        it('should build a HybridEventBus and register it for ApiService', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: true,
-                transport: 'memory'
-            });
-            const bus = getBusProvider(dynamicModule.providers).useFactory();
-            expect(bus).toBeInstanceOf(_hybrideventbusclass.HybridEventBus);
-            expect(_eventbusregistry.EventBusRegistry.getBus()).toBe(bus);
-        });
-        it('should apply the default module events config', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: true,
-                transport: 'memory',
-                defaultModuleEvents: {
-                    enabled: true
-                }
-            });
-            getBusProvider(dynamicModule.providers).useFactory();
-            expect(_eventbusregistry.EventBusRegistry.getModuleConfig('anything')).toEqual({
-                enabled: true
-            });
-        });
-        it('should close the bus and clear the registry on shutdown', async ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: true,
-                transport: 'memory'
-            });
-            const bus = getBusProvider(dynamicModule.providers).useFactory();
-            const closeSpy = jest.spyOn(bus, 'close');
-            await new _eventbusmodule.EventBusModule().onApplicationShutdown();
-            expect(closeSpy).toHaveBeenCalled();
-            expect(_eventbusregistry.EventBusRegistry.getBus()).toBeUndefined();
-        });
-    });
-    describe('when disabled', ()=>{
-        it('should still export the bus instance so injecting it keeps working', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: false
-            });
-            expect(dynamicModule.exports).toEqual([
-                _constants.EVENT_BUS_INSTANCE,
-                _constants.EVENT_BUS_MODULE_OPTIONS
-            ]);
-        });
-        it('should provide an inert bus', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: false
-            });
-            const bus = getBusProvider(dynamicModule.providers).useFactory();
-            expect(bus).toBeInstanceOf(_disabledeventbusclass.DisabledEventBus);
-        });
-        it('should not register the explorer, so no handler is ever bound', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: false
-            });
-            expect(dynamicModule.providers).not.toContain(_eventbusexplorer.EventBusExplorer);
-        });
-        it('should not import DiscoveryModule', ()=>{
-            expect(_eventbusmodule.EventBusModule.forRoot({
-                enabled: false
-            }).imports).toBeUndefined();
-        });
-        it('should leave the registry empty so every publish becomes a no-op', ()=>{
-            const dynamicModule = _eventbusmodule.EventBusModule.forRoot({
-                enabled: false
-            });
-            getBusProvider(dynamicModule.providers).useFactory();
-            expect(_eventbusregistry.EventBusRegistry.getBus()).toBeUndefined();
-        });
-        it('should shut down cleanly with no bus registered', async ()=>{
-            _eventbusmodule.EventBusModule.forRoot({
-                enabled: false
-            });
-            await expect(new _eventbusmodule.EventBusModule().onApplicationShutdown()).resolves.toBeUndefined();
-        });
-    });
-    describe('default from the environment', ()=>{
-        it('should be enabled when ENABLE_DOMAIN_EVENTS is true', ()=>{
-            process.env.ENABLE_DOMAIN_EVENTS = 'true';
-            expect(_eventbusmodule.EventBusModule.forRoot().providers).toContain(_eventbusexplorer.EventBusExplorer);
-        });
-        it('should be disabled when ENABLE_DOMAIN_EVENTS is false', ()=>{
-            process.env.ENABLE_DOMAIN_EVENTS = 'false';
-            expect(_eventbusmodule.EventBusModule.forRoot().providers).not.toContain(_eventbusexplorer.EventBusExplorer);
-        });
-        it('should be disabled when ENABLE_DOMAIN_EVENTS is not set', ()=>{
-            delete process.env.ENABLE_DOMAIN_EVENTS;
-            expect(_eventbusmodule.EventBusModule.forRoot().providers).not.toContain(_eventbusexplorer.EventBusExplorer);
-        });
-        it('should let an explicit option override the environment', ()=>{
-            process.env.ENABLE_DOMAIN_EVENTS = 'false';
-            expect(_eventbusmodule.EventBusModule.forRoot({
-                enabled: true
-            }).providers).toContain(_eventbusexplorer.EventBusExplorer);
-        });
-    });
-});

package/cjs/modules/event-bus/module-events.provider.js

@@ -1,39 +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 createModuleEventsProvider () {
-        return createModuleEventsProvider;
-    },
-    get moduleEventsToken () {
-        return moduleEventsToken;
-    }
-});
-const _eventbusregistry = require("../../classes/event-bus.registry");
-const moduleEventsToken = (moduleName)=>`${moduleName.toUpperCase().replace(/-/g, '_')}_EVENTS_CONFIG`;
-const providerCache = new Map();
-function createModuleEventsProvider(moduleName, optionsToken) {
-    const cacheKey = `${moduleName}|${optionsToken}`;
-    const cached = providerCache.get(cacheKey);
-    if (cached) return cached;
-    const provider = {
-        provide: moduleEventsToken(moduleName),
-        useFactory: (options)=>{
-            const events = options?.config?.events ?? {};
-            _eventbusregistry.EventBusRegistry.configureModule(moduleName, events);
-            return events;
-        },
-        inject: [
-            optionsToken
-        ]
-    };
-    providerCache.set(cacheKey, provider);
-    return provider;
-}

package/cjs/modules/event-bus/module-events.provider.spec.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _eventbusregistry = require("../../classes/event-bus.registry");
-const _moduleeventsprovider = require("./module-events.provider");
-describe('moduleEventsToken', ()=>{
-    it('should build an upper snake case token', ()=>{
-        expect((0, _moduleeventsprovider.moduleEventsToken)('storage')).toBe('STORAGE_EVENTS_CONFIG');
-        expect((0, _moduleeventsprovider.moduleEventsToken)('form-builder')).toBe('FORM_BUILDER_EVENTS_CONFIG');
-    });
-});
-describe('createModuleEventsProvider', ()=>{
-    beforeEach(()=>{
-        _eventbusregistry.EventBusRegistry.reset();
-    });
-    it('should inject the module options token', ()=>{
-        const provider = (0, _moduleeventsprovider.createModuleEventsProvider)('storage', 'STORAGE_MODULE_OPTIONS');
-        expect(provider.provide).toBe('STORAGE_EVENTS_CONFIG');
-        expect(provider.inject).toEqual([
-            'STORAGE_MODULE_OPTIONS'
-        ]);
-    });
-    it('should register the events block from the module config', ()=>{
-        const provider = (0, _moduleeventsprovider.createModuleEventsProvider)('storage', 'STORAGE_MODULE_OPTIONS');
-        const result = provider.useFactory({
-            config: {
-                events: {
-                    enabled: true
-                }
-            }
-        });
-        expect(result).toEqual({
-            enabled: true
-        });
-        expect(_eventbusregistry.EventBusRegistry.getModuleConfig('storage')).toEqual({
-            enabled: true
-        });
-    });
-    it('should register an empty config when the module supplies no events block', ()=>{
-        const provider = (0, _moduleeventsprovider.createModuleEventsProvider)('auth', 'AUTH_MODULE_OPTIONS');
-        provider.useFactory({
-            config: {}
-        });
-        expect(_eventbusregistry.EventBusRegistry.getModuleConfig('auth')).toEqual({});
-    });
-    it('should return the same provider for repeated calls so module comparisons stay stable', ()=>{
-        const first = (0, _moduleeventsprovider.createModuleEventsProvider)('event-manager', 'EVENT_MANAGER_MODULE_OPTIONS');
-        const second = (0, _moduleeventsprovider.createModuleEventsProvider)('event-manager', 'EVENT_MANAGER_MODULE_OPTIONS');
-        expect(first).toBe(second);
-    });
-    it('should tolerate missing options', ()=>{
-        const provider = (0, _moduleeventsprovider.createModuleEventsProvider)('iam', 'IAM_MODULE_OPTIONS');
-        expect(provider.useFactory(undefined)).toEqual({});
-    });
-});

package/cjs/modules/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./cache/cache.module"), exports);
-_export_star(require("./datasource"), exports);
-_export_star(require("./event-bus/event-bus.explorer"), exports);
-_export_star(require("./event-bus/event-bus.module"), exports);
-_export_star(require("./event-bus/module-events.provider"), exports);
-_export_star(require("./shared-permission-cache/shared-permission-cache.module"), exports);
-_export_star(require("./shared-permission-cache/shared-permission-cache.service"), exports);
-_export_star(require("./utils/utils.module"), exports);
-_export_star(require("./utils/utils.service"), 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;
-}

package/cjs/modules/shared-permission-cache/shared-permission-cache.module.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SharedPermissionCacheModule", {
-    enumerable: true,
-    get: function() {
-        return SharedPermissionCacheModule;
-    }
-});
-const _common = require("@nestjs/common");
-const _sharedpermissioncacheservice = require("./shared-permission-cache.service");
-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;
-}
-let SharedPermissionCacheModule = class SharedPermissionCacheModule {
-};
-SharedPermissionCacheModule = _ts_decorate([
-    (0, _common.Global)(),
-    (0, _common.Module)({
-        imports: [],
-        providers: [
-            _sharedpermissioncacheservice.SharedPermissionCacheService
-        ],
-        exports: [
-            _sharedpermissioncacheservice.SharedPermissionCacheService
-        ]
-    })
-], SharedPermissionCacheModule);

package/cjs/modules/shared-permission-cache/shared-permission-cache.service.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SharedPermissionCacheService", {
-    enumerable: true,
-    get: function() {
-        return SharedPermissionCacheService;
-    }
-});
-const _common = require("@nestjs/common");
-const _hybridcacheclass = require("../../classes/hybrid-cache.class");
-const _constants = require("../../constants");
-const _interfaces = require("../../interfaces");
-const _permissioncachekeyutil = require("../../utils/permission-cache-key.util");
-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);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let SharedPermissionCacheService = class SharedPermissionCacheService {
-    /** Read the cached permission codes for a user; empty array when cache is unavailable or unset */ async getPermissions(options) {
-        if (!this.cache) return [];
-        const cacheKey = (0, _permissioncachekeyutil.buildPermissionCacheKey)(options, this.config);
-        const cached = await this.cache.get(cacheKey);
-        if (!cached) return [];
-        return Array.isArray(cached) ? cached : cached.backendCodes || [];
-    }
-    /** Overwrite the cached permission codes for a user with a fixed list */ async setPermissions(options, permissions, ttl) {
-        if (!this.cache) return;
-        const cacheKey = (0, _permissioncachekeyutil.buildPermissionCacheKey)(options, this.config);
-        await this.cache.set(cacheKey, permissions, ttl);
-    }
-    /** Clear the cached permission codes for a user */ async clearPermissions(options) {
-        if (!this.cache) return;
-        const cacheKey = (0, _permissioncachekeyutil.buildPermissionCacheKey)(options, this.config);
-        await this.cache.del(cacheKey);
-    }
-    /** Check a single permission against the cached list, honoring `*` and `prefix.*` wildcards */ async hasPermission(options, requiredPermission) {
-        const permissions = await this.getPermissions(options);
-        return this.matchPermission(permissions, requiredPermission);
-    }
-    /** Whether a cache instance is wired up; false means permission checks can't be served at all */ isCacheConfigured() {
-        return !!this.cache;
-    }
-    /** Match an already-fetched permission list against a required permission, honoring `*` and `prefix.*` wildcards */ matchPermission(userPermissions, requiredPermission) {
-        if (userPermissions.includes(requiredPermission)) return true;
-        for (const permission of userPermissions){
-            if (permission === '*') return true;
-            if (permission.endsWith('.*') && requiredPermission.startsWith(permission.slice(0, -1))) {
-                return true;
-            }
-        }
-        return false;
-    }
-    constructor(cache, config){
-        _define_property(this, "cache", void 0);
-        _define_property(this, "config", void 0);
-        this.cache = cache;
-        this.config = {
-            enableCompanyFeature: false,
-            userPermissionKeyFormat: _permissioncachekeyutil.DEFAULT_USER_PERMISSION_KEY_FORMAT,
-            companyPermissionKeyFormat: _permissioncachekeyutil.DEFAULT_COMPANY_PERMISSION_KEY_FORMAT,
-            ...config
-        };
-    }
-};
-SharedPermissionCacheService = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Optional)()),
-    _ts_param(0, (0, _common.Inject)(_constants.CACHE_INSTANCE)),
-    _ts_param(1, (0, _common.Optional)()),
-    _ts_param(1, (0, _common.Inject)(_constants.PERMISSION_GUARD_CONFIG)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _hybridcacheclass.HybridCache === "undefined" ? Object : _hybridcacheclass.HybridCache,
-        typeof _interfaces.PermissionGuardConfig === "undefined" ? Object : _interfaces.PermissionGuardConfig
-    ])
-], SharedPermissionCacheService);

package/cjs/modules/shared-permission-cache/shared-permission-cache.service.spec.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _sharedpermissioncacheservice = require("./shared-permission-cache.service");
-describe('SharedPermissionCacheService', ()=>{
-    let service;
-    let mockCache;
-    beforeEach(()=>{
-        mockCache = {
-            get: jest.fn(),
-            set: jest.fn(),
-            del: jest.fn()
-        };
-        service = new _sharedpermissioncacheservice.SharedPermissionCacheService(mockCache);
-    });
-    describe('getPermissions', ()=>{
-        it('returns an empty array when nothing is cached', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            const permissions = await service.getPermissions({
-                userId: 'user-1'
-            });
-            expect(permissions).toEqual([]);
-            expect(mockCache.get).toHaveBeenCalledWith('my-permissions:user:user-1');
-        });
-        it('returns the cached array as-is', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.read',
-                'file.update'
-            ]);
-            const permissions = await service.getPermissions({
-                userId: 'user-1'
-            });
-            expect(permissions).toEqual([
-                'file.read',
-                'file.update'
-            ]);
-        });
-        it('unwraps a { backendCodes } shaped cache value', async ()=>{
-            mockCache.get.mockResolvedValue({
-                backendCodes: [
-                    'file.read'
-                ]
-            });
-            const permissions = await service.getPermissions({
-                userId: 'user-1'
-            });
-            expect(permissions).toEqual([
-                'file.read'
-            ]);
-        });
-        it('scopes the cache key by company and branch when enableCompanyFeature is on', async ()=>{
-            const scopedService = new _sharedpermissioncacheservice.SharedPermissionCacheService(mockCache, {
-                enableCompanyFeature: true
-            });
-            mockCache.get.mockResolvedValue(undefined);
-            await scopedService.getPermissions({
-                userId: 'user-1',
-                companyId: 'company-1',
-                branchId: 'branch-1'
-            });
-            expect(mockCache.get).toHaveBeenCalledWith('my-permissions:company:company-1:branch:branch-1:user:user-1');
-        });
-        it('returns an empty array when no cache instance is configured', async ()=>{
-            const noCacheService = new _sharedpermissioncacheservice.SharedPermissionCacheService();
-            await expect(noCacheService.getPermissions({
-                userId: 'user-1'
-            })).resolves.toEqual([]);
-        });
-    });
-    describe('setPermissions', ()=>{
-        it('writes the fixed permission list under the user cache key', async ()=>{
-            await service.setPermissions({
-                userId: 'user-1'
-            }, [
-                'file.read',
-                'file.update'
-            ]);
-            expect(mockCache.set).toHaveBeenCalledWith('my-permissions:user:user-1', [
-                'file.read',
-                'file.update'
-            ], undefined);
-        });
-        it('forwards a ttl when given', async ()=>{
-            await service.setPermissions({
-                userId: 'user-1'
-            }, [
-                'file.read'
-            ], 60);
-            expect(mockCache.set).toHaveBeenCalledWith('my-permissions:user:user-1', [
-                'file.read'
-            ], 60);
-        });
-        it('does nothing when no cache instance is configured', async ()=>{
-            const noCacheService = new _sharedpermissioncacheservice.SharedPermissionCacheService();
-            await expect(noCacheService.setPermissions({
-                userId: 'user-1'
-            }, [
-                'file.read'
-            ])).resolves.toBeUndefined();
-        });
-    });
-    describe('clearPermissions', ()=>{
-        it('deletes the cache key for the user', async ()=>{
-            await service.clearPermissions({
-                userId: 'user-1'
-            });
-            expect(mockCache.del).toHaveBeenCalledWith('my-permissions:user:user-1');
-        });
-    });
-    describe('hasPermission', ()=>{
-        it('returns true when the exact permission is cached', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.view.private'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(true);
-        });
-        it('returns false when the permission is missing', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.read'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(false);
-        });
-        it('honors the global "*" wildcard', async ()=>{
-            mockCache.get.mockResolvedValue([
-                '*'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(true);
-        });
-        it('honors a "prefix.*" wildcard', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.*'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(true);
-        });
-    });
-    describe('matchPermission', ()=>{
-        it('matches an already-fetched list without touching the cache', ()=>{
-            expect(service.matchPermission([
-                'file.read'
-            ], 'file.read')).toBe(true);
-            expect(service.matchPermission([
-                'file.read'
-            ], 'file.write')).toBe(false);
-            expect(mockCache.get).not.toHaveBeenCalled();
-        });
-    });
-    describe('isCacheConfigured', ()=>{
-        it('returns true when a cache instance is injected', ()=>{
-            expect(service.isCacheConfigured()).toBe(true);
-        });
-        it('returns false when no cache instance is injected', ()=>{
-            const noCacheService = new _sharedpermissioncacheservice.SharedPermissionCacheService();
-            expect(noCacheService.isCacheConfigured()).toBe(false);
-        });
-    });
-});

package/cjs/modules/utils/utils.module.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "UtilsModule", {
-    enumerable: true,
-    get: function() {
-        return UtilsModule;
-    }
-});
-const _common = require("@nestjs/common");
-const _utilsservice = require("./utils.service");
-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;
-}
-let UtilsModule = class UtilsModule {
-};
-UtilsModule = _ts_decorate([
-    (0, _common.Global)(),
-    (0, _common.Module)({
-        imports: [],
-        providers: [
-            _utilsservice.UtilsService
-        ],
-        exports: [
-            _utilsservice.UtilsService
-        ]
-    })
-], UtilsModule);