@eleven-am/pondsocket-nest 0.0.133 → 0.0.135

package/performers/action.js

@@ -42,9 +42,12 @@ function performGuards(moduleRef, globalGuards, context) {
         const guards = globalGuards
             .concat(classGuards, methodGuards)
             .map((Guard) => (0, misc_1.retrieveInstance)(moduleRef, Guard));
-        const promises = guards.map((guard) => guard.canActivate(context));
-        const results = yield Promise.all(promises);
-        return results.every((result) => result);
+        for (const guard of guards) {
+            if (!(yield guard.canActivate(context))) {
+                return false;
+            }
+        }
+        return true;
     });
 }
 function getNestContext(context) {
@@ -78,7 +81,7 @@ function performAction(instance, moduleRef, globalGuards, globalPipes, originalM
             const data = yield originalMethod.apply(instance, yield retrieveParameters(context, globalPipes, moduleRef));
             (0, response_1.performResponse)(socketId, channel, data, input);
         }
-        else if ((0, narrow_1.isJoinContext)(input) || (0, narrow_1.isJoinContext)(input)) {
+        else if ((0, narrow_1.isJoinContext)(input) || (0, narrow_1.isConnectionContext)(input)) {
             input.decline('Unauthorized', 403);
         }
     });

package/performers/errors.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectionContext, JoinContext, EventContext } from '@eleven-am/pondsocket/types';
+export declare function performErrors(error: unknown, response: ConnectionContext<string> | JoinContext<string> | EventContext<string>): ConnectionContext<string> | JoinContext<string> | EventContext<string> | undefined;

