socket-function 0.155.0 → 0.157.0

package/SetProcessVariables.d.ts

@@ -0,0 +1 @@
+export {};

package/SocketFunction.d.ts

@@ -0,0 +1,104 @@
+/// <reference path="require/RequireController.d.ts" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
+import { SocketServerConfig } from "./src/webSocketServer";
+import { Args, MaybePromise } from "./src/types";
+import "./SetProcessVariables";
+type ExtractShape<ClassType, Shape> = {
+    [key in keyof ClassType]: (key extends keyof Shape ? ClassType[key] extends SocketExposedInterface[""] ? ClassType[key] : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never : "Function is in shape, but not in class");
+};
+export declare class SocketFunction {
+    static logMessages: boolean;
+    static trackMessageSizes: {
+        upload: ((size: number) => void)[];
+        download: ((size: number) => void)[];
+        callTimes: ((obj: {
+            start: number;
+            end: number;
+        }) => void)[];
+    };
+    static MAX_MESSAGE_SIZE: number;
+    static HTTP_ETAG_CACHE: boolean;
+    static silent: boolean;
+    static HTTP_COMPRESS: boolean;
+    static COEP: string;
+    static COOP: string;
+    static readonly WIRE_SERIALIZER: {
+        serialize: (obj: unknown) => MaybePromise<Buffer[]>;
+        deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
+    };
+    static WIRE_WARN_TIME: number;
+    private static onMountCallbacks;
+    static exposedClasses: Set<string>;
+    static callerContext: CallerContext | undefined;
+    static getCaller(): CallerContext;
+    static harvestFailedCallCount: () => number;
+    static getPendingCallCount: () => number;
+    static harvestCallTimes: () => {
+        start: number;
+        end: number;
+    }[];
+    static register<ClassInstance extends object, Shape extends SocketExposedShape<{
+        [key in keyof ClassInstance]: (...args: any[]) => Promise<unknown>;
+    }>, Statics>(classGuid: string, instance: ClassInstance | (() => ClassInstance), shapeFnc: () => Shape, defaultHooksFnc?: () => SocketExposedShape[""] & {
+        onMount?: () => MaybePromise<void>;
+    }, config?: {
+        /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */
+        noAutoExpose?: boolean;
+        statics?: Statics;
+        /** Skip timing functions calls. Useful if a lot of functions have wait time that
+                is unrelated to processing, and therefore their timings won't be useful.
+                - Also useful if our auto function wrapping code is breaking functionality,
+                    such as if you have a singleton function which you compare with ===,
+                    which will breaks because we replaced it with a wrapped measure function.
+        */
+        noFunctionMeasure?: boolean;
+    }): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics;
+    private static socketCache;
+    static rehydrateSocketCaller<Controller>(socketRegistered: SocketRegisterType<Controller>, shapeFnc?: () => SocketExposedShape): SocketRegistered<Controller>;
+    private static callFromGuid;
+    static onNextDisconnect(nodeId: string, callback: () => void): void;
+    static getLastDisconnectTime(nodeId: string): number | undefined;
+    static isNodeConnected(nodeId: string): boolean;
+    /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
+     *      as we have no way of knowing how to contain a nodeId).
+     *  */
+    static getHTTPCallLink(call: FullCallType): string;
+    private static ignoreExposeCount;
+    static ignoreExposeCalls<T>(code: () => Promise<T>): Promise<T>;
+    /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,
+     *      so the class type's module construction runs, which should trigger register. Otherwise you would have
+     *      to add additional imports to ensure the register call runs.
+     */
+    static expose(socketRegistered: SocketRegistered): void;
+    static mountedNodeId: string;
+    static isMounted(): boolean;
+    static mountedIP: string;
+    private static hasMounted;
+    private static onMountCallback;
+    static 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.
+     *          - However, to load new content, you should probably just use `require("./example.ts")`, which works on any files
+     *              clientside that have also been required serverside (and whitelisted with module.allowclient = true,
+     *              or with an `allowclient.flag` file in the directory or parent directory).
+    */
+    static setDefaultHTTPCall<Registered extends SocketRegistered, FunctionName extends keyof Registered["nodes"][""] & string>(registered: Registered, functionName: FunctionName, ...args: Args<Registered["nodes"][""][FunctionName]>): void;
+    static connect(location: {
+        address: string;
+        port: number;
+    }): string;
+    static browserNodeId(): string;
+    static getBrowserNodeId(): string;
+    static addGlobalHook(hook: SocketFunctionHook): void;
+    static addGlobalClientHook(hook: SocketFunctionClientHook): void;
+}
+declare global {
+    var BOOTED_EDGE_NODE: {
+        host: string;
+    } | undefined;
+}
+export declare function _setSocketContext<T>(caller: CallerContext, code: () => T): T;
+export {};

