@eleven-am/pondsocket-nest 0.0.136 → 0.0.138

package/dist/context/context.d.ts

@@ -0,0 +1,41 @@
+import type { AnyPondSchema, AssignsOf, EventPayload, EventReplyPayload, EventsOf, JoinParamsOf, Params, PondEvent, PondMessage, PresenceOf, ServerActions, UserData } from '@eleven-am/pondsocket-common';
+import { NestContext } from '../types';
+export declare class Context<Schema extends AnyPondSchema = AnyPondSchema, Path extends string = string, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>> {
+    #private;
+    constructor(context: NestContext<Schema, Path, EventName>, instance: any, propertyKey: string);
+    get joinContext(): import("@eleven-am/pondsocket").JoinContext<Path, Schema> | null;
+    get eventContext(): import("@eleven-am/pondsocket").EventContext<Path, Schema, EventName> | null;
+    get outgoingContext(): import("@eleven-am/pondsocket").OutgoingContext<Path, Schema, EventName, ServerActions.SYSTEM | ServerActions.BROADCAST | ServerActions.ERROR | ServerActions.CONNECT> | null;
+    get connectionContext(): import("@eleven-am/pondsocket").ConnectionContext<Path> | null;
+    get leaveEvent(): import("@eleven-am/pondsocket").LeaveEvent | null;
+    get payload(): EventPayload<EventsOf<Schema>, EventName> | EventReplyPayload<EventsOf<Schema>, EventName> | PondMessage | null;
+    get action(): ServerActions.BROADCAST | ServerActions.SYSTEM | ServerActions.ERROR | ServerActions.CONNECT | null;
+    get params(): Params<Path>;
+    get query(): Record<string, string>;
+    get joinParams(): JoinParamsOf<Schema> | null;
+    get presence(): PresenceOf<Schema>;
+    get assigns(): AssignsOf<Schema>;
+    get user(): UserData<PresenceOf<Schema>, AssignsOf<Schema>>;
+    get channel(): import("@eleven-am/pondsocket").Channel<AnyPondSchema> | null;
+    get event(): PondEvent<string> | null;
+    getClass(): any;
+    getHandler(): any;
+    getInstance(): any;
+    getMethod(): string;
+    accept(assigns?: Partial<AssignsOf<Schema>>): this;
+    decline(message?: string, status?: number): this;
+    assign(assigns: Partial<AssignsOf<Schema>>): this;
+    reply(payload: EventReplyPayload<EventsOf<Schema>, EventName>): this;
+    reply<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventReplyPayload<EventsOf<Schema>, Event>): this;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>, users: string | string[]): this;
+    trackPresence(presence: PresenceOf<Schema>): this;
+    updatePresence(presence: Partial<PresenceOf<Schema>>): this;
+    evictUser(reason: string, userId?: string): this;
+    removePresence(userId?: string): this;
+    transform(payload: EventPayload<EventsOf<Schema>, EventName> | EventReplyPayload<EventsOf<Schema>, EventName>): this;
+    block(): this;
+    addData(key: string, value: unknown): void;
+    getData(key: string): {} | null;
+}

package/dist/context/context.js

