@punks/backend-entity-manager 0.0.16 → 0.0.18

package/dist/cjs/types/platforms/nest/processors/initializer/index.d.ts

@@ -1,14 +1,21 @@
 import { INestApplicationContext } from "@nestjs/common";
+import { EventEmitter2 } from "@nestjs/event-emitter";
 import { EntityManagerRegistry } from "../../ioc/registry";
 import { CustomDiscoveryService } from "../../ioc/discovery";
 import { NestEventEmitter } from "../../providers/events";
+import { ModulesContainer } from "@nestjs/core";
+export interface EntityManagerStaticProviders {
+    eventEmitter: EventEmitter2;
+    modulesContainer: ModulesContainer;
+}
 export declare class EntityManagerInitializer {
     private readonly discover;
     private readonly registry;
     private readonly eventEmitter;
     private readonly logger;
     constructor(discover: CustomDiscoveryService, registry: EntityManagerRegistry, eventEmitter: NestEventEmitter);
-    initialize(app: INestApplicationContext): Promise<void>;
+    initialize(app: INestApplicationContext, staticProviders: EntityManagerStaticProviders): Promise<void>;
+    private initializeProviders;
     private discoverEntities;
     private discoverRepositories;
     private discoverQueryBuilders;

package/dist/cjs/types/platforms/nest/providers/events/index.d.ts

@@ -1,7 +1,8 @@
 import { EventEmitter2 } from "@nestjs/event-emitter";
 import { IEventEmitter } from "../../../../abstractions/events";
 export declare class NestEventEmitter implements IEventEmitter {
-    private readonly eventEmitter;
-    constructor(eventEmitter: EventEmitter2);
+    private eventEmitter;
+    constructor();
+    setEmitter(eventEmitter: EventEmitter2): void;
     emit(event: string, ...args: any[]): Promise<void>;
 }

package/dist/esm/index.js

@@ -48782,6 +48782,112 @@ CustomDiscoveryModule = __decorate$3([
     })
 ], CustomDiscoveryModule);
 
+let NestEventEmitter = class NestEventEmitter {
+    constructor() { }
+    setEmitter(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    async emit(event, ...args) {
+        await this.eventEmitter.emitAsync(event, ...args);
+    }
+};
+NestEventEmitter = __decorate$3([
+    common.Injectable(),
+    __metadata$2("design:paramtypes", [])
+], NestEventEmitter);
+
+var EntityManagerInitializer_1;
+let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerInitializer {
+    constructor(discover, registry, eventEmitter) {
+        this.discover = discover;
+        this.registry = registry;
+        this.eventEmitter = eventEmitter;
+        this.logger = new common.Logger(EntityManagerInitializer_1.name);
+    }
+    async initialize(app, staticProviders) {
+        this.logger.log("Initializing entity manager static providers 🥁");
+        await this.initializeProviders(app, staticProviders);
+        this.logger.log("Initializing entity manager global services 🥁");
+        await this.registry.resisterGlobalServices({
+            eventEmitter: this.eventEmitter,
+        });
+        this.logger.log("Initializing entity manager types 🥁");
+        // const entities = await this.discoverEntities()
+        const repositories = await this.discoverRepositories();
+        const queryBuilders = await this.discoverQueryBuilders();
+        const converters = await this.discoverConverters();
+        const adapters = await this.discoverAdapters();
+        const auth = await this.discoverAuthMiddlewares();
+        const queryBuilderDict = toDict(queryBuilders, (q) => q.meta.entityName);
+        const converterDict = toDict(converters, (c) => c.meta.entityName);
+        const adapterDict = toDict(adapters, (a) => a.meta.entityName);
+        const authDict = toDict(auth, (a) => a.meta.entityName);
+        for (const repository of repositories) {
+            const entityName = repository.meta.entityName;
+            const queryBuilder = queryBuilderDict[entityName];
+            if (!queryBuilder) {
+                throw new Error(`No query builder found for entity: ${entityName}`);
+            }
+            const converter = converterDict[entityName];
+            const adapter = adapterDict[entityName];
+            const authMiddleware = authDict[entityName];
+            await this.registry.registerDiscoveredEntity(app, {
+                entityName,
+                adapter,
+                repository,
+                queryBuilder,
+                converter,
+                authMiddleware,
+            });
+            this.logger.debug(`Entity ${entityName} registered:
+  - Repository: ${repository.discoveredClass.injectType?.name ?? ""}
+  - Query builder: ${queryBuilder.discoveredClass.injectType?.name ?? ""}
+  - Adapter: ${adapter?.discoveredClass.injectType?.name ?? ""}
+  - Converter: ${converter?.discoveredClass.injectType?.name ?? ""}
+  - Auth middleware: ${authMiddleware?.discoveredClass.injectType?.name ?? ""}
+✨
+      `);
+        }
+        this.logger.log("Entity manager types initialized 🚀");
+    }
+    async initializeProviders(app, staticProviders) {
+        app
+            .get(ModulesContainerProvider)
+            .setModulesContainer(staticProviders.modulesContainer);
+        app.get(NestEventEmitter).setEmitter(staticProviders.eventEmitter);
+    }
+    async discoverEntities() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.Entity);
+    }
+    async discoverRepositories() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityRepository);
+    }
+    async discoverQueryBuilders() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityQueryBuilder);
+    }
+    async discoverConverters() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityConverter);
+    }
+    async discoverAdapters() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityAdapter);
+    }
+    async discoverAuthMiddlewares() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityAuthMiddleware);
+    }
+};
+EntityManagerInitializer = EntityManagerInitializer_1 = __decorate$3([
+    common.Injectable(),
+    __metadata$2("design:paramtypes", [CustomDiscoveryService,
+        EntityManagerRegistry,
+        NestEventEmitter])
+], EntityManagerInitializer);
+
+const Services = [];
+
+const IoC = [EntityManagerRegistry];
+
+const Processors = [EntityManagerInitializer];
+
 var dist = {};
 
 var eventemitter2 = {exports: {}};
