@eleven-am/pondsocket 0.1.49 → 0.1.51

package/endpoint/endpoint.js

@@ -0,0 +1,233 @@
+"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 _Endpoint_instances, _Endpoint_middleware, _Endpoint_server, _Endpoint_channels, _Endpoint_sockets, _Endpoint_sendMessage, _Endpoint_joinChannel, _Endpoint_execute, _Endpoint_handleMessage, _Endpoint_readMessage, _Endpoint_isObjectEmpty;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoint = void 0;
+const middleware_1 = require("../abstracts/middleware");
+const enums_1 = require("../enums");
+const pondError_1 = require("../errors/pondError");
+const joinRequest_1 = require("../lobby/joinRequest");
+const joinResponse_1 = require("../lobby/joinResponse");
+const lobby_1 = require("../lobby/lobby");
+const matcher_1 = require("../matcher/matcher");
+class Endpoint {
+    constructor(server) {
+        _Endpoint_instances.add(this);
+        _Endpoint_middleware.set(this, void 0);
+        _Endpoint_server.set(this, void 0);
+        _Endpoint_channels.set(this, void 0);
+        _Endpoint_sockets.set(this, void 0);
+        __classPrivateFieldSet(this, _Endpoint_server, server, "f");
+        __classPrivateFieldSet(this, _Endpoint_sockets, new Set(), "f");
+        __classPrivateFieldSet(this, _Endpoint_middleware, new middleware_1.Middleware(), "f");
+        __classPrivateFieldSet(this, _Endpoint_channels, new Set(), "f");
+    }
+    /**
+     * @desc Adds a new PondChannel to this path on this endpoint
+     * @param path - The path to add the channel to
+     * @param handler - The handler to use to authenticate the client
+     *
+     * @example
+     * const channel = endpoint.createChannel('/chat', (request, response) => {
+     *     if (request.user.assigns.admin)
+     *         response.accept();
+     *
+     *     else
+     *         response.reject('You are not an admin', 403);
+     * });
+     */
+    createChannel(path, handler) {
+        const pondChannel = new lobby_1.LobbyEngine();
+        __classPrivateFieldGet(this, _Endpoint_middleware, "f").use((user, joinParams, next) => {
+            const event = (0, matcher_1.parseAddress)(path, user.channelName);
+            if (event) {
+                const newChannel = pondChannel.getChannel(user.channelName) || pondChannel.createChannel(user.channelName);
+                const request = new joinRequest_1.JoinRequest(user, joinParams, newChannel);
+                const response = new joinResponse_1.JoinResponse(user, newChannel);
+                if (request._parseQueries(path)) {
+                    return handler(request, response);
+                }
+            }
+            next();
+        });
+        __classPrivateFieldGet(this, _Endpoint_channels, "f").add(pondChannel);
+        return new lobby_1.PondChannel(pondChannel);
+    }
+    /**
+     * @desc List all clients connected to this endpoint
+     */
+    listConnections() {
+        return [...__classPrivateFieldGet(this, _Endpoint_sockets, "f")].map(({ clientId }) => clientId);
+    }
+    /**
+     * @desc Gets all clients connected to this endpoint
+     */
+    getClients() {
+        return [...__classPrivateFieldGet(this, _Endpoint_sockets, "f")];
+    }
+    /**
+     * @desc Broadcasts a message to all clients connected to this endpoint
+     * @param event - The event to broadcast
+     * @param payload - The payload to broadcast
+     */
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _Endpoint_sockets, "f").forEach(({ socket }) => {
+            const message = {
+                event,
+                payload,
+                action: enums_1.ServerActions.BROADCAST,
+                channelName: enums_1.SystemSender.ENDPOINT,
+            };
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, socket, message);
+        });
+    }
+    /**
+     * @desc Closes specific clients connected to this endpoint
+     * @param clientIds - The id for the client / clients to close
+     */
+    closeConnection(clientIds) {
+        const clients = typeof clientIds === 'string' ? [clientIds] : clientIds;
+        this.getClients()
+            .forEach(({ clientId, socket }) => {
+            if (clients.includes(clientId)) {
+                socket.close();
+            }
+        });
+    }
+    /**
+     * @desc Manages a new socket connection
+     * @param cache - The socket cache
+     */
+    manageSocket(cache) {
+        __classPrivateFieldGet(this, _Endpoint_sockets, "f").add(cache);
+        const socket = cache.socket;
+        socket.addEventListener('message', (message) => {
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_readMessage).call(this, cache, message.data);
+        });
+        socket.addEventListener('close', () => {
+            __classPrivateFieldGet(this, _Endpoint_channels, "f")
+                .forEach((manager) => manager.removeUser(cache.clientId, true));
+        });
+        socket.addEventListener('error', () => {
+            __classPrivateFieldGet(this, _Endpoint_channels, "f")
+                .forEach((manager) => manager.removeUser(cache.clientId, true));
+        });
+    }
+}
+exports.Endpoint = Endpoint;
+_Endpoint_middleware = new WeakMap(), _Endpoint_server = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpoint_sockets = new WeakMap(), _Endpoint_instances = new WeakSet(), _Endpoint_sendMessage = function _Endpoint_sendMessage(socket, message) {
+    socket.send(JSON.stringify(message));
+}, _Endpoint_joinChannel = function _Endpoint_joinChannel(channel, socket, joinParams) {
+    const cache = Object.assign(Object.assign({}, socket), { channelName: channel });
+    __classPrivateFieldGet(this, _Endpoint_middleware, "f").run(cache, joinParams, () => {
+        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);
+    });
+}, _Endpoint_execute = function _Endpoint_execute(channel, handler) {
+    for (const manager of __classPrivateFieldGet(this, _Endpoint_channels, "f")) {
+        const isPresent = manager.listChannels()
+            .includes(channel);
+        if (isPresent) {
+            return manager.execute(channel, handler);
+        }
+    }
+    throw new Error(`GatewayEngine: Channel ${channel} does not exist`);
+}, _Endpoint_handleMessage = function _Endpoint_handleMessage(cache, message) {
+    switch (message.action) {
+        case enums_1.ClientActions.JOIN_CHANNEL:
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_joinChannel).call(this, message.channelName, cache, message.payload);
+            break;
+        case enums_1.ClientActions.LEAVE_CHANNEL:
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
+                channel.removeUser(cache.clientId);
+            });
+            break;
+        case enums_1.ClientActions.BROADCAST:
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
+                channel.broadcastMessage(cache.clientId, message);
+            });
+            break;
+        default:
+            throw new Error(`GatewayEngine: Action ${message.action} does not exist`);
+    }
+}, _Endpoint_readMessage = function _Endpoint_readMessage(cache, message) {
+    const errorMessage = {
+        event: enums_1.ErrorTypes.INVALID_MESSAGE,
+        action: enums_1.ServerActions.ERROR,
+        channelName: enums_1.SystemSender.ENDPOINT,
+        payload: {},
+    };
+    try {
+        const data = JSON.parse(message);
+        if (!data.action) {
+            errorMessage.payload = {
+                message: 'No action provided',
+            };
+        }
+        else if (!data.channelName) {
+            errorMessage.payload = {
+                message: 'No channel name provided',
+            };
+        }
+        else if (!data.payload) {
+            errorMessage.payload = {
+                message: 'No payload provided',
+            };
+        }
+        if (!__classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_isObjectEmpty).call(this, errorMessage.payload)) {
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, cache.socket, errorMessage);
+        }
+        else {
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_handleMessage).call(this, cache, data);
+        }
+    }
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            errorMessage.payload = {
+                message: 'Invalid JSON',
+            };
+        }
+        else if (e instanceof Error) {
+            errorMessage.event = enums_1.ErrorTypes.INTERNAL_SERVER_ERROR;
+            errorMessage.payload = {
+                message: e.message,
+            };
+        }
+        else if (e instanceof pondError_1.PresenceError) {
+            errorMessage.event = enums_1.ErrorTypes.PRESENCE_ERROR;
+            errorMessage.channelName = e.channel;
+            errorMessage.payload = {
+                message: e.message,
+                code: e.code,
+                action: e.event,
+            };
+        }
+        else if (e instanceof pondError_1.ChannelError) {
+            errorMessage.event = enums_1.ErrorTypes.CHANNEL_ERROR;
+            errorMessage.channelName = e.channel;
+            errorMessage.payload = {
+                message: e.message,
+                code: e.code,
+            };
+        }
+        else if (e instanceof pondError_1.EndpointError) {
+            errorMessage.event = enums_1.ErrorTypes.ENDPOINT_ERROR;
+            errorMessage.payload = {
+                message: e.message,
+                code: e.code,
+            };
+        }
+        __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, cache.socket, errorMessage);
+    }
+}, _Endpoint_isObjectEmpty = function _Endpoint_isObjectEmpty(obj) {
+    return Object.keys(obj).length === 0;
+};