@@ -0,0 +1,238 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Context_instances, _Context_data, _Context_context, _Context_instance, _Context_propertyKey, _Context_getChannelContext;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+class Context {
+    constructor(context, instance, propertyKey) {
+        _Context_instances.add(this);
+        _Context_data.set(this, {});
+        _Context_context.set(this, void 0);
+        _Context_instance.set(this, void 0);
+        _Context_propertyKey.set(this, void 0);
+        __classPrivateFieldSet(this, _Context_context, context, "f");
+        __classPrivateFieldSet(this, _Context_instance, instance, "f");
+        __classPrivateFieldSet(this, _Context_propertyKey, propertyKey, "f");
+    }
+    get joinContext() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Context_context, "f").join) !== null && _a !== void 0 ? _a : null;
+    }
+    get eventContext() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Context_context, "f").event) !== null && _a !== void 0 ? _a : null;
+    }
+    get outgoingContext() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Context_context, "f").outgoing) !== null && _a !== void 0 ? _a : null;
+    }
+    get connectionContext() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Context_context, "f").connection) !== null && _a !== void 0 ? _a : null;
+    }
+    get leaveEvent() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Context_context, "f").leave) !== null && _a !== void 0 ? _a : null;
+    }
+    get payload() {
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this.eventContext) === null || _a === void 0 ? void 0 : _a.payload) !== null && _b !== void 0 ? _b : (_c = this.outgoingContext) === null || _c === void 0 ? void 0 : _c.payload) !== null && _d !== void 0 ? _d : null;
+    }
+    get action() {
+        var _a, _b;
+        return (_b = (_a = this.outgoingContext) === null || _a === void 0 ? void 0 : _a.action) !== null && _b !== void 0 ? _b : null;
+    }
+    get params() {
+        var _a, _b;
+        return ((_b = (_a = this.event) === null || _a === void 0 ? void 0 : _a.params) !== null && _b !== void 0 ? _b : {});
+    }
+    get query() {
+        var _a, _b;
+        return (_b = (_a = this.event) === null || _a === void 0 ? void 0 : _a.query) !== null && _b !== void 0 ? _b : {};
+    }
+    get joinParams() {
+        var _a, _b;
+        return (_b = (_a = this.joinContext) === null || _a === void 0 ? void 0 : _a.joinParams) !== null && _b !== void 0 ? _b : null;
+    }
+    get presence() {
+        return this.user.presence;
+    }
+    get assigns() {
+        return this.user.assigns;
+    }
+    get user() {
+        var _a, _b, _c, _d, _e;
+        if (this.connectionContext) {
+            const user = {
+                id: this.connectionContext.clientId,
+                assigns: {},
+                presence: {},
+            };
+            return user;
+        }
+        else if (this.leaveEvent) {
+            return this.leaveEvent.user;
+        }
+        const user = (_d = (_b = (_a = this.joinContext) === null || _a === void 0 ? void 0 : _a.user) !== null && _b !== void 0 ? _b : (_c = this.eventContext) === null || _c === void 0 ? void 0 : _c.user) !== null && _d !== void 0 ? _d : (_e = this.outgoingContext) === null || _e === void 0 ? void 0 : _e.user;
+        if (!user) {
+            throw new Error('PondSocket context does not contain a user');
+        }
+        return user;
+    }
+    get channel() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return (_h = (_f = (_d = (_b = (_a = this.joinContext) === null || _a === void 0 ? void 0 : _a.channel) !== null && _b !== void 0 ? _b : (_c = this.eventContext) === null || _c === void 0 ? void 0 : _c.channel) !== null && _d !== void 0 ? _d : (_e = this.outgoingContext) === null || _e === void 0 ? void 0 : _e.channel) !== null && _f !== void 0 ? _f : (_g = this.leaveEvent) === null || _g === void 0 ? void 0 : _g.channel) !== null && _h !== void 0 ? _h : null;
+    }
+    get event() {
+        var _a, _b, _c, _d, _e, _f;
+        if (this.connectionContext) {
+            const event = {
+                params: this.connectionContext.params,
+                query: this.connectionContext.query,
+                payload: {},
+                event: 'CONNECTION',
+            };
+            return event;
+        }
+        return (_f = (_d = (_b = (_a = this.joinContext) === null || _a === void 0 ? void 0 : _a.event) !== null && _b !== void 0 ? _b : (_c = this.eventContext) === null || _c === void 0 ? void 0 : _c.event) !== null && _d !== void 0 ? _d : (_e = this.outgoingContext) === null || _e === void 0 ? void 0 : _e.event) !== null && _f !== void 0 ? _f : null;
+    }
+    getClass() {
+        return __classPrivateFieldGet(this, _Context_instance, "f").constructor;
+    }
+    getHandler() {
+        return __classPrivateFieldGet(this, _Context_instance, "f")[__classPrivateFieldGet(this, _Context_propertyKey, "f")];
+    }
+    getInstance() {
+        return __classPrivateFieldGet(this, _Context_instance, "f");
+    }
+    getMethod() {
+        return __classPrivateFieldGet(this, _Context_propertyKey, "f");
+    }
+    accept(assigns) {
+        var _a;
+        const context = (_a = this.joinContext) !== null && _a !== void 0 ? _a : this.connectionContext;
+        if (!context) {
+            throw new Error('accept() is only available for connection and join handlers');
+        }
+        context.accept(assigns);
+        return this;
+    }
+    decline(message, status) {
+        var _a;
+        const context = (_a = this.joinContext) !== null && _a !== void 0 ? _a : this.connectionContext;
+        if (!context) {
+            throw new Error('decline() is only available for connection and join handlers');
+        }
+        context.decline(message, status);
+        return this;
+    }
+    assign(assigns) {
+        var _a, _b;
+        const context = (_b = (_a = this.joinContext) !== null && _a !== void 0 ? _a : this.eventContext) !== null && _b !== void 0 ? _b : this.connectionContext;
+        if (!context) {
+            throw new Error('assign() is not available for this handler');
+        }
+        context.assign(assigns);
+        return this;
+    }
+    reply(eventOrPayload, payload) {
+        var _a, _b;
+        const context = (_b = (_a = this.joinContext) !== null && _a !== void 0 ? _a : this.eventContext) !== null && _b !== void 0 ? _b : this.connectionContext;
+        if (!context) {
+            throw new Error('reply() is not available for this handler');
+        }
+        if (typeof eventOrPayload !== 'string') {
+            if (!this.eventContext) {
+                throw new Error('reply(payload) is only available for event handlers');
+            }
+            const replyToCurrentEvent = this.eventContext.reply.bind(this.eventContext);
+            replyToCurrentEvent(this.eventContext.event.event, eventOrPayload);
+            return this;
+        }
+        const reply = context.reply.bind(context);
+        reply(eventOrPayload, payload !== null && payload !== void 0 ? payload : {});
+        return this;
+    }
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _Context_instances, "m", _Context_getChannelContext).call(this, 'broadcast').broadcast(event, payload);
+        return this;
+    }
+    broadcastFrom(event, payload) {
+        __classPrivateFieldGet(this, _Context_instances, "m", _Context_getChannelContext).call(this, 'broadcastFrom').broadcastFrom(event, payload);
+        return this;
+    }
+    broadcastTo(event, payload, users) {
+        __classPrivateFieldGet(this, _Context_instances, "m", _Context_getChannelContext).call(this, 'broadcastTo').broadcastTo(event, payload, users);
+        return this;
+    }
+    trackPresence(presence) {
+        var _a;
+        const context = (_a = this.joinContext) !== null && _a !== void 0 ? _a : this.eventContext;
+        if (!context) {
+            throw new Error('trackPresence() is only available for join and event handlers');
+        }
+        context.trackPresence(presence);
+        return this;
+    }
+    updatePresence(presence) {
+        if (!this.eventContext) {
+            throw new Error('updatePresence() is only available for event handlers');
+        }
+        this.eventContext.updatePresence(presence);
+        return this;
+    }
+    evictUser(reason, userId) {
+        if (!this.eventContext) {
+            throw new Error('evictUser() is only available for event handlers');
+        }
+        this.eventContext.evictUser(reason, userId);
+        return this;
+    }
+    removePresence(userId) {
+        if (!this.eventContext) {
+            throw new Error('removePresence() is only available for event handlers');
+        }
+        this.eventContext.removePresence(userId);
+        return this;
+    }
+    transform(payload) {
+        if (!this.outgoingContext) {
+            throw new Error('transform() is only available for outgoing handlers');
+        }
+        this.outgoingContext.transform(payload);
+        return this;
+    }
+    block() {
+        if (!this.outgoingContext) {
+            throw new Error('block() is only available for outgoing handlers');
+        }
+        this.outgoingContext.block();
+        return this;
+    }
+    addData(key, value) {
+        __classPrivateFieldGet(this, _Context_data, "f")[key] = value;
+    }
+    getData(key) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Context_data, "f")[key]) !== null && _a !== void 0 ? _a : null;
+    }
+}
+exports.Context = Context;
+_Context_data = new WeakMap(), _Context_context = new WeakMap(), _Context_instance = new WeakMap(), _Context_propertyKey = new WeakMap(), _Context_instances = new WeakSet(), _Context_getChannelContext = function _Context_getChannelContext(method) {
+    var _a;
+    const context = (_a = this.joinContext) !== null && _a !== void 0 ? _a : this.eventContext;
+    if (!context) {
+        throw new Error(`${method}() is only available for join and event handlers`);
+    }
+    return context;
+};

