socket-function 0.8.1 → 0.8.4

package/SocketFunctionTypes.ts

@@ -33,13 +33,13 @@ export interface SocketFunctionHook<ExposedType extends SocketExposedInterface =
 export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
     call: CallType;
     context: SocketRegistered["context"];
-    // If the result is overriden, we continue evaluating hooks and perform the final call
+    // If the result is overriden, we continue evaluating hooks BUT NOT perform the final call
     overrideResult?: unknown;
 };
 
 export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
     call: CallType;
-    // If the result is overriden, we continue evaluating hooks and perform the final call
+    // If the result is overriden, we continue evaluating hooks BUT NOT perform the final call
     overrideResult?: unknown;
 };
 export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {

package/hot/HotReloadController.ts

@@ -0,0 +1,67 @@
+module.allowclient = true;
+
+import { SocketFunction } from "../SocketFunction";
+import { cache, lazy } from "../src/caching";
+import * as fs from "fs";
+
+/** Hot reloads server and client files, just trigger a refresh clientside,
+ *      while triggering per file re-evaluation and export updates serverside.
+ *      - Requires HotReloadController to be exposed both serverside and clientside.
+ */
+export function watchFilesAndTriggerHotReloading() {
+    setInterval(() => {
+        for (let module of Object.values(require.cache)) {
+            if (!module) continue;
+            hotReloadModule(module);
+        }
+    }, 5000);
+}
+
+
+const hotReloadModule = cache((module: NodeJS.Module) => {
+    if (!module.updateContents) return;
+    fs.watchFile(module.filename, { persistent: false, interval: 1000 }, (curr, prev) => {
+        if (curr.mtime.getTime() === prev.mtime.getTime()) return;
+        console.log(`Hot reloading due to change: ${module.filename}`);
+        module.updateContents?.();
+        triggerClientSideReload();
+    });
+});
+let reloadTriggering = false;
+let clientWatcherNodes = new Set<string>();
+function triggerClientSideReload() {
+    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(() => {
+                console.log(`Removing erroring client: ${clientNodeId}`);
+                clientWatcherNodes.delete(clientNodeId);
+            });
+        }
+    }, 300);
+}
+
+class HotReloadControllerBase {
+    async watchFiles() {
+        let callerId = HotReloadController.context.caller?.nodeId;
+        if (!callerId) {
+            throw new Error("No nodeId?");
+        }
+        clientWatcherNodes.add(callerId);
+    }
+    async fileUpdated() {
+        document.location.reload();
+    }
+}
+
+export const HotReloadController = SocketFunction.register(
+    "HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5",
+    new HotReloadControllerBase(),
+    {
+        watchFiles: {},
+        fileUpdated: {}
+    }
+);

package/package.json

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

package/src/callHTTPHandler.ts

@@ -175,8 +175,8 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
 
         // NOTE: Our ETag caching is only to reduce data sent on the wire, we evaluate the calls
         //  every time (so it is strictly a wire cache, not computation cache)
-        response.setHeader("cache-control", "private, s-maxage=0, max-age=0, must-revalidate");
         if (SocketFunction.httpETagCache) {
+            response.setHeader("cache-control", "private, s-maxage=0, max-age=0, must-revalidate");
             let hash = sha256Hash(resultBuffer);
             response.setHeader("ETag", hash);
             if (request.headers["if-none-match"] === hash) {