package/endpoint/response.js

@@ -0,0 +1,86 @@
+"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 _ConnectionResponse_instances, _ConnectionResponse_webSocket, _ConnectionResponse_engine, _ConnectionResponse_clientId, _ConnectionResponse_executed, _ConnectionResponse_sendMessage, _ConnectionResponse_performChecks;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionResponse = void 0;
+const abstractResponse_1 = require("../abstracts/abstractResponse");
+const enums_1 = require("../enums");
+const pondError_1 = require("../errors/pondError");
+class ConnectionResponse extends abstractResponse_1.PondResponse {
+    constructor(webSocket, engine, clientId) {
+        super();
+        _ConnectionResponse_instances.add(this);
+        _ConnectionResponse_webSocket.set(this, void 0);
+        _ConnectionResponse_engine.set(this, void 0);
+        _ConnectionResponse_clientId.set(this, void 0);
+        _ConnectionResponse_executed.set(this, void 0);
+        __classPrivateFieldSet(this, _ConnectionResponse_webSocket, webSocket, "f");
+        __classPrivateFieldSet(this, _ConnectionResponse_engine, engine, "f");
+        __classPrivateFieldSet(this, _ConnectionResponse_clientId, clientId, "f");
+        __classPrivateFieldSet(this, _ConnectionResponse_executed, false, "f");
+    }
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    accept(assigns) {
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_performChecks).call(this);
+        const cache = {
+            clientId: __classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"),
+            socket: __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f"),
+            assigns: assigns || {},
+        };
+        __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").manageSocket(cache);
+    }
+    /**
+     * @desc Rejects the request with the given error message
+     * @param message - the error message
+     * @param errorCode - the error code
+     */
+    reject(message, errorCode) {
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_performChecks).call(this);
+        const payload = {
+            message: message || 'Unauthorized connection',
+            code: errorCode || 401,
+        };
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, enums_1.ServerActions.ERROR, enums_1.ErrorTypes.UNAUTHORIZED_CONNECTION, payload);
+        __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f").close();
+    }
+    /**
+     * @desc Emits a direct message to the client
+     * @param event - the event name
+     * @param payload - the payload to send
+     * @param assigns - the data to assign to the client
+     */
+    send(event, payload, assigns) {
+        this.accept(assigns);
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, enums_1.ServerActions.BROADCAST, event, payload);
+    }
+}
+exports.ConnectionResponse = ConnectionResponse;
+_ConnectionResponse_webSocket = new WeakMap(), _ConnectionResponse_engine = new WeakMap(), _ConnectionResponse_clientId = new WeakMap(), _ConnectionResponse_executed = new WeakMap(), _ConnectionResponse_instances = new WeakSet(), _ConnectionResponse_sendMessage = function _ConnectionResponse_sendMessage(action, event, payload) {
+    const message = {
+        action,
+        event,
+        payload,
+        channelName: enums_1.SystemSender.ENDPOINT,
+    };
+    __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f").send(JSON.stringify(message));
+}, _ConnectionResponse_performChecks = function _ConnectionResponse_performChecks() {
+    if (__classPrivateFieldGet(this, _ConnectionResponse_executed, "f")) {
+        const message = 'Cannot execute response more than once';
+        const code = 403;
+        throw new pondError_1.EndpointError(message, code);
+    }
+    __classPrivateFieldSet(this, _ConnectionResponse_executed, true, "f");
+};

