socket-function 0.8.15 → 0.8.17

package/SocketFunctionTypes.ts

@@ -23,6 +23,10 @@ export type SocketExposedInterfaceClass = {
 };
 export interface SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
     [functionName: string]: {
+        /** Indicates with the same input, we give the same output, forever,
+         *      independent of code changes. This only works for data storage.
+         */
+        dataImmutable?: boolean;
         hooks?: SocketFunctionHook<ExposedType, CallContext>[];
         clientHooks?: SocketFunctionClientHook<ExposedType, CallContext>[];
     };

package/mobx/promiseToObservable.tsx

@@ -39,11 +39,12 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
     invalidate(key: Key): void;
     invalidateAll(): void;
 } {
-    // NOTE: Not very efficient (invalidates too much), but... makes triggering invalidations much faster/easier,
-    //  making an invalidate depend on the total render time, not the total cached state size.
-    let invalidateSeqNum = observable({ seqNum: 1 }, undefined, { deep: false, proxy: false });
+    let invalidateAllSeqNum = observable({ seqNum: 1 }, undefined, { deep: false, proxy: false });
     let startingCalculating = new Set<string>();
-    let values = new Map<string, { value: Output | undefined }>();
+    let values = new Map<string, {
+        valueObs: { value: Output | undefined };
+        seqNum: { value: number };
+    }>();
 
     get["invalidate"] = (key: Key) => {
         let hash = JSON.stringify(key);
@@ -51,37 +52,43 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
         if (!value) return;
         values.delete(hash);
         startingCalculating.delete(hash);
-        invalidateSeqNum.seqNum++;
+        value.seqNum.value++;
     };
     get["invalidateAll"] = () => {
         startingCalculating.clear();
         values.clear();
-        invalidateSeqNum.seqNum++;
+        invalidateAllSeqNum.seqNum++;
     };
     function get(key: Key) {
-        invalidateSeqNum.seqNum;
+
         let hash = JSON.stringify(key);
         let value = values.get(hash);
-        if (value) {
-            return value.value;
-        }
-        if (startingCalculating.has(hash)) {
-            throw new Error(`Cyclic access in cache`);
-        }
-        startingCalculating.add(hash);
+        if (!value) {
 
-        // Not very efficient, but clearing the entire state is a lot easier to do then
-        //  keep track of the order they are accessed (and it does make MOST accesses
-        //  MUCH faster).
-        if (values.size >= maxCount) {
-            values.clear();
-            startingCalculating.clear();
-        }
+            if (startingCalculating.has(hash)) {
+                throw new Error(`Cyclic access in cache`);
+            }
+            startingCalculating.add(hash);
+
+            // Not very efficient, but clearing the entire state is a lot easier to do then
+            //  keep track of the order they are accessed (and it does make MOST accesses
+            //  MUCH faster).
+            if (values.size >= maxCount) {
+                values.clear();
+                startingCalculating.clear();
+            }
 
-        // We call inside another function so that synchronous errors still get wrapped in the observable
-        value = promiseToObservable((async () => getValue(key))());
-        values.set(hash, value);
-        return value.value;
+            // We call inside another function so that synchronous errors still get wrapped in the observable
+            let valueObs = promiseToObservable((async () => getValue(key))());
+            value = {
+                valueObs,
+                seqNum: observable({ value: 1 }, undefined, { deep: false, proxy: false }),
+            };
+            values.set(hash, value);
+        }
+        invalidateAllSeqNum.seqNum;
+        value.seqNum.value;
+        return value.valueObs.value;
     }
     return get;
 }

package/package.json

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

package/src/callHTTPHandler.ts

@@ -3,7 +3,7 @@ import http from "http";
 import net from "net";
 import tls from "tls";
 import { CallerContext, CallType, NetworkLocation, setCertInfo } from "../SocketFunctionTypes";
-import { performLocalCall } from "./callManager";
+import { isDataImmutable, performLocalCall } from "./callManager";
 import { getNodeIdRaw } from "./nodeAuthentication";
 import debugbreak from "debugbreak";
 import * as cookie from "cookie";
@@ -150,6 +150,22 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
             args,
         };
 
+        if (isDataImmutable(call)) {
+            /** ETag cache, BUT, hashes only the input. Only valid for fully immutable resources
+             *      (ex data storage, as any endpoints that run code could have that code change).
+             *      - Shouldn't be needed, but I am seeing chrome fail to cache a lot of requests,
+             *          which could cost us multiple dollars in server costs from atlas.
+            */
+            response.setHeader("cache-control", "public, max-age=15206400, immutable");
+            let hash = sha256Hash(Buffer.from(JSON.stringify(call)));
+            response.setHeader("ETag", hash);
+            if (request.headers["if-none-match"] === hash) {
+                response.writeHead(304);
+                console.log(`CACHED Immutable HTTP response (${request.method}) ${url}`);
+                return;
+            }
+        }
+
         let result = await performLocalCall({
             caller,
             call
@@ -174,9 +190,9 @@ 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)
+        //  every time (so it is strictly a wire cache, not a computation cache)
         if (SocketFunction.httpETagCache) {
-            response.setHeader("cache-control", "private, s-maxage=0, max-age=0, must-revalidate");
+            response.setHeader("cache-control", "private, max-age=0, must-revalidate");
             let hash = sha256Hash(resultBuffer);
             response.setHeader("ETag", hash);
             if (request.headers["if-none-match"] === hash) {

package/src/callManager.ts

@@ -53,6 +53,10 @@ export async function performLocalCall(
     return await result;
 }
 
+export function isDataImmutable(call: CallType) {
+    return !!classes[call.classGuid]?.shape[call.functionName]?.dataImmutable;
+}
+
 export function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape) {
     if (classes[classGuid]) {
         throw new Error(`Class ${classGuid} already registered`);