@eleven-am/pondsocket-nest 0.0.136 → 0.0.138

package/services/pondSocket.js

@@ -1,190 +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.PondSocketService = void 0;
-const pondsocket_1 = require("@eleven-am/pondsocket");
-const common_1 = require("@nestjs/common");
-const constants_1 = require("../constants");
-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 join_1 = require("../managers/join");
-const leave_1 = require("../managers/leave");
-const outgoingEvent_1 = require("../managers/outgoingEvent");
-class PondSocketService {
-    constructor(moduleRef, discovery, adapterHost, globalGuards, globalPipes, isExclusiveSocketServer, distributedBackend, maxMessageSize, heartbeatInterval) {
-        this.moduleRef = moduleRef;
-        this.discovery = discovery;
-        this.adapterHost = adapterHost;
-        this.globalGuards = globalGuards;
-        this.globalPipes = globalPipes;
-        this.isExclusiveSocketServer = isExclusiveSocketServer;
-        this.distributedBackend = distributedBackend;
-        this.maxMessageSize = maxMessageSize;
-        this.heartbeatInterval = heartbeatInterval;
-        this.logger = new common_1.Logger(PondSocketService.name);
-        this.socket = null;
-    }
-    onModuleInit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instances = yield this.getGroupedInstances();
-            this.socket = new pondsocket_1.PondSocket({
-                server: this.adapterHost.httpAdapter.getHttpServer(),
-                exclusiveServer: this.isExclusiveSocketServer,
-                distributedBackend: this.distributedBackend,
-                maxMessageSize: this.maxMessageSize,
-                heartbeatInterval: this.heartbeatInterval,
-            });
-            instances.forEach((instance) => this.manageEndpoint(this.socket, instance));
-        });
-    }
-    onModuleDestroy() {
-        var _a;
-        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close();
-        this.socket = null;
-    }
-    manageEndpoint(socket, groupedInstance) {
-        const instance = groupedInstance.endpoint.instance;
-        const constructor = instance.constructor;
-        const metadata = (0, endpoint_1.manageEndpoint)(constructor).get();
-        const { set: setEndpoint } = (0, endpointInstance_1.manageEndpointInstance)(instance);
-        if (!metadata) {
-            return;
-        }
-        const { get } = (0, connection_1.manageConnection)(instance);
-        const channels = [...new Set([...groupedInstance.channels.map((channel) => channel)])];
-        const [handler] = get();
-        const endpoint = socket.createEndpoint(metadata, (context) => __awaiter(this, void 0, void 0, function* () {
-            if (handler) {
-                yield handler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
-            }
-            else {
-                context.accept();
-            }
-        }));
-        this.logger.log(`${groupedInstance.endpoint.name} {${metadata}}`);
-        if (handler) {
-            this.logger.log(`Mapped {${metadata}, CONNECTION}`);
-        }
-        setEndpoint(endpoint);
-        channels.forEach((channel) => this.manageChannel(channel, endpoint, metadata));
-    }
-    manageChannel(channel, endpoint, endpointPath) {
-        const instance = channel.instance;
-        const constructor = instance.constructor;
-        const path = (0, channel_1.manageChannel)(constructor).get();
-        if (!path) {
-            return;
-        }
-        const { set: setChannel } = (0, channelInstance_1.manageChannelInstance)(instance);
-        const { get } = (0, join_1.manageJoin)(instance);
-        const [handler] = get();
-        const channelInstance = endpoint.createChannel(path, (context) => __awaiter(this, void 0, void 0, function* () {
-            if (handler) {
-                yield handler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
-            }
-            else {
-                context.accept();
-            }
-        }));
-        const newPath = `${endpointPath}/${path}`.replace(/\/+/g, '/');
-        this.logger.log(`${channel.name} {${newPath}}`);
-        if (handler) {
-            this.logger.log(`Mapped {${newPath}, JOIN}`);
-        }
-        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, (context) => __awaiter(this, void 0, void 0, function* () {
-                yield handler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
-            }));
-            const newEventPath = `${newPath}/${handler.path}`.replace(/\/+/g, '/');
-            this.logger.log(`Mapped {${newEventPath}, EVENT}`);
-        });
-        const { get: getOutgoingHandlers } = (0, outgoingEvent_1.manageOutgoingEvent)(instance);
-        getOutgoingHandlers().forEach((handler) => {
-            channelInstance.handleOutgoingEvent(handler.path, (context) => __awaiter(this, void 0, void 0, function* () {
-                yield handler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, context);
-            }));
-            const newOutgoingPath = `${newPath}/${handler.path}`.replace(/\/+/g, '/');
-            this.logger.log(`Mapped {${newOutgoingPath}, OUTGOING}`);
-        });
-        const [leaveHandler] = getLeaveHandlers();
-        if (leaveHandler) {
-            channelInstance.onLeave((event) => __awaiter(this, void 0, void 0, function* () {
-                yield leaveHandler.value(instance, this.moduleRef, this.globalGuards, this.globalPipes, event);
-            }));
-            this.logger.log(`Mapped {${newPath}, LEAVE}`);
-        }
-    }
-    getGroupedInstances() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const endpoints = yield this.discovery.providersWithMetaAtKey(constants_1.endpointKey);
-            const channels = yield this.discovery.providersWithMetaAtKey(constants_1.channelKey);
-            const modules = new Map();
-            endpoints.forEach((endpoint) => {
-                const module = endpoint.discoveredClass.parentModule.injectType;
-                if (!modules.has(module)) {
-                    modules.set(module, {
-                        endpoints: [],
-                        channels: [],
-                    });
-                }
-                modules.get(module).endpoints.push(endpoint.discoveredClass);
-            });
-            channels.forEach((channel) => {
-                const module = channel.discoveredClass.parentModule.injectType;
-                if (!modules.has(module)) {
-                    modules.set(module, {
-                        endpoints: [],
-                        channels: [],
-                    });
-                }
-                modules.get(module).channels.push(channel.discoveredClass);
-            });
-            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 groupedInstances = channelsWithEndpoints.map((instance) => instance.endpoints.map((endpoint) => ({
-                endpoint,
-                channels: instance.channels,
-            }))).flat();
-            const baseEndpoint = endpoints.length === 1 ?
-                endpoints[0].discoveredClass :
-                (_a = endpoints
-                    .find((endpoint) => endpoint.discoveredClass.parentModule.name === 'AppModule')) === null || _a === void 0 ? void 0 : _a.discoveredClass;
-            const groupedInstanceWithBaseEndpoint = groupedInstances.find((groupedInstance) => groupedInstance.endpoint.instance === (baseEndpoint === null || baseEndpoint === void 0 ? void 0 : baseEndpoint.instance));
-            if (channelsWithNoEndpoints.length > 0) {
-                if (groupedInstanceWithBaseEndpoint) {
-                    const channels = channelsWithNoEndpoints.map((instance) => instance.channels).flat();
-                    groupedInstanceWithBaseEndpoint.channels = [...new Set([...groupedInstanceWithBaseEndpoint.channels, ...channels])];
-                }
-                else if (baseEndpoint) {
-                    const channels = channelsWithNoEndpoints.map((instance) => instance.channels).flat();
-                    groupedInstances.push({
-                        endpoint: baseEndpoint,
-                        channels,
-                    });
-                }
-                else {
-                    throw new Error('No base endpoint found');
-                }
-            }
-            return groupedInstances;
-        });
-    }
-}
-exports.PondSocketService = PondSocketService;

