cloudstorm 0.4.0 → 0.4.3

package/dist/structures/BetterWs.js

@@ -2,193 +2,543 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+// This ultra light weigth WS code is a slimmed down version originally found at https://github.com/timotejroiko/tiny-discord
+// Modifications and use of this code was granted for this project by the author, Timotej Roiko.
+// A major thank you to Tim for better performing software.
 const events_1 = require("events");
-const zlib_sync_1 = __importDefault(require("zlib-sync"));
-let Erlpack;
-try {
-    Erlpack = require("erlpack");
-}
-catch (e) {
-    Erlpack = null;
-}
+const crypto_1 = require("crypto");
+const zlib_1 = require("zlib");
+const https_1 = require("https");
+const util_1 = __importDefault(require("util"));
+const Z_SYNC_FLUSH = zlib_1.constants.Z_SYNC_FLUSH;
 const Constants_1 = require("../Constants");
-const ws_1 = __importDefault(require("ws"));
 const RatelimitBucket_1 = __importDefault(require("./RatelimitBucket"));
 /**
  * Helper Class for simplifying the websocket connection to Discord.
  */
 class BetterWs extends events_1.EventEmitter {
-    /**
-     * Create a new BetterWs instance.
-     */
-    constructor(address, options = {}) {
+    constructor(address, options) {
         super();
-        this.zlibInflate = null;
-        this.ws = new ws_1.default(address, options.socket);
-        this.bindWs(this.ws);
         this.wsBucket = new RatelimitBucket_1.default(120, 60000);
-        this.presenceBucket = new RatelimitBucket_1.default(5, 20000);
-        if (options.compress) {
-            this.zlibInflate = new zlib_sync_1.default.Inflate({ chunkSize: 65535 });
-            this.compress = true;
-        }
-        else
-            this.compress = false;
+        this.presenceBucket = new RatelimitBucket_1.default(5, 60000);
+        this._connecting = false;
+        this.encoding = options.encoding === "etf" ? "etf" : "json";
+        this.compress = options.compress || false;
+        this.address = address;
         this.options = options;
+        this._socket = null;
+        this._internal = {
+            closePromise: null,
+            zlib: null,
+        };
+    }
+    get status() {
+        const internal = this._internal;
+        if (this._connecting)
+            return 2;
+        if (internal.closePromise)
+            return 3; // closing
+        if (!this._socket)
+            return 4; // closed
+        return 1; // connected
     }
-    /**
-     * Get the raw websocket connection currently used.
-     */
-    get rawWs() {
-        return this.ws;
+    connect() {
+        if (this._socket)
+            return Promise.resolve(void 0);
+        const key = (0, crypto_1.randomBytes)(16).toString("base64");
+        this.emit("debug", "Creating connection");
+        const url = new URL(this.address);
+        const req = (0, https_1.request)({
+            hostname: url.hostname,
+            path: `${url.pathname}${url.search}`,
+            headers: {
+                "Connection": "Upgrade",
+                "Upgrade": "websocket",
+                "Sec-WebSocket-Key": key,
+                "Sec-WebSocket-Version": "13",
+            }
+        });
+        this._connecting = true;
+        return new Promise((resolve, reject) => {
+            req.on("upgrade", (res, socket) => {
+                const hash = (0, crypto_1.createHash)("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
+                const accept = res.headers["sec-websocket-accept"];
+                if (hash !== accept) {
+                    socket.end(() => {
+                        this.emit("debug", "Failed websocket-key validation");
+                        this._connecting = false;
+                        reject(new Error(`Invalid Sec-Websocket-Accept | expected: ${hash} | received: ${accept}`));
+                    });
+                    return;
+                }
+                socket.on("error", this._onError.bind(this));
+                socket.on("close", this._onClose.bind(this));
+                socket.on("readable", this._onReadable.bind(this));
+                this._socket = socket;
+                this._connecting = false;
+                if (this.compress) {
+                    const z = (0, zlib_1.createInflate)();
+                    // @ts-ignore
+                    z._c = z.close;
+                    // @ts-ignore
+                    z._h = z._handle;
+                    // @ts-ignore
+                    z._hc = z._handle.close;
+                    // @ts-ignore
+                    z._v = () => void 0;
+                    this._internal.zlib = z;
+                }
+                this.emit("ws_open");
+                resolve(void 0);
+            });
+            req.on("error", e => {
+                this._connecting = false;
+                reject(e);
+            });
+            req.end();
+        });
     }
-    /**
-     * Add eventlisteners to a passed websocket connection.
-     * @param ws Websocket.
-     */
-    bindWs(ws) {
-        ws.on("message", (msg) => {
-            this.onMessage(msg);
+    async close(code, reason) {
+        const internal = this._internal;
+        if (internal.closePromise)
+            return internal.closePromise;
+        if (!this._socket)
+            return Promise.resolve(void 0);
+        let resolver;
+        const promise = new Promise(resolve => {
+            resolver = resolve;
+            const from = Buffer.from([code >> 8, code & 255]);
+            this._write(reason ? Buffer.concat([from, Buffer.from(reason)]) : from, 8);
+        }).then(() => {
+            internal.closePromise = null;
         });
-        ws.on("close", (code, reason) => this.onClose(code, reason.toString()));
-        ws.on("error", (err) => {
-            this.emit("error", err);
+        // @ts-ignore
+        promise.resolve = resolver;
+        internal.closePromise = promise;
+    }
+    sendMessage(data) {
+        if (!isValidRequest(data))
+            return Promise.reject(new Error("Invalid request"));
+        return new Promise(res => {
+            const presence = data.op === Constants_1.GATEWAY_OP_CODES.PRESENCE_UPDATE;
+            const sendMsg = () => {
+                this.wsBucket.queue(() => {
+                    this.emit("debug_send", data);
+                    if (this.encoding === "json")
+                        this._write(Buffer.from(JSON.stringify(data)), 1);
+                    else {
+                        const etf = writeETF(data);
+                        this._write(etf, 2);
+                    }
+                    res(void 0);
+                });
+            };
+            if (presence)
+                this.presenceBucket.queue(sendMsg);
+            else
+                sendMsg();
         });
-        ws.on("open", () => this.onOpen());
     }
-    /**
-     * Create a new websocket connection if the old one was closed/destroyed.
-     * @param address Address to connect to.
-     * @param options Options used by the websocket connection.
-     */
-    recreateWs(address, options = {}) {
-        this.ws.removeAllListeners();
-        if (options.compress) {
-            this.zlibInflate = new zlib_sync_1.default.Inflate({ chunkSize: 65535 });
-            this.compress = true;
+    _write(packet, opcode) {
+        const socket = this._socket;
+        if (!socket || !socket.writable)
+            return;
+        const length = packet.length;
+        let frame;
+        if (length < 126) {
+            frame = Buffer.allocUnsafe(6 + length);
+            frame[1] = 128 + length;
+        }
+        else if (length < (1 << 16)) {
+            frame = Buffer.allocUnsafe(8 + length);
+            frame[1] = 254;
+            frame[2] = length >> 8;
+            frame[3] = length & 255;
         }
         else {
-            this.zlibInflate = null;
-            this.compress = false;
+            frame = Buffer.allocUnsafe(14 + length);
+            frame[1] = 255;
+            frame.writeBigUInt64BE(BigInt(length), 2);
         }
-        this.ws = new ws_1.default(address, options.socket);
-        this.options = options;
+        frame[0] = 128 + opcode;
+        frame.writeUInt32BE(0, frame.length - length - 4);
+        frame.set(packet, frame.length - length);
+        socket.write(frame);
+    }
+    _onError(error) {
+        if (!this._socket)
+            return;
+        this.emit("debug", util_1.default.inspect(error, true, 1, false));
+        this._write(Buffer.allocUnsafe(0), 8);
+    }
+    _onClose() {
+        const socket = this._socket;
+        const internal = this._internal;
+        if (!socket)
+            return;
+        this.emit("debug", "Connection closed");
+        socket.removeListener("data", this._onReadable);
+        socket.removeListener("error", this._onError);
+        socket.removeListener("close", this._onClose);
         this.wsBucket.dropQueue();
         this.presenceBucket.dropQueue();
-        this.wsBucket = new RatelimitBucket_1.default(120, 60000);
-        this.presenceBucket = new RatelimitBucket_1.default(5, 60000);
-        this.bindWs(this.ws);
-    }
-    /**
-     * Called upon opening of the websocket connection.
-     */
-    onOpen() {
-        this.emit("ws_open");
+        this._socket = null;
+        if (internal.zlib) {
+            internal.zlib.close();
+            internal.zlib = null;
+        }
+        if (internal.closePromise) {
+            // @ts-ignore
+            internal.closePromise.resolve(void 0);
+        }
     }
-    /**
-     * Called once a websocket message is received,
-     * uncompresses the message using zlib and parses it via Erlpack or JSON.parse.
-     * @param message Message received by websocket.
-     */
-    onMessage(message) {
-        let parsed;
-        try {
-            let msg;
-            if (this.compress && this.zlibInflate) {
-                const length = message.length;
-                const flush = length >= 4 &&
-                    message[length - 4] === 0x00 &&
-                    message[length - 3] === 0x00 &&
-                    message[length - 2] === 0xFF &&
-                    message[length - 1] === 0xFF;
-                this.zlibInflate.push(message, flush ? zlib_sync_1.default.Z_SYNC_FLUSH : false);
-                if (!flush)
+    _onReadable() {
+        const socket = this._socket;
+        while (socket.readableLength > 1) {
+            let length = readRange(socket, 1, 1) & 127;
+            let bytes = 0;
+            if (length > 125) {
+                bytes = length === 126 ? 2 : 8;
+                if (socket.readableLength < 2 + bytes)
                     return;
-                msg = this.zlibInflate.result;
+                length = readRange(socket, 2, bytes);
             }
-            else
-                msg = message;
-            if (Erlpack) {
-                parsed = Erlpack.unpack(msg);
+            const frame = socket.read(2 + bytes + length);
+            if (!frame)
+                return;
+            const fin = frame[0] >> 7;
+            const opcode = frame[0] & 15;
+            if (fin !== 1 || opcode === 0)
+                this.emit("debug", "discord actually does send messages with fin=0. if you see this error let me know");
+            const payload = frame.slice(2 + bytes);
+            this._processFrame(opcode, payload);
+        }
+    }
+    _processFrame(opcode, message) {
+        const internal = this._internal;
+        switch (opcode) {
+            case 1: {
+                const packet = JSON.parse(message.toString());
+                this.emit("ws_message", packet);
+                break;
             }
-            else {
-                parsed = JSON.parse(String(msg));
+            case 2: {
+                let packet;
+                if (this.compress) {
+                    const z = internal.zlib;
+                    let error = null;
+                    let data = null;
+                    // @ts-ignore
+                    z.close = z._handle.close = z._v;
+                    try {
+                        // @ts-ignore
+                        data = z._processChunk(message, Z_SYNC_FLUSH);
+                    }
+                    catch (e) {
+                        error = e;
+                    }
+                    const l = message.length;
+                    if (message[l - 4] !== 0 || message[l - 3] !== 0 || message[l - 2] !== 255 || message[l - 1] !== 255)
+                        this.emit("debug", "discord actually does send fragmented zlib messages. if you see this error let me know");
+                    // @ts-ignore
+                    z.close = z._c;
+                    // @ts-ignore
+                    z._handle = z._h;
+                    // @ts-ignore
+                    z._handle.close = z._hc;
+                    // @ts-ignore
+                    z._events.error = void 0;
+                    // @ts-ignore
+                    z._eventCount--;
+                    z.removeAllListeners("error");
+                    if (error) {
+                        this.emit("debug", "Zlib error");
+                        this._write(Buffer.allocUnsafe(0), 8);
+                        return;
+                    }
+                    if (!data)
+                        return; // This should never run, but TS is lame
+                    packet = this.encoding === "json" ? JSON.parse(String(data)) : readETF(data, 1);
+                }
+                else if (this.encoding === "json") {
+                    const data = (0, zlib_1.inflateSync)(message);
+                    packet = JSON.parse(data.toString());
+                }
+                else
+                    packet = readETF(message, 1);
+                this.emit("ws_message", packet);
+                break;
+            }
+            case 8: {
+                const code = message.length > 1 ? (message[0] << 8) + message[1] : 0;
+                const reason = message.length > 2 ? message.slice(2).toString() : "";
+                this.emit("ws_close", code, reason);
+                this._write(Buffer.from([code >> 8, code & 255]), 8);
+                break;
+            }
+            case 9: {
+                this._write(message, 10);
+                break;
             }
         }
-        catch (e) {
-            this.emit("error", `Message: ${message} was not parseable`);
-            return;
-        }
-        this.emit("ws_message", parsed);
     }
-    /**
-     * Called when the websocket connection closes for some reason.
-     * @param code Websocket close code.
-     * @param reason Reason of the close if any.
-     */
-    onClose(code, reason) {
-        this.emit("ws_close", code, reason);
-    }
-    /**
-     * Send a message to the Discord gateway.
-     * @param data Data to send.
-     */
-    sendMessage(data) {
-        if (this.ws.readyState !== ws_1.default.OPEN)
-            return Promise.reject(new Error("WS is not open"));
-        this.emit("debug_send", data);
-        return new Promise((res, rej) => {
-            const presence = data.op === Constants_1.GATEWAY_OP_CODES.PRESENCE_UPDATE;
-            try {
-                if (Erlpack) {
-                    data = Erlpack.pack(data);
+}
+function isValidRequest(value) {
+    return value && typeof value === "object" && Number.isInteger(value.op) && typeof value.d !== "undefined";
+}
+function readRange(socket, index, bytes) {
+    // @ts-ignore
+    let head = socket._readableState.buffer.head;
+    let cursor = 0;
+    let read = 0;
+    let num = 0;
+    do {
+        for (let i = 0; i < head.data.length; i++) {
+            if (++cursor > index) {
+                num *= 256;
+                num += head.data[i];
+                if (++read === bytes)
+                    return num;
+            }
+        }
+    } while ((head = head.next));
+    throw new Error("readRange failed?");
+}
+function readETF(data, start) {
+    let view;
+    let x = start;
+    const loop = () => {
+        const type = data[x++];
+        switch (type) {
+            case 97: {
+                return data[x++];
+            }
+            case 98: {
+                const int = data.readInt32BE(x);
+                x += 4;
+                return int;
+            }
+            case 100: {
+                const length = data.readUInt16BE(x);
+                let atom = "";
+                if (length > 30) {
+                    // @ts-ignore
+                    atom = data.latin1Slice(x += 2, x + length);
                 }
                 else {
-                    data = JSON.stringify(data);
+                    for (let i = x += 2; i < x + length; i++) {
+                        atom += String.fromCharCode(data[i]);
+                    }
                 }
+                x += length;
+                if (!atom)
+                    return undefined;
+                if (atom === "nil" || atom === "null")
+                    return null;
+                if (atom === "true")
+                    return true;
+                if (atom === "false")
+                    return false;
+                return atom;
             }
-            catch (e) {
-                return rej(e);
+            case 108:
+            case 106: {
+                const array = [];
+                if (type === 108) {
+                    const length = data.readUInt32BE(x);
+                    x += 4;
+                    for (let i = 0; i < length; i++) {
+                        array.push(loop());
+                    }
+                    x++;
+                }
+                return array;
             }
-            const sendMsg = () => {
-                // The promise from wsBucket is ignored, since the method passed to it does not return a promise
-                this.wsBucket.queue(() => {
-                    this.ws.send(data, {}, (e) => {
-                        if (e) {
-                            return rej(e);
-                        }
-                        res();
-                    });
-                });
-            };
-            if (presence) {
-                // same here
-                this.presenceBucket.queue(sendMsg);
+            case 107: {
+                const array = [];
+                const length = data.readUInt16BE(x);
+                x += 2;
+                for (let i = 0; i < length; i++) {
+                    array.push(data[x++]);
+                }
+                return array;
             }
-            else {
-                sendMsg();
+            case 109: {
+                const length = data.readUInt32BE(x);
+                let str = "";
+                if (length > 30) {
+                    // @ts-ignore
+                    str = data.utf8Slice(x += 4, x + length);
+                }
+                else {
+                    let i = x += 4;
+                    const l = x + length;
+                    while (i < l) {
+                        const byte = data[i++];
+                        if (byte < 128)
+                            str += String.fromCharCode(byte);
+                        else if (byte < 224)
+                            str += String.fromCharCode(((byte & 31) << 6) + (data[i++] & 63));
+                        else if (byte < 240)
+                            str += String.fromCharCode(((byte & 15) << 12) + ((data[i++] & 63) << 6) + (data[i++] & 63));
+                        else
+                            str += String.fromCodePoint(((byte & 7) << 18) + ((data[i++] & 63) << 12) + ((data[i++] & 63) << 6) + (data[i++] & 63));
+                    }
+                }
+                x += length;
+                return str;
             }
-        });
-    }
-    /**
-     * Close the current websocket connection.
-     * @param code Websocket close code to use.
-     * @param reason Reason of the disconnect.
-     */
-    close(code = 1000, reason = "Unknown") {
-        if (this.ws.readyState === ws_1.default.CLOSING || this.ws.readyState === ws_1.default.CLOSED)
-            return Promise.reject(new Error("WS is already closing or is closed"));
-        return new Promise((res, rej) => {
-            const timeout = setTimeout(() => {
-                return rej("Websocket not closed within 5 seconds");
-            }, 5 * 1000);
-            this.ws.once("close", () => {
-                clearTimeout(timeout);
-                return res();
-            });
-            this.ws.close(code, reason);
-        });
-    }
+            case 110: {
+                // @ts-ignore
+                if (!view)
+                    view = new DataView(data.buffer, data.offset, data.byteLength);
+                const length = data[x++];
+                const sign = data[x++];
+                let left = length;
+                let num = BigInt(0);
+                while (left > 0) {
+                    if (left >= 8) {
+                        num <<= BigInt(64);
+                        num += view.getBigUint64(x + (left -= 8), true);
+                    }
+                    else if (left >= 4) {
+                        num <<= BigInt(32);
+                        // @ts-ignore
+                        num += BigInt(view.getUint32(x + (left -= 4)), true);
+                    }
+                    else if (left >= 2) {
+                        num <<= BigInt(16);
+                        // @ts-ignore
+                        num += BigInt(view.getUint16(x + (left -= 2)), true);
+                    }
+                    else {
+                        num <<= BigInt(8);
+                        num += BigInt(data[x]);
+                        left--;
+                    }
+                }
+                x += length;
+                return (sign ? -num : num).toString();
+            }
+            case 116: {
+                const obj = {};
+                const length = data.readUInt32BE(x);
+                x += 4;
+                for (let i = 0; i < length; i++) {
+                    const key = loop();
+                    // @ts-ignore
+                    obj[key] = loop();
+                }
+                return obj;
+            }
+        }
+        throw new Error(`Missing etf type: ${type}`);
+    };
+    return loop();
+}
+function writeETF(data) {
+    const b = Buffer.allocUnsafe(1 << 12);
+    b[0] = 131;
+    let i = 1;
+    const loop = (obj) => {
+        const type = typeof obj;
+        switch (type) {
+            case "boolean": {
+                b[i++] = 100;
+                if (obj) {
+                    b.writeUInt16BE(4, i);
+                    // @ts-ignore
+                    b.latin1Write("true", i += 2);
+                    i += 4;
+                }
+                else {
+                    b.writeUInt16BE(5, i);
+                    // @ts-ignore
+                    b.latin1Write("false", i += 2);
+                    i += 5;
+                }
+                break;
+            }
+            case "string": {
+                const length = Buffer.byteLength(obj);
+                b[i++] = 109;
+                b.writeUInt32BE(length, i);
+                // @ts-ignore
+                b.utf8Write(obj, i += 4);
+                i += length;
+                break;
+            }
+            case "number": {
+                if (Number.isInteger(obj)) {
+                    const abs = Math.abs(obj);
+                    if (abs < 2147483648) {
+                        b[i++] = 98;
+                        b.writeInt32BE(obj, i);
+                        i += 4;
+                    }
+                    else if (abs < Number.MAX_SAFE_INTEGER) {
+                        b[i++] = 110;
+                        b[i++] = 8;
+                        b[i++] = Number(obj < 0);
+                        b.writeBigUInt64LE(BigInt(abs), i);
+                        i += 8;
+                        break;
+                    }
+                    else {
+                        b[i++] = 70;
+                        b.writeDoubleBE(obj, i);
+                        i += 8;
+                    }
+                }
+                else {
+                    b[i++] = 70;
+                    b.writeDoubleBE(obj, i);
+                    i += 8;
+                }
+                break;
+            }
+            case "bigint": {
+                b[i++] = 110;
+                b[i++] = 8;
+                b[i++] = Number(obj < 0);
+                b.writeBigUInt64LE(obj, i);
+                i += 8;
+                break;
+            }
+            case "object": {
+                if (obj === null) {
+                    b[i++] = 100;
+                    b.writeUInt16BE(3, i);
+                    // @ts-ignore
+                    b.latin1Write("nil", i += 2);
+                    i += 3;
+                }
+                else if (Array.isArray(obj)) {
+                    if (obj.length) {
+                        b[i++] = 108;
+                        b.writeUInt32BE(obj.length, i);
+                        i += 4;
+                        for (const item of obj) {
+                            loop(item);
+                        }
+                    }
+                    b[i++] = 106;
+                }
+                else {
+                    const entries = Object.entries(obj).filter(x => typeof x[1] !== "undefined");
+                    b[i++] = 116;
+                    b.writeUInt32BE(entries.length, i);
+                    i += 4;
+                    for (const [key, value] of entries) {
+                        loop(key);
+                        loop(value);
+                    }
+                }
+                break;
+            }
+        }
+    };
+    loop(data);
+    return Buffer.from(b.slice(0, i));
 }
-BetterWs.default = BetterWs;
 module.exports = BetterWs;