@eleven-am/pondsocket 0.1.55 → 0.1.57

package/dist/README.md

@@ -0,0 +1,139 @@
+
+# PondSocket
+
+PondSocket is a fast, minimalist and bidirectional socket framework for NodeJS. Pond allows you to think of each action during a sockets lifetime as a request instead of a huge callback that exists inside the connection event.
+## Documentation
+
+This is a Node.js module available through the npm registry.
+
+```bash
+  npm install @eleven-am/pondsocket
+```
+
+PondSocket usage depends on the environment in which it is being used.
+
+#### On the server
+
+When using PondSocket, an endpoint is created. The endpoint is the gateway by which sockets actually connect to the server.
+Multiple endpoints can be created but every endpoint is independent of the other, ie sockets on one endpoint cannot communicate with sockets on another endpoint.
+
+```js
+  import { PondSocket } from "@eleven-am/pondsocket";
+  
+  const pond = new PondSocket();
+ 
+  const endpoint = pond.createEndpoint('/api/socket', (req, res, _endpoint) => {
+       const token = req.query.token;   
+       if (!token)         
+            return res.reject('No token provided');      
+       res.accept({
+            assign: {
+                token
+            }
+       });  
+  })
+```
+
+While sockets connect through the endpoint, communication between sockets cannot occur on the endpoint level. Sockets have to join a channel to communicate
+between themselves.
+
+```js
+  const channel = endpoint.createChannel(/^channel(.*?)/, (req, res, channel) => {
+       const isAdmin = req.clientAssigns.admin;
+       if (!isAdmin)       
+            return res.reject('You are not an admin');
+
+       res.accept({
+           assign: {
+               admin: true, 
+               joinedDate: new Date()
+            }, 
+            presence: {
+                state: 'online'
+            }, 
+            channelData: {
+                locked: true,
+                numberOfUsers: channel.presence.length
+            }
+        });  
+   });   
+```
+
+A user goes through the createChannel function to join a channel.
+When a user joins a channel, some private information can be assigned to the user. This assign could be viewed as a cookie that is only available serverside.
+The presence is the current state of the user. When you reassign a new presence information to a user, all other users connected to the same channel are informed of the change.
+This could be used as *user is typing*, *user is away*, etc. The channelData is information that is stored on the channel and accessible from anywhere the channel is available.
+It can be anything from a boolean to an instance of a class. This data cannot be accessed from another channel as it is private to the channel.
+
+```js
+    channel.on('hello', (req, res, channel) => {      
+       const users = channel.presence;      
+       res.assign({
+           assign: {
+               pingDate: new Date(),
+               users: users.length
+           }
+        }); 
+
+        // res.reject('curse words are not allowed on a child friendly channel') 
+        // channel.closeFromChannel(req.client.clientId);
+    })
+```
+
+When a message is sent on a channel by a user, an event is triggered. The *on* function can be used to listen for these events. If the function is specified, it is called when the message is received.
+You can choose to decline the message being sent, or you can allow the message to be sent as usual. You can also do all the normal assigns to the channel, or user.
+In case there is no *on* function, the message will be sent without any action being taken.
+
+#### On the browser
+
+```js
+    import { PondClient } from "@eleven-am/pondsocket/client";
+
+    export const socket = new PondClient('/api/socket', {});
+    socket.connect();
+```
+
+The browser compatible package can be imported from @eleven-am/pondsocket/client.
+AN url string is provided to the class along with other url params, like token.
+
+Multiple classes can be created, but it is advised to use a single class throughout the application.
+You can just create multiple channels and maintain the single socket connection.
+
+```js
+    const channelTopic = 'channel:one';
+    const options = {
+        username: 'eleven-am'
+    }
+
+    export const channel = socket.createChannel(channelTopic, options);
+    channel.join();
+```
+
+When connected to the channel you can subscribe to the events from the channel.
+
+```js
+    const subscriptionPresence = channel.onPresenceUpdate(presence => {
+        // handle the presence changes of the channel
+    });
+
+    const subscriptionMessage = channel.onMessage((event, data) => {
+        // handle the message being received 
+    });
+
+    // When done with the channel remember to unsubscribe from these listeners
+    subscriptionPresence.unsubscribe();
+    subscriptionMessage.unsubscribe();
+```
+
+There are many other features available on the channel object. Since the application is completely typed,
+suggestions should be provided by your IDE.
+
+```js
+    channel.broadcast('hello', {
+        name: 'eleven-am',
+        message: 'I am the man, man'
+    })
+
+    // channel.broadcastFrom broadcasts a message to everyone but the client that emitted the message
+    // channel.sendMessage sends a message to clients specified in the function
+```

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