package/{decorators → dist/decorators}/onConnectionRequest.js

@@ -19,10 +19,10 @@ function OnConnectionRequest() {
         const { set } = (0, connection_1.manageConnection)(target);
         set('', (instance, moduleRef, globalGuards, globalPipes, ctx) => __awaiter(this, void 0, void 0, function* () {
             try {
-                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, ctx);
+                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, ctx, 'connection');
             }
             catch (error) {
-                (0, errors_1.performErrors)(error, ctx);
+                (0, errors_1.performErrors)(error, ctx, 'connection');
             }
         }));
     };

package/{decorators → dist/decorators}/onEvent.js

@@ -19,10 +19,10 @@ function OnEvent(event = '*') {
         const { set } = (0, event_1.manageEvent)(target);
         set(event, (instance, moduleRef, globalGuards, globalPipes, ctx) => __awaiter(this, void 0, void 0, function* () {
             try {
-                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, ctx);
+                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, ctx, 'event');
             }
             catch (error) {
-                (0, errors_1.performErrors)(error, ctx);
+                (0, errors_1.performErrors)(error, ctx, 'event');
             }
         }));
     };

package/{decorators → dist/decorators}/onJoinRequest.js

@@ -19,10 +19,10 @@ function OnJoinRequest() {
         const { set } = (0, join_1.manageJoin)(target);
         set('', (instance, moduleRef, globalGuards, globalPipes, ctx) => __awaiter(this, void 0, void 0, function* () {
             try {
-                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, ctx);
+                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, ctx, 'join');
             }
             catch (error) {
-                (0, errors_1.performErrors)(error, ctx);
+                (0, errors_1.performErrors)(error, ctx, 'join');
             }
         }));
     };