package/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemSender = exports.ErrorTypes = exports.ChannelState = exports.PondState = exports.ClientActions = exports.ServerActions = exports.PresenceEventTypes = void 0;
+exports.Events = exports.ChannelReceiver = exports.SystemSender = exports.ErrorTypes = exports.ChannelState = exports.ClientActions = exports.ServerActions = exports.PresenceEventTypes = void 0;
 var PresenceEventTypes;
 (function (PresenceEventTypes) {
     PresenceEventTypes["JOIN"] = "JOIN";
@@ -20,13 +20,6 @@ var ClientActions;
     ClientActions["LEAVE_CHANNEL"] = "LEAVE_CHANNEL";
     ClientActions["BROADCAST"] = "BROADCAST";
 })(ClientActions = exports.ClientActions || (exports.ClientActions = {}));
-var PondState;
-(function (PondState) {
-    PondState["CONNECTING"] = "CONNECTING";
-    PondState["OPEN"] = "OPEN";
-    PondState["CLOSING"] = "CLOSING";
-    PondState["CLOSED"] = "CLOSED";
-})(PondState = exports.PondState || (exports.PondState = {}));
 var ChannelState;
 (function (ChannelState) {
     ChannelState["IDLE"] = "IDLE";
@@ -37,16 +30,27 @@ var ChannelState;
 })(ChannelState = exports.ChannelState || (exports.ChannelState = {}));
 var ErrorTypes;
 (function (ErrorTypes) {
+    ErrorTypes["UNAUTHORIZED_CONNECTION"] = "UNAUTHORIZED_CONNECTION";
     ErrorTypes["UNAUTHORIZED_JOIN_REQUEST"] = "UNAUTHORIZED_JOIN_REQUEST";
     ErrorTypes["UNAUTHORIZED_BROADCAST"] = "UNAUTHORIZED_BROADCAST";
     ErrorTypes["INVALID_MESSAGE"] = "INVALID_MESSAGE";
     ErrorTypes["HANDLER_NOT_FOUND"] = "HANDLER_NOT_FOUND";
-    ErrorTypes["PRESENCE_LEAVE_FAILED"] = "PRESENCE_LEAVE_FAILED";
+    ErrorTypes["PRESENCE_ERROR"] = "PRESENCE_ERROR";
+    ErrorTypes["CHANNEL_ERROR"] = "CHANNEL_ERROR";
+    ErrorTypes["ENDPOINT_ERROR"] = "ENDPOINT_ERROR";
     ErrorTypes["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
 })(ErrorTypes = exports.ErrorTypes || (exports.ErrorTypes = {}));
 var SystemSender;
 (function (SystemSender) {
-    SystemSender["SERVER"] = "SERVER";
     SystemSender["ENDPOINT"] = "ENDPOINT";
     SystemSender["CHANNEL"] = "CHANNEL";
 })(SystemSender = exports.SystemSender || (exports.SystemSender = {}));
+var ChannelReceiver;
+(function (ChannelReceiver) {
+    ChannelReceiver["ALL_USERS"] = "ALL_USERS";
+    ChannelReceiver["ALL_EXCEPT_SENDER"] = "ALL_EXCEPT_SENDER";
+})(ChannelReceiver = exports.ChannelReceiver || (exports.ChannelReceiver = {}));
+var Events;
+(function (Events) {
+    Events["ACKNOWLEDGE"] = "ACKNOWLEDGE";
+})(Events = exports.Events || (exports.Events = {}));

package/errors/pondError.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceError = exports.ChannelError = exports.EndpointError = exports.PondError = void 0;
+class PondError {
+    constructor(message, code) {
+        this.code = code;
+        this.message = message;
+    }
+}
+exports.PondError = PondError;
+class EndpointError extends PondError {
+}
+exports.EndpointError = EndpointError;
+class ChannelError extends EndpointError {
+    constructor(message, code, channel) {
+        super(message, code);
+        this.channel = channel;
+    }
+}
+exports.ChannelError = ChannelError;
+class PresenceError extends ChannelError {
+    constructor(message, code, channel, event) {
+        super(message, code, channel);
+        this.event = event;
+    }
+}
+exports.PresenceError = PresenceError;

package/express.d.ts

@@ -1,3 +1,3 @@
-import { PondSocketFromExpress } from './types';
+import { pondSocket } from './types';
 
-export default PondSocketFromExpress;
+export default pondSocket;

package/express.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const http_1 = require("http");
-const pondSocket_1 = require("./server/server/pondSocket");
+const pondSocket_1 = require("./server/pondSocket");
 /**
  * @desc Creates a pond socket server
  * @param app - The Express app to be used by the server
  * @constructor
  */
-const PondSocket = (app) => {
+const pondSocket = (app) => {
     const server = (0, http_1.createServer)(app);
     const pondSocket = new pondSocket_1.PondSocket(server);
     app.upgrade = (path, handler) => pondSocket.createEndpoint(path, handler);
     app.listen = (...args) => pondSocket.listen(...args);
     return app;
 };
-exports.default = PondSocket;
+exports.default = pondSocket;

package/index.d.ts

@@ -1,4 +1,3 @@
-import { PondSocket, PondChannel } from './types';
+import { PondSocket } from './types';
 
 export default PondSocket;
-export { PondChannel };

package/index.js

@@ -1,7 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondChannel = void 0;
-const pondChannel_1 = require("./server/pondChannel/pondChannel");
-Object.defineProperty(exports, "PondChannel", { enumerable: true, get: function () { return pondChannel_1.PondChannel; } });
-const pondSocket_1 = require("./server/server/pondSocket");
+const pondSocket_1 = require("./server/pondSocket");
 exports.default = pondSocket_1.PondSocket;

package/lobby/joinRequest.js

@@ -0,0 +1,39 @@
+"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 _JoinRequest_params, _JoinRequest_clientId, _JoinRequest_assigns;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinRequest = void 0;
+const abstractRequest_1 = require("../abstracts/abstractRequest");
+class JoinRequest extends abstractRequest_1.AbstractRequest {
+    constructor(event, params, engine) {
+        super(engine.name, engine, params);
+        _JoinRequest_params.set(this, void 0);
+        _JoinRequest_clientId.set(this, void 0);
+        _JoinRequest_assigns.set(this, void 0);
+        __classPrivateFieldSet(this, _JoinRequest_params, params, "f");
+        __classPrivateFieldSet(this, _JoinRequest_clientId, event.clientId, "f");
+        __classPrivateFieldSet(this, _JoinRequest_assigns, event.assigns, "f");
+    }
+    get joinParams() {
+        return __classPrivateFieldGet(this, _JoinRequest_params, "f");
+    }
+    get user() {
+        return {
+            id: __classPrivateFieldGet(this, _JoinRequest_clientId, "f"),
+            assigns: __classPrivateFieldGet(this, _JoinRequest_assigns, "f"),
+            presence: {},
+        };
+    }
+}
+exports.JoinRequest = JoinRequest;
+_JoinRequest_params = new WeakMap(), _JoinRequest_clientId = new WeakMap(), _JoinRequest_assigns = new WeakMap();

package/lobby/joinResponse.js

@@ -0,0 +1,125 @@
+"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 _JoinResponse_instances, _JoinResponse_user, _JoinResponse_engine, _JoinResponse_executed, _JoinResponse_performChecks;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinResponse = void 0;
+const abstractResponse_1 = require("../abstracts/abstractResponse");
+const enums_1 = require("../enums");
+const pondError_1 = require("../errors/pondError");
+class JoinResponse extends abstractResponse_1.PondResponse {
+    constructor(user, engine) {
+        super();
+        _JoinResponse_instances.add(this);
+        _JoinResponse_user.set(this, void 0);
+        _JoinResponse_engine.set(this, void 0);
+        _JoinResponse_executed.set(this, void 0);
+        __classPrivateFieldSet(this, _JoinResponse_user, user, "f");
+        __classPrivateFieldSet(this, _JoinResponse_engine, engine, "f");
+        __classPrivateFieldSet(this, _JoinResponse_executed, false, "f");
+    }
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    accept(assigns) {
+        __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
+        assigns = Object.assign(Object.assign({}, assigns), __classPrivateFieldGet(this, _JoinResponse_user, "f").assigns);
+        const acknowledgement = {
+            action: enums_1.ServerActions.SYSTEM,
+            channelName: __classPrivateFieldGet(this, _JoinResponse_engine, "f").name,
+            event: enums_1.Events.ACKNOWLEDGE,
+            payload: {},
+        };
+        __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(acknowledgement));
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").addUser(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, assigns, (event) => {
+            __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(event));
+        });
+        return this;
+    }
+    /**
+     * @desc Rejects the request and optionally assigns data to the client
+     * @param message - the error message
+     * @param errorCode - the error code
+     */
+    reject(message, errorCode) {
+        __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
+        const text = `Request to join channel ${__classPrivateFieldGet(this, _JoinResponse_engine, "f").name} rejected: ${message || 'Unauthorized request'}`;
+        const errorMessage = {
+            event: enums_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            payload: {
+                message: text,
+                code: errorCode || 403,
+            },
+            channelName: __classPrivateFieldGet(this, _JoinResponse_engine, "f").name,
+            action: enums_1.ServerActions.ERROR,
+        };
+        __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(errorMessage));
+        return this;
+    }
+    /**
+     * @desc Emits a direct message to the client
+     * @param event - the event name
+     * @param payload - the payload to send
+     * @param assigns - the data to assign to the client
+     */
+    send(event, payload, assigns) {
+        this.accept(assigns);
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(enums_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId], enums_1.ServerActions.SYSTEM, event, payload);
+        return this;
+    }
+    /**
+     * @desc Emits a message to all clients in the channel
+     * @param event - the event name
+     * @param payload - the payload to send
+     */
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc Emits a message to all clients in the channel except the sender
+     * @param event - the event name
+     * @param payload - the payload to send
+     */
+    broadcastFromUser(event, payload) {
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, enums_1.ChannelReceiver.ALL_EXCEPT_SENDER, enums_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc Emits a message to a specific set of clients
+     * @param event - the event name
+     * @param payload  - the payload to send
+     * @param userIds - the ids of the clients to send the message to
+     */
+    sendToUsers(event, payload, userIds) {
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, userIds, enums_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc tracks the presence of a client
+     * @param presence - the presence data to track
+     */
+    trackPresence(presence) {
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").trackPresence(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, presence);
+        return this;
+    }
+}
+exports.JoinResponse = JoinResponse;
+_JoinResponse_user = new WeakMap(), _JoinResponse_engine = new WeakMap(), _JoinResponse_executed = new WeakMap(), _JoinResponse_instances = new WeakSet(), _JoinResponse_performChecks = function _JoinResponse_performChecks() {
+    if (__classPrivateFieldGet(this, _JoinResponse_executed, "f")) {
+        const message = `Request to join channel ${__classPrivateFieldGet(this, _JoinResponse_engine, "f").name} rejected: Request already executed`;
+        const code = 403;
+        throw new pondError_1.ChannelError(message, code, __classPrivateFieldGet(this, _JoinResponse_engine, "f").name);
+    }
+    __classPrivateFieldSet(this, _JoinResponse_executed, true, "f");
+};