sonic-ws 1.2.2 → 1.3.0

package/dist/ws/server/SonicWSConnection.js

@@ -54,6 +54,7 @@ const PacketUtils_1 = require("../util/packets/PacketUtils");
 const BatchHelper_1 = require("../util/packets/BatchHelper");
 const RateHandler_1 = require("../util/packets/RateHandler");
 const BufferUtil_1 = require("../util/BufferUtil");
+const Connection_1 = require("../Connection");
 const CLIENT_RATELIMIT_TAG = "C", SERVER_RATELIMIT_TAG = "S";
 class SonicWSConnection {
     /** Raw 'ws' library socket */
@@ -61,15 +62,16 @@ class SonicWSConnection {
     host;
     listeners;
     print = false;
+    name;
     handshakePacket;
     handshakeLambda;
     messageLambda = (data) => this.messageHandler(this.parseData(data));
     handshakedMessageLambda = (data) => {
         const parsed = this.parseData(data);
         if (parsed == null)
-            return this.socket.close(4004);
+            return this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
         if (parsed[0] == this.handshakePacket)
-            return this.socket.close(4005);
+            return this.socket.close(Connection_1.CloseCodes.REPEATED_HANDSHAKE);
         this.messageHandler(parsed);
     };
     batcher;
@@ -83,11 +85,11 @@ class SonicWSConnection {
     asyncMap = {};
     asyncData = {};
     closed = false;
-    _state = WebSocket.OPEN;
     constructor(socket, host, id, handshakePacket, clientRateLimit, serverRateLimit) {
         this.socket = socket;
         this.host = host;
         this.id = id;
+        this.name = "Socket " + id;
         this.handshakePacket = handshakePacket;
         this.listeners = {};
         for (const tag of host.clientPackets.getTags()) {
@@ -128,6 +130,9 @@ class SonicWSConnection {
             for (const packet of host.clientPackets.getPackets()) {
                 delete packet.lastReceived[this.id];
             }
+            for (const packet of host.serverPackets.getPackets()) {
+                delete packet.lastSent[this.id];
+            }
         });
     }
     parseData(event) {
@@ -137,22 +142,22 @@ class SonicWSConnection {
             return null;
         const message = new Uint8Array(event.data);
         if (this.print)
-            console.log(`\x1b[31m⬇ \x1b[38;5;245m(${this.id},${message.byteLength})\x1b[0m`, (0, BufferUtil_1.stringifyBuffer)(message));
+            console.log(`\x1b[31m⬇ \x1b[38;5;245m(${this.id},${message.byteLength})\x1b[0m`, (message.length > 0 && this.host.clientPackets.getTag(message[0])) || "<INVALID>", (0, BufferUtil_1.stringifyBuffer)(message));
         if (message.byteLength < 1) {
-            this.socket.close(4001);
+            this.socket.close(Connection_1.CloseCodes.SMALL);
             return null;
         }
         const key = message[0];
         const value = message.slice(1);
         // not a key, bye bye
         if (!this.host.clientPackets.hasKey(key)) {
-            this.socket.close(4002);
+            this.socket.close(Connection_1.CloseCodes.INVALID_KEY);
             return null;
         }
         const tag = this.host.clientPackets.getTag(key);
         // disabled, bye bye
         if (!this.enabledPackets[tag]) {
-            this.socket.close(4006);
+            this.socket.close(Connection_1.CloseCodes.DISABLED_PACKET);
             return null;
         }
         if (this.rater.trigger("client" + key))
@@ -162,9 +167,9 @@ class SonicWSConnection {
     handshakeHandler(data) {
         const parsed = this.parseData(data);
         if (parsed == null)
-            return this.socket.close(4004);
+            return this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
         if (parsed[0] != this.handshakePacket) {
-            this.socket.close(4004);
+            this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
             return;
         }
         this.messageHandler(parsed);
@@ -174,18 +179,31 @@ class SonicWSConnection {
     }
     invalidPacket(listened) {
         console.log("Closure cause", listened);
-        this.socket.close(4003, listened);
+        this.socket.close(Connection_1.CloseCodes.INVALID_PACKET, listened);
     }
     isAsync(tag) {
         return this.asyncMap[tag];
     }
     listenLock = false;
     packetQueue = [];
-    async listenPacket(data, tag) {
+    async listenPacket(data, tag, packetQueue, isAsync, asyncData) {
         if (this.closed)
             return;
-        if (await this.callMiddleware('onReceive_post', tag, typeof data == 'string' ? [data] : data[0]))
+        await (0, PacketUtils_1.listenPacket)(data, this.listeners[tag], this.invalidPacket);
+        await this.callMiddleware('onReceive_post', tag, typeof data == 'string' ? [data] : data[0]);
+        if (isAsync)
+            asyncData[0] = false;
+        else
+            this.listenLock = false;
+        if (packetQueue.length != 0) {
+            this.messageHandler(packetQueue.shift());
             return;
+        }
+    }
+    async messageHandler(data, recall = false) {
+        if (data == null)
+            return;
+        const [tag, value] = data;
         const isAsync = this.isAsync(tag);
         let locked, packetQueue, asyncData;
         if (isAsync) {
@@ -198,54 +216,39 @@ class SonicWSConnection {
             packetQueue = this.packetQueue;
         }
         if (locked) {
-            packetQueue.push([data, tag]);
+            packetQueue.push(data);
             return;
         }
         if (isAsync)
             asyncData[0] = true;
         else
             this.listenLock = true;
-        let currentData = data;
-        let currentTag = tag;
-        while (true) {
-            await (0, PacketUtils_1.listenPacket)(currentData, this.listeners[currentTag], this.invalidPacket);
-            if (packetQueue.length === 0)
-                break;
-            [currentData, currentTag] = packetQueue.shift();
-        }
-        if (isAsync)
-            asyncData[0] = false;
-        else
-            this.listenLock = false;
-    }
-    async messageHandler(data) {
-        if (data == null)
-            return;
-        const [tag, value] = data;
         const packet = this.host.clientPackets.getPacket(tag);
-        if (await this.callMiddleware('onReceive_pre', packet.tag, value))
+        if (!recall && await this.callMiddleware('onReceive_pre', packet.tag, value, value.length))
             return;
         if (packet.rereference && value.length == 0) {
-            if (packet.lastReceived[this.id] === undefined)
+            const lastRecv = packet.lastReceived[this.id];
+            if (lastRecv === undefined)
                 return this.invalidPacket("No previous value to rereference");
-            this.listenPacket(packet.lastReceived[this.id], tag);
+            this.listenPacket(lastRecv, tag, packetQueue, isAsync, asyncData);
             return;
         }
         if (packet.dataBatching == 0) {
-            const res = packet.lastReceived[this.id] = await packet.listen(value, this);
-            this.listenPacket(res, tag);
+            const res = await packet.listen(value, this);
+            packet.lastReceived[this.id] = res;
+            this.listenPacket(res, tag, packetQueue, isAsync, asyncData);
             return;
         }
         const batchData = await BatchHelper_1.BatchHelper.unravelBatch(packet, value, this);
         if (typeof batchData == 'string')
             return this.invalidPacket(batchData);
         for (const data of batchData) {
-            this.listenPacket(data, tag);
+            this.listenPacket(data, tag, packetQueue, isAsync, asyncData);
         }
     }
-    basicMiddlewares = [];
-    addBasicMiddleware(middleware) {
-        this.basicMiddlewares.push(middleware);
+    middlewares = [];
+    addMiddleware(middleware) {
+        this.middlewares.push(middleware);
         const m = middleware;
         try {
             if (typeof m.init === 'function')
@@ -257,12 +260,12 @@ class SonicWSConnection {
     }
     async callMiddleware(method, ...values) {
         let cancelled = false;
-        for (const middleware of this.basicMiddlewares) {
+        for (const middleware of this.middlewares) {
             const fn = middleware[method];
             if (!fn)
                 continue;
             try {
-                if (!await fn(...values)) {
+                if (await fn(...values)) {
                     cancelled = true;
                 }
             }
@@ -322,16 +325,17 @@ class SonicWSConnection {
         else
             this.batcher.batchPacket(code, data);
     }
+    sendQueue = [false, [], undefined];
     /**
      * Sends a packet with the tag and values
      * @param tag The tag to send
      * @param values The values to send
      */
     async send(tag, ...values) {
-        if (await this.callMiddleware('onSend_pre', tag, values))
+        if (await this.callMiddleware('onSend_pre', tag, values, Date.now(), performance.now()))
             return;
-        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.id);
-        if (await this.callMiddleware('onSend_post', tag, data))
+        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.sendQueue, this.id);
+        if (await this.callMiddleware('onSend_post', tag, data, data.length))
             return;
         this.send_processed(code, data, packet);
     }
@@ -366,7 +370,7 @@ class SonicWSConnection {
         if (this.rater.trigger(SERVER_RATELIMIT_TAG))
             return;
         if (this.print)
-            console.log(`\x1b[32m⬆ \x1b[38;5;245m(${this.id},${data.byteLength})\x1b[0m`, (0, BufferUtil_1.stringifyBuffer)(data));
+            console.log(`\x1b[32m⬆ \x1b[38;5;245m(${this.id},${data.byteLength})\x1b[0m`, (data.length > 0 && this.host.serverPackets.getTag(data[0])) || "<INVALID>", (0, BufferUtil_1.stringifyBuffer)(data));
         this.socket.send(data);
     }
     close(code = 1000, reason) {
@@ -401,5 +405,19 @@ class SonicWSConnection {
     tag(tag, replace = true) {
         this.host.tag(this, tag, replace);
     }
+    /**
+     * Sets the name of this connection for the debug menu; good for setting e.g. usernames on games
+     */
+    async setName(name) {
+        if (await this.callMiddleware("onNameChange", name))
+            return;
+        this.name = name;
+    }
+    /**
+     * @returns Name of the socket, defaults to Socket [ID] unless set with setName()
+     */
+    getName() {
+        return this.name;
+    }
 }
 exports.SonicWSConnection = SonicWSConnection;

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

@@ -3,6 +3,13 @@ import { SonicWSConnection } from './SonicWSConnection';
 import { PacketHolder } from '../util/packets/PacketHolder';
 import { Packet } from '../packets/Packets';
 import { PacketType } from '../packets/PacketType';
+import { FuncKeys, MiddlewareHolder, ServerMiddleware } from '../PacketProcessor';
+export type SonicServerSettings = {
+    /** If it should check for updates; defaults to true. */
+    readonly checkForUpdates?: boolean;
+    /** If the rereference should use a 64 bit hash which is less prone to collision (1% after ~600 million) or a 32 bit hash. Defaults to true. */
+    readonly bit64Hash?: boolean;
+};
 /**
  * Sonic WS Server Options
  */
@@ -13,11 +20,10 @@ export type SonicServerOptions = {
     readonly serverPackets?: PacketTypings;
     /** Default WS Options */
     readonly websocketOptions?: WS.ServerOptions;
-    /** If it should check for updates; defaults to true. */
-    readonly checkForUpdates?: boolean;
+    readonly sonicServerSettings?: SonicServerSettings;
 };
 export type PacketTypings = readonly Packet<PacketType | readonly PacketType[]>[];
-export declare class SonicWSServer {
+export declare class SonicWSServer implements MiddlewareHolder<ServerMiddleware> {
     private wss;
     private availableIds;
     private lastId;
@@ -31,12 +37,16 @@ export declare class SonicWSServer {
     private handshakePacket;
     tags: Map<SonicWSConnection, Set<String>>;
     tagsInv: Map<String, Set<SonicWSConnection>>;
+    private serverwideSendQueue;
     /**
      * Initializes and hosts a websocket with sonic protocol
      * Rate limits can be set with wss.setClientRateLimit(x) and wss.setServerRateLimit(x); it is defaulted at 500/second per both
      * @param settings Sonic Server Options such as schema data for client and server packets, alongside websocket options
      */
     constructor(settings: SonicServerOptions);
+    private middlewares;
+    addMiddleware(middleware: ServerMiddleware): void;
+    callMiddleware<K extends FuncKeys<ServerMiddleware> & keyof ServerMiddleware>(method: K, ...values: Parameters<NonNullable<Extract<ServerMiddleware[K], (...args: any[]) => any>>>): Promise<boolean>;
     private generateSocketID;
     /**
      * Requires each client to send this packet upon initialization
@@ -94,26 +104,10 @@ export declare class SonicWSServer {
      * @param callback Called when server closes
      */
     shutdown(callback: (err?: Error) => void): void;
-    /**
-     * Broadcasts a packet to tagged users; this is fast as it is a record rather than looping and filtering
-     * @param tag The tag to send packets to
-     * @param packetTag Packet tag to send
-     * @param values Values to send
-     */
+    private broadcastInternal;
     broadcastTagged(tag: string, packetTag: string, ...values: any): Promise<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): Promise<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;
+    broadcast(tag: string, ...values: any): Promise<void>;
     /**
      * @returns All users connected to the socket
      */
@@ -135,4 +129,14 @@ export declare class SonicWSServer {
      * @param replace If it should replace a previous tag; defaults to true. If using false, you can add multiple tags.
      */
     tag(socket: SonicWSConnection, tag: string, replace?: boolean): void;
+    private debugServer;
+    /**
+     * Opens a debug menu; this launches the browser and starts a subserver
+     * @param port Port of the server/http, defaults to 0 which finds an open port
+     * @param password Toggles the requirement of a password to access the server. Defaults to empty, which doesn't ask for a password.
+     */
+    OpenDebug(data: {
+        port?: number;
+        password?: string;
+    }): void;
 }