package/{decorators → dist/decorators}/onLeave.js

@@ -10,20 +10,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnLeave = OnLeave;
-const common_1 = require("@nestjs/common");
 const leave_1 = require("../managers/leave");
 const action_1 = require("../performers/action");
-const logger = new common_1.Logger('OnLeave');
+const errors_1 = require("../performers/errors");
 function OnLeave() {
     return (target, propertyKey, descriptor) => {
         const originalMethod = descriptor.value;
         const { set } = (0, leave_1.manageLeave)(target);
         set('', (instance, moduleRef, globalGuards, globalPipes, leaveEvent) => __awaiter(this, void 0, void 0, function* () {
             try {
-                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, leaveEvent);
+                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, leaveEvent, 'leave');
             }
             catch (err) {
-                logger.error(`Error in OnLeave handler "${String(propertyKey)}": ${err instanceof Error ? err.message : err}`);
+                (0, errors_1.logHandlerError)(err, 'leave', propertyKey);
             }
         }));
     };

package/{decorators → dist/decorators}/onOutgoingEvent.js

@@ -11,12 +11,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnOutgoingEvent = OnOutgoingEvent;
 const outgoingEvent_1 = require("../managers/outgoingEvent");
+const action_1 = require("../performers/action");
+const errors_1 = require("../performers/errors");
 function OnOutgoingEvent(event = '*') {
     return (target, propertyKey, descriptor) => {
         const originalMethod = descriptor.value;
         const { set } = (0, outgoingEvent_1.manageOutgoingEvent)(target);
-        set(event, (instance, _moduleRef, _globalGuards, _globalPipes, ctx) => __awaiter(this, void 0, void 0, function* () {
-            yield originalMethod.call(instance, ctx);
+        set(event, (instance, moduleRef, globalGuards, globalPipes, ctx) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, action_1.performAction)(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, ctx, 'outgoing');
+            }
+            catch (error) {
+                (0, errors_1.logHandlerError)(error, 'outgoing', propertyKey);
+                ctx.block();
+            }
         }));
     };
 }

package/{helpers → dist/helpers}/createParamDecorator.js

