@eleven-am/pondsocket-nest 0.0.2

package/services/discovery.js

@@ -0,0 +1,127 @@
+"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;

package/services/pondSocket.js

@@ -0,0 +1,138 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondSocketService = void 0;
+const http_1 = require("http");
+const pondsocket_1 = __importDefault(require("@eleven-am/pondsocket"));
+const channel_1 = require("../managers/channel");
+const channelInstance_1 = require("../managers/channelInstance");
+const connection_1 = require("../managers/connection");
+const endpoint_1 = require("../managers/endpoint");
+const endpointInstance_1 = require("../managers/endpointInstance");
+const event_1 = require("../managers/event");
+const guards_1 = require("../managers/guards");
+const join_1 = require("../managers/join");
+const leave_1 = require("../managers/leave");
+class PondSocketService {
+    constructor(moduleRef, discovery, adapterHost, externalGuards) {
+        this.moduleRef = moduleRef;
+        this.discovery = discovery;
+        this.adapterHost = adapterHost;
+        this.externalGuards = externalGuards;
+        const httpAdapter = this.adapterHost.httpAdapter;
+        httpAdapter.listen = (...args) => __awaiter(this, void 0, void 0, function* () {
+            const socket = yield this.init(httpAdapter);
+            return socket.listen(...args);
+        });
+    }
+    init(httpAdapter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const groupedInstances = yield this.buildInstances();
+            const app = httpAdapter.getInstance();
+            const server = (0, http_1.createServer)(app);
+            const socket = new pondsocket_1.default(server);
+            groupedInstances.forEach((groupedInstance) => {
+                this.manageEndpoint(socket, groupedInstance);
+            });
+            return socket;
+        });
+    }
+    buildInstances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modules = yield this.discovery.groupToModules();
+            const values = [...modules.values()];
+            const channelsWithNoEndpoint = values.filter((value) => value.endpoints.length === 0 && value.channels.length > 0);
+            const channelsWithEndpoint = values.filter((value) => value.endpoints.length > 0 && value.channels.length > 0);
+            const groupedInstances = channelsWithEndpoint.map((group) => group.endpoints.map((endpoint) => ({
+                endpoint,
+                channels: group.channels,
+            }))).flat();
+            if (channelsWithNoEndpoint.length > 0) {
+                const appModule = yield this.discovery.getAppModule();
+                const value = modules.get(appModule.dependencyType);
+                if (value && value.endpoints.length > 0) {
+                    value.endpoints.forEach((endpoint) => {
+                        groupedInstances.push({
+                            endpoint,
+                            channels: channelsWithNoEndpoint.map((group) => group.channels).flat(),
+                        });
+                    });
+                }
+            }
+            return groupedInstances;
+        });
+    }
+    manageEndpoint(socket, groupedInstance) {
+        const instance = groupedInstance.endpoint.instance;
+        const constructor = instance.constructor;
+        const metadata = (0, endpoint_1.manageEndpoint)(constructor).get();
+        const { set: setGuards } = (0, guards_1.manageGuards)(constructor);
+        const { set: setEndpoint } = (0, endpointInstance_1.manageEndpointInstance)(instance);
+        if (!metadata) {
+            return;
+        }
+        setGuards(this.externalGuards);
+        const endpoint = socket.createEndpoint(metadata, (request, response) => __awaiter(this, void 0, void 0, function* () {
+            const { get } = (0, connection_1.manageConnection)(instance);
+            const [handler] = get();
+            if (handler) {
+                yield handler.value(instance, this.moduleRef, request, response);
+            }
+            else {
+                response.accept();
+            }
+        }));
+        setEndpoint(endpoint);
+        const channels = [...new Set([...groupedInstance.channels.map((channel) => channel)])];
+        channels.forEach((channel) => {
+            this.manageChannel(channel, endpoint);
+        });
+    }
+    manageChannel(channel, endpoint) {
+        const instance = channel.instance;
+        const constructor = instance.constructor;
+        const path = (0, channel_1.manageChannel)(constructor).get();
+        if (!path) {
+            return;
+        }
+        const { set: setGuards } = (0, guards_1.manageGuards)(constructor);
+        const { set: setChannel } = (0, channelInstance_1.manageChannelInstance)(instance);
+        setGuards(this.externalGuards);
+        const channelInstance = endpoint.createChannel(path, (request, response) => __awaiter(this, void 0, void 0, function* () {
+            const { get } = (0, join_1.manageJoin)(instance);
+            const [handler] = get();
+            if (handler) {
+                yield handler.value(instance, this.moduleRef, request, response);
+            }
+            else {
+                response.accept();
+            }
+        }));
+        setChannel(channelInstance);
+        const { get: getEventHandlers } = (0, event_1.manageEvent)(instance);
+        const { get: getLeaveHandlers } = (0, leave_1.manageLeave)(instance);
+        getEventHandlers().forEach((handler) => {
+            channelInstance.onEvent(handler.path, (request, response) => __awaiter(this, void 0, void 0, function* () {
+                yield handler.value(instance, this.moduleRef, request, response);
+            }));
+        });
+        const [leaveHandler] = getLeaveHandlers();
+        if (leaveHandler) {
+            channelInstance.onLeave((event) => __awaiter(this, void 0, void 0, function* () {
+                yield leaveHandler.value(instance, this.moduleRef, event);
+            }));
+        }
+    }
+}
+exports.PondSocketService = PondSocketService;

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });