socket-function 1.1.16 → 1.1.18

package/index.d.ts

@@ -467,6 +467,7 @@ declare module "socket-function/src/CallFactory" {
     import * as tls from "tls";
     export interface CallFactory {
         nodeId: string;
+        realNodeId?: string;
         lastClosed: number;
         closedForever?: boolean;
         isConnected?: boolean;

package/package.json

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

package/src/CallFactory.d.ts

@@ -6,6 +6,7 @@ import * as ws from "ws";
 import * as tls from "tls";
 export interface CallFactory {
     nodeId: string;
+    realNodeId?: string;
     lastClosed: number;
     closedForever?: boolean;
     isConnected?: boolean;

package/src/CallFactory.ts

@@ -44,6 +44,7 @@ type InternalReturnType = {
 
 export interface CallFactory {
     nodeId: string;
+    realNodeId?: string;
     lastClosed: number;
     closedForever?: boolean;
     isConnected?: boolean;
@@ -53,6 +54,7 @@ export interface CallFactory {
     performCall(call: CallType): Promise<unknown>;
     onNextDisconnect(callback: () => void): void;
     disconnect(): void;
+    // If we change the node ID we need to recreate this object, essentially this object should be immutable. I forget why we wanted this. I think it's because we didn't know for sure if node ID would be unique, but it will be. 
     connectionId: { nodeId: string };
 }
 
@@ -161,6 +163,8 @@ export async function createCallFactory(
         receivedInitializeState: undefined,
         onNextDisconnect,
         disconnect() {
+            canReconnect = false;
+            callFactory.closedForever = true;
             if (webSocketPromise) {
                 webSocketPromise.then(ws => ws.close()).catch(() => { });
             }
@@ -557,18 +561,25 @@ export async function createCallFactory(
             if (!SocketFunction.LEGACY_INITIALIZE && call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
                 callFactory.receivedInitializeState = call.result as InitializeState;
                 let otherReconnectionUrl = callFactory.receivedInitializeState.ownReconnectionUrl;
+                callFactory.realNodeId = otherReconnectionUrl;
+                if (SocketFunction.logMessages) {
+                    console.log(green(`Received initialize state from ${callFactory.realNodeId} (for ${nodeId}) at ${Date.now()}`));
+                }
                 if (otherReconnectionUrl && !canReconnect && !!getNodeIdLocation(otherReconnectionUrl) && otherReconnectionUrl !== ownReconnectionUrl) {
                     if (changeNodeId({
                         originalNodeId: nodeId,
                         newNodeId: otherReconnectionUrl,
                         callFactory,
                     })) {
+                        if (SocketFunction.logMessages) {
+                            console.log(green(`Changed node id from ${nodeId} to ${otherReconnectionUrl}`));
+                        }
                         nodeId = otherReconnectionUrl;
                         niceConnectionName = otherReconnectionUrl;
                         callerContext.nodeId = nodeId;
                         canReconnect = !!getNodeIdLocation(nodeId);
                         callFactory.nodeId = nodeId;
-                        callFactory.connectionId.nodeId = nodeId;
+                        callFactory.connectionId = { nodeId };
                     }
                 }
                 return;
@@ -790,8 +801,14 @@ export async function createCallFactory(
             result: initState,
             seqNum: INITIALIZE_STATE_SEQ_NUM,
         };
+        if (SocketFunction.logMessages) {
+            console.log(`Sending initialize state to ${nodeId}`);
+        }
         let data = await SocketFunction.WIRE_SERIALIZER.serialize(initReturn);
         await send(data);
+        if (SocketFunction.logMessages) {
+            console.log(`Sent initialize state to ${nodeId}`);
+        }
     }
 
     return callFactory;