@@ -19,9 +19,9 @@ function wrapTransform(metadata, data, handler) {
         const value = yield handler(data, context, metadata);
         const classTransforms = (0, pipes_1.managePipes)(context.getClass()).get();
         const methodTransforms = (0, pipes_1.managePipes)(context.getInstance(), context.getMethod()).get();
-        const transformers = globalPipes
+        const transformers = yield Promise.all(globalPipes
             .concat(classTransforms, methodTransforms)
-            .map((Transformer) => (0, misc_1.retrieveInstance)(moduleRef, Transformer));
+            .map((Transformer) => (0, misc_1.retrieveInstance)(moduleRef, Transformer)));
         const argumentMetadata = {
             metatype: metadata,
             type: 'body',
@@ -36,7 +36,8 @@ function wrapTransform(metadata, data, handler) {
 function createParamDecorator(callback) {
     return (data) => (target, propertyKey, index) => {
         const { set } = (0, parametres_1.manageParameters)(target, propertyKey);
-        const type = Reflect.getMetadata('design:paramtypes', target, propertyKey)[index];
+        const parameterTypes = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+        const type = parameterTypes === null || parameterTypes === void 0 ? void 0 : parameterTypes[index];
         set(index, wrapTransform(type, data, callback));
     };
 }

package/{helpers → dist/helpers}/misc.d.ts

@@ -1,3 +1,3 @@
 import type { ModuleRef } from '@nestjs/core';
 import { Constructor } from '../types';
-export declare function retrieveInstance<Interface>(moduleRef: ModuleRef, Guard: Constructor<Interface>): Interface;
+export declare function retrieveInstance<Interface>(moduleRef: ModuleRef, Type: Constructor<Interface>): Promise<Interface>;

package/dist/helpers/misc.js

@@ -0,0 +1,27 @@
+"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.retrieveInstance = retrieveInstance;
+function retrieveInstance(moduleRef, Type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return moduleRef.get(Type, { strict: false });
+        }
+        catch (_a) {
+            try {
+                return yield moduleRef.resolve(Type, undefined, { strict: false });
+            }
+            catch (_b) {
+                throw new Error(`Unable to resolve ${Type.name}. Register it in the PondSocketModule providers array.`);
+            }
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './decorators';
+export * from './modules/pondSocket';
+export * from './services/pondSocket';
+export * from './helpers/createParamDecorator';
+export { Context } from './context/context';
+export type { AsyncFactoryResult, AsyncMetadata, CanActivate, Constructor, Metadata, NestContext, ParamDecoratorCallback, PondEventContext, PondEventHandler, PondEventPayload, PondCoreEventContext, PondCoreJoinContext, PondCoreOutgoingContext, PondConnectionContext, PondJoinContext, PondOutgoingContext, PondResponse, PondResponseFor, PondSchemaAssigns, PondSchemaPresence, } from './types';

package/{index.js → dist/index.js}

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./modules/pondSocket"), exports);
+__exportStar(require("./services/pondSocket"), exports);
 __exportStar(require("./helpers/createParamDecorator"), exports);
 var context_1 = require("./context/context");
 Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });

package/dist/managers/outgoingEvent.d.ts

@@ -0,0 +1,5 @@
+import type { OutgoingContext } from '@eleven-am/pondsocket/types';
+export declare function manageOutgoingEvent(target: unknown): {
+    get(): import("../types").HandlerData<OutgoingContext<string, import("@eleven-am/pondsocket/types").AnyPondSchema, string, import("@eleven-am/pondsocket/types").ServerActions.SYSTEM | import("@eleven-am/pondsocket/types").ServerActions.BROADCAST | import("@eleven-am/pondsocket/types").ServerActions.ERROR | import("@eleven-am/pondsocket/types").ServerActions.CONNECT>>[];
+    set(path: string, value: import("../types").HandlerFunction<OutgoingContext<string, import("@eleven-am/pondsocket/types").AnyPondSchema, string, import("@eleven-am/pondsocket/types").ServerActions.SYSTEM | import("@eleven-am/pondsocket/types").ServerActions.BROADCAST | import("@eleven-am/pondsocket/types").ServerActions.ERROR | import("@eleven-am/pondsocket/types").ServerActions.CONNECT>>): void;
+};

package/{modules → dist/modules}/pondSocket.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocketModule = void 0;
-const nestjs_discovery_1 = require("@golevelup/nestjs-discovery");
 const core_1 = require("@nestjs/core");
 const guards_1 = require("../managers/guards");
 const pipes_1 = require("../managers/pipes");
@@ -23,7 +22,7 @@ class PondSocketModule {
                 var _a, _b, _c;
                 return new pondSocket_1.PondSocketService(moduleRef, discovery, adapterHost, (_a = metadata.guards) !== null && _a !== void 0 ? _a : [], (_b = metadata.pipes) !== null && _b !== void 0 ? _b : [], (_c = metadata.isExclusiveSocketServer) !== null && _c !== void 0 ? _c : false, metadata.backend, metadata.maxMessageSize, metadata.heartbeatInterval);
             },
-            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, nestjs_discovery_1.DiscoveryService],
+            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, core_1.DiscoveryService],
         };
         return this.buildModule(pondSocketProvider, metadata);
     }
