socket-function 0.8.16 → 0.8.18

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

@@ -34,9 +34,9 @@ export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefi
     };
 }
 
-export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: Key) => Promise<Output>): {
-    (key: Key): Output | undefined;
-    invalidate(key: Key): void;
+export function asyncObservable<Output, Args extends any[]>(maxCount: number, getValue: (...args: Args) => Promise<Output>): {
+    (...args: Args): Output | undefined;
+    invalidate(...args: Args): void;
     invalidateAll(): void;
 } {
     let invalidateAllSeqNum = observable({ seqNum: 1 }, undefined, { deep: false, proxy: false });
@@ -46,8 +46,8 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
         seqNum: { value: number };
     }>();
 
-    get["invalidate"] = (key: Key) => {
-        let hash = JSON.stringify(key);
+    get["invalidate"] = (...args: Args) => {
+        let hash = JSON.stringify(args);
         let value = values.get(hash);
         if (!value) return;
         values.delete(hash);
@@ -59,9 +59,9 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
         values.clear();
         invalidateAllSeqNum.seqNum++;
     };
-    function get(key: Key) {
+    function get(...args: Args) {
 
-        let hash = JSON.stringify(key);
+        let hash = JSON.stringify(args);
         let value = values.get(hash);
         if (!value) {
 
@@ -79,7 +79,7 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
             }
 
             // We call inside another function so that synchronous errors still get wrapped in the observable
-            let valueObs = promiseToObservable((async () => getValue(key))());
+            let valueObs = promiseToObservable((async () => getValue(...args))());
             value = {
                 valueObs,
                 seqNum: observable({ value: 1 }, undefined, { deep: false, proxy: false }),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.8.16",
+	"version": "0.8.18",
 	"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`);