socket-function 0.12.3 → 0.12.4

package/SocketFunction.ts

@@ -211,7 +211,7 @@ export class SocketFunction {
      *      to add additional imports to ensure the register call runs.
      */
     public static expose(socketRegistered: SocketRegistered) {
-        console.log(blue(`Exposing Controller ${socketRegistered._classGuid}`));
+        console.log(`Exposing Controller ${blue(socketRegistered._classGuid)}`);
         exposeClass(socketRegistered);
         this.exposedClasses.add(socketRegistered._classGuid);
 
@@ -257,7 +257,12 @@ export class SocketFunction {
         return this.mountedNodeId;
     }
 
-    /** Sets the default call when an http request is made, but no classGuid is set. */
+    /** 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).
+    */
     public static setDefaultHTTPCall<
         Registered extends SocketRegistered,
         FunctionName extends keyof Registered["nodes"][""] & string,

package/hot/HotReloadController.ts

@@ -7,7 +7,7 @@ import { cache, lazy } from "../src/caching";
 import * as fs from "fs";
 import debugbreak from "debugbreak";
 import { isNode } from "../src/misc";
-import { red } from "../src/formatting/logColors";
+import { magenta, red } from "../src/formatting/logColors";
 
 /** Enables some hot reload functionality.
  *      - Triggers a refresh clientside
@@ -35,8 +35,13 @@ export function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch = false
 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;
-            noserverhotreload?: boolean;
+            /** Only hotreloads the file in the browser. */
+            hotreloadBrowser?: boolean;
         }
     }
 }
@@ -48,10 +53,20 @@ export function isHotReloading() {
 export function setExternalHotReloading(value: boolean) {
     isHotReloadingValue = value;
 }
+let hotReloadCallbacks: ((modules: NodeJS.Module[]) => void)[] = [];
+export function onHotReload(callback: (modules: NodeJS.Module[]) => void) {
+    hotReloadCallbacks.push(callback);
+}
 
 const hotReloadModule = cache((module: NodeJS.Module) => {
     if (!module.updateContents) return;
-    fs.watchFile(module.filename, { persistent: false, interval: 1000 }, (curr, prev) => {
+    let interval = 1000;
+    let fast = false;
+    if (module.hotreload || module.hotreloadBrowser) {
+        interval = 50;
+        fast = true;
+    }
+    fs.watchFile(module.filename, { persistent: false, interval }, (curr, prev) => {
         if (curr.mtime.getTime() === prev.mtime.getTime()) return;
         console.log(`Hot reloading due to change: ${module.filename}`);
         module.updateContents?.();
@@ -75,24 +90,32 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
                 }
             }
         }
-        triggerClientSideReload();
+        triggerClientSideReload({
+            files: [module.filename],
+            changeTime: curr.mtimeMs,
+            fast,
+        });
     });
 });
 let reloadTriggering = false;
 let clientWatcherNodes = new Set<string>();
