socket-function 1.1.15 → 1.1.16

package/index.d.ts

@@ -473,6 +473,7 @@ declare module "socket-function/src/CallFactory" {
         receivedInitializeState?: InitializeState;
         performCall(call: CallType): Promise<unknown>;
         onNextDisconnect(callback: () => void): void;
+        disconnect(): void;
         connectionId: {
             nodeId: string;
         };
@@ -481,6 +482,7 @@ declare module "socket-function/src/CallFactory" {
         nodeId?: string;
         _socket?: tls.TLSSocket;
         send(data: string | Buffer): void;
+        close(): void;
         addEventListener(event: "open", listener: () => void): void;
         addEventListener(event: "close", listener: () => void): void;
         addEventListener(event: "error", listener: (err: {
@@ -1072,7 +1074,7 @@ declare module "socket-function/src/nodeCache" {
         originalNodeId: string;
         newNodeId: string;
         callFactory: CallFactory;
-    }): void;
+    }): boolean;
     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.15",
+	"version": "1.1.16",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.d.ts

@@ -12,6 +12,7 @@ export interface CallFactory {
     receivedInitializeState?: InitializeState;
     performCall(call: CallType): Promise<unknown>;
     onNextDisconnect(callback: () => void): void;
+    disconnect(): void;
     connectionId: {
         nodeId: string;
     };
@@ -20,6 +21,7 @@ export interface SenderInterface {
     nodeId?: string;
     _socket?: tls.TLSSocket;
     send(data: string | Buffer): void;
+    close(): void;
     addEventListener(event: "open", listener: () => void): void;
     addEventListener(event: "close", listener: () => void): void;
     addEventListener(event: "error", listener: (err: {

package/src/CallFactory.ts

@@ -52,6 +52,7 @@ export interface CallFactory {
     //  Trigger performLocalCall on the other side of the connection
     performCall(call: CallType): Promise<unknown>;
     onNextDisconnect(callback: () => void): void;
+    disconnect(): void;
     connectionId: { nodeId: string };
 }
 
@@ -61,6 +62,7 @@ export interface SenderInterface {
     _socket?: tls.TLSSocket;
 
     send(data: string | Buffer): void;
+    close(): void;
 
     addEventListener(event: "open", listener: () => void): void;
     addEventListener(event: "close", listener: () => void): void;
@@ -108,7 +110,8 @@ export async function createCallFactory(
     // The node id we are connecting to (or that connected to us)
     nodeId: string,
     // The node id that we were contacted on
-    localNodeId = "",
+    // NOTE: This used to default to empty string, which would be the case if we made the connection. But this caused problems when we want it to stop making two connections per server and reuse the connection if both the servers want it to talk to each other. I guess we can default it to our reconnection URL. I mean, how else are people going to connect to us other than that?
+    localNodeId = ownReconnectionUrl || "",
 ): Promise<CallFactory> {
     let niceConnectionName = nodeId;
 
@@ -157,6 +160,11 @@ export async function createCallFactory(
         connectionId: { nodeId },
         receivedInitializeState: undefined,
         onNextDisconnect,
+        disconnect() {
+            if (webSocketPromise) {
+                webSocketPromise.then(ws => ws.close()).catch(() => { });
+            }
+        },
         async performCall(call: CallType) {
             let seqNum = nextSeqNum++;
             let fullCall: InternalCallType = {
@@ -549,18 +557,19 @@ 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;
-                if (otherReconnectionUrl && !canReconnect && !!getNodeIdLocation(otherReconnectionUrl)) {
-                    changeNodeId({
+                if (otherReconnectionUrl && !canReconnect && !!getNodeIdLocation(otherReconnectionUrl) && otherReconnectionUrl !== ownReconnectionUrl) {
+                    if (changeNodeId({
                         originalNodeId: nodeId,
                         newNodeId: otherReconnectionUrl,
                         callFactory,
-                    });
-                    nodeId = otherReconnectionUrl;
-                    niceConnectionName = otherReconnectionUrl;
-                    callerContext.nodeId = nodeId;
-                    canReconnect = !!getNodeIdLocation(nodeId);
-                    callFactory.nodeId = nodeId;
-                    callFactory.connectionId.nodeId = nodeId;
+                    })) {
+                        nodeId = otherReconnectionUrl;
+                        niceConnectionName = otherReconnectionUrl;
+                        callerContext.nodeId = nodeId;
+                        canReconnect = !!getNodeIdLocation(nodeId);
+                        callFactory.nodeId = nodeId;
+                        callFactory.connectionId.nodeId = nodeId;
+                    }
                 }
                 return;
             }

package/src/nodeCache.d.ts

@@ -22,7 +22,7 @@ export declare function changeNodeId(config: {
     originalNodeId: string;
     newNodeId: string;
     callFactory: CallFactory;
-}): void;
+}): boolean;
 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

@@ -82,9 +82,13 @@ export function changeNodeId(config: {
     newNodeId: string;
     callFactory: CallFactory;
 }) {
-    if (nodeCache.has(config.newNodeId)) return;
+    if (nodeCache.has(config.newNodeId)) {
+        console.warn(`Received connection we already have. Likely we and them tried to connect at the same time. Other nodeId: ${config.newNodeId}`);
+        return false;
+    }
     nodeCache.delete(config.originalNodeId);
     nodeCache.set(config.newNodeId, config.callFactory);
+    return true;
 }
 
 export function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory> {