package/types.d.ts

@@ -1,64 +0,0 @@
-import type { ConnectionContext, EventContext, IDistributedBackend, JoinContext, LeaveEvent, PondAssigns, PondMessage, PondPresence } from '@eleven-am/pondsocket/types';
-import type { DiscoveredClass } from '@golevelup/nestjs-discovery/lib/discovery.interfaces';
-import type { ModuleMetadata, PipeTransform } from '@nestjs/common';
-import type { ModuleRef } from '@nestjs/core';
-import type { Context } from './context/context';
-export interface NestContext {
-    connection?: ConnectionContext<string>;
-    join?: JoinContext<string>;
-    event?: EventContext<string>;
-    leave?: LeaveEvent;
-}
-export type ParamDecoratorCallback<Input> = (data: Input, context: Context, type: unknown) => unknown | Promise<unknown>;
-export interface ParamDecoratorMetadata {
-    index: number;
-    callback: (context: Context, globalPipes: Constructor<PipeTransform>[], moduleRef: ModuleRef) => Promise<unknown>;
-}
-export type HandlerFunction<Context> = (instance: unknown, moduleRef: ModuleRef, globalGuards: Constructor<CanActivate>[], globalPipes: Constructor<PipeTransform>[], ctx: Context) => Promise<void>;
-export type HandlerData<Context> = {
-    path: string;
-    value: HandlerFunction<Context>;
-};
-export type Constructor<T, Parameters extends any[] = any[]> = new (...args: Parameters) => T;
-export interface CanActivate {
-    /**
-     * @desc Whether the client can continue with the request
-     * @param context - The context of the request
-     */
-    canActivate(context: Context): boolean | Promise<boolean>;
-}
-export type GroupedInstances = {
-    endpoint: DiscoveredClass;
-    channels: DiscoveredClass[];
-};
-export interface Metadata extends Omit<ModuleMetadata, 'controllers'> {
-    guards?: Constructor<CanActivate>[];
-    pipes?: Constructor<PipeTransform>[];
-    isExclusiveSocketServer?: boolean;
-    backend?: IDistributedBackend;
-    maxMessageSize?: number;
-    heartbeatInterval?: number;
-    isGlobal?: boolean;
-}
-export interface AsyncFactoryResult {
-    backend?: IDistributedBackend;
-    maxMessageSize?: number;
-    heartbeatInterval?: number;
-}
-export interface AsyncMetadata extends Omit<Metadata, 'backend' | 'maxMessageSize' | 'heartbeatInterval'> {
-    isGlobal?: boolean;
-    inject?: any[];
-    imports?: any[];
-    useFactory: (...args: any[]) => Promise<AsyncFactoryResult> | AsyncFactoryResult;
-}
-export type PondResponse<Event extends string = string, Payload extends PondMessage = PondMessage, Presence extends PondPresence = PondPresence, Assigns extends PondAssigns = PondAssigns> = {
-    event?: Event;
-    broadcast?: Event;
-    broadcastFrom?: Event;
-    assigns?: Partial<Assigns>;
-    presence?: Partial<Presence>;
-    broadcastTo?: {
-        event: Event;
-        users: string[];
-    };
-} & Payload;