@@ -60503,103 +60609,6 @@ Object.defineProperty(exports, "EVENT_PAYLOAD", { enumerable: true, get: functio
 
 }(dist));
 
-let NestEventEmitter = class NestEventEmitter {
-    constructor(eventEmitter) {
-        this.eventEmitter = eventEmitter;
-    }
-    async emit(event, ...args) {
-        await this.eventEmitter.emitAsync(event, ...args);
-    }
-};
-NestEventEmitter = __decorate$3([
-    common.Injectable(),
-    __metadata$2("design:paramtypes", [dist.EventEmitter2])
-], NestEventEmitter);
-
-var EntityManagerInitializer_1;
-let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerInitializer {
-    constructor(discover, registry, eventEmitter) {
-        this.discover = discover;
-        this.registry = registry;
-        this.eventEmitter = eventEmitter;
-        this.logger = new common.Logger(EntityManagerInitializer_1.name);
-    }
-    async initialize(app) {
-        this.logger.log("Initializing entity manager global services 🥁");
-        await this.registry.resisterGlobalServices({
-            eventEmitter: this.eventEmitter,
-        });
-        this.logger.log("Initializing entity manager types 🥁");
-        // const entities = await this.discoverEntities()
-        const repositories = await this.discoverRepositories();
-        const queryBuilders = await this.discoverQueryBuilders();
-        const converters = await this.discoverConverters();
-        const adapters = await this.discoverAdapters();
-        const auth = await this.discoverAuthMiddlewares();
-        const queryBuilderDict = toDict(queryBuilders, (q) => q.meta.entityName);
-        const converterDict = toDict(converters, (c) => c.meta.entityName);
-        const adapterDict = toDict(adapters, (a) => a.meta.entityName);
-        const authDict = toDict(auth, (a) => a.meta.entityName);
-        for (const repository of repositories) {
-            const entityName = repository.meta.entityName;
-            const queryBuilder = queryBuilderDict[entityName];
-            if (!queryBuilder) {
-                throw new Error(`No query builder found for entity: ${entityName}`);
-            }
-            const converter = converterDict[entityName];
-            const adapter = adapterDict[entityName];
-            const authMiddleware = authDict[entityName];
-            await this.registry.registerDiscoveredEntity(app, {
-                entityName,
-                adapter,
-                repository,
-                queryBuilder,
-                converter,
-                authMiddleware,
-            });
-            this.logger.debug(`Entity ${entityName} registered:
-  - Repository: ${repository.discoveredClass.injectType?.name ?? ""}
-  - Query builder: ${queryBuilder.discoveredClass.injectType?.name ?? ""}
-  - Adapter: ${adapter?.discoveredClass.injectType?.name ?? ""}
-  - Converter: ${converter?.discoveredClass.injectType?.name ?? ""}
-  - Auth middleware: ${authMiddleware?.discoveredClass.injectType?.name ?? ""}
-✨
-      `);
-        }
-        this.logger.log("Entity manager types initialized 🚀");
-    }
-    async discoverEntities() {
-        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.Entity);
-    }
-    async discoverRepositories() {
-        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityRepository);
-    }
-    async discoverQueryBuilders() {
-        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityQueryBuilder);
-    }
-    async discoverConverters() {
-        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityConverter);
-    }
-    async discoverAdapters() {
-        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityAdapter);
-    }
-    async discoverAuthMiddlewares() {
-        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityAuthMiddleware);
-    }
-};
-EntityManagerInitializer = EntityManagerInitializer_1 = __decorate$3([
-    common.Injectable(),
-    __metadata$2("design:paramtypes", [CustomDiscoveryService,
-        EntityManagerRegistry,
-        NestEventEmitter])
-], EntityManagerInitializer);
-
-const Services = [];
-
-const IoC = [EntityManagerRegistry];
-
-const Processors = [EntityManagerInitializer];
-
 const Providers = [NestEventEmitter];
 
 let EntityManagerModule = class EntityManagerModule {