package/performers/errors.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.performErrors = performErrors;
-// eslint-disable-next-line import/no-unresolved
 const common_1 = require("@nestjs/common");
 const narrow_1 = require("./narrow");
 function performErrors(error, response) {

package/performers/narrow.d.ts

@@ -0,0 +1,7 @@
+import type { JoinContext, EventContext, ConnectionContext, LeaveEvent } from '@eleven-am/pondsocket/types';
+type Context = JoinContext<string> | EventContext<string> | ConnectionContext<string> | LeaveEvent;
+export declare function isEventContext(response: Context): response is EventContext<string>;
+export declare function isJoinContext(response: Context): response is JoinContext<string>;
+export declare function isConnectionContext(response: Context): response is ConnectionContext<string>;
+export declare function isLeaveEvent(response: Context): response is LeaveEvent;
+export {};

package/performers/response.d.ts

@@ -0,0 +1,3 @@
+import { Channel, JoinContext, EventContext, ConnectionContext, LeaveEvent } from '@eleven-am/pondsocket/types';
+import { PondResponse } from '../types';
+export declare function performResponse(socketId: string, channel: Channel | null, data: PondResponse | null | undefined, context: JoinContext<string> | EventContext<string> | ConnectionContext<string> | LeaveEvent): void;

package/performers/response.js

@@ -14,55 +14,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.performResponse = performResponse;
 const narrow_1 = require("./narrow");
 function isNotEmpty(value) {
-    return value !== null &&
-        value !== undefined &&
-        value !== '' &&
-        Object.keys(value).length !== 0;
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length !== 0;
+    }
+    return value !== '';
 }
 function performResponse(socketId, channel, data, context) {
     if (((0, narrow_1.isLeaveEvent)(context) || !isNotEmpty(data)) || (!(0, narrow_1.isEventContext)(context) && context.hasResponded)) {
         return;
     }
     const { event, presence, assigns, broadcast, broadcastFrom, broadcastTo } = data, rest = __rest(data, ["event", "presence", "assigns", "broadcast", "broadcastFrom", "broadcastTo"]);
-    if (context) {
-        if ((0, narrow_1.isConnectionContext)(context) || (0, narrow_1.isJoinContext)(context)) {
-            context
-                .assign(typeof assigns === 'object' ? assigns : {})
-                .accept();
+    if ((0, narrow_1.isConnectionContext)(context) || (0, narrow_1.isJoinContext)(context)) {
+        context
+            .assign(typeof assigns === 'object' ? assigns : {})
+            .accept();
+    }
+    else {
+        context
+            .assign(typeof assigns === 'object' ? assigns : {});
+    }
+    const payload = isNotEmpty(rest) ? rest : {};
+    if (event) {
+        context.reply(event, payload);
+    }
+    if ((0, narrow_1.isJoinContext)(context) || (0, narrow_1.isEventContext)(context)) {
+        if (broadcast) {
+            context.broadcast(broadcast, payload);
         }
-        else {
-            context
-                .assign(typeof assigns === 'object' ? assigns : {});
+        if (broadcastFrom) {
+            context.broadcastFrom(broadcastFrom, payload);
         }
-        if (isNotEmpty(rest)) {
-            if (event) {
-                context.reply(event, rest);
-            }
-            if ((0, narrow_1.isJoinContext)(context) || (0, narrow_1.isEventContext)(context)) {
-                if (broadcast) {
-                    context.broadcast(broadcast, rest);
-                }
-                if (broadcastFrom) {
-                    context.broadcastFrom(broadcastFrom, rest);
-                }
-                if (broadcastTo) {
-                    context.broadcastTo(broadcastTo.event, rest, broadcastTo.users);
-                }
-            }
+        if (broadcastTo) {
+            context.broadcastTo(broadcastTo.event, payload, broadcastTo.users);
         }
     }
-    if (channel) {
-        if (isNotEmpty(rest) && !context) {
-            if (broadcast || event) {
-                const newEvent = (broadcast || event);
-                channel.broadcast(newEvent, rest);
-            }
-            if (broadcastTo) {
-                channel.broadcastTo(broadcastTo.users, broadcastTo.event, rest);
-            }
-        }
-        if (isNotEmpty(presence)) {
-            channel.upsertPresence(socketId, presence);
-        }
+    if (channel && isNotEmpty(presence)) {
+        channel.upsertPresence(socketId, presence);
     }
 }

package/services/pondSocket.d.ts

@@ -0,0 +1,24 @@
+import type { IDistributedBackend } from '@eleven-am/pondsocket/types';
+import { DiscoveryService } from '@golevelup/nestjs-discovery';
+import { OnModuleInit, OnModuleDestroy, PipeTransform } from '@nestjs/common';
+import { HttpAdapterHost, ModuleRef } from '@nestjs/core';
+import { CanActivate, Constructor } from '../types';
+export declare class PondSocketService implements OnModuleInit, OnModuleDestroy {
+    private readonly moduleRef;
+    private readonly discovery;
+    private readonly adapterHost;
+    private readonly globalGuards;
+    private readonly globalPipes;
+    private readonly isExclusiveSocketServer;
+    private readonly distributedBackend?;
+    private readonly maxMessageSize?;
+    private readonly heartbeatInterval?;
+    private readonly logger;
+    private socket;
+    constructor(moduleRef: ModuleRef, discovery: DiscoveryService, adapterHost: HttpAdapterHost, globalGuards: Constructor<CanActivate>[], globalPipes: Constructor<PipeTransform>[], isExclusiveSocketServer: boolean, distributedBackend?: IDistributedBackend | undefined, maxMessageSize?: number | undefined, heartbeatInterval?: number | undefined);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): void;
+    private manageEndpoint;
+    private manageChannel;
+    private getGroupedInstances;
+}

package/services/pondSocket.js

@@ -8,13 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 pondsocket_1 = __importDefault(require("@eleven-am/pondsocket"));
-// eslint-disable-next-line import/no-unresolved
+const pondsocket_1 = require("@eleven-am/pondsocket");
 const common_1 = require("@nestjs/common");
 const constants_1 = require("../constants");
 const channel_1 = require("../managers/channel");
@@ -25,8 +21,9 @@ 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) {
+    constructor(moduleRef, discovery, adapterHost, globalGuards, globalPipes, isExclusiveSocketServer, distributedBackend, maxMessageSize, heartbeatInterval) {
         this.moduleRef = moduleRef;
         this.discovery = discovery;
         this.adapterHost = adapterHost;
@@ -34,19 +31,29 @@ class PondSocketService {
         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();
-            const socket = new pondsocket_1.default({
+            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(socket, instance));
+            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;
@@ -106,6 +113,14 @@ class PondSocketService {
             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* () {

package/types.d.ts

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