socket-function 1.0.2 → 1.0.4

package/SocketFunction.d.ts

@@ -1,5 +1,6 @@
 /// <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";

package/generateIndexDts.js

@@ -24,7 +24,7 @@ function generateIndexDts() {
     const renderUtilsPath = __dirname;
     const dtsFiles = getAllDtsFiles(renderUtilsPath);
 
-    const excludedModules = ["socket-function/SocketFunction", "socket-function/index"];
+    const excludedModules = ["socket-function/index"];
 
     const modules = dtsFiles
         .map(filePath => {
@@ -45,6 +45,15 @@ function generateIndexDts() {
                 }
             );
 
+            // Resolve dynamic imports like import("../path")
+            content = content.replace(
+                /import\(["'](\.[^"']+)["']\)/g,
+                (match, relativeImport) => {
+                    const absoluteModulePath = path.join(moduleDir, relativeImport).replace(/\\/g, "/");
+                    return `import("${absoluteModulePath}")`;
+                }
+            );
+
             const indentedContent = content
                 .split("\n")
                 .map(line => line ? "    " + line : line)

package/index.d.ts

@@ -6,6 +6,114 @@ declare module "socket-function/SetProcessVariables" {
 
 }
 
+declare module "socket-function/SocketFunction" {
+    /// <reference path="require/RequireController.d.ts" />
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "socket-function/SocketFunctionTypes";
+    import { SocketServerConfig } from "socket-function/src/webSocketServer";
+    import { Args, MaybePromise } from "socket-function/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 has implementation but is not exposed in the SocketFunction.register call");
+    };
+    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 {};
+
+}
+
 declare module "socket-function/SocketFunctionTypes" {
     /// <reference path="require/RequireController.d.ts" />
     import { getCallObj } from "socket-function/src/nodeProxy";
@@ -127,7 +235,7 @@ declare module "socket-function/hot/HotReloadController" {
     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<{
+    export declare const HotReloadController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
         watchFiles: () => Promise<void>;
         fileUpdated: (files: string[], changeTime: number) => Promise<void>;
     }>;
@@ -194,6 +302,7 @@ declare module "socket-function/require/CSSShim" {
 declare module "socket-function/require/RequireController" {
     /// <reference path="../../typenode/index.d.ts" />
     /// <reference types="node" />
+    /// <reference types="node" />
     declare global {
         namespace NodeJS {
             interface Module {
@@ -272,7 +381,7 @@ declare module "socket-function/require/RequireController" {
     /** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
     export declare function setRequireBootRequire(dir: string): void;
     export declare function allowAllNodeModules(): void;
-    export declare const RequireController: import("../SocketFunctionTypes").SocketRegistered<{
+    export declare const RequireController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
         rootResolvePath: "Function has implementation but is not exposed in the SocketFunction.register call";
         requireHTML: (config?: {
             requireCalls?: string[];
@@ -317,6 +426,7 @@ declare module "socket-function/require/compileFlags" {
 }
 
 declare module "socket-function/require/extMapper" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export declare function getExtContentType(ext: string): string;
     export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;
@@ -342,6 +452,7 @@ declare module "socket-function/require/require" {
 }
 
 declare module "socket-function/src/CallFactory" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import { CallType } from "socket-function/SocketFunctionTypes";
@@ -382,6 +493,7 @@ declare module "socket-function/src/CallFactory" {
 }
 
 declare module "socket-function/src/JSONLACKS/JSONLACKS" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export interface JSONLACKS_ParseConfig {
         extended?: boolean;
@@ -528,6 +640,7 @@ declare module "socket-function/src/caching" {
 }
 
 declare module "socket-function/src/callHTTPHandler" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import http from "http";
@@ -582,6 +695,7 @@ declare module "socket-function/src/callManager" {
 }
 
 declare module "socket-function/src/certStore" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /** Must be populated before the server starts */
     export declare function trustCertificate(cert: string | Buffer): void;
@@ -695,6 +809,7 @@ declare module "socket-function/src/forwardPort" {
 }
 
 declare module "socket-function/src/https" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
         headers?: {
@@ -706,6 +821,7 @@ declare module "socket-function/src/https" {
 }
 
 declare module "socket-function/src/misc" {
+    /// <reference types="node" />
     /// <reference types="node" />
     import { MaybePromise } from "socket-function/src/types";
     export declare const timeInSecond = 1000;
@@ -1116,6 +1232,7 @@ declare module "socket-function/src/storagePath" {
 }
 
 declare module "socket-function/src/tlsParsing" {
+    /// <reference types="node" />
     /// <reference types="node" />
     export declare function parseTLSHello(buffer: Buffer): {
         extensions: {
@@ -1140,6 +1257,7 @@ declare module "socket-function/src/types" {
 }
 
 declare module "socket-function/src/webSocketServer" {
+    /// <reference types="node" />
     /// <reference types="node" />
     /// <reference types="node" />
     import https from "https";

package/package.json

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

package/require/RequireController.d.ts

@@ -1,5 +1,6 @@
 /// <reference path="../../typenode/index.d.ts" />
 /// <reference types="node" />
+/// <reference types="node" />
 declare global {
     namespace NodeJS {
         interface Module {

package/require/extMapper.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export declare function getExtContentType(ext: string): string;
 export declare function getContentTypeFromBuffer(buffer: Buffer): string | undefined;

package/src/CallFactory.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { CallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
 import * as tls from "tls";

package/src/JSONLACKS/JSONLACKS.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export interface JSONLACKS_ParseConfig {
     extended?: boolean;
     discardMissingReferences?: boolean;

package/src/callHTTPHandler.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import http from "http";
 import { CallType } from "../SocketFunctionTypes";
 export declare function setDefaultHTTPCall(call: CallType): void;

package/src/certStore.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 /** Must be populated before the server starts */
 export declare function trustCertificate(cert: string | Buffer): void;
 export declare function getTrustedCertificates(): string[];

package/src/https.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export declare function httpsRequest(url: string, payload?: Buffer | Buffer[], method?: string, sendSessionCookies?: boolean, config?: {
     headers?: {
         [key: string]: string | undefined;

package/src/misc.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { MaybePromise } from "./types";
 export declare const timeInSecond = 1000;
 export declare const timeInMinute: number;

package/src/tlsParsing.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 export declare function parseTLSHello(buffer: Buffer): {
     extensions: {
         type: number;

package/src/webSocketServer.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import https from "https";
 import { Watchable } from "./misc";
 export type SocketServerConfig = (https.ServerOptions & {