socket-function 1.1.42 → 1.1.44

package/hot/HotReloadController.ts

@@ -4,6 +4,7 @@ module.allowclient = true;
 
 import { SocketFunction } from "../SocketFunction";
 import { cache, lazy } from "../src/caching";
+import { createSingleton } from "../src/createSingleton";
 import * as fs from "fs";
 import crypto from "crypto";
 import debugbreak from "debugbreak";
@@ -56,18 +57,23 @@ declare global {
     var isHotReloading: (() => boolean) | undefined;
 }
 
-let isHotReloadingValue = false;
+// Shared across copies of this package, so the "currently hot reloading" flag is consistent no
+//  matter which copy set it (ex, setExternalHotReloading) or reads it (callManager.registerClass
+//  reads it via the globalThis.isHotReloading bridge, which each copy overwrites). See createSingleton.
+const isHotReloadingState = createSingleton("HotReloadController.isHotReloading", 1, () => ({ value: false }));
 export function isHotReloading() {
-    return isHotReloadingValue;
+    return isHotReloadingState.get().value;
 }
 globalThis.isHotReloading = isHotReloading;
 export function hotReloadingGuard(): true {
     return !isHotReloading() as any;
 }
 export function setExternalHotReloading(value: boolean) {
-    isHotReloadingValue = value;
+    isHotReloadingState.get().value = value;
 }
-let hotReloadCallbacks: ((modules: NodeJS.Module[]) => void)[] = [];
+// Shared across copies, so callbacks registered through one copy's onHotReload still fire when the
+//  first-registered copy's controller performs a reload. See createSingleton.
+const hotReloadCallbacks = createSingleton("HotReloadController.hotReloadCallbacks", 1, () => [] as ((modules: NodeJS.Module[]) => void)[]).get();
 export function onHotReload(callback: (modules: NodeJS.Module[]) => void) {
     hotReloadCallbacks.push(callback);
 }
@@ -124,7 +130,7 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
                 || module.moduleContents?.includes("\r\nmodule.hotreload = true;" + "\r\n")
             ) {
                 console.log(`Serverside reloading ${module.id}`);
-                isHotReloadingValue = true;
+                isHotReloadingState.get().value = true;
                 try {
                     module.loaded = false;
                     module.load(module.id);
@@ -133,7 +139,7 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
                     console.error(e);
                 } finally {
                     setTimeout(() => {
-                        isHotReloadingValue = false;
+                        isHotReloadingState.get().value = false;
                     }, 1000);
                 }
             }
