@flusys/nestjs-shared 7.1.0 → 8.0.0

package/fesm/667.js

@@ -0,0 +1,606 @@
+import { SnakeNamingStrategy } from "typeorm-naming-strategies";
+export const __rspack_esm_id = 667;
+export const __rspack_esm_ids = [667];
+export const __webpack_modules__ = {
+686(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  vd: () => (/* reexport */ CacheModule),
+  K6: () => (/* reexport */ EventBusExplorer),
+  Zv: () => (/* reexport */ EventBusModule),
+  Ct: () => (/* reexport */ MultiTenantDataSourceService),
+  nE: () => (/* reexport */ SharedPermissionCacheModule),
+  U8: () => (/* reexport */ shared_permission_cache_service/* .SharedPermissionCacheService */.U),
+  uh: () => (/* reexport */ UtilsModule),
+  TJ: () => (/* reexport */ utils_service/* .UtilsService */.T),
+  fv: () => (/* reexport */ createModuleEventsProvider),
+  Ri: () => (/* reexport */ moduleEventsToken)
+});
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/hybrid-cache.class.ts + 3 modules
+var hybrid_cache_class = __webpack_require__(375);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/index.ts
+var constants = __webpack_require__(43);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/cache/cache.module.ts
+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;
+}
+
+
+
+class CacheModule {
+    static forRoot(isGlobal = true, memoryTtl = 60_000, memorySize = 5000) {
+        return {
+            module: CacheModule,
+            global: isGlobal,
+            providers: [
+                {
+                    provide: constants/* .CACHE_INSTANCE */.zl,
+                    useFactory: ()=>new hybrid_cache_class/* .HybridCache */.l(memoryTtl, memorySize)
+                }
+            ],
+            exports: [
+                constants/* .CACHE_INSTANCE */.zl
+            ]
+        };
+    }
+}
+CacheModule = _ts_decorate([
+    (0,common_.Module)({})
+], CacheModule);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-core"
+var nestjs_core_ = __webpack_require__(436);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/message-keys.ts
+var message_keys = __webpack_require__(389);
+// EXTERNAL MODULE: external "@nestjs/core"
+var core_ = __webpack_require__(75);
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+;// CONCATENATED MODULE: external "typeorm-naming-strategies"
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/datasource/multi-tenant-datasource.service.ts
+function multi_tenant_datasource_service_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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+class MultiTenantDataSourceService {
+    options;
+    request;
+    static tenantConnections = new Map();
+    static singleDataSource = null;
+    static tenantsRegistry = new Map();
+    static initialized = false;
+    static connectionLocks = new Map();
+    static singleConnectionLock = null;
+    tenantHeader = nestjs_core_.DEFAULT_TENANT_HEADER;
+    constructor(options, request){
+        this.options = options;
+        this.request = request;
+        this.initializeFromOptions();
+    }
+    get self() {
+        return this.constructor;
+    }
+    initializeFromOptions() {
+        if (!this.options) return;
+        if (!this.self.initialized) {
+            this.registerTenants();
+            this.self.initialized = true;
+        }
+    }
+    registerTenants() {
+        this.options?.tenants?.forEach((tenant)=>{
+            this.self.tenantsRegistry.set(tenant.id, tenant);
+        });
+    }
+    getDatabaseMode() {
+        return this.options?.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    getCurrentTenantId() {
+        if (!this.request) return null;
+        const tenantId = this.request.headers[this.tenantHeader];
+        if (!tenantId) return null;
+        if (!/^[a-zA-Z0-9_-]+$/.test(tenantId)) {
+            throw new common_.BadRequestException({
+                message: 'Invalid tenant ID format',
+                messageKey: message_keys/* .SYSTEM_MESSAGES.INVALID_TENANT_ID */.hg.INVALID_TENANT_ID
+            });
+        }
+        return tenantId;
+    }
+    getCurrentTenant() {
+        const tenantId = this.getCurrentTenantId();
+        return tenantId ? this.getTenant(tenantId) : null;
+    }
+    getTenant(tenantId) {
+        return this.self.tenantsRegistry.get(tenantId) ?? null;
+    }
+    async getDataSource() {
+        return this.isMultiTenant() ? this.getTenantDataSource() : this.getSingleDataSource();
+    }
+    async getRepository(entity) {
+        const dataSource = await this.getDataSource();
+        return dataSource.getRepository(entity);
+    }
+    async closeTenantConnection(tenantId) {
+        const connection = this.self.tenantConnections.get(tenantId);
+        if (connection?.isInitialized) {
+            await connection.destroy();
+            this.self.tenantConnections.delete(tenantId);
+        }
+    }
+    async onModuleDestroy() {
+        for (const [tenantId] of this.self.tenantConnections){
+            await this.closeTenantConnection(tenantId);
+        }
+    }
+    async getSingleDataSource() {
+        if (this.self.singleDataSource?.isInitialized) {
+            return this.self.singleDataSource;
+        }
+        if (this.self.singleConnectionLock) {
+            return this.self.singleConnectionLock;
+        }
+        const config = this.getDefaultDatabaseConfig();
+        if (!config) {
+            throw new common_.InternalServerErrorException({
+                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
+                messageKey: message_keys/* .SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE */.hg.DATABASE_CONFIG_NOT_AVAILABLE
+            });
+        }
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        this.self.singleConnectionLock = connectionPromise;
+        try {
+            const dataSource = await connectionPromise;
+            this.self.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            this.self.singleConnectionLock = null;
+        }
+    }
+    async getTenantDataSource() {
+        const tenant = this.getCurrentTenant();
+        if (!tenant) {
+            throw new common_.BadRequestException({
+                message: `Tenant not found. Ensure '${this.tenantHeader}' header is set.`,
+                messageKey: message_keys/* .SYSTEM_MESSAGES.TENANT_HEADER_REQUIRED */.hg.TENANT_HEADER_REQUIRED,
+                messageVariables: {
+                    header: this.tenantHeader
+                }
+            });
+        }
+        return this.getOrCreateTenantConnection(tenant);
+    }
+    async getOrCreateTenantConnection(tenant) {
+        const existing = this.self.tenantConnections.get(tenant.id);
+        if (existing?.isInitialized) return existing;
+        const pendingConnection = this.self.connectionLocks.get(tenant.id);
+        if (pendingConnection) return pendingConnection;
+        const config = this.buildTenantDatabaseConfig(tenant);
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        this.self.connectionLocks.set(tenant.id, connectionPromise);
+        try {
+            const dataSource = await connectionPromise;
+            this.self.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            this.self.connectionLocks.delete(tenant.id);
+        }
+    }
+    getDefaultDatabaseConfig() {
+        return this.options?.defaultDatabaseConfig ?? this.options?.tenantDefaultDatabaseConfig;
+    }
+    buildTenantDatabaseConfig(tenant) {
+        const defaultConfig = this.getDefaultDatabaseConfig();
+        if (!defaultConfig) {
+            throw new common_.InternalServerErrorException({
+                message: 'No default database config for multi-tenant mode.',
+                messageKey: message_keys/* .SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE */.hg.DATABASE_CONFIG_NOT_AVAILABLE
+            });
+        }
+        return {
+            type: defaultConfig.type,
+            host: tenant.host ?? defaultConfig.host,
+            port: tenant.port ?? defaultConfig.port,
+            username: tenant.username ?? defaultConfig.username,
+            password: tenant.password ?? defaultConfig.password,
+            database: tenant.database
+        };
+    }
+    async createDataSourceFromConfig(config, entities = []) {
+        const dataSource = new external_typeorm_.DataSource({
+            type: config.type,
+            host: config.host,
+            port: config.port,
+            username: config.username,
+            password: config.password,
+            database: config.database,
+            entities,
+            synchronize: false,
+            namingStrategy: new SnakeNamingStrategy()
+        });
+        if (!dataSource.isInitialized) await dataSource.initialize();
+        return dataSource;
+    }
+}
+MultiTenantDataSourceService = multi_tenant_datasource_service_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    _ts_param(0, (0,common_.Optional)()),
+    _ts_param(0, (0,common_.Inject)(nestjs_core_.MODULE_OPTIONS)),
+    _ts_param(1, (0,common_.Optional)()),
+    _ts_param(1, (0,common_.Inject)(core_.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof IDataSourceServiceOptions === "undefined" ? Object : IDataSourceServiceOptions,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], MultiTenantDataSourceService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/datasource/index.ts
+
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/event-bus/event-bus.explorer.ts
+function event_bus_explorer_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 event_bus_explorer_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function event_bus_explorer_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+class EventBusExplorer {
+    eventBus;
+    discovery;
+    metadataScanner;
+    logger = new common_.Logger(EventBusExplorer.name);
+    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    // @Optional() so nothing here is a hard dependency on EventBusModule being registered
+    constructor(eventBus, discovery, metadataScanner){
+        this.eventBus = eventBus;
+        this.discovery = discovery;
+        this.metadataScanner = metadataScanner;
+    }
+    async onApplicationBootstrap() {
+        const bus = this.eventBus;
+        if (!bus) return;
+        const wrappers = [
+            ...this.discovery.getProviders(),
+            ...this.discovery.getControllers()
+        ];
+        // The same provider is returned once per module that registers it; binding
+        // it twice would run every handler twice for a single event.
+        const seen = new Set();
+        let bound = 0;
+        for (const wrapper of wrappers){
+            const instance = wrapper.instance;
+            if (!instance || typeof instance !== 'object' || wrapper.isNotMetatype) {
+                this.warnIfUnreachableConsumer(wrapper);
+                continue;
+            }
+            if (seen.has(instance)) continue;
+            seen.add(instance);
+            bound += await this.bindInstance(instance, bus);
+        }
+        if (bound) {
+            const active = bus.getActiveTransports();
+            this.logger.log(`Bound ${bound} domain event handler(s); transport '${bus.getTransportLabel()}' ` + `live over ${active.length ? active.join(', ') : 'no transport'}`);
+        }
+    }
+    async bindInstance(instance, bus) {
+        const prototype = Object.getPrototypeOf(instance);
+        if (!prototype) return 0;
+        let bound = 0;
+        for (const methodName of this.metadataScanner.getAllMethodNames(prototype)){
+            const method = instance[methodName];
+            const patterns = this.readPatterns(method);
+            if (!patterns.length) continue;
+            const handler = method;
+            for (const pattern of patterns){
+                await bus.subscribe(pattern, (event)=>handler.call(instance, event));
+                bound++;
+            }
+        }
+        return bound;
+    }
+    /**
+   * A request scoped provider has no singleton instance to bind, so its
+   * handlers would never run - that must not fail silently.
+   */ warnIfUnreachableConsumer(wrapper) {
+        const prototype = wrapper.metatype?.prototype;
+        if (wrapper.instance || !prototype) return;
+        const hasHandler = this.metadataScanner.getAllMethodNames(prototype).some((methodName)=>this.readPatterns(prototype[methodName]).length > 0);
+        if (hasHandler) {
+            this.logger.warn(`${wrapper.name} declares @OnDomainEvent methods but has no singleton instance ` + `(request scoped providers cannot consume events) - move the handler to a default scoped provider`);
+        }
+    }
+    readPatterns(method) {
+        if (typeof method !== 'function') return [];
+        return Reflect.getMetadata(constants/* .DOMAIN_EVENT_HANDLER_KEY */.PT, method) ?? [];
+    }
+}
+EventBusExplorer = event_bus_explorer_ts_decorate([
+    (0,common_.Injectable)(),
+    event_bus_explorer_ts_param(0, (0,common_.Optional)()),
+    event_bus_explorer_ts_param(0, (0,common_.Inject)(constants/* .EVENT_BUS_INSTANCE */.Qj)),
+    event_bus_explorer_ts_param(1, (0,common_.Inject)(core_.DiscoveryService)),
+    event_bus_explorer_ts_param(2, (0,common_.Inject)(core_.MetadataScanner)),
+    event_bus_explorer_ts_metadata("design:type", Function),
+    event_bus_explorer_ts_metadata("design:paramtypes", [
+        Object,
+        typeof core_.DiscoveryService === "undefined" ? Object : core_.DiscoveryService,
+        typeof core_.MetadataScanner === "undefined" ? Object : core_.MetadataScanner
+    ])
+], EventBusExplorer);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-core/config"
+var config_ = __webpack_require__(307);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/disabled-event-bus.class.ts
+var disabled_event_bus_class = __webpack_require__(864);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/event-bus.registry.ts
+var event_bus_registry = __webpack_require__(228);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/hybrid-event-bus.class.ts
+var hybrid_event_bus_class = __webpack_require__(710);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/event-bus/event-bus.module.ts
+function event_bus_module_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;
+}
+
+
+
+
+
+
+
+
+class EventBusModule {
+    static forRoot(options = {}) {
+        const enabled = options.enabled ?? config_.envConfig.getBoolean('ENABLE_DOMAIN_EVENTS', false);
+        return enabled ? this.enabledModule(options) : this.disabledModule(options);
+    }
+    static enabledModule(options) {
+        return {
+            module: EventBusModule,
+            global: options.global ?? true,
+            imports: [
+                core_.DiscoveryModule
+            ],
+            providers: [
+                {
+                    provide: constants/* .EVENT_BUS_MODULE_OPTIONS */.SL,
+                    useValue: options
+                },
+                {
+                    provide: constants/* .EVENT_BUS_INSTANCE */.Qj,
+                    useFactory: ()=>{
+                        const bus = new hybrid_event_bus_class/* .HybridEventBus */.Z(options);
+                        event_bus_registry/* .EventBusRegistry.setBus */.q.setBus(bus);
+                        event_bus_registry/* .EventBusRegistry.setDefaultModuleEvents */.q.setDefaultModuleEvents(options.defaultModuleEvents ?? {});
+                        return bus;
+                    }
+                },
+                EventBusExplorer
+            ],
+            exports: [
+                constants/* .EVENT_BUS_INSTANCE */.Qj,
+                constants/* .EVENT_BUS_MODULE_OPTIONS */.SL
+            ]
+        };
+    }
+    /**
+   * The explorer is left out, so no handler is bound and nothing ever calls
+   * `subscribe` - which is what would otherwise open a broker connection. The
+   * bus is not registered either, so every `publishDomainEvent` call is a no-op
+   * rather than an error.
+   */ static disabledModule(options) {
+        return {
+            module: EventBusModule,
+            global: options.global ?? true,
+            providers: [
+                {
+                    provide: constants/* .EVENT_BUS_MODULE_OPTIONS */.SL,
+                    useValue: options
+                },
+                {
+                    provide: constants/* .EVENT_BUS_INSTANCE */.Qj,
+                    useFactory: ()=>{
+                        new common_.Logger(EventBusModule.name).log('Domain events are disabled - set ENABLE_DOMAIN_EVENTS=true to publish and consume them');
+                        return new disabled_event_bus_class/* .DisabledEventBus */.X();
+                    }
+                }
+            ],
+            exports: [
+                constants/* .EVENT_BUS_INSTANCE */.Qj,
+                constants/* .EVENT_BUS_MODULE_OPTIONS */.SL
+            ]
+        };
+    }
+    async onApplicationShutdown() {
+        await event_bus_registry/* .EventBusRegistry */.q.getBus()?.close();
+        event_bus_registry/* .EventBusRegistry.reset */.q.reset();
+    }
+}
+EventBusModule = event_bus_module_ts_decorate([
+    (0,common_.Module)({})
+], EventBusModule);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/event-bus/module-events.provider.ts
+
+const moduleEventsToken = (moduleName)=>`${moduleName.toUpperCase().replace(/-/g, '_')}_EVENTS_CONFIG`;
+const providerCache = new Map();
+/**
+ * Registers a feature package's `events` block so every ApiService in that
+ * module starts publishing. Add it to the module's own providers:
+ *
+ *   providers: [createModuleEventsProvider('storage', STORAGE_MODULE_OPTIONS)]
+ */ 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 ?? {};
+            event_bus_registry/* .EventBusRegistry.configureModule */.q.configureModule(moduleName, events);
+            return events;
+        },
+        inject: [
+            optionsToken
+        ]
+    };
+    providerCache.set(cacheKey, provider);
+    return provider;
+}
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/modules/shared-permission-cache/shared-permission-cache.service.ts
+var shared_permission_cache_service = __webpack_require__(657);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/shared-permission-cache/shared-permission-cache.module.ts
+function shared_permission_cache_module_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;
+}
+
+
+class SharedPermissionCacheModule {
+}
+SharedPermissionCacheModule = shared_permission_cache_module_ts_decorate([
+    (0,common_.Global)(),
+    (0,common_.Module)({
+        imports: [],
+        providers: [
+            shared_permission_cache_service/* .SharedPermissionCacheService */.U
+        ],
+        exports: [
+            shared_permission_cache_service/* .SharedPermissionCacheService */.U
+        ]
+    })
+], SharedPermissionCacheModule);
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/modules/utils/utils.service.ts
+var utils_service = __webpack_require__(169);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/utils/utils.module.ts
+function utils_module_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;
+}
+
+
+class UtilsModule {
+}
+UtilsModule = utils_module_ts_decorate([
+    (0,common_.Global)(),
+    (0,common_.Module)({
+        imports: [],
+        providers: [
+            utils_service/* .UtilsService */.T
+        ],
+        exports: [
+            utils_service/* .UtilsService */.T
+        ]
+    })
+], UtilsModule);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/modules/index.ts
+
+
+
+
+
+
+
+
+
+
+
+},
+
+};