socket-function 1.1.10 → 1.1.12

package/index.d.ts

@@ -592,8 +592,12 @@ declare module "socket-function/src/batching" {
         parallelCount: number;
         callTimeout?: number;
     }, fnc: T): T;
-    export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void): void;
-    export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void): Promise<void>;
+    export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+        stop: boolean;
+    }): void;
+    export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+        stop: boolean;
+    }): Promise<void>;
     /** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
     export declare function shutdownPolling(): Promise<void>;
     export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
@@ -1064,6 +1068,7 @@ declare module "socket-function/src/nodeCache" {
     export declare function registerNodeClient(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[];
     export declare function resetAllNodeCallFactories(): void;
     export declare function countOpenConnections(): number;
 

package/package.json

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

package/src/batching.d.ts

@@ -19,8 +19,12 @@ export declare function runInParallel<T extends (...args: any[]) => Promise<any>
     parallelCount: number;
     callTimeout?: number;
 }, fnc: T): T;
-export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void): void;
-export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void): Promise<void>;
+export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+    stop: boolean;
+}): void;
+export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+    stop: boolean;
+}): Promise<void>;
 /** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
 export declare function shutdownPolling(): Promise<void>;
 export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?: {

package/src/batching.ts

@@ -253,10 +253,11 @@ let pendingPolls = new Set<Promise<unknown>>();
 
 export function runInfinitePoll(
     delayTime: number,
-    fnc: () => Promise<void> | void
+    fnc: () => Promise<void> | void,
+    stopObj?: { stop: boolean; }
 ) {
     void (async () => {
-        while (pollingRunning) {
+        while (!stopObj?.stop && pollingRunning) {
             await delay(delayTime);
             if (!pollingRunning) break;
             await runPollFnc(fnc);
@@ -266,13 +267,14 @@ export function runInfinitePoll(
 
 export async function runInfinitePollCallAtStart(
     delayTime: number,
-    fnc: () => Promise<void> | void
+    fnc: () => Promise<void> | void,
+    stopObj?: { stop: boolean; }
 ) {
     try {
         return await fnc();
     } finally {
         void (async () => {
-            while (true) {
+            while (!stopObj?.stop && pollingRunning) {
                 await delay(delayTime);
                 if (!pollingRunning) break;
                 await runPollFnc(fnc);

package/src/nodeCache.d.ts

@@ -20,5 +20,6 @@ export declare function getNodeIdDomainMaybeUndefined(nodeId: string): string |
 export declare function registerNodeClient(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[];
 export declare function resetAllNodeCallFactories(): void;
 export declare function countOpenConnections(): number;

package/src/nodeCache.ts

@@ -89,6 +89,17 @@ export function getCallFactory(nodeId: string): MaybePromise<CallFactory | undef
     return nodeCache.get(nodeId);
 }
 
+export function debugGetAllCallFactories(): CallFactory[] {
+    let result: CallFactory[] = [];
+    for (let [key, value] of nodeCache.entries()) {
+        if (value instanceof Promise) {
+            continue;
+        }
+        result.push(value);
+    }
+    return result;
+}
+
 export function resetAllNodeCallFactories() {
     // Needs to be done if you want to reset authentication. Outstanding calls still work,
     //  but new calls use new factories (and connections).