sonic-ws 1.0.0-beta.9 → 1.0.0-rc.0-patch

package/dist/ws/server/SonicWSConnection.d.ts

@@ -5,23 +5,84 @@ export declare class SonicWSConnection {
     private host;
     private listeners;
     private print;
-    /** The index of the connection. Alternative, check `this.code` for a low bandwidth usage. */
+    private rateLimitInterval;
+    private rateLimit;
+    private received;
+    private timers;
+    private handshakePacket;
+    private handshakeLambda;
+    private messageLambda;
+    private handshakedMessageLambda;
+    /** If the packet handshake has been completed; `wss.requireHandshake(packet)` */
+    handshakeComplete: boolean;
+    /** The index of the connection. Alternatively, check `this.code` for a low bandwidth character. */
     id: number;
     /** The indexed character of the connection. Smaller data packet in strings. */
     code: string;
-    constructor(socket: WS.WebSocket, host: SonicWSServer, id: number);
+    constructor(socket: WS.WebSocket, host: SonicWSServer, id: number, handshakePacket: string | null);
+    private parseData;
+    private handshakeHandler;
+    private messageHandler;
     private hideNewLines;
-    on_close(listener: (code: number, reason: Buffer) => void): void;
+    /** Sends raw data to the user; will likely fail validity checks if used externally */
     raw_send(data: string): void;
-    close(): void;
+    /**
+     * Checks if the connection is closed
+     * @returns If it's closed or not
+     */
+    isClosed(): boolean;
+    /**
+     * Sets the rate limit of the client
+     * @param limit How many packets can be sent every second, 0 for no limit
+     */
+    setRateLimit(limit: number): void;
+    /**
+     * Listens for when the connection closes
+     * @param listener Called when it closes
+     */
+    on_close(listener: (code: number, reason: Buffer) => void): void;
     /**
      * Listens for a packet
      * @param tag The tag of the key to listen for
      * @param listener A function to listen for it
      */
     on(tag: string, listener: (...values: any) => void): void;
+    /**
+     * Sends a packet with the tag and values
+     * @param tag The tag to send
+     * @param values The values to send
+     */
     send(tag: string, ...values: any[]): void;
-    /** Toggles printing all sent and received messages */
-    togglePrint(): void;
+    /**
+     * Broadcasts a packet to all other users connected
+     * @param tag The tag to send
+     * @param values The values to send
+     */
+    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection) => boolean, ...values: any[]): void;
+    /**
+     * Broadcasts a packet to all other users connected
+     * @param tag The tag to send
+     * @param values The values to send
+     */
     broadcast(tag: string, ...values: any[]): void;
+    /**
+     * Toggles printing all sent and received messages
+     */
+    togglePrint(): void;
+    /**
+     * Closes the socket
+     */
+    close(code?: number): void;
+    /**
+     * Sets a timeout that will automatically end when the socket closes
+     * @param call The function to call
+     * @param time The time between now and the call (ms)
+     */
+    setTimeout(call: () => void, time: number): number;
+    /**
+     * Sets an interval that will automatically end when the socket closes
+     * @param call The function to call
+     * @param time The time between calls (ms)
+     */
+    setInterval(call: () => void, time: number): number;
 }