package/SocketFunction.ts

@@ -41,7 +41,7 @@ type ExtractShape<ClassType, Shape> = {
         ? ClassType[key] extends SocketExposedInterface[""]
         ? ClassType[key]
         : ClassType[key] extends Function ? "All exposed function must be async (or return a Promise)" : never
-        : "Function is in shape, but not in class"
+        : "Function has implementation but is not exposed in the SocketFunction.register call"
     );
 };
 

package/SocketFunctionTypes.d.ts

@@ -0,0 +1,86 @@
+/// <reference path="require/RequireController.d.ts" />
+import { getCallObj } from "./src/nodeProxy";
+import { Args, MaybePromise } from "./src/types";
+export declare const socket: unique symbol;
+export type SocketExposedInterface = {
+    [functionName: string]: (...args: any[]) => Promise<unknown>;
+};
+export type SocketInternalInterface = {
+    [functionName: string]: {
+        [getCallObj]: (...args: any[]) => FullCallType;
+        (...args: any[]): Promise<unknown>;
+    };
+};
+export type SocketExposedInterfaceClass = {
+    new (): unknown;
+    prototype: unknown;
+};
+export type FunctionFlags = {
+    compress?: boolean;
+    /** Indicates with the same input, we give the same output, forever,
+     *      independent of code changes. This only works for data storage.
+     */
+    dataImmutable?: boolean;
+    /** Allows overriding SocketFunction.MAX_MESSAGE_SIZE for responses from this function. */
+    responseLimit?: number;
+};
+export type SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+    [functionName in keyof ExposedType]?: FunctionFlags & {
+        hooks?: SocketFunctionHook[];
+        clientHooks?: SocketFunctionClientHook[];
+        noDefaultHooks?: boolean;
+        /** BUG: I think this is broken if it is on the default hooks function? */
+        noClientHooks?: boolean;
+    };
+};
+export type FncType = (...args: any[]) => Promise<unknown>;
+export interface CallType<FncT extends FncType = FncType, FncName extends string = string> {
+    classGuid: string;
+    functionName: FncName;
+    args: unknown[];
+}
+export interface FullCallType<FncT extends FncType = FncType, FncName extends string = string> extends CallType<FncT, FncName> {
+    nodeId: string;
+}
+export interface SocketFunctionHook {
+    (config: HookContext): MaybePromise<void>;
+    /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
+    clientHook?: SocketFunctionClientHook;
+}
+export type HookContext = {
+    call: FullCallType;
+    overrideResult?: unknown;
+    onResult: ((result: unknown) => MaybePromise<void>)[];
+};
+export type ClientHookContext = {
+    call: FullCallType;
+    overrideResult?: unknown;
+    onResult: ((result: unknown) => MaybePromise<void>)[];
+    connectionId: {
+        nodeId: string;
+    };
+};
+export interface SocketFunctionClientHook {
+    (config: ClientHookContext): MaybePromise<void>;
+}
+export interface SocketRegisterType<ExposedType = any> {
+    _classGuid: string;
+    _internalType: ExposedType;
+}
+export interface SocketRegistered<ExposedType = any> {
+    nodes: {
+        [nodeId: string]: {
+            [functionName in keyof ExposedType]: ExposedType[functionName] & {
+                [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
+            };
+        };
+    };
+    _classGuid: string;
+    _internalType: ExposedType;
+}
+export type ControllerPick<T extends SocketRegistered, K extends keyof T["_internalType"]> = (SocketRegistered<Pick<T["_internalType"], K>>);
+export type CallerContext = Readonly<CallerContextBase>;
+export type CallerContextBase = {
+    nodeId: string;
+    localNodeId: string;
+};

package/generateIndexDts.js

@@ -0,0 +1,52 @@
+const fs = require("fs");
+const path = require("path");
+
+function getAllDtsFiles(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+        if (file === "node_modules") continue;
+        if (file === "dist") continue;
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+
+        if (stat.isDirectory()) {
+            getAllDtsFiles(filePath, fileList);
+        } else if (file.endsWith(".d.ts")) {
+            fileList.push(filePath);
+        }
+    }
+
+    return fileList;
+}
+
+function generateIndexDts() {
+    const renderUtilsPath = __dirname;
+    const dtsFiles = getAllDtsFiles(renderUtilsPath);
+
+    const modules = dtsFiles
+        .map(filePath => {
+            const relativePath = path.relative(renderUtilsPath, filePath);
+            const withoutExt = relativePath.replace(/\.d\.ts$/, "");
+            const modulePath = "socket-function/" + withoutExt.replace(/\\/g, "/");
+
+            const content = fs.readFileSync(filePath, "utf8");
+            const indentedContent = content
+                .split("\n")
+                .map(line => line ? "    " + line : line)
+                .join("\n");
+
+            return `declare module "${modulePath}" {\n${indentedContent}\n}`;
+        })
+        .sort()
+        .join("\n\n");
+
+    const outputPath = path.join(__dirname, "index.d.ts");
+    const header = `// Auto-generated file. Do not edit manually.\n// Generated by: yarn generate-index-dts\n\n`;
+
+    fs.writeFileSync(outputPath, header + modules + "\n", "utf8");
+    console.log(`Generated ${outputPath} with ${dtsFiles.length} module declarations`);
+}
+
+generateIndexDts();
+

