socket-function 1.1.40 → 1.1.42

package/SocketFunction.d.ts

@@ -37,8 +37,10 @@ export declare class SocketFunction {
     static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
     static WIRE_WARN_TIME: number;
     private static onMountCallbacks;
-    static exposedClasses: Set<string>;
-    static callerContext: CallerContext | undefined;
+    private static exposedClassesSingleton;
+    static get exposedClasses(): Set<string>;
+    static get callerContext(): CallerContext | undefined;
+    static set callerContext(value: CallerContext | undefined);
     static getCaller(): CallerContext;
     static harvestFailedCallCount: () => number;
     static getPendingCallCount: () => number;
@@ -82,12 +84,13 @@ export declare class SocketFunction {
      *      to add additional imports to ensure the register call runs.
      */
     static expose(socketRegistered: SocketRegistered): void;
-    static mountedNodeId: string;
+    private static mountState;
+    static get mountedNodeId(): string;
+    static set mountedNodeId(value: string);
     static isMounted(): boolean;
-    static mountedIP: string;
-    private static hasMounted;
-    private static onMountCallback;
-    static mountPromise: Promise<void>;
+    static get mountedIP(): string;
+    static set mountedIP(value: string);
+    static get mountPromise(): Promise<void>;
     static mount(config: SocketServerConfig): Promise<string>;
     /** Sets the default call when an http request is made, but no classGuid is set.
      *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.

package/SocketFunction.ts

@@ -9,6 +9,7 @@ import { Args, MaybePromise } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
 import debugbreak from "debugbreak";
 import { lazy } from "./src/caching";
+import { createSingleton } from "./src/createSingleton";
 import { delay } from "./src/batching";
 import { blue, magenta } from "./src/formatting/logColors";
 import { JSONLACKS } from "./src/JSONLACKS/JSONLACKS";
@@ -36,6 +37,14 @@ if (isNode()) {
 
 module.allowclient = true;
 
+// The active call's caller, plus a sequence number used to reset it synchronously (see
+//  _setSocketContext). Shared across copies of this package, so SocketFunction.getCaller()
+//  returns the right caller even when the call was set up by a different copy. See createSingleton.
+const socketContext = createSingleton("SocketFunction.socketContext", 1, () => ({
+    seqNum: 1,
+    caller: undefined as CallerContext | undefined,
+}));
+
 type ExtractShape<ClassType, Shape> = {
     [key in keyof ClassType]: (
         key extends keyof Shape
@@ -89,10 +98,16 @@ export class SocketFunction {
 
     public static WIRE_WARN_TIME = 100;
 
-    private static onMountCallbacks = new Map<string, (() => MaybePromise<void>)[]>();
-    public static exposedClasses = new Set<string>();
+    // Shared across copies of this package, so onMount callbacks registered through one copy still
+    //  fire when another copy mounts. See createSingleton.
+    private static onMountCallbacks = createSingleton("SocketFunction.onMountCallbacks", 1, () => new Map<string, (() => MaybePromise<void>)[]>()).get();
+    // Shared across copies of this package, so the set of exposed classes is consistent regardless
+    //  of which copy a class was exposed through. See createSingleton.
+    private static exposedClassesSingleton = createSingleton("SocketFunction.exposedClasses", 1, () => new Set<string>());
+    public static get exposedClasses() { return SocketFunction.exposedClassesSingleton.get(); }
 
-    public static callerContext: CallerContext | undefined;
+    public static get callerContext(): CallerContext | undefined { return socketContext.get().caller; }
+    public static set callerContext(value: CallerContext | undefined) { socketContext.get().caller = value; }
     public static getCaller(): CallerContext {
         const caller = SocketFunction.callerContext;
         if (!caller) throw new Error(`Tried to access caller when not in the synchronous phase of a function call`);
@@ -215,7 +230,9 @@ export class SocketFunction {
         return Object.assign(socketCaller, config?.statics) as any;
     }
 
-    private static socketCache = new Map<string, SocketRegistered>();
+    // Shared across copies of this package, so a given classGuid resolves to one canonical caller
+    //  regardless of which copy rehydrated it. See createSingleton.
+    private static socketCache = createSingleton("SocketFunction.socketCache", 1, () => new Map<string, SocketRegistered>()).get();
     public static rehydrateSocketCaller<Controller>(
         socketRegistered: SocketRegisterType<Controller>,
         // Shape is required for client hooks.
@@ -359,13 +376,15 @@ export class SocketFunction {
         return url.toString();
     }
 
-    private static ignoreExposeCount = 0;
+    // Shared across copies of this package, so suppressing expose calls in one copy also suppresses
+    //  them in the others. See createSingleton.
+    private static ignoreExposeCount = createSingleton("SocketFunction.ignoreExposeCount", 1, () => ({ count: 0 }));
     public static async ignoreExposeCalls<T>(code: () => Promise<T>) {
-        this.ignoreExposeCount++;
+        SocketFunction.ignoreExposeCount.get().count++;
         try {
             return await code();
         } finally {
-            this.ignoreExposeCount--;
+            SocketFunction.ignoreExposeCount.get().count--;
         }
     }
 
@@ -374,7 +393,7 @@ export class SocketFunction {
      *      to add additional imports to ensure the register call runs.
      */
     public static expose(socketRegistered: SocketRegistered) {
-        if (this.ignoreExposeCount > 0) return;
+        if (SocketFunction.ignoreExposeCount.get().count > 0) return;
         if (!socketRegistered._classGuid) {
             throw new Error("SocketFunction.expose must be called with a classGuid");
         }
@@ -382,7 +401,7 @@ export class SocketFunction {
         exposeClass(socketRegistered);
         this.exposedClasses.add(socketRegistered._classGuid);
 
-        if (this.hasMounted) {
+        if (SocketFunction.mountState.get().hasMounted) {
             let mountCallbacks = SocketFunction.onMountCallbacks.get(socketRegistered._classGuid);
             for (let onMount of mountCallbacks || []) {
                 Promise.resolve(onMount()).catch(e => {
@@ -392,12 +411,26 @@ export class SocketFunction {
         }
     }
 
-    public static mountedNodeId: string = "";
+    // All mount state is shared across copies of this package, so a second mount (even from a
+    //  different copy) is rejected, and onMount/mountPromise observers fire once across them all.
+    //  See createSingleton.
+    private static mountState = createSingleton("SocketFunction.mountState", 1, () => {
+        let mountResolve!: () => void;
+        let mountPromise = new Promise<void>(resolve => mountResolve = resolve);
+        return {
+            hasMounted: false,
+            mountedNodeId: "",
+            mountedIP: "",
+            mountResolve,
+            mountPromise,
+        };
+    });
+    public static get mountedNodeId() { return SocketFunction.mountState.get().mountedNodeId; }
+    public static set mountedNodeId(value: string) { SocketFunction.mountState.get().mountedNodeId = value; }
     public static isMounted() { return !!this.mountedNodeId; }
-    public static mountedIP: string = "";
-    private static hasMounted = false;
-    private static onMountCallback: () => void = () => { };
-    public static mountPromise: Promise<void> = new Promise(r => this.onMountCallback = r);
+    public static get mountedIP() { return SocketFunction.mountState.get().mountedIP; }
+    public static set mountedIP(value: string) { SocketFunction.mountState.get().mountedIP = value; }
+    public static get mountPromise() { return SocketFunction.mountState.get().mountPromise; }
     public static async mount(config: SocketServerConfig) {
         if (this.mountedNodeId) {
             throw new Error("SocketFunction already mounted, mounting twice in one thread is not allowed.");
@@ -416,7 +449,7 @@ export class SocketFunction {
         await delay("immediate");
 
         this.mountedNodeId = await startSocketServer(config);
-        this.hasMounted = true;
+        SocketFunction.mountState.get().hasMounted = true;
         for (let classGuid of SocketFunction.exposedClasses) {
             let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
             if (!callbacks) continue;
@@ -424,7 +457,7 @@ export class SocketFunction {
                 await callback();
             }
         }
-        this.onMountCallback();
+        SocketFunction.mountState.get().mountResolve();
         return this.mountedNodeId;
     }
 
@@ -484,20 +517,19 @@ function getBootedEdgeNode() {
 }
 
 
-let socketContextSeqNum = 1;
-
 export function _setSocketContext<T>(
     caller: CallerContext,
     code: () => T,
 ) {
-    socketContextSeqNum++;
-    let seqNum = socketContextSeqNum;
-    SocketFunction.callerContext = caller;
+    let ctx = socketContext.get();
+    ctx.seqNum++;
+    let seqNum = ctx.seqNum;
+    ctx.caller = caller;
     try {
         return code();
     } finally {
-        if (seqNum === socketContextSeqNum) {
-            SocketFunction.callerContext = undefined;
+        if (seqNum === ctx.seqNum) {
+            ctx.caller = undefined;
         }
     }
 }

package/index.d.ts

@@ -46,8 +46,10 @@ declare module "socket-function/SocketFunction" {
         static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
         static WIRE_WARN_TIME: number;
         private static onMountCallbacks;
-        static exposedClasses: Set<string>;
-        static callerContext: CallerContext | undefined;
+        private static exposedClassesSingleton;
+        static get exposedClasses(): Set<string>;
+        static get callerContext(): CallerContext | undefined;
+        static set callerContext(value: CallerContext | undefined);
         static getCaller(): CallerContext;
         static harvestFailedCallCount: () => number;
         static getPendingCallCount: () => number;
@@ -91,12 +93,13 @@ declare module "socket-function/SocketFunction" {
          *      to add additional imports to ensure the register call runs.
          */
         static expose(socketRegistered: SocketRegistered): void;
-        static mountedNodeId: string;
+        private static mountState;
+        static get mountedNodeId(): string;
+        static set mountedNodeId(value: string);
         static isMounted(): boolean;
-        static mountedIP: string;
-        private static hasMounted;
-        private static onMountCallback;
-        static mountPromise: Promise<void>;
+        static get mountedIP(): string;
+        static set mountedIP(value: string);
+        static get mountPromise(): Promise<void>;
         static mount(config: SocketServerConfig): Promise<string>;
         /** Sets the default call when an http request is made, but no classGuid is set.
          *      NOTE: All other calls should be endpoint calls, even if those endpoints return a static file with an HTML content type.
@@ -816,6 +819,29 @@ declare module "socket-function/src/corsCheck" {
 
 }
 
+declare module "socket-function/src/createSingleton" {
+    export interface Singleton<T> {
+        get(): T;
+        set(value: T): void;
+    }
+    /** Stores a value on globalThis so it is shared across every copy of socket-function loaded in
+     *      the process, provided each copy passes the same name and version. Use this only for state
+     *      that MUST be process-global to stay correct when multiple compatible versions are installed
+     *      at once - ex, the registry of exposed classes, the node connection cache, and mount state.
+     *      Regular config and caches that are fine to keep per-copy should NOT use this.
+     *  - version is part of the identity. Bump it only when the shape of the stored value changes in a
+     *      way that makes an old and a new copy unable to safely share it. Copies that disagree on the
+     *      version get separate slots (so they will NOT share), which is the correct outcome, as they
+     *      can't interoperate - and we warn so the situation is visible.
+     *  - getDefault runs at most once per name+version, lazily, the first time get() is called.
+     *  - For a value that is mutated in place (a Map/Set/array/object), just call get() once and keep
+     *      the reference. For a value that gets reassigned (a primitive, or a whole-object swap), use
+     *      get()/set() at each access so every copy sees the latest.
+     */
+    export declare function createSingleton<T>(name: string, version: string | number, getDefault: () => T): Singleton<T>;
+
+}
+
 declare module "socket-function/src/fixLargeNetworkCalls" {
     export declare function markArrayAsSplitable<T>(data: T[]): T[];
     export declare function isSplitableArray<T>(data: T): data is T & (unknown[]);

package/package.json

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

package/src/callHTTPHandler.ts

@@ -7,11 +7,14 @@ import { gzip } from "zlib";
 import zlib from "zlib";
 import { formatNumberSuffixed, getRootDomain, sha256Hash } from "./misc";
 import { getClientNodeId, getNodeId } from "./nodeCache";
+import { createSingleton } from "./createSingleton";
 
-let defaultHTTPCall: CallType | undefined;
+// Shared across copies of this package, so the default HTTP call set through one copy is used by
+//  the HTTP handler of any other copy. See createSingleton.
+const defaultHTTPCall = createSingleton("callHTTPHandler.defaultHTTPCall", 1, () => ({ call: undefined as CallType | undefined }));
 
 export function setDefaultHTTPCall(call: CallType) {
-    defaultHTTPCall = call;
+    defaultHTTPCall.get().call = call;
 }
 
 export function getServerLocationFromRequest(request: http.IncomingMessage) {
@@ -49,7 +52,9 @@ export function getNodeIdsFromRequest(request: http.IncomingMessage) {
     return { nodeId, localNodeId };
 }
 
-let requests = new Map<CallerContext, http.IncomingMessage>();
+// Shared across copies of this package, so getCurrentHTTPRequest works even when the call was set
+//  up by a different copy's HTTP handler. See createSingleton.
+const requests = createSingleton("callHTTPHandler.requests", 1, () => new Map<CallerContext, http.IncomingMessage>()).get();
 export function getCurrentHTTPRequest(): http.IncomingMessage | undefined {
     return requests.get(SocketFunction.getCaller());
 }
@@ -139,10 +144,11 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
         let args: string | unknown[] | null = urlObj.searchParams.get("args");
 
         if (!classGuid) {
-            if (defaultHTTPCall) {
-                classGuid = defaultHTTPCall.classGuid;
-                functionName = defaultHTTPCall.functionName;
-                args = defaultHTTPCall.args;
+            let defaultCall = defaultHTTPCall.get().call;
+            if (defaultCall) {
+                classGuid = defaultCall.classGuid;
+                functionName = defaultCall.functionName;
+                args = defaultCall.args;
             } else {
                 throw new Error("Missing classGuid in URL query");
             }

package/src/callManager.ts

@@ -5,17 +5,20 @@ import { entries, isNode } from "./misc";
 import debugbreak from "debugbreak";
 import { measureBlock, measureWrap } from "./profiling/measure";
 import { formatTime } from "./formatting/format";
+import { createSingleton } from "./createSingleton";
 
-let classes: {
+// Shared across copies of this package, so a call routed through one copy can find a class
+//  (and its hooks) registered through another copy. See createSingleton.
+const classes = createSingleton("callManager.classes", 1, () => ({} as {
     [classGuid: string]: {
         controller: SocketExposedInterface;
         shape: SocketExposedShape;
     }
-} = {};
-let exposedClasses = new Set<string>();
+})).get();
+const exposedClasses = createSingleton("callManager.exposedClasses", 1, () => new Set<string>()).get();
 
-let globalHooks: SocketFunctionHook[] = [];
-let globalClientHooks: SocketFunctionClientHook[] = [];
+const globalHooks = createSingleton("callManager.globalHooks", 1, () => [] as SocketFunctionHook[]).get();
+const globalClientHooks = createSingleton("callManager.globalClientHooks", 1, () => [] as SocketFunctionClientHook[]).get();
 
 export function getCallFlags(call: CallType): FunctionFlags | undefined {
     return classes[call.classGuid]?.shape[call.functionName];
@@ -83,7 +86,8 @@ export function registerClass(classGuid: string, controller: SocketExposedInterf
     noFunctionMeasure?: boolean;
 }) {
     if (!globalThis.isHotReloading?.() && classes[classGuid]) {
-        throw new Error(`Class ${classGuid} already registered`);
+        console.warn(`Class ${classGuid} already registered. This is normal if you are using multiple copies of socket-function at once.`);
+        return;
     }
 
     if (!config?.noFunctionMeasure) {

package/src/createSingleton.d.ts

@@ -0,0 +1,19 @@
+export interface Singleton<T> {
+    get(): T;
+    set(value: T): void;
+}
+/** Stores a value on globalThis so it is shared across every copy of socket-function loaded in
+ *      the process, provided each copy passes the same name and version. Use this only for state
+ *      that MUST be process-global to stay correct when multiple compatible versions are installed
+ *      at once - ex, the registry of exposed classes, the node connection cache, and mount state.
+ *      Regular config and caches that are fine to keep per-copy should NOT use this.
+ *  - version is part of the identity. Bump it only when the shape of the stored value changes in a
+ *      way that makes an old and a new copy unable to safely share it. Copies that disagree on the
+ *      version get separate slots (so they will NOT share), which is the correct outcome, as they
+ *      can't interoperate - and we warn so the situation is visible.
+ *  - getDefault runs at most once per name+version, lazily, the first time get() is called.
+ *  - For a value that is mutated in place (a Map/Set/array/object), just call get() once and keep
+ *      the reference. For a value that gets reassigned (a primitive, or a whole-object swap), use
+ *      get()/set() at each access so every copy sees the latest.
+ */
+export declare function createSingleton<T>(name: string, version: string | number, getDefault: () => T): Singleton<T>;

package/src/createSingleton.ts

@@ -0,0 +1,76 @@
+// A namespace on globalThis that holds state shared across every copy of this package that
+//  happens to be loaded in the same process. When two (type-compatible) versions of
+//  socket-function end up installed at once - ex, as nested dependencies - each gets its own
+//  set of module instances, so module-level registries (exposed classes, the node connection
+//  cache, mount state, ...) would otherwise be split into disconnected copies, and a call
+//  routed through one copy wouldn't see a class registered through the other. Every copy of
+//  this file references the same string literal below, so they all read and write the same
+//  underlying store, letting compatible versions share that state instead.
+const GLOBAL_KEY = "__socketFunctionSingletons__";
+
+interface SingletonStore {
+    values: { [key: string]: unknown };
+    // name => the set of versions that have been requested, so we can warn when incompatible
+    //  versions are loaded together (which is the situation that makes sharing impossible).
+    versions: { [name: string]: Set<string> };
+}
+
+function getStore(): SingletonStore {
+    let store = (globalThis as any)[GLOBAL_KEY] as SingletonStore | undefined;
+    if (!store) {
+        store = { values: Object.create(null), versions: Object.create(null) };
+        (globalThis as any)[GLOBAL_KEY] = store;
+    }
+    return store;
+}
+
+export interface Singleton<T> {
+    get(): T;
+    set(value: T): void;
+}
+
+/** Stores a value on globalThis so it is shared across every copy of socket-function loaded in
+ *      the process, provided each copy passes the same name and version. Use this only for state
+ *      that MUST be process-global to stay correct when multiple compatible versions are installed
+ *      at once - ex, the registry of exposed classes, the node connection cache, and mount state.
+ *      Regular config and caches that are fine to keep per-copy should NOT use this.
+ *  - version is part of the identity. Bump it only when the shape of the stored value changes in a
+ *      way that makes an old and a new copy unable to safely share it. Copies that disagree on the
+ *      version get separate slots (so they will NOT share), which is the correct outcome, as they
+ *      can't interoperate - and we warn so the situation is visible.
+ *  - getDefault runs at most once per name+version, lazily, the first time get() is called.
+ *  - For a value that is mutated in place (a Map/Set/array/object), just call get() once and keep
+ *      the reference. For a value that gets reassigned (a primitive, or a whole-object swap), use
+ *      get()/set() at each access so every copy sees the latest.
+ */
+export function createSingleton<T>(
+    name: string,
+    version: string | number,
+    getDefault: () => T,
+): Singleton<T> {
+    const store = getStore();
+    const versionStr = String(version);
+    const key = `${name}@${versionStr}`;
+
+    let seenVersions = store.versions[name];
+    if (!seenVersions) {
+        seenVersions = store.versions[name] = new Set();
+    }
+    seenVersions.add(versionStr);
+    if (seenVersions.size > 1) {
+        console.warn(`socket-function: singleton ${JSON.stringify(name)} requested at multiple versions (${Array.from(seenVersions).join(", ")}). These copies will NOT share state, which usually means incompatible versions of a package are loaded at once.`);
+    }
+
+    return {
+        get(): T {
+            const values = store.values;
+            if (!(key in values)) {
+                values[key] = getDefault();
+            }
+            return values[key] as T;
+        },
+        set(value: T) {
+            store.values[key] = value;
+        },
+    };
+}

package/src/nodeCache.ts

@@ -3,6 +3,7 @@ import { MaybePromise } from "./types";
 import { lazy } from "./caching";
 import { SocketFunction } from "../SocketFunction";
 import { isNode } from "./misc";
+import { createSingleton } from "./createSingleton";
 
 // TODO: Add CallInstanceFactory.isClosed, so nodeCache can clean up old entries.
 //  This is only needed for memory management, and not for correctness. Entries never
@@ -67,8 +68,10 @@ export function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefine
 }
 
 // NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called
-// nodeId => 
-const nodeCache = new Map<string, MaybePromise<CallFactory>>();
+// nodeId =>
+// Shared across copies of this package, so connections established through one copy are reused
+//  by the others (instead of each copy opening its own duplicate connection). See createSingleton.
+const nodeCache = createSingleton("nodeCache", 1, () => new Map<string, MaybePromise<CallFactory>>()).get();
 
 // NOTE: Should be called directly inside call factory constructor whenever
 //      their nodeId changes (and on construction).