-function triggerClientSideReload() {
+function triggerClientSideReload(config: {
+    files: string[];
+    changeTime: number;
+    fast?: boolean;
+}) {
     if (reloadTriggering) return;
     reloadTriggering = true;
     setTimeout(async () => {
         reloadTriggering = false;
         for (let clientNodeId of clientWatcherNodes) {
             console.log(`Notifying client of hot reload: ${clientNodeId}`);
-            HotReloadController.nodes[clientNodeId].fileUpdated().catch(() => {
+            HotReloadController.nodes[clientNodeId].fileUpdated(config.files, config.changeTime).catch(() => {
                 console.log(`Removing erroring client: ${clientNodeId}`);
                 clientWatcherNodes.delete(clientNodeId);
             });
         }
-    }, 300);
+    }, config.fast ? 10 : 300);
 }
 
 class HotReloadControllerBase {
@@ -102,8 +125,36 @@ class HotReloadControllerBase {
         let callerId = SocketFunction.getCaller().nodeId;
         clientWatcherNodes.add(callerId);
     }
-    async fileUpdated() {
-        document.location.reload();
+    async fileUpdated(files: string[], changeTime: number) {
+        console.groupCollapsed(magenta(`Trigger hotreload for files (${Date.now() - changeTime}ms after file change)`));
+        for (let file of files) {
+            console.log(file);
+        }
+        console.groupEnd();
+        let modules: NodeJS.Module[] = [];
+        for (let file of files) {
+            let module = require.cache[file];
+            if (!module) {
+                console.log(`Module not found: ${file}, reloading page to ensure new version is loaded`);
+                document.location.reload();
+                return;
+            }
+            if (!module.hotreload && !module.hotreloadBrowser) {
+                console.log(`Module not hotreloadable: ${file}, reloading page to ensure new version is loaded`);
+                document.location.reload();
+                return;
+            }
+            modules.push(module);
+        }
+        for (let module of modules) {
+            module.loaded = false;
+        }
+        await Promise.all(modules.map(module => module.load(module.filename)));
+
+        for (let callback of hotReloadCallbacks) {
+            callback(modules);
+        }
+        console.log(magenta(`Hot reload complete (${Date.now() - changeTime}ms after file change)`));
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.12.3",
+	"version": "0.12.4",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/require/RequireController.ts

@@ -98,13 +98,17 @@ function addMapGetModules(remap: typeof mapGetModules[number]["remap"]) {
 class RequireControllerBase {
     public rootResolvePath = "";
 
-    public async requireHTML(bootRequirePath?: string) {
+    public async requireHTML(config?: {
+        requireCalls?: string[];
+    }) {
+        let { requireCalls } = config || {};
         let result = resolvedHTMLFile;
         if (beforeEntryText.length > 0) {
             result = result.replace(BEFORE_ENTRY_TEMPLATE, beforeEntryText.join("\n"));
         }
-        if (bootRequirePath) {
-            result = result.replace(ENTRY_TEMPLATE, `<script>require(${JSON.stringify(bootRequirePath)});</script>`);
+        if (requireCalls) {
+            result = result.replace(ENTRY_TEMPLATE, `<script>\n${requireCalls.map(x => `require(${JSON.stringify(x)});`).join(" \n")
+                }</script>`);
         }
         return setHTTPResultHeaders(Buffer.from(result), { "Content-Type": "text/html" });
     }

package/require/require.js

@@ -245,22 +245,27 @@
                 return builtInModuleExports[request];
             }
 
-            if (!(request in serializedModule.requests)) {
-                if (!asyncIsFine) {
-                    console.warn(`Accessed unexpected module %c${request}%c in %c${module.id}%c\n\tTreating it as an async require.\n\tAll modules require synchronously clientside must be required serverside at a module level.`,
-                        "color: red", "color: unset",
-                        "color: red", "color: unset",
-                    );
+            let resolvedPath;
+            if (request in moduleCache) {
+                resolvedPath = request;
+            } else {
+                if (!(request in serializedModule.requests)) {
+                    if (!asyncIsFine) {
+                        console.warn(`Accessed unexpected module %c${request}%c in %c${module.id}%c\n\tTreating it as an async require.\n\tAll modules require synchronously clientside must be required serverside at a module level.`,
+                            "color: red", "color: unset",
+                            "color: red", "color: unset",
+                        );
+                    }
+                    return rootRequire(request);
                 }
-                return rootRequire(request);
-            }
 
-            // Built in modules that we haven't been implemented
-            if (serializedModule.requests[request] === "") {
-                return {};
-            }
+                // Built in modules that we haven't been implemented
+                if (serializedModule.requests[request] === "") {
+                    return {};
+                }
 
-            let resolvedPath = serializedModule.requests[request];
+                resolvedPath = serializedModule.requests[request];
+            }
             if (resolvedPath !== "NOTALLOWEDCLIENTSIDE" && !serializedModules[resolvedPath]) {
                 if (!asyncIsFine) {
                     console.warn(`Accessed unexpected module %c${request}%c in %c${module.id}%c\n\tTreating it as an async require.\n\tAll modules require synchronously clientside must be required serverside at a module level.`,
@@ -381,11 +386,10 @@
                     delete alreadyHave.seqNums[serializedModule.seqNum];
                 }
                 // NOTE: There is almost never recovery from module downloading errors, so just don't catch them
-                void Promise.resolve().then(() => rootRequire(resolvedId, true)).then(() => {
+                return Promise.resolve().then(() => rootRequire(resolvedId, true)).then(async () => {
                     module.loaded = true;
-                    load();
+                    await load();
                 });
-                return;
             }
 
             module.requires = serializedModule.requests;

package/src/webSocketServer.ts

@@ -16,6 +16,7 @@ import { delay, runInfinitePoll } from "./batching";
 import { magenta } from "./formatting/logColors";
 import { yellow } from "./formatting/logColors";
 import { green } from "./formatting/logColors";
+import { formatTime } from "./formatting/format";
 
 export type SocketServerConfig = (
     https.ServerOptions & {
@@ -210,21 +211,21 @@ export async function startSocketServer(
     }
 
     let port = config.port;
+    async function isPortInUse(port: number): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            let server = net.createServer();
+            server.listen(port, host)
+                .on("listening", function () {
+                    server.close();
+                    resolve(false);
+                }).on("close", function () {
+                    resolve(true);
+                }).on("error", function (e) {
+                    resolve(true);
+                });
+        });
+    }
     if (config.useAvailablePortIfPortInUse && port) {
-        async function isPortInUse(port: number): Promise<boolean> {
-            return new Promise<boolean>((resolve, reject) => {
-                let server = net.createServer();
-                server.listen(port, host)
-                    .on("listening", function () {
-                        server.close();
-                        resolve(false);
-                    }).on("close", function () {
-                        resolve(true);
-                    }).on("error", function (e) {
-                        resolve(true);
-                    });
-            });
-        }
         if (await isPortInUse(port)) {
             port = 0;
         }
@@ -239,7 +240,7 @@ export async function startSocketServer(
 
     port = (realServer.address() as net.AddressInfo).port;
     let nodeId = getNodeId(getCommonName(config.cert), port);
-    console.log(green(`Started Listening on ${nodeId}`));
+    console.log(green(`Started Listening on ${nodeId} after ${formatTime(process.uptime() * 1000)}`));
 
     return nodeId;
 }