@@ -215,12 +221,12 @@ class HotReloadControllerBase {
             for (let module of modules) {
                 module.loaded = false;
             }
-            isHotReloadingValue = true;
+            isHotReloadingState.get().value = true;
             try {
                 await Promise.all(modules.map(module => module.load(module.filename)));
             } finally {
                 setTimeout(() => {
-                    isHotReloadingValue = false;
+                    isHotReloadingState.get().value = false;
                 }, 1000);
             }
 

package/index.d.ts

@@ -360,8 +360,14 @@ declare module "socket-function/require/RequireController" {
     declare function addStaticRoot(root: string): void;
     type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
     export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
-    declare let mapGetModules: {
-        remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>;
+    declare const mapGetModules: {
+        remap(result: GetModulesResult, args: [pathRequests: string[], alreadyHave?: {
+            requireSeqNumProcessId: string;
+            seqNumRanges: {
+                s: number;
+                e?: number;
+            }[];
+        } | undefined, config?: {} | undefined]): Promise<GetModulesResult>;
     }[];
     declare function addMapGetModules(remap: typeof mapGetModules[number]["remap"]): void;
     declare class RequireControllerBase {
@@ -624,6 +630,8 @@ declare module "socket-function/src/batching" {
         shouldRetry?: (message: string) => boolean;
         minDelay?: number;
         maxDelay?: number;
+        timeout?: number;
+        warningInterval?: number;
     }): T;
     /** @deprecated Use safeLoop instead */
     export declare const throttledLoop: typeof unblockLoop;
@@ -1125,6 +1133,9 @@ declare module "socket-function/src/misc" {
     export declare function timeoutToUndefined<T>(time: number, p: Promise<T>): Promise<T | undefined>;
     export declare function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>): Promise<T | undefined>;
     export declare function errorToWarning<T>(promise: Promise<T>): void;
+    export declare function watchSlowPromise<T>(title: string, promise: Promise<T>, config: {
+        interval?: number;
+    }): Promise<T>;
 
 }
 

package/package.json

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

package/require/RequireController.d.ts

@@ -45,8 +45,14 @@ declare function injectHTMLBeforeStartup(text: string | (() => Promise<string>))
 declare function addStaticRoot(root: string): void;
 type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
 export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
-declare let mapGetModules: {
-    remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>;
+declare const mapGetModules: {
+    remap(result: GetModulesResult, args: [pathRequests: string[], alreadyHave?: {
+        requireSeqNumProcessId: string;
+        seqNumRanges: {
+            s: number;
+            e?: number;
+        }[];
+    } | undefined, config?: {} | undefined]): Promise<GetModulesResult>;
 }[];
 declare function addMapGetModules(remap: typeof mapGetModules[number]["remap"]): void;
 declare class RequireControllerBase {

package/require/RequireController.ts

@@ -6,6 +6,7 @@ import { getCurrentHTTPRequest, setHTTPResultHeaders } from "../src/callHTTPHand
 import { formatNumberSuffixed, isNode, isNodeTrue, sha256Hash, sha256HashPromise } from "../src/misc";
 import zlib from "zlib";
 import { cacheLimited, lazy } from "../src/caching";
+import { createSingleton } from "../src/createSingleton";
 import { formatNumber } from "../src/formatting/format";
 import { requireMain } from "./require";
 import path from "path";
@@ -88,11 +89,16 @@ const resolvedHTMLFile = lazy(() => {
         );
 });
 
-let beforeEntryText: (string | (() => Promise<string>))[] = [];
+// All of these are mutated by the static helpers below (injectHTMLBeforeStartup, addStaticRoot,
+//  addMapGetModules), which callers invoke on RequireController. But only the first-registered
+//  copy's controller actually serves requireHTML/getModules, and it reads these vars. So they must
+//  be shared across copies, or a caller using a different copy would add (ex) before-entry HTML
+//  that the serving controller never reads. See createSingleton.
+const beforeEntryText = createSingleton("RequireController.beforeEntryText", 1, () => [] as (string | (() => Promise<string>))[]).get();
 function injectHTMLBeforeStartup(text: string | (() => Promise<string>)) {
     beforeEntryText.push(text);
 }
-let staticRoots: string[] = [];
+const staticRoots = createSingleton("RequireController.staticRoots", 1, () => [] as string[]).get();
 function addStaticRoot(root: string) {
     if (!root.endsWith("/")) {
         root += "/";
@@ -102,9 +108,9 @@ function addStaticRoot(root: string) {
 
 type GetModulesResult = ReturnType<RequireControllerBase["getModules"]> extends Promise<infer T> ? T : never;
 export type GetModulesArgs = Parameters<RequireControllerBase["getModules"]>;
-let mapGetModules: {
+const mapGetModules = createSingleton("RequireController.mapGetModules", 1, () => [] as {
     remap(result: GetModulesResult, args: GetModulesArgs): Promise<GetModulesResult>
-}[] = [];
+}[]).get();
 function addMapGetModules(remap: typeof mapGetModules[number]["remap"]) {
     mapGetModules.push({ remap });
 }
@@ -421,7 +427,7 @@ async function compressCached(bufferKey: string, buffer: () => Buffer): Promise<
 export function getIsAllowClient(module: NodeJS.Module) {
     if (module.serveronly) return false;
     // IMPORTANT! We do not allow everything in node modules by default, as most things in node modules, you don't want to import client-side, and it will break if you import it client-side. Many of these are imported, but will never end up being called client-side, so it's fine to exclude them.
-    if (allowAllNodeModulesFlag && module.filename.includes("node_modules")) {
+    if (allowAllNodeModulesFlag.get().value && module.filename.includes("node_modules")) {
         return true;
     }
     return module.allowclient;
@@ -434,7 +440,9 @@ declare global {
     var remapImportRequestsClientside: undefined | ClientRemapCallback[];
 }
 
-let baseController = new RequireControllerBase();
+// Shared across copies of this package, so the registered controller and rootResolvePath (set by
+//  setRequireBootRequire) are the same instance everyone reads/writes. See createSingleton.
+const baseController = createSingleton("RequireController.baseController", 1, () => new RequireControllerBase()).get();
 /** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
 export function setRequireBootRequire(dir: string) {
     dir = path.resolve(dir);
@@ -445,9 +453,11 @@ export function setRequireBootRequire(dir: string) {
     baseController.rootResolvePath = dir;
 }
 
-let allowAllNodeModulesFlag = false;
+// Shared across copies, so calling allowAllNodeModules() on any copy is seen by the serving
+//  controller's getIsAllowClient. See createSingleton.
+const allowAllNodeModulesFlag = createSingleton("RequireController.allowAllNodeModules", 1, () => ({ value: false }));
 export function allowAllNodeModules() {
-    allowAllNodeModulesFlag = true;
+    allowAllNodeModulesFlag.get().value = true;
 }
 
 export const RequireController = SocketFunction.register(

package/src/batching.d.ts

@@ -32,6 +32,8 @@ export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?:
     shouldRetry?: (message: string) => boolean;
     minDelay?: number;
     maxDelay?: number;
+    timeout?: number;
+    warningInterval?: number;
 }): T;
 /** @deprecated Use safeLoop instead */
 export declare const throttledLoop: typeof unblockLoop;

package/src/batching.ts

@@ -1,6 +1,6 @@
 import { formatTime } from "./formatting/format";
 import { red } from "./formatting/logColors";
-import { PromiseObj, isNode, timeoutToError } from "./misc";
+import { PromiseObj, isNode, timeoutToError, watchSlowPromise } from "./misc";
 import { measureWrap } from "./profiling/measure";
 import { AnyFunction, Args, MaybePromise } from "./types";
 
@@ -312,18 +312,32 @@ export function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
     shouldRetry?: (message: string) => boolean;
     minDelay?: number;
     maxDelay?: number;
+    timeout?: number;
+    warningInterval?: number;
 }): T {
-    let { maxRetries = DEFAULT_MAX_RETRIES, shouldRetry, minDelay = DEFAULT_RETRY_DELAY, maxDelay = DEFAULT_RETRY_DELAY } = config || {};
+    let {
+        maxRetries = DEFAULT_MAX_RETRIES, shouldRetry, minDelay = DEFAULT_RETRY_DELAY, maxDelay = DEFAULT_RETRY_DELAY,
+        timeout,
+        warningInterval,
+    } = config || {};
     let expFactor = Math.max(1, Math.log(maxDelay / minDelay) / Math.log(Math.max(maxRetries, 2)));
+    let name = fnc.name || fnc.toString().slice(0, 100);
     async function runFnc(args: any[], retries: number): Promise<ReturnType<T>> {
         try {
-            return await (fnc as any)(...args);
+            let promise = (fnc as any)(...args);
+            if (timeout !== undefined) {
+                promise = timeoutToError(timeout, promise, () => new Error(`timed out after ${formatTime(timeout)}`));
+            }
+            if (warningInterval !== undefined) {
+                promise = watchSlowPromise(name, promise, { interval: warningInterval });
+            }
+            return await promise;
         } catch (e: any) {
             if (shouldRetry && !shouldRetry(String(e.stack))) {
                 throw e;
             }
             if (retries < 0) throw e;
-            console.warn(`Retrying ${fnc.name}, due to error ${String(e.stack)}`);
+            console.warn(`Retrying ${name}, due to error ${String(e.stack)}`);
             retries--;
             let curCount = maxRetries - retries;
             await delay(minDelay * expFactor ** curCount);

package/src/misc.d.ts

@@ -96,3 +96,6 @@ export declare function timeoutToError<T>(time: number, p: Promise<T>, err: () =
 export declare function timeoutToUndefined<T>(time: number, p: Promise<T>): Promise<T | undefined>;
 export declare function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>): Promise<T | undefined>;
 export declare function errorToWarning<T>(promise: Promise<T>): void;
+export declare function watchSlowPromise<T>(title: string, promise: Promise<T>, config: {
+    interval?: number;
+}): Promise<T>;

package/src/misc.ts

@@ -1,5 +1,7 @@
 import { canHaveChildren, MaybePromise } from "./types";
-import { formatNumber } from "./formatting/format";
+import { formatNumber, formatTime } from "./formatting/format";
+import { delay } from "./batching";
+import { yellow } from "./formatting/logColors";
 
 export const timeInSecond = 1000;
 export const timeInMinute = timeInSecond * 60;
@@ -458,3 +460,20 @@ export function errorToWarning<T>(promise: Promise<T>): void {
         return undefined as any;
     }) as any;
 }
+
+export function watchSlowPromise<T>(title: string, promise: Promise<T>, config: {
+    interval?: number;
+}) {
+    let { interval = 5000 } = config;
+    let fulfilled = false;
+    void promise.finally(() => fulfilled = true);
+    let startTime = Date.now();
+    void (async () => {
+        while (true) {
+            await delay(interval);
+            if (fulfilled) break;
+            console.log(`${yellow(`Slow promise running for ${formatTime(Date.now() - startTime)}`)} | ${title}`);
+        }
+    })();
+    return promise;
+}