socket-function 1.1.12 → 1.1.14

package/SocketFunction.d.ts

@@ -26,6 +26,7 @@ export declare class SocketFunction {
     static COEP: string;
     static COOP: string;
     static TOTAL_CALLS: number;
+    static registerOwnReconnectionUrl(url: string): void;
     static readonly WIRE_SERIALIZER: {
         serialize: (obj: unknown) => MaybePromise<Buffer[]>;
         deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;

package/SocketFunction.ts

@@ -16,7 +16,7 @@ import "./SetProcessVariables";
 import cborx from "cbor-x";
 import { setFlag } from "./require/compileFlags";
 import { isNode } from "./src/misc";
-import { getPendingCallCount, harvestCallTimes, harvestFailedCallCount } from "./src/CallFactory";
+import { getPendingCallCount, harvestCallTimes, harvestFailedCallCount, registerOwnReconnectionUrl } from "./src/CallFactory";
 import { measureWrap } from "./src/profiling/measure";
 
 setFlag(require, "cbor-x", "allowclient", true);
@@ -71,6 +71,10 @@ export class SocketFunction {
 
     public static TOTAL_CALLS = 0;
 
+    public static registerOwnReconnectionUrl(url: string) {
+        registerOwnReconnectionUrl(url);
+    }
+
     // 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

package/index.d.ts

@@ -35,6 +35,7 @@ declare module "socket-function/SocketFunction" {
         static COEP: string;
         static COOP: string;
         static TOTAL_CALLS: number;
+        static registerOwnReconnectionUrl(url: string): void;
         static readonly WIRE_SERIALIZER: {
             serialize: (obj: unknown) => MaybePromise<Buffer[]>;
             deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
@@ -492,6 +493,7 @@ declare module "socket-function/src/CallFactory" {
     }
     type InitializeState = {
         supportsLZ4?: boolean;
+        ownReconnectionUrl?: string;
     };
     export declare function harvestFailedCallCount(): number;
     export declare function getPendingCallCount(): number;
@@ -500,6 +502,7 @@ declare module "socket-function/src/CallFactory" {
         end: number;
     }[];
     export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
+    export declare function registerOwnReconnectionUrl(url: string): void;
     export {};
 
 }
@@ -1066,6 +1069,11 @@ declare module "socket-function/src/nodeCache" {
     export declare function getNodeIdDomain(nodeId: string): string;
     export declare function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefined;
     export declare function registerNodeClient(callFactory: CallFactory): void;
+    export declare function changeNodeId(config: {
+        originalNodeId: string;
+        newNodeId: string;
+        callFactory: CallFactory;
+    }): void;
     export declare function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory>;
     export declare function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined>;
     export declare function debugGetAllCallFactories(): CallFactory[];

package/package.json

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

package/src/CallFactory.d.ts

@@ -31,6 +31,7 @@ export interface SenderInterface {
 }
 type InitializeState = {
     supportsLZ4?: boolean;
+    ownReconnectionUrl?: string;
 };
 export declare function harvestFailedCallCount(): number;
 export declare function getPendingCallCount(): number;
@@ -39,4 +40,5 @@ export declare function harvestCallTimes(): {
     end: number;
 }[];
 export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
+export declare function registerOwnReconnectionUrl(url: string): void;
 export {};

package/src/CallFactory.ts

@@ -5,7 +5,7 @@ import { convertErrorStackToError, formatNumberSuffixed, isBufferType, isNode, l
 import { createWebsocketFactory, getTLSSocket } from "./websocketFactory";
 import { SocketFunction } from "../SocketFunction";
 import * as tls from "tls";
-import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCache";
+import { changeNodeId, getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCache";
 import debugbreak from "debugbreak";
 import { lazy } from "./caching";
 import { blue, green, red, yellow } from "./formatting/logColors";
@@ -74,6 +74,7 @@ export interface SenderInterface {
 
 type InitializeState = {
     supportsLZ4?: boolean;
+    ownReconnectionUrl?: string;
 };
 
 const INITIALIZE_STATE_SEQ_NUM = -1;
@@ -114,7 +115,7 @@ export async function createCallFactory(
     const createWebsocket = createWebsocketFactory();
     const registerOnce = lazy(() => registerNodeClient(callFactory));
 
-    const canReconnect = !!getNodeIdLocation(nodeId);
+    let canReconnect = !!getNodeIdLocation(nodeId);
 
     let pendingCalls: Map<number, {
         data: Buffer[];
@@ -547,6 +548,20 @@ export async function createCallFactory(
         if (call.isReturn) {
             if (!SocketFunction.LEGACY_INITIALIZE && call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
                 callFactory.receivedInitializeState = call.result as InitializeState;
+                let otherReconnectionUrl = callFactory.receivedInitializeState.ownReconnectionUrl;
+                if (otherReconnectionUrl && !canReconnect && !!getNodeIdLocation(otherReconnectionUrl)) {
+                    changeNodeId({
+                        originalNodeId: nodeId,
+                        newNodeId: otherReconnectionUrl,
+                        callFactory,
+                    });
+                    nodeId = otherReconnectionUrl;
+                    niceConnectionName = otherReconnectionUrl;
+                    callerContext.nodeId = nodeId;
+                    canReconnect = !!getNodeIdLocation(nodeId);
+                    callFactory.nodeId = nodeId;
+                    callFactory.connectionId.nodeId = nodeId;
+                }
                 return;
             }
             let callbackObj = pendingCalls.get(call.seqNum);
@@ -759,6 +774,7 @@ export async function createCallFactory(
     if (!SocketFunction.LEGACY_INITIALIZE) {
         let initState: InitializeState = {
             supportsLZ4: true,
+            ownReconnectionUrl,
         };
         let initReturn: InternalReturnType = {
             isReturn: true,
@@ -772,6 +788,10 @@ export async function createCallFactory(
     return callFactory;
 }
 
+let ownReconnectionUrl: string | undefined;
+export function registerOwnReconnectionUrl(url: string) {
+    ownReconnectionUrl = url;
+}
 
 
 let uncompressedSent = 0;

package/src/nodeCache.d.ts

@@ -18,6 +18,11 @@ export declare function getNodeIdLocation(nodeId: string): {
 export declare function getNodeIdDomain(nodeId: string): string;
 export declare function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefined;
 export declare function registerNodeClient(callFactory: CallFactory): void;
+export declare function changeNodeId(config: {
+    originalNodeId: string;
+    newNodeId: string;
+    callFactory: CallFactory;
+}): void;
 export declare function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory>;
 export declare function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined>;
 export declare function debugGetAllCallFactories(): CallFactory[];

package/src/nodeCache.ts

@@ -77,6 +77,16 @@ export function registerNodeClient(callFactory: CallFactory) {
     startCleanupLoop();
 }
 
+export function changeNodeId(config: {
+    originalNodeId: string;
+    newNodeId: string;
+    callFactory: CallFactory;
+}) {
+    if (nodeCache.has(config.newNodeId)) return;
+    nodeCache.delete(config.originalNodeId);
+    nodeCache.set(config.newNodeId, config.callFactory);
+}
+
 export function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory> {
     let callFactory = nodeCache.get(nodeId);
     if (callFactory === undefined) {