socket-function 0.7.12 → 0.7.15

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.7.12",
+	"version": "0.7.15",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.ts

@@ -83,10 +83,10 @@ export interface SenderInterface {
 
     send(data: string | Buffer): void;
 
-    on(event: "open", listener: () => void): this;
-    on(event: "close", listener: (code: number, reason: Buffer) => void): this;
-    on(event: "error", listener: (err: Error) => void): this;
-    on(event: "message", listener: (data: ws.RawData, isBinary: boolean) => void): this;
+    addEventListener(event: "open", listener: () => void): void;
+    addEventListener(event: "close", listener: () => void): void;
+    addEventListener(event: "error", listener: (err: { message: string }) => void): void;
+    addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
 }
 
 async function createCallFactory(
@@ -205,20 +205,20 @@ async function createCallFactory(
                 let port = ports[reconnectAttempts % ports.length];
                 let newWebSocket = createWebsocket(location.address, port);
 
-                setupWebsocket(newWebSocket);
-
                 let connectError = await new Promise<string | undefined>(resolve => {
-                    newWebSocket.on("open", () => {
+                    newWebSocket.addEventListener("open", () => {
                         resolve(undefined);
                     });
-                    newWebSocket.on("close", () => {
+                    newWebSocket.addEventListener("close", () => {
                         resolve("Connection closed for non-error reason?");
                     });
-                    newWebSocket.on("error", e => {
-                        resolve(String(e.stack));
+                    newWebSocket.addEventListener("error", e => {
+                        resolve(String(e.message));
                     });
                 });
 
+                setupWebsocket(newWebSocket);
+
                 if (!connectError) {
                     console.log(`Reconnected to ${location.address}:${port}`);
 
@@ -266,27 +266,27 @@ async function createCallFactory(
     }
 
     function setupWebsocket(webSocket: SenderInterface) {
-        webSocket.on("error", e => {
+        webSocket.addEventListener("error", e => {
             console.log(`Websocket error for ${niceConnectionName}`, e);
         });
 
-        webSocket.on("close", async () => {
+        webSocket.addEventListener("close", async () => {
             console.log(`Websocket closed ${niceConnectionName}`);
             if (retriesEnabled) {
                 await tryToReconnect();
             }
         });
 
-        webSocket.on("message", onMessage);
+        webSocket.addEventListener("message", onMessage);
     }
 
 
-    async function onMessage(message: ws.RawData | MessageEvent | string) {
+    async function onMessage(message: ws.RawData | ws.MessageEvent | string) {
         try {
+            if (typeof message === "object" && "data" in message) {
+                message = message.data;
+            }
             if (!isNode()) {
-                if (typeof message === "object" && "data" in message) {
-                    message = message.data;
-                }
                 if (message instanceof Blob) {
                     message = Buffer.from(await message.arrayBuffer());
                 }

package/src/nodeAuthentication.ts

@@ -90,14 +90,7 @@ export function createWebsocket(address: string, port: number): SenderInterface
         // NOTE: We assume an HTTP request has already been made, which will setup a nodeId cookie
         //  (And as this point we can't even use peer certificates if we wanted to, as this must be done
         //      directly in the browser)
-        let webSocket = new WebSocket(`wss://${address}:${port}`);
-        return Object.assign(webSocket, {
-            on(event: string, callback: any) {
-                // TODO: Use better type safety here
-                (webSocket as any)["on" + event] = callback;
-                return this as any;
-            },
-        });
+        return new WebSocket(`wss://${address}:${port}`);
     } else {
         let { key, cert } = getCertKeyPair();
         return new ws.WebSocket(`wss://${address}:${port}`, {

package/src/webSocketServer.ts

@@ -73,20 +73,6 @@ export async function startSocketServer(
         res.end();
     });
 
-    httpServer.listen(0, "127.0.0.1");
-    httpsServer.listen(0, "127.0.0.1");
-
-    // TODO: We should really add error handling here, but... we should always be able to listen
-    //  on ANY port on localhost, as why couldn't we?
-    let httpServerReady = new Promise(resolve => httpServer.once("listening", resolve));
-    let httpsServerReady = new Promise(resolve => httpsServer.once("listening", resolve));
-    await httpServerReady;
-    await httpsServerReady;
-
-    let httpAddress = httpServer.address() as net.AddressInfo;
-    let httpsAddress = httpsServer.address() as net.AddressInfo;
-
-
     let realServer = net.createServer(socket => {
         // NOTE: ONCE is used, so we only look at the first buffer, and then after that
         //  we pipe. This should be very efficient, as pipe has insane throughput
@@ -94,21 +80,11 @@ export async function startSocketServer(
         socket.once("data", buffer => {
             // All HTTPS requests start with 22, and no HTTP requests start with 22,
             //  so we just need to read the first byte.
-            let byte = buffer[0];
-            let isHTTPS = byte === 22;
-            let address = httpAddress;
-            if (isHTTPS) {
-                address = httpsAddress;
-            }
-            let baseSocket = net.connect(address.port);
-
-            baseSocket.write(buffer);
-            socket.pipe(baseSocket);
-            baseSocket.pipe(socket);
-
-            baseSocket.on("error", (e) => {
-                console.error(`Base socket error, ${e.stack}`);
-            });
+            let server = buffer[0] === 22 ? httpsServer : httpServer;
+
+            // NOTE: Messages aren't dequeued until the current handler finishes, so we don't need to pause the socket or anything.
+            server.emit("connection", socket);
+            socket.unshift(buffer);
         });
         socket.on("error", (e) => {
             console.error(`Exposed socket error, ${e.stack}`);