socket-function 0.8.18 → 0.8.20

package/SocketFunctionTypes.ts

@@ -3,7 +3,7 @@ module.allowclient = true;
 import debugbreak from "debugbreak";
 import * as tls from "tls";
 import { getCallObj } from "./src/nodeProxy";
-import { Args } from "./src/types";
+import { Args, MaybePromise } from "./src/types";
 
 export const socket = Symbol("socket");
 
@@ -45,7 +45,7 @@ export interface FullCallType extends CallType {
 }
 
 export interface SocketFunctionHook<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
-    (config: HookContext<ExposedType, CallContext>): Promise<void>;
+    (config: HookContext<ExposedType, CallContext>): MaybePromise<void>;
 }
 export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
     call: CallType;
@@ -60,7 +60,7 @@ export type ClientHookContext<ExposedType extends SocketExposedInterface = Socke
     overrideResult?: unknown;
 };
 export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
-    (config: ClientHookContext<ExposedType, CallContext>): Promise<void>;
+    (config: ClientHookContext<ExposedType, CallContext>): MaybePromise<void>;
 }
 
 export type CallContextType = {

package/mobx/promiseToObservable.tsx

@@ -1,16 +1,22 @@
 import { observable, Reaction, IObservable } from "mobx";
 import { cacheLimited } from "../src/caching";
 
-export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefined } {
+interface InternalResult {
+    result: { value: unknown } | undefined;
+}
+export function promiseToObservable<T>(promise: Promise<T>, staleValue?: T): { value: T | undefined } {
     let isDone = false;
     let error: unknown;
     let result: T | undefined;
 
+    let internalResult: InternalResult = { result: undefined };
+
     let isDoneTrigger = observable({
         value: false
     });
     promise.then(
         r => {
+            internalResult.result = { value: r };
             result = r;
             isDoneTrigger.value = true;
             isDone = true;
@@ -22,16 +28,16 @@ export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefi
         }
     );
 
-    return {
+    return Object.assign({
         get value() {
             if (isDone) {
                 if (error) throw error;
                 return result;
             }
             isDoneTrigger.value;
-            return undefined;
+            return staleValue;
         }
-    };
+    }, { internalResult });
 }
 
 export function asyncObservable<Output, Args extends any[]>(maxCount: number, getValue: (...args: Args) => Promise<Output>): {
@@ -45,22 +51,37 @@ export function asyncObservable<Output, Args extends any[]>(maxCount: number, ge
         valueObs: { value: Output | undefined };
         seqNum: { value: number };
     }>();
+    let staleValues = new Map<string, Output>();
 
     get["invalidate"] = (...args: Args) => {
         let hash = JSON.stringify(args);
         let value = values.get(hash);
         if (!value) return;
+        // Access the value specially, to prevent causing a mobx subscription
+        let internalValue = (value.valueObs as any as { internalResult: InternalResult }).internalResult;
+        if (internalValue.result) {
+            staleValues.set(hash, internalValue.result.value as any);
+        }
         values.delete(hash);
         startingCalculating.delete(hash);
         value.seqNum.value++;
     };
     get["invalidateAll"] = () => {
+        // HACK: It sucks to have to iterate over everything, but... our maxCount is limited anyway, so... hopefully it isn't too slow?
+        //  TODO: If we are iterating anyway... we should probably just store a LRU queue for cache eviction...
+        for (let [hash, value] of values) {
+            // Access the value specially, to prevent causing a mobx subscription
+            let internalValue = (value.valueObs as any as { internalResult: InternalResult }).internalResult;
+            if (internalValue.result) {
+                staleValues.set(hash, internalValue.result.value as any);
+            }
+        }
+
         startingCalculating.clear();
         values.clear();
         invalidateAllSeqNum.seqNum++;
     };
     function get(...args: Args) {
-
         let hash = JSON.stringify(args);
         let value = values.get(hash);
         if (!value) {
@@ -73,13 +94,14 @@ export function asyncObservable<Output, Args extends any[]>(maxCount: number, ge
             // 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) {
+            if (values.size >= maxCount || staleValues.size > maxCount) {
                 values.clear();
                 startingCalculating.clear();
+                staleValues.clear();
             }
 
             // We call inside another function so that synchronous errors still get wrapped in the observable
-            let valueObs = promiseToObservable((async () => getValue(...args))());
+            let valueObs = promiseToObservable((async () => getValue(...args))(), staleValues.get(hash));
             value = {
                 valueObs,
                 seqNum: observable({ value: 1 }, undefined, { deep: false, proxy: false }),

package/package.json

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