@@ -123,11 +123,12 @@ class ChannelEngine {
      * @param userId - The id of the user to get
      */
     getUserData(userId) {
+        const assigns = __classPrivateFieldGet(this, _ChannelEngine_users, "f").get(userId);
         const presence = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f") ? __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").getUserPresence(userId) : {};
-        if (__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(userId)) {
+        if (assigns) {
             return {
+                assigns,
                 id: userId,
-                assigns: __classPrivateFieldGet(this, _ChannelEngine_users, "f").get(userId),
                 presence: presence || {},
             };
         }
@@ -201,11 +202,8 @@ class ChannelEngine {
         if (!__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(userId)) {
             throw new pondError_1.ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
         }
-        __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, (_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) !== null && _a !== void 0 ? _a : new presence_1.PresenceEngine(this.name), "f");
-        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").trackPresence(userId, presence, (change) => {
-            const { type } = change, rest = __rest(change, ["type"]);
-            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], enums_1.ServerActions.PRESENCE, type, rest);
-        });
+        __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, (_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) !== null && _a !== void 0 ? _a : new presence_1.PresenceEngine(this), "f");
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").trackPresence(userId, presence);
     }
     /**
      * @desc Gets the presence engine for the channel

package/{lobby → dist/lobby}/joinResponse.js

@@ -33,7 +33,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      */
     accept(assigns) {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
-        assigns = Object.assign(Object.assign({}, assigns), __classPrivateFieldGet(this, _JoinResponse_user, "f").assigns);
+        const newAssigns = 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,
@@ -41,7 +41,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
             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_engine, "f").addUser(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, newAssigns, (event) => {
             __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(event));
         });
         return this;

package/dist/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@eleven-am/pondsocket",
+  "version": "0.1.56",
+  "description": "PondSocket is a fast simple socket server",
+  "keywords": [
+    "socket",
+    "server",
+    "ws",
+    "websocket",
+    "pubsub",
+    "presence",
+    "realtime",
+    "realtime server"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest --coverage --verbose --watchAll",
+    "build": "tsc --project tsconfig.build.json",
+    "publishToNpm": "npm version patch && npm publish"
+  },
+  "author": "Roy OSSAI",
+  "license": "GPL-3.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Eleven-am/pondSocket.git"
+  },
+  "dependencies": {
+    "websocket": "^1.0.34",
+    "ws": "^8.12.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.14",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^16.10.3",
+    "@types/websocket": "^1.0.5",
+    "@types/ws": "^8.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
+    "eslint": "^8.38.0",
+    "eslint-plugin-file-progress": "^1.3.0",
+    "eslint-plugin-import": "^2.27.5",
+    "jest": "^29.0.1",
+    "superwstest": "^2.0.3",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  }
+}

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

@@ -10,19 +10,17 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _PresenceEngine_engine, _PresenceEngine_presenceMap, _PresenceEngine_channel;
+var _PresenceEngine_instances, _PresenceEngine_presenceMap, _PresenceEngine_channel, _PresenceEngine_publish;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresenceEngine = void 0;
 const enums_1 = require("../enums");
 const pondError_1 = require("../errors/pondError");
-const subject_1 = require("../subjects/subject");
 class PresenceEngine {
     constructor(channel) {
-        _PresenceEngine_engine.set(this, void 0);
+        _PresenceEngine_instances.add(this);
         _PresenceEngine_presenceMap.set(this, void 0);
         _PresenceEngine_channel.set(this, void 0);
         __classPrivateFieldSet(this, _PresenceEngine_channel, channel, "f");
-        __classPrivateFieldSet(this, _PresenceEngine_engine, new subject_1.BehaviorSubject(), "f");
         __classPrivateFieldSet(this, _PresenceEngine_presenceMap, new Map(), "f");
     }
     /**
@@ -46,13 +44,11 @@ class PresenceEngine {
      * @desc Tracks a presence
      * @param presenceKey - The key of the presence
      * @param presence - The presence
-     * @param onPresenceChange - The callback to be called when the presence changes
      */
-    trackPresence(presenceKey, presence, onPresenceChange) {
+    trackPresence(presenceKey, presence) {
         if (!__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").has(presenceKey)) {
             __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, presence);
-            __classPrivateFieldGet(this, _PresenceEngine_engine, "f").publish({
-                type: enums_1.PresenceEventTypes.JOIN,
+            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, enums_1.PresenceEventTypes.JOIN, {
                 changed: presence,
                 presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
             });
@@ -60,9 +56,8 @@ class PresenceEngine {
         else {
             const code = 400;
             const message = `PresenceEngine: Presence with key ${presenceKey} already exists`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f"), enums_1.PresenceEventTypes.JOIN);
+            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, enums_1.PresenceEventTypes.JOIN);
         }
-        return __classPrivateFieldGet(this, _PresenceEngine_engine, "f").subscribeWith(presenceKey, onPresenceChange);
     }
     /**
      * @desc Removes a presence from the presence engine
@@ -72,10 +67,8 @@ class PresenceEngine {
     removePresence(presenceKey, graceful = false) {
         const presence = __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").get(presenceKey);
         if (presence) {
-            __classPrivateFieldGet(this, _PresenceEngine_engine, "f").unsubscribe(presenceKey);
             __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").delete(presenceKey);
-            __classPrivateFieldGet(this, _PresenceEngine_engine, "f").publish({
-                type: enums_1.PresenceEventTypes.LEAVE,
+            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, enums_1.PresenceEventTypes.LEAVE, {
                 changed: presence,
                 presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
             });
@@ -83,7 +76,7 @@ class PresenceEngine {
         else if (!graceful) {
             const code = 404;
             const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f"), enums_1.PresenceEventTypes.LEAVE);
+            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, enums_1.PresenceEventTypes.LEAVE);
         }
     }
     /**
@@ -96,8 +89,7 @@ class PresenceEngine {
         if (oldPresence) {
             const newPresence = Object.assign(Object.assign({}, oldPresence), presence);
             __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, newPresence);
-            __classPrivateFieldGet(this, _PresenceEngine_engine, "f").publish({
-                type: enums_1.PresenceEventTypes.UPDATE,
+            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, enums_1.PresenceEventTypes.UPDATE, {
                 changed: newPresence,
                 presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
             });
@@ -105,9 +97,15 @@ class PresenceEngine {
         else {
             const code = 404;
             const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f"), enums_1.PresenceEventTypes.UPDATE);
+            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, enums_1.PresenceEventTypes.UPDATE);
         }
     }
 }
 exports.PresenceEngine = PresenceEngine;
-_PresenceEngine_engine = new WeakMap(), _PresenceEngine_presenceMap = new WeakMap(), _PresenceEngine_channel = new WeakMap();
+_PresenceEngine_presenceMap = new WeakMap(), _PresenceEngine_channel = new WeakMap(), _PresenceEngine_instances = new WeakSet(), _PresenceEngine_publish = function _PresenceEngine_publish(event, payload) {
+    const recipients = Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").keys());
+    if (recipients.length === 0) {
+        return;
+    }
+    __classPrivateFieldGet(this, _PresenceEngine_channel, "f").sendMessage(enums_1.SystemSender.CHANNEL, recipients, enums_1.ServerActions.PRESENCE, event, payload);
+};

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

@@ -88,7 +88,7 @@ _PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _P
                 return socket.terminate();
             }
             socket.isAlive = false;
-            socket.ping(() => { });
+            socket.ping();
         });
     }, 30000);
     __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('close', () => clearInterval(interval));

package/{subjects → dist/subjects}/subject.js

@@ -18,13 +18,24 @@ class SimpleSubject {
         _SimpleSubject_observers.set(this, void 0);
         __classPrivateFieldSet(this, _SimpleSubject_observers, new Set(), "f");
     }
+    /**
+     * @desc Subscribes to a subject
+     * @param observer - The observer to subscribe
+     */
     subscribe(observer) {
         __classPrivateFieldGet(this, _SimpleSubject_observers, "f").add(observer);
         return () => __classPrivateFieldGet(this, _SimpleSubject_observers, "f").delete(observer);
     }
+    /**
+     * @desc Publishes a message to all subscribers
+     * @param message - The message to publish
+     */
     publish(message) {
         __classPrivateFieldGet(this, _SimpleSubject_observers, "f").forEach((observer) => observer(message));
     }
+    /**
+     * @desc Returns the number of subscribers
+     */
     get size() {
         return __classPrivateFieldGet(this, _SimpleSubject_observers, "f").size;
     }
@@ -37,13 +48,24 @@ class SimpleBehaviorSubject extends SimpleSubject {
         _SimpleBehaviorSubject_lastMessage.set(this, void 0);
         __classPrivateFieldSet(this, _SimpleBehaviorSubject_lastMessage, initialValue, "f");
     }
+    /**
+     * @desc Returns the last message published
+     */
     get value() {
         return __classPrivateFieldGet(this, _SimpleBehaviorSubject_lastMessage, "f");
     }
+    /**
+     * @desc Publishes a message to all subscribers
+     * @param message - The message to publish
+     */
     publish(message) {
         __classPrivateFieldSet(this, _SimpleBehaviorSubject_lastMessage, message, "f");
         super.publish(message);
     }
+    /**
+     * @desc Subscribes to a subject
+     * @param observer - The observer to subscribe
+     */
     subscribe(observer) {
         if (__classPrivateFieldGet(this, _SimpleBehaviorSubject_lastMessage, "f")) {
             observer(__classPrivateFieldGet(this, _SimpleBehaviorSubject_lastMessage, "f"));
@@ -58,14 +80,27 @@ class Subject extends SimpleSubject {
         super(...arguments);
         _Subject_subscriptions.set(this, {});
     }
+    /**
+     * @desc Subscribes to a subject
+     * @param identifier - The identifier of the subscription
+     * @param observer - The observer to subscribe
+     */
     subscribeWith(identifier, observer) {
         __classPrivateFieldGet(this, _Subject_subscriptions, "f")[identifier] = super.subscribe(observer);
     }
+    /**
+     * @desc Unsubscribes from a subject
+     * @param identifier - The identifier of the subscription
+     */
     unsubscribe(identifier) {
         var _a, _b;
         (_b = (_a = __classPrivateFieldGet(this, _Subject_subscriptions, "f"))[identifier]) === null || _b === void 0 ? void 0 : _b.call(_a);
         delete __classPrivateFieldGet(this, _Subject_subscriptions, "f")[identifier];
     }
+    /**
+     * @desc Checks if a subscription exists
+     * @param identifier - The identifier of the subscription
+     */
     has(identifier) {
         return Boolean(__classPrivateFieldGet(this, _Subject_subscriptions, "f")[identifier]);
     }
@@ -78,12 +113,21 @@ class BehaviorSubject extends Subject {
         _BehaviorSubject_lastMessage.set(this, void 0);
         __classPrivateFieldSet(this, _BehaviorSubject_lastMessage, initialValue, "f");
     }
+    /**
+     * @desc Subscribes to a subject
+     * @param identifier - The identifier of the subscription
+     * @param observer - The observer to subscribe
+     */
     subscribeWith(identifier, observer) {
         if (__classPrivateFieldGet(this, _BehaviorSubject_lastMessage, "f")) {
             observer(__classPrivateFieldGet(this, _BehaviorSubject_lastMessage, "f"));
         }
         super.subscribeWith(identifier, observer);
     }
+    /**
+     * @desc Publishes a message to all subscribers
+     * @param message - The message to publish
+     */
     publish(message) {
         __classPrivateFieldSet(this, _BehaviorSubject_lastMessage, message, "f");
         super.publish(message);

package/{types.d.ts → dist/types.d.ts}

@@ -188,9 +188,6 @@ declare class EventResponse extends PondResponse {
 }
 
 export declare class Channel {
-    /**
-     * @desc Gets the current connection state of the channel.
-     */
     channelState: ChannelState;
 
     /**
@@ -323,8 +320,6 @@ declare class JoinRequest<Path extends string> extends AbstractRequest<Path> {
 }
 
 declare class JoinResponse extends PondResponse {
-    #private;
-
     /**
      * @desc Accepts the request and optionally assigns data to the client
      * @param assigns - the data to assign to the client

package/jest.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+    transform: {
+        '^.+\\.ts?$': 'ts-jest',
+    },
+    moduleFileExtensions: ['ts', 'js', 'json', 'node', 'd.ts'],
+    collectCoverage: true,
+    collectCoverageFrom: [
+        "src/**/*.{js,jsx,ts,tsx}",
+        "!src/**/*.d.ts"
+    ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -22,8 +22,8 @@
   },
   "author": "Roy OSSAI",
   "license": "GPL-3.0",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Eleven-am/pondSocket.git"

package/src/abstracts/abstractRequest.test.ts

@@ -0,0 +1,49 @@
+import { AbstractRequest } from './abstractRequest';
+
+const createMockChannelEngine = () => ({
+    name: 'test',
+    getAssigns: () => ({}),
+    getPresence: () => ({}),
+} as any);
+
+describe('AbstractRequest', () => {
+    it('should be able to be instantiated', () => {
+        const request = new AbstractRequest('/test', createMockChannelEngine(), {});
+
+        expect(request).toBeTruthy();
+        expect(request.channelNme).toBe('test');
+        expect(request.assigns).toEqual({});
+        expect(request.presence).toEqual({});
+    });
+
+    it('should be able to parse queries', () => {
+        const request = new AbstractRequest('/1234?choke=balls', createMockChannelEngine(), {});
+
+        expect(() => request.event).toThrowError('Event was not parsed');
+        expect(request['_parseQueries']('/:id')).toBe(true);
+        expect(request.event).toEqual({
+            event: '/1234?choke=balls',
+            params: { id: '1234' },
+            query: { choke: 'balls' },
+            payload: {},
+        });
+    });
+
+    it('should be return the value of the payload', () => {
+        const request = new AbstractRequest('/test', createMockChannelEngine(), { test: 'test' });
+
+        expect(request['_parseQueries']('/:id')).toBe(true);
+        expect(request.event.payload).toEqual({ test: 'test' });
+
+        const request2 = new AbstractRequest('/test', createMockChannelEngine(), {
+            test: 'test',
+            test2: 'test2',
+        });
+
+        expect(request2['_parseQueries']('/:id')).toBe(true);
+        expect(request2.event.payload).toEqual({
+            test: 'test',
+            test2: 'test2',
+        });
+    });
+});

package/src/abstracts/abstractRequest.ts

@@ -0,0 +1,56 @@
+import { ChannelEngine } from '../channel/channel';
+import { parseAddress } from '../matcher/matcher';
+// eslint-disable-next-line import/no-unresolved
+import { PondMessage, UserPresences, UserAssigns, PondPath, PondEvent, EventParams } from '../types';
+
+export class AbstractRequest<Path extends string> {
+    protected readonly _engine: ChannelEngine;
+
+    #eventObject: EventParams<Path> | null;
+
+    readonly #event: string;
+
+    readonly #payload: PondMessage;
+
+    constructor (event: string, engine: ChannelEngine, payload: PondMessage) {
+        this._engine = engine;
+        this.#event = event;
+        this.#eventObject = null;
+        this.#payload = payload;
+    }
+
+    public get event (): PondEvent<Path> {
+        if (this.#eventObject === null) {
+            throw new Error('Event was not parsed');
+        }
+
+        return {
+            event: this.#event,
+            params: this.#eventObject.params || {},
+            query: this.#eventObject.query || {},
+            payload: this.#payload,
+        };
+    }
+
+    public get channelNme (): string {
+        return this._engine.name;
+    }
+
+    public get assigns (): UserAssigns {
+        return this._engine.getAssigns();
+    }
+
+    public get presence (): UserPresences {
+        return this._engine.presenceEngine?.getPresence() || {};
+    }
+
+    /**
+     * @desc Parses the event and returns true if the event matches the path
+     * @param path - the path to match
+     */
+    public _parseQueries (path: PondPath<Path>): boolean {
+        this.#eventObject = parseAddress(path, this.#event);
+
+        return this.#eventObject !== null;
+    }
+}

package/src/abstracts/abstractResponse.ts

@@ -0,0 +1,26 @@
+// eslint-disable-next-line import/no-unresolved
+import { PondAssigns, PondMessage } from '../types';
+
+export abstract class PondResponse {
+    /**
+     * @desc Rejects the request with the given error message
+     * @param message - the error message
+     * @param errorCode - the error code
+     * @param assigns - the data to assign to the client
+     */
+    public abstract reject(message?: string, errorCode?: number, assigns?: PondAssigns): void
+
+    /**
+     * @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
+     */
+    public abstract send(event: string, payload: PondMessage, assigns?: PondAssigns): void
+
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    public abstract accept(assigns?: PondAssigns): void
+}