socket-function 1.1.5 → 1.1.6

package/SocketFunction.d.ts

@@ -29,6 +29,10 @@ export declare class SocketFunction {
         serialize: (obj: unknown) => MaybePromise<Buffer[]>;
         deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
     };
+    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
+     *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+     */
+    static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
     static WIRE_WARN_TIME: number;
     private static onMountCallbacks;
     static exposedClasses: Set<string>;

package/SocketFunction.ts

@@ -72,11 +72,17 @@ export class SocketFunction {
     // In retrospect... dynamically changing the wire serializer is a BAD idea. If any calls happen
     //  before it is changed, things just break. Also, it needs to be changed on both sides,
     //  or else things break. Also, it is very hard to detect when the issue is different serializers
+    // NOTE: The only reason this is still exposed is in case in the future we want to intercept our traffic, and we want convenient functions to know how to decode it (although there are a still few other layers under this, for compression and Buffer[] sending efficiency).
     public static readonly WIRE_SERIALIZER = {
         serialize: measureWrap((obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)], "WIRE_SERIALIZER|serialize"),
         deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), "WIRE_SERIALIZER|deserialize"),
     };
 
+    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID. 
+     *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+     */
+    public static GET_ALTERNATE_NODE_IDS = (nodeId: string): MaybePromise<string[] | undefined> => undefined;
+
     public static WIRE_WARN_TIME = 100;
 
     private static onMountCallbacks = new Map<string, (() => MaybePromise<void>)[]>();

package/index.d.ts

@@ -38,6 +38,10 @@ declare module "socket-function/SocketFunction" {
             serialize: (obj: unknown) => MaybePromise<Buffer[]>;
             deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
         };
+        /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
+         *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+         */
+        static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
         static WIRE_WARN_TIME: number;
         private static onMountCallbacks;
         static exposedClasses: Set<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.1.5",
+	"version": "1.1.6",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
@@ -20,7 +20,6 @@
 		"type": "yarn tsc --noEmit",
 		"emit-dts": "yarn tsc --project tsconfig.declarations.json || exit 0",
 		"generate-index-dts": "node ./generateIndexDts.js",
-		"update-typings": "yarn generate-index-dts && yarn emit-dts",
 		"update-types": "yarn emit-dts && yarn generate-index-dts",
 		"prepublishOnly": "yarn update-types",
 		"testsni": "yarn typenode ./src/sniTest.ts"

package/src/CallFactory.ts

@@ -19,8 +19,6 @@ import { measureFnc, measureWrap, registerMeasureInfo } from "./profiling/measur
 import { MaybePromise } from "./types";
 import { Zip } from "./Zip";
 import { LZ4 } from "./lz4/LZ4";
-//LZ4.compress;
-//LZ4.decompress;
 
 setFlag(require, "pako", "allowclient", true);
 
@@ -282,16 +280,22 @@ export async function createCallFactory(
     };
 
     let webSocketPromise: Promise<SenderInterface> | undefined;
+    let hasEverConnected = false;
     if (webSocketBase) {
         webSocketPromise = Promise.resolve(webSocketBase);
         await initializeWebsocket(webSocketBase);
     }
 
-    async function initializeWebsocket(newWebSocket: SenderInterface) {
+    async function initializeWebsocket(newWebSocket: SenderInterface, skipCloseHandling = false) {
         registerOnce();
         callFactory.receivedInitializeState = undefined;
 
         function onClose(error: string) {
+            // We try various connections, and if they fail, we will just try other node IDs until we finally do connect, and then we stick with that nodeId, and when it disconnects we need to handle disconnections normally.
+            if (skipCloseHandling && !hasEverConnected) {
+                return;
+            }
+
             callFactory.connectionId = { nodeId };
             callFactory.lastClosed = Date.now();
             callFactory.isConnected = false;
@@ -341,6 +345,7 @@ export async function createCallFactory(
                         console.log(`Connection established to ${niceConnectionName}`);
                     }
                     callFactory.isConnected = true;
+                    hasEverConnected = true;
                     resolve();
                 });
                 newWebSocket.addEventListener("close", () => resolve());
@@ -348,6 +353,7 @@ export async function createCallFactory(
             });
         } else if (newWebSocket.readyState === 1 /* OPEN */) {
             callFactory.isConnected = true;
+            hasEverConnected = true;
         } else {
             onClose(new Error(`Websocket received in closed state`).stack!);
         }
@@ -441,6 +447,23 @@ export async function createCallFactory(
         }
         lastConnectionAttempt = Date.now();
 
+        // Try alternates, and if any work, use them
+        try {
+            let alternates = await SocketFunction.GET_ALTERNATE_NODE_IDS(nodeId);
+            if (alternates) {
+                for (let alternateNodeId of alternates) {
+                    let newWebSocket = createWebsocket(alternateNodeId);
+                    await initializeWebsocket(newWebSocket, true);
+
+                    if (callFactory.isConnected) {
+                        return newWebSocket;
+                    }
+                }
+            }
+        } catch (e) {
+            console.error("Error getting alternate node IDs", e);
+        }
+
         let newWebSocket = createWebsocket(nodeId);
         await initializeWebsocket(newWebSocket);