@@ -35,7 +34,7 @@ class PondSocketModule {
                 const resolvedMetadata = yield metadata.useFactory(...args);
                 return new pondSocket_1.PondSocketService(moduleRef, discovery, adapterHost, (_a = metadata.guards) !== null && _a !== void 0 ? _a : [], (_b = metadata.pipes) !== null && _b !== void 0 ? _b : [], (_c = metadata.isExclusiveSocketServer) !== null && _c !== void 0 ? _c : false, resolvedMetadata.backend, resolvedMetadata.maxMessageSize, resolvedMetadata.heartbeatInterval);
             }),
-            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, nestjs_discovery_1.DiscoveryService, ...(metadata.inject || [])],
+            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, core_1.DiscoveryService, ...(metadata.inject || [])],
         };
         return this.buildModule(pondSocketProvider, metadata);
     }
@@ -45,9 +44,9 @@ class PondSocketModule {
         pipes = [...new Set([...localPipes, ...pipes])];
         guards = [...new Set([...localGuards, ...guards])];
         return {
-            exports,
+            exports: [pondSocket_1.PondSocketService, ...exports],
             global: isGlobal,
-            imports: [...imports, nestjs_discovery_1.DiscoveryModule],
+            imports: [...imports, core_1.DiscoveryModule],
             module: PondSocketModule,
             providers: [
                 provider,

package/dist/performers/action.d.ts

@@ -0,0 +1,8 @@
+import type { AnyPondChannelDefinition, ConnectionContext, EventContext, JoinContext, LeaveEvent, OutgoingContext, PondEndpointDefinition } from '@eleven-am/pondsocket/types';
+import type { PipeTransform } from '@nestjs/common';
+import type { ModuleRef } from '@nestjs/core';
+import { CanActivate, Constructor, PondLifecycle, PondResponse } from '../types';
+type HandlerInput = LeaveEvent | JoinContext<string> | EventContext<string> | ConnectionContext<string> | OutgoingContext<string>;
+type HandlerDefinition = AnyPondChannelDefinition | PondEndpointDefinition;
+export declare function performAction(instance: any, moduleRef: ModuleRef, globalGuards: Constructor<CanActivate>[], globalPipes: Constructor<PipeTransform>[], originalMethod: (...args: any[]) => Promise<PondResponse | null | undefined | void> | PondResponse | null | undefined | void, propertyKey: string, input: HandlerInput, lifecycle: PondLifecycle, activeDefinition?: HandlerDefinition): Promise<void>;
+export {};

package/dist/performers/action.js

@@ -0,0 +1,121 @@
+"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.performAction = performAction;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const context_1 = require("../context/context");
+const misc_1 = require("../helpers/misc");
+const guards_1 = require("../managers/guards");
+const parametres_1 = require("../managers/parametres");
+const response_1 = require("./response");
+function retrieveParameters(context, globalPipes, moduleRef, activeDefinition) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const managedParameters = (0, parametres_1.manageParameters)(context.getInstance(), context.getMethod()).get();
+        const boundParameters = ((_a = (0, pondsocket_common_1.getPondMetadata)(context.getInstance(), pondsocket_common_1.pondParameterMetadataKey)) !== null && _a !== void 0 ? _a : []).filter(({ propertyKey }) => propertyKey === context.getMethod());
+        boundParameters.forEach(({ definition }) => {
+            if (definition !== activeDefinition) {
+                throw new Error(`${context.getClass().name}.${context.getMethod()} uses GetContext() from a different PondSocket definition`);
+            }
+        });
+        const parameters = [
+            ...managedParameters,
+            ...boundParameters.map(({ index }) => ({
+                index,
+                callback: () => Promise.resolve(context),
+            })),
+        ];
+        const decoratedIndices = new Set(parameters.map(({ index }) => index));
+        if (decoratedIndices.size !== parameters.length) {
+            throw new Error(`${context.getClass().name}.${context.getMethod()} has multiple PondSocket decorators on the same parameter`);
+        }
+        const reflectedTypes = Reflect.getMetadata('design:paramtypes', context.getInstance(), context.getMethod());
+        const highestDecoratedIndex = parameters.reduce((highest, { index }) => Math.max(highest, index), -1);
+        const parameterCount = Math.max((_b = reflectedTypes === null || reflectedTypes === void 0 ? void 0 : reflectedTypes.length) !== null && _b !== void 0 ? _b : 0, context.getHandler().length, highestDecoratedIndex + 1);
+        for (let index = 0; index < parameterCount; index++) {
+            if (!decoratedIndices.has(index)) {
+                throw new Error(`${context.getClass().name}.${context.getMethod()} parameter at index ${index} must use a PondSocket parameter decorator`);
+            }
+        }
+        const values = Array.from({ length: parameterCount });
+        const resolved = yield Promise.all(parameters.map((_a) => __awaiter(this, [_a], void 0, function* ({ callback, index }) {
+            return ({
+                index,
+                value: yield callback(context, globalPipes, moduleRef),
+            });
+        })));
+        resolved.forEach(({ index, value }) => {
+            values[index] = value;
+        });
+        return values;
+    });
+}
+function performGuards(moduleRef, globalGuards, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const classGuards = (0, guards_1.manageGuards)(context.getClass()).get();
+        const methodGuards = (0, guards_1.manageGuards)(context.getInstance(), context.getMethod()).get();
+        const guards = yield Promise.all(globalGuards
+            .concat(classGuards, methodGuards)
+            .map((Guard) => (0, misc_1.retrieveInstance)(moduleRef, Guard)));
+        for (const guard of guards) {
+            if (!(yield guard.canActivate(context))) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+function getNestContext(context, lifecycle) {
+    switch (lifecycle) {
+        case 'connection':
+            return { connection: context };
+        case 'join':
+            return { join: context };
+        case 'event':
+            return { event: context };
+        case 'outgoing':
+            return { outgoing: context };
+        case 'leave':
+            return { leave: context };
+        default:
+            throw new Error(`Unsupported PondSocket lifecycle: ${String(lifecycle)}`);
+    }
+}
+function rejectGuard(input, lifecycle) {
+    if (lifecycle === 'join' || lifecycle === 'connection') {
+        input.decline('Unauthorized', 403);
+    }
+    else if (lifecycle === 'event') {
+        input.reply(pondsocket_common_1.ErrorTypes.UNAUTHORIZED_BROADCAST, {
+            code: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_BROADCAST,
+            message: 'Unauthorized',
+            status: 403,
+        });
+    }
+    else if (lifecycle === 'outgoing') {
+        input.block();
+    }
+}
+function performAction(instance, moduleRef, globalGuards, globalPipes, originalMethod, propertyKey, input, lifecycle, activeDefinition) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = new context_1.Context(getNestContext(input, lifecycle), instance, propertyKey);
+        const canProceed = yield performGuards(moduleRef, globalGuards, context);
+        if (!canProceed) {
+            rejectGuard(input, lifecycle);
+            return;
+        }
+        const data = yield originalMethod.apply(instance, yield retrieveParameters(context, globalPipes, moduleRef, activeDefinition));
+        if (lifecycle === 'outgoing') {
+            return;
+        }
+        (0, response_1.performResponse)(context.user.id, context.channel, data, input, lifecycle);
+    });
+}

package/dist/performers/errors.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectionContext, EventContext, JoinContext } from '@eleven-am/pondsocket/types';
+import { PondLifecycle } from '../types';
+export declare function performErrors(error: unknown, response: ConnectionContext<string> | JoinContext<string> | EventContext<string>, lifecycle: 'connection' | 'join' | 'event'): EventContext<string, import("@eleven-am/pondsocket-common").AnyPondSchema, string> | JoinContext<string, import("@eleven-am/pondsocket-common").AnyPondSchema> | ConnectionContext<string> | undefined;
+export declare function logHandlerError(error: unknown, lifecycle: PondLifecycle, propertyKey: string | symbol): void;