socket-function 1.1.14 → 1.1.16

package/SocketFunction.d.ts

@@ -26,7 +26,6 @@ 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

@@ -71,10 +71,6 @@ 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,7 +35,6 @@ 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>;
@@ -474,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;
         };
@@ -482,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: {
@@ -1073,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.14",
+	"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> {

package/src/webSocketServer.ts

@@ -5,7 +5,7 @@ import tls from "tls";
 import { getNodeIdsFromRequest, httpCallHandler } from "./callHTTPHandler";
 import { SocketFunction } from "../SocketFunction";
 import { getTrustedCertificates, watchTrustedCertificates } from "./certStore";
-import { createCallFactory } from "./CallFactory";
+import { createCallFactory, registerOwnReconnectionUrl } from "./CallFactory";
 import { parseSNIExtension, parseTLSHello, SNIType } from "./tlsParsing";
 import debugbreak from "debugbreak";
 import { getNodeId } from "./nodeCache";
@@ -351,6 +351,7 @@ export async function startSocketServer(
 
     let nodeId = getNodeId(getCommonName(config.cert), port);
     console.log(green(`Started Listening on ${nodeId} (${host}) after ${formatTime(process.uptime() * 1000)}`));
+    registerOwnReconnectionUrl(nodeId);
 
     return nodeId;
 }