package/hot/HotReloadController.d.ts

@@ -0,0 +1,34 @@
+/// <reference path="../../typenode/index.d.ts" />
+/// <reference path="../require/RequireController.d.ts" />
+/** Enables some hot reload functionality.
+ *      - Triggers a refresh clientside
+ *      - Triggers a reload server, for modules marked with `module.hotreload`
+ */
+export declare function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch?: boolean): void;
+declare global {
+    namespace NodeJS {
+        interface Module {
+            /** Causes us to hotreload the file. Applies both serverside and clientside.
+             *      - If not set for any files clientside, we will refresh.
+             *      - If not set for any files serverside, we will do nothing (and just leave old code running).
+             */
+            hotreload?: boolean;
+            /** Overrides hotreload to disable hot reloading. Useful if you add "hotreload.flag" to a directory
+             *      (which sets hotreload on all files in and under that directory), but want a specific file
+             *      to not hotreload.
+             *  - Also useful if you want files to hotreload clientside, but not serverside.
+             */
+            noserverhotreload?: boolean;
+            watchAdditionalFiles?: string[];
+        }
+    }
+    var isHotReloading: (() => boolean) | undefined;
+}
+export declare function isHotReloading(): boolean;
+export declare function hotReloadingGuard(): true;
+export declare function setExternalHotReloading(value: boolean): void;
+export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
+export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
+    watchFiles: () => Promise<void>;
+    fileUpdated: (files: string[], changeTime: number) => Promise<void>;
+}>;

package/hot/HotReloadController.ts

@@ -188,6 +188,8 @@ class HotReloadControllerBase {
         let callerId = SocketFunction.getCaller().nodeId;
         clientWatcherNodes.add(callerId);
     }
+    // TODO: This is actually broken related to lazy loaded and server-only code, as the server will tell us a file changed, and then we'll see that we don't have it loaded, and so we will try to refresh.
+    //      - The reason we refresh is because it might be a new file. I don't know how we could check to see if it was lazy loaded. Maybe we just shouldn't refresh ever if we can't find the module? We'll see how much we run into the extra refresh due to lazy loading...
     async fileUpdated(files: string[], changeTime: number) {
         try {
             console.groupCollapsed(magenta(`Trigger hotreload for files ${formatTime(Date.now() - changeTime)} after file change`));