@eleven-am/pondsocket-nest 0.0.23 → 0.0.25

package/modules/pondSocket.js

@@ -10,12 +10,12 @@ class PondSocketModule {
         const pondSocketProvider = {
             provide: pondSocket_1.PondSocketService,
             useFactory: (moduleRef, adapterHost, discovery) => new pondSocket_1.PondSocketService(moduleRef, discovery, adapterHost, guards),
-            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, nestjs_discovery_1.DiscoveryModule],
+            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, nestjs_discovery_1.DiscoveryService],
         };
         return {
-            imports,
             exports,
             global: isGlobal,
+            imports: [...imports, nestjs_discovery_1.DiscoveryModule],
             module: PondSocketModule,
             providers: [
                 pondSocketProvider,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket-nest",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",

package/services/pondSocket.js

@@ -138,6 +138,7 @@ class PondSocketService {
             const instances = [...modules.values()];
             const channelsWithNoEndpoints = instances.filter((instance) => instance.channels.length > 0 && instance.endpoints.length === 0);
             const channelsWithEndpoints = instances.filter((instance) => instance.channels.length > 0 && instance.endpoints.length > 0);
+            const endpointsWithNoChannels = instances.filter((instance) => instance.endpoints.length > 0 && instance.channels.length === 0);
             const groupedInstances = channelsWithEndpoints.map((instance) => instance.endpoints.map((endpoint) => ({
                 endpoint,
                 channels: instance.channels,
@@ -149,7 +150,8 @@ class PondSocketService {
                 baseEndpointInstance.channels.push(...channels);
             }
             else if (channelsWithNoEndpoints.length > 0) {
-                throw new Error('No base endpoint found');
+                const channels = channelsWithNoEndpoints.map((instance) => instance.channels).flat();
+                endpointsWithNoChannels.forEach((instance) => instance.channels.push(...channels));
             }
             return groupedInstances;
         });

package/services/discovery.js

@@ -1,127 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscoveryService = void 0;
-// eslint-disable-next-line import/no-unresolved
-const common_1 = require("@nestjs/common");
-// eslint-disable-next-line import/no-unresolved
-const constants_1 = require("@nestjs/core/injector/constants");
-const constants_2 = require("../constants");
-class DiscoveryService {
-    constructor(modulesContainer, appModuleName) {
-        this.modulesContainer = modulesContainer;
-        this.appModuleName = appModuleName;
-        this.providers = [];
-    }
-    groupToModules() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const endpoints = yield this.findEndpoints();
-            const channels = yield this.findChannels();
-            const modules = new Map();
-            endpoints.forEach((endpoint) => {
-                const module = endpoint.parentModule.injectType;
-                if (!modules.has(module)) {
-                    modules.set(module, {
-                        endpoints: [],
-                        channels: [],
-                    });
-                }
-                modules.get(module).endpoints.push(endpoint);
-            });
-            channels.forEach((channel) => {
-                const module = channel.parentModule.injectType;
-                if (!modules.has(module)) {
-                    modules.set(module, {
-                        endpoints: [],
-                        channels: [],
-                    });
-                }
-                modules.get(module).channels.push(channel);
-            });
-            return modules;
-        });
-    }
-    getAppModule() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const providers = yield this.getProviders();
-            const appModule = providers
-                .find((provider) => provider.name === this.appModuleName);
-            if (!appModule) {
-                throw new Error('AppModule not found');
-            }
-            return appModule;
-        });
-    }
-    getProviders() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.providers.length) {
-                return this.providers;
-            }
-            const promises = [...this.modulesContainer.values()]
-                .flatMap((nestModule) => {
-                const providers = [...nestModule.providers.values()];
-                return providers
-                    .filter((wrapper) => wrapper.isDependencyTreeStatic())
-                    .filter((component) => component.scope !== common_1.Scope.REQUEST)
-                    .map((wrapper) => this.toDiscoveredClass(nestModule, wrapper));
-            });
-            const resolvedProviders = yield Promise.all(promises);
-            this.providers.push(...resolvedProviders.filter((provider) => provider !== undefined));
-            return this.providers;
-        });
-    }
-    toDiscoveredClass(nestModule, wrapper) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instanceHost = wrapper.getInstanceByContextId(constants_1.STATIC_CONTEXT, wrapper && wrapper.id ? wrapper.id : undefined);
-            if (instanceHost.isPending && !instanceHost.isResolved) {
-                yield instanceHost.donePromise;
-            }
-            if (!instanceHost.instance) {
-                return;
-            }
-            return {
-                name: wrapper.name,
-                instance: instanceHost.instance,
-                injectType: wrapper.metatype,
-                dependencyType: instanceHost.instance.constructor,
-                parentModule: {
-                    name: nestModule.metatype.name,
-                    instance: nestModule.instance,
-                    injectType: nestModule.metatype,
-                    dependencyType: nestModule.instance.constructor,
-                },
-            };
-        });
-    }
-    findEndpoints() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const providers = yield this.getProviders();
-            return providers
-                .filter((provider) => this.withMetadata(constants_2.endpointKey, provider));
-        });
-    }
-    findChannels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const providers = yield this.getProviders();
-            return providers
-                .filter((provider) => this.withMetadata(constants_2.channelKey, provider));
-        });
-    }
-    withMetadata(metaKey, provider) {
-        return [
-            provider.instance.constructor,
-            provider.dependencyType,
-            provider.injectType,
-        ].filter((target) => target !== null && target !== undefined)
-            .some((target) => Reflect.getMetadata(metaKey, target));
-    }
-}
-exports.DiscoveryService = DiscoveryService;