package/dist/ws/server/SonicWSConnection.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -10,62 +43,140 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SonicWSConnection = void 0;
+var WS = __importStar(require("ws"));
 var PacketListener_1 = require("../packets/PacketListener");
 var CodePointUtil_1 = require("../util/CodePointUtil");
 var PacketUtils_1 = require("../util/PacketUtils");
 var SonicWSConnection = /** @class */ (function () {
-    function SonicWSConnection(socket, host, id) {
+    function SonicWSConnection(socket, host, id, handshakePacket) {
         var _this = this;
         this.print = false;
+        this.rateLimit = 50;
+        this.received = 0;
+        this.timers = [];
+        this.messageLambda = function (data) { return _this.messageHandler(_this.parseData(data)); };
+        this.handshakedMessageLambda = function (data) {
+            var parsed = _this.parseData(data);
+            if (parsed == null)
+                return;
+            if (parsed[0] == _this.handshakePacket)
+                return _this.socket.close(4005);
+            _this.messageHandler(parsed);
+        };
+        /** If the packet handshake has been completed; `wss.requireHandshake(packet)` */
+        this.handshakeComplete = false;
         this.socket = socket;
         this.host = host;
         this.id = id;
         this.code = String.fromCharCode(id);
+        this.handshakePacket = handshakePacket;
         this.listeners = {};
-        for (var _i = 0, _a = Object.values(host.clientPackets.getKeys()); _i < _a.length; _i++) {
+        for (var _i = 0, _a = Object.values(host.clientPackets.getTags()); _i < _a.length; _i++) {
             var key = _a[_i];
-            this.listeners[String.fromCharCode(key)] = [];
+            this.listeners[key] = [];
         }
-        this.socket.on('message', function (data) {
-            var message = data.toString();
-            if (_this.print)
-                console.log("\u001B[31m\u2B07 \u001B[38;5;245m(".concat(_this.id, ",").concat((0, CodePointUtil_1.getStringBytes)(message), ")\u001B[0m ").concat(_this.hideNewLines(message)));
-            if (message.length < 1) {
-                _this.socket.close(4001);
-                return;
-            }
-            var key = message[0];
-            var value = message.substring(1);
-            // not a key, bye bye
-            if (!_this.host.clientPackets.has(key)) {
-                _this.socket.close(4002);
-                return;
-            }
-            for (var _i = 0, _a = _this.listeners[key]; _i < _a.length; _i++) {
-                var listener = _a[_i];
-                var valid = listener.listen(value);
-                // if invalid then ignore it
-                if (!valid) {
-                    socket.close(4003);
-                    break;
-                }
-            }
-            ;
+        if (this.handshakePacket == null) {
+            this.socket.addEventListener('message', this.messageLambda);
+        }
+        else {
+            this.handshakeLambda = function (data) { return _this.handshakeHandler(data); };
+            this.socket.addEventListener('message', this.handshakeLambda);
+        }
+        this.socket.on('close', function () {
+            if (_this.rateLimit != 0)
+                clearInterval(_this.rateLimitInterval);
+            _this.timers.forEach(clearTimeout);
         });
+        if (this.rateLimit != 0)
+            this.rateLimitInterval = setInterval(function () { return _this.received = 0; }, 1000);
     }
+    SonicWSConnection.prototype.parseData = function (data) {
+        if (this.rateLimit != 0 && ++this.received > this.rateLimit) {
+            this.socket.close(4000);
+            return null;
+        }
+        var message = data.data.toString();
+        if (this.print)
+            console.log("\u001B[31m\u2B07 \u001B[38;5;245m(".concat(this.id, ",").concat((0, CodePointUtil_1.getStringBytes)(message), ")\u001B[0m ").concat(this.hideNewLines(message)));
+        if (message.length < 1) {
+            this.socket.close(4001);
+            return null;
+        }
+        var key = message[0];
+        var value = message.substring(1);
+        // not a key, bye bye
+        if (!this.host.clientPackets.has(key)) {
+            this.socket.close(4002);
+            return null;
+        }
+        return [this.host.clientPackets.getTag(key), value];
+    };
+    SonicWSConnection.prototype.handshakeHandler = function (data) {
+        var parsed = this.parseData(data);
+        if (parsed == null)
+            return;
+        if (parsed[0] != this.handshakePacket) {
+            this.socket.close(4004);
+            return;
+        }
+        this.messageHandler(parsed);
+        this.socket.removeEventListener('message', this.handshakeLambda);
+        this.socket.addEventListener('message', this.handshakedMessageLambda);
+        this.handshakeComplete = true;
+    };
+    SonicWSConnection.prototype.messageHandler = function (data) {
+        if (data == null)
+            return;
+        var tag = data[0], value = data[1];
+        var listened = this.host.clientPackets.getPacket(tag).listen(value);
+        // if invalid then ignore it
+        if (listened == null) {
+            this.socket.close(4003);
+            return;
+        }
+        var processed = listened[0], isArray = listened[1];
+        for (var _i = 0, _a = this.listeners[tag]; _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener.listen(processed, isArray);
+        }
+        ;
+    };
     SonicWSConnection.prototype.hideNewLines = function (str) {
         return str.split("\n").join("☺");
     };
-    SonicWSConnection.prototype.on_close = function (listener) {
-        this.socket.on('close', listener);
-    };
+    /** Sends raw data to the user; will likely fail validity checks if used externally */
     SonicWSConnection.prototype.raw_send = function (data) {
+        if (this.isClosed())
+            throw new Error("Connection is already closed!");
         if (this.print)
             console.log("\u001B[32m\u2B06 \u001B[38;5;245m(".concat(this.id, ",").concat((0, CodePointUtil_1.getStringBytes)(data), ")\u001B[0m ").concat(this.hideNewLines(data)));
         this.socket.send(data);
     };
-    SonicWSConnection.prototype.close = function () {
-        this.socket.close(1000);
+    /**
+     * Checks if the connection is closed
+     * @returns If it's closed or not
+     */
+    SonicWSConnection.prototype.isClosed = function () {
+        return this.socket.readyState == WS.CLOSED;
+    };
+    /**
+     * Sets the rate limit of the client
+     * @param limit How many packets can be sent every second, 0 for no limit
+     */
+    SonicWSConnection.prototype.setRateLimit = function (limit) {
+        // so that i can store limits in 1 packet
+        if (limit > CodePointUtil_1.MAX_C) {
+            limit = 0;
+            console.warn("A rate limit above ".concat(CodePointUtil_1.MAX_C, " is considered infinite."));
+        }
+        this.rateLimit = limit;
+    };
+    /**
+     * Listens for when the connection closes
+     * @param listener Called when it closes
+     */
+    SonicWSConnection.prototype.on_close = function (listener) {
+        this.socket.on('close', listener);
     };
     /**
      * Listens for a packet
@@ -77,10 +188,15 @@ var SonicWSConnection = /** @class */ (function () {
         if (code == null)
             throw new Error("Tag \"".concat(tag, "\" has not been created!"));
         var packet = this.host.clientPackets.getPacket(tag);
-        if (!this.listeners[code])
-            this.listeners[code] = [];
-        this.listeners[code].push(new PacketListener_1.PacketListener(packet, listener));
+        if (!this.listeners[tag])
+            this.listeners[tag] = [];
+        this.listeners[tag].push(new PacketListener_1.PacketListener(packet, listener));
     };
+    /**
+     * Sends a packet with the tag and values
+     * @param tag The tag to send
+     * @param values The values to send
+     */
     SonicWSConnection.prototype.send = function (tag) {
         var _this = this;
         var values = [];
@@ -89,17 +205,64 @@ var SonicWSConnection = /** @class */ (function () {
         }
         (0, PacketUtils_1.emitPacket)(this.host.serverPackets, function (d) { return _this.raw_send(d); }, tag, values);
     };
-    /** Toggles printing all sent and received messages */
-    SonicWSConnection.prototype.togglePrint = function () {
-        this.print = !this.print;
+    /**
+     * Broadcasts a packet to all other users connected
+     * @param tag The tag to send
+     * @param values The values to send
+     */
+    SonicWSConnection.prototype.broadcastFiltered = function (tag, filter) {
+        var _a;
+        var _this = this;
+        var values = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            values[_i - 2] = arguments[_i];
+        }
+        (_a = this.host).broadcastFiltered.apply(_a, __spreadArray([tag, function (socket) { return socket != _this && filter(socket); }], values, false));
     };
+    /**
+     * Broadcasts a packet to all other users connected
+     * @param tag The tag to send
+     * @param values The values to send
+     */
     SonicWSConnection.prototype.broadcast = function (tag) {
-        var _this = this;
         var values = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             values[_i - 1] = arguments[_i];
         }
-        this.host.getConnected().forEach(function (conn) { return conn != _this && conn.send.apply(conn, __spreadArray([tag], values, false)); });
+        this.broadcastFiltered.apply(this, __spreadArray([tag, function () { return true; }], values, false));
+    };
+    /**
+     * Toggles printing all sent and received messages
+     */
+    SonicWSConnection.prototype.togglePrint = function () {
+        this.print = !this.print;
+    };
+    /**
+     * Closes the socket
+     */
+    SonicWSConnection.prototype.close = function (code) {
+        if (code === void 0) { code = 1000; }
+        this.socket.close(code);
+    };
+    /**
+     * Sets a timeout that will automatically end when the socket closes
+     * @param call The function to call
+     * @param time The time between now and the call (ms)
+     */
+    SonicWSConnection.prototype.setTimeout = function (call, time) {
+        var timeout = setTimeout(call, time);
+        this.timers.push(timeout);
+        return timeout;
+    };
+    /**
+     * Sets an interval that will automatically end when the socket closes
+     * @param call The function to call
+     * @param time The time between calls (ms)
+     */
+    SonicWSConnection.prototype.setInterval = function (call, time) {
+        var interval = setInterval(call, time);
+        this.timers.push(interval);
+        return interval;
     };
     return SonicWSConnection;
 }());

package/dist/ws/server/SonicWSServer.d.ts

@@ -2,6 +2,17 @@ import * as WS from 'ws';
 import { SonicWSConnection } from './SonicWSConnection';
 import { PacketHolder } from '../util/PacketHolder';
 import { Packet } from '../packets/Packets';
+/**
+ * Sonic WS Server Options
+ */
+export type SonicServerOptions = {
+    /** An array of packets the client can send and server can listen for; using CreatePacket(), CreateObjPacket(), and CreateEnumPacket() */
+    clientPackets?: Packet[];
+    /** An array of packets the server can send and client can listen for; using CreatePacket(), CreateObjPacket(), and CreateEnumPacket() */
+    serverPackets?: Packet[];
+    /** Default WS Options */
+    websocketOptions?: WS.ServerOptions;
+};
 export declare class SonicWSServer {
     private wss;
     private availableIds;
@@ -10,13 +21,81 @@ export declare class SonicWSServer {
     serverPackets: PacketHolder;
     private connections;
     private connectionMap;
-    constructor(clientPackets: Packet[], serverPackets: Packet[], options?: WS.ServerOptions);
+    private rateLimit;
+    private handshakePacket;
+    /**
+     * Initializes and hosts a websocket with sonic protocol
+     * Rate limits can be set with wss.setRateLimit(x); it is defaulted at 50/second
+     * @param settings Sonic Server Options such as schema data for client and server packets, alongside websocket options
+     */
+    constructor(settings: SonicServerOptions);
     private generateSocketID;
+    /**
+     * Requires each client to send this packet upon initialization
+     *
+     * Recreates this:
+     * ```js
+     * let initiated = false;
+     * socket.on('init', () => {
+     *  if(initiated) return socket.close();
+     *  initiated = true;
+     *  // process
+     * });
+     *
+     * socket.on('otherPacket', () => {
+     *  if(!initiated) return socket.close();
+     *  // process
+     * })
+     * ```
+     *
+     * @param packet The tag of the packet to require as a handshake
+     */
+    requireHandshake(packet: string): void;
+    /**
+     * Sets the rate limit for all clients
+     * @param limit Amount of packets the sockets can send every second, or 0 for infinite
+     */
+    setRateLimit(limit: number): void;
+    /**
+     * Listens for whenever a client connects
+     * @param runner Called when ready
+     */
     on_connect(runner: (client: SonicWSConnection) => void): void;
+    /**
+     * Listens for whenever the server is ready
+     * @param runner Called when ready
+     */
     on_ready(runner: () => void): void;
+    /**
+     * Closes the server
+     * @param callback Called when server closes
+     */
     shutdown(callback: (err?: Error) => void): void;
+    /**
+    * Broadcasts a packet to all users connected, but with a filter
+    * @param tag The tag to send
+    * @param filter The filter for who to send to
+    * @param values The values to send
+    */
+    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection) => boolean, ...values: any): void;
+    /**
+ * Broadcasts a packet to all users connected
+ * @param tag The tag to send
+ * @param values The values to send
+ */
     broadcast(tag: string, ...values: any): void;
+    /**
+     * @returns All users connected to the socket
+     */
     getConnected(): SonicWSConnection[];
+    /**
+     * @param id The socket id
+     * @returns The socket
+     */
     getSocket(id: number): SonicWSConnection;
+    /**
+     * Closes a socket by id
+     * @param id The socket id
+     */
     closeSocket(id: number): void;
 }

package/dist/ws/server/SonicWSServer.js

@@ -53,23 +53,30 @@ var PacketHolder_1 = require("../util/PacketHolder");
 var CodePointUtil_1 = require("../util/CodePointUtil");
 var version_1 = require("../../version");
 var SonicWSServer = /** @class */ (function () {
-    function SonicWSServer(clientPackets, serverPackets, options) {
-        if (options === void 0) { options = {}; }
+    /**
+     * Initializes and hosts a websocket with sonic protocol
+     * Rate limits can be set with wss.setRateLimit(x); it is defaulted at 50/second
+     * @param settings Sonic Server Options such as schema data for client and server packets, alongside websocket options
+     */
+    function SonicWSServer(settings) {
         var _this = this;
         this.availableIds = Array.from({ length: 501 }, function (_, i) { return i; });
         this.connectListeners = [];
         this.connections = [];
         this.connectionMap = {};
-        this.wss = new WS.WebSocketServer(options);
+        this.rateLimit = 50;
+        this.handshakePacket = null;
+        var _a = settings.clientPackets, clientPackets = _a === void 0 ? [] : _a, _b = settings.serverPackets, serverPackets = _b === void 0 ? [] : _b, _c = settings.websocketOptions, websocketOptions = _c === void 0 ? {} : _c;
+        this.wss = new WS.WebSocketServer(websocketOptions);
         this.clientPackets = new PacketHolder_1.PacketHolder(clientPackets);
         this.serverPackets = new PacketHolder_1.PacketHolder(serverPackets);
         var s_clientPackets = this.clientPackets.serialize();
         var s_serverPackets = this.serverPackets.serialize();
         var keyData = "SWS" + version_1.VERSION_CHAR + s_clientPackets + CodePointUtil_1.NULL + s_serverPackets;
         this.wss.on('connection', function (socket) {
-            var sonicConnection = new SonicWSConnection_1.SonicWSConnection(socket, _this, _this.generateSocketID());
+            var sonicConnection = new SonicWSConnection_1.SonicWSConnection(socket, _this, _this.generateSocketID(), _this.handshakePacket);
             // send tags to the client so it doesn't have to hard code them in
-            socket.send(keyData);
+            socket.send(keyData + CodePointUtil_1.NULL + String.fromCharCode(_this.rateLimit));
             _this.connections.push(sonicConnection);
             _this.connectionMap[sonicConnection.id] = sonicConnection;
             _this.connectListeners.forEach(function (l) { return l(sonicConnection); });
@@ -94,28 +101,106 @@ var SonicWSServer = /** @class */ (function () {
     SonicWSServer.prototype.generateSocketID = function () {
         return this.availableIds.shift();
     };
+    /**
+     * Requires each client to send this packet upon initialization
+     *
+     * Recreates this:
+     * ```js
+     * let initiated = false;
+     * socket.on('init', () => {
+     *  if(initiated) return socket.close();
+     *  initiated = true;
+     *  // process
+     * });
+     *
+     * socket.on('otherPacket', () => {
+     *  if(!initiated) return socket.close();
+     *  // process
+     * })
+     * ```
+     *
+     * @param packet The tag of the packet to require as a handshake
+     */
+    SonicWSServer.prototype.requireHandshake = function (packet) {
+        if (!this.clientPackets.hasTag(packet))
+            throw new Error("The client cannot send \"".concat(packet, "\" for handshake!"));
+        this.handshakePacket = packet;
+    };
+    /**
+     * Sets the rate limit for all clients
+     * @param limit Amount of packets the sockets can send every second, or 0 for infinite
+     */
+    SonicWSServer.prototype.setRateLimit = function (limit) {
+        // so that i can store limits in 1 packet
+        if (limit > CodePointUtil_1.MAX_C) {
+            limit = 0;
+            console.warn("A rate limit above ".concat(CodePointUtil_1.MAX_C, " is considered infinite."));
+        }
+        this.rateLimit = limit;
+    };
+    /**
+     * Listens for whenever a client connects
+     * @param runner Called when ready
+     */
     SonicWSServer.prototype.on_connect = function (runner) {
         this.connectListeners.push(runner);
     };
+    /**
+     * Listens for whenever the server is ready
+     * @param runner Called when ready
+     */
     SonicWSServer.prototype.on_ready = function (runner) {
         this.wss.on('listening', runner);
     };
+    /**
+     * Closes the server
+     * @param callback Called when server closes
+     */
     SonicWSServer.prototype.shutdown = function (callback) {
         this.wss.close(callback);
     };
+    /**
+    * Broadcasts a packet to all users connected, but with a filter
+    * @param tag The tag to send
+    * @param filter The filter for who to send to
+    * @param values The values to send
+    */
+    SonicWSServer.prototype.broadcastFiltered = function (tag, filter) {
+        var values = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            values[_i - 2] = arguments[_i];
+        }
+        this.connections.filter(filter).forEach(function (conn) { return conn.send.apply(conn, __spreadArray([tag], values, false)); });
+    };
+    /**
+ * Broadcasts a packet to all users connected
+ * @param tag The tag to send
+ * @param values The values to send
+ */
     SonicWSServer.prototype.broadcast = function (tag) {
         var values = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             values[_i - 1] = arguments[_i];
         }
-        this.connections.forEach(function (conn) { return conn.send.apply(conn, __spreadArray([tag], values, false)); });
+        this.broadcastFiltered.apply(this, __spreadArray([tag, function () { return true; }], values, false));
     };
+    /**
+     * @returns All users connected to the socket
+     */
     SonicWSServer.prototype.getConnected = function () {
         return this.connections;
     };
+    /**
+     * @param id The socket id
+     * @returns The socket
+     */
     SonicWSServer.prototype.getSocket = function (id) {
         return this.connectionMap[id];
     };
+    /**
+     * Closes a socket by id
+     * @param id The socket id
+     */
     SonicWSServer.prototype.closeSocket = function (id) {
         this.getSocket(id).close();
     };