@eleven-am/pondsocket 0.1.57 → 0.1.58

package/dist/README.md

@@ -1,139 +0,0 @@
-
-# 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/dist/package.json

@@ -1,51 +0,0 @@
-{
-  "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/jest.config.js

@@ -1,11 +0,0 @@
-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/src/abstracts/abstractRequest.test.ts

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

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

@@ -1,26 +0,0 @@
-// 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
-}

package/src/abstracts/middleware.test.ts

@@ -1,75 +0,0 @@
-import { Middleware } from './middleware';
-
-describe('Middleware', () => {
-    it('should be able to add middleware to the stack', () => {
-        const middleware = new Middleware();
-
-        middleware.use(() => {});
-        expect(middleware.length).toBe(1);
-    });
-
-    it('should be able to run middleware', async () => {
-        const middleware = new Middleware();
-        const mock = jest.fn();
-
-        middleware.use(mock);
-        await middleware.run({}, {} as any, () => {});
-        expect(mock).toHaveBeenCalled();
-    });
-
-    it('should be able to run multiple middleware', async () => {
-        const middleware = new Middleware();
-        const mock = jest.fn();
-
-        middleware.use((_, __, next) => {
-            mock('first');
-            next();
-        });
-
-        middleware.use((_, __, next) => {
-            mock('second');
-            next();
-        });
-        await middleware.run({}, {} as any, () => {});
-        expect(mock).toHaveBeenCalledTimes(2);
-        expect(mock.mock.calls[0][2]).toBe(mock.mock.calls[1][2]);
-    });
-
-    it('should be merge middleware in the correct order', async () => {
-        const middleware = new Middleware();
-        const mock = jest.fn();
-
-        middleware.use(mock);
-        middleware.use(mock);
-        const middleware2 = new Middleware(middleware);
-
-        expect(middleware2.length).toBe(2);
-    });
-
-    it('should call the final function when the middleware stack is empty', async () => {
-        const middleware = new Middleware();
-        const mock = jest.fn();
-
-        await middleware.run({}, {} as any, mock);
-        expect(mock).toHaveBeenCalled();
-    });
-
-    it('should be able to run middleware in the correct order when using a second middleware', async () => {
-        const middleware = new Middleware();
-        const mock = jest.fn();
-
-        middleware.use((_, __, next) => {
-            mock('first');
-            next();
-        });
-
-        middleware.use((_, __, next) => {
-            mock('second');
-            next();
-        });
-        const middleware2 = new Middleware(middleware);
-
-        await middleware2.run({}, {} as any, () => {});
-        expect(mock.mock.calls[0][2]).toBe(mock.mock.calls[1][2]);
-    });
-});

package/src/abstracts/middleware.ts

@@ -1,50 +0,0 @@
-type NextFunction = () => void;
-
-export type MiddlewareFunction<Request, Response> = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
-
-export class Middleware<Request, Response> {
-    readonly #stack: MiddlewareFunction<Request, Response>[] = [];
-
-    constructor (second?: Middleware<Request, Response>) {
-        if (second) {
-            this.#stack.push(...second.#stack);
-        }
-    }
-
-    /**
-     * @desc Adds a middleware function to the middleware stack
-     * @param middleware - the middleware function to add
-     */
-    public use (middleware: MiddlewareFunction<Request, Response>) {
-        this.#stack.push(middleware);
-    }
-
-    /**
-     * @desc Runs the middleware stack
-     * @param req - the request object
-     * @param res - the response object
-     * @param final - the final function to call
-     */
-    public run (req: Request, res: Response, final: NextFunction) {
-        const temp = this.#stack.concat();
-
-        const nextFunction = () => {
-            const middleware = temp.shift();
-
-            if (middleware) {
-                middleware(req, res, nextFunction);
-            } else {
-                final();
-            }
-        };
-
-        nextFunction();
-    }
-
-    /**
-     * @desc Returns the middleware stack length
-     */
-    public get length () {
-        return this.#stack.length;
-    }
-}