fix(store): improve loose mode invalidation for listing models (#294)

Author: smalluban

src/cache.js

@@ -129,7 +129,7 @@ export function assert(target, key, value, force) {
   dispatch(entry);
 }
 
-export function set(target, key, fn, value) {
+export function sync(target, key, fn, value) {
   const entry = getEntry(target, key);
   const nextValue = fn(target, value, entry.value);
 
@@ -138,6 +138,9 @@ export function set(target, key, fn, value) {
     entry.assertValue = undefined;
 
     dispatch(entry);
+
+    // mark as resolved to avoid double fn call in get
+    entry.resolved = true;
   }
 }
 

src/store.js

@@ -51,7 +51,7 @@ function resolveWithInvalidate(config, model, lastModel) {
 }
 
 function syncCache(config, id, model, invalidate = true) {
-  cache.set(config, id, invalidate ? resolveWithInvalidate : resolve, model);
+  cache.sync(config, id, invalidate ? resolveWithInvalidate : resolve, model);
   return model;
 }
 
@@ -1120,33 +1120,19 @@ function get(Model, id) {
   const entry = cache.getEntry(config, stringId);
   const cachedModel = entry.value;
 
-  if (
-    cachedModel &&
-    getModelState(cachedModel).state !== "pending" &&
-    !validate(cachedModel)
-  ) {
+  if (entry.resolved && cachedModel && !validate(cachedModel)) {
     entry.resolved = false;
   }
 
   return cache.get(config, stringId, () => {
     id = normalizeId(id);
 
-    let validContexts = true;
     if (config.contexts) {
       for (const context of config.contexts) {
-        if (
-          cache.get(context, context, () => getCurrentTimestamp()) ===
-          getCurrentTimestamp()
-        ) {
-          validContexts = false;
-        }
+        cache.get(context, context, getCurrentTimestamp);
       }
     }
 
-    if (validContexts && cachedModel && validate(cachedModel)) {
-      return cachedModel;
-    }
-
     const fallback = () =>
       cachedModel ||
       (offline && config.create(offline.get(stringId))) ||
@@ -1734,6 +1720,9 @@ function store(Model, options = {}) {
       ...Model,
       [connect]: {
         get(id) {
+          const value = cache.getCurrentValue();
+          if (value) return value;
+
           const model = get(config.model, id);
           return pending(model) || model;
         },

test/spec/cache.js

@@ -1,6 +1,6 @@
 import {
   get,
-  set,
+  sync,
   assert,
   getEntries,
   invalidate,
@@ -94,12 +94,12 @@ describe("cache:", () => {
       get(target, "one", () => {
         get(target, "two", () => "value");
         get(target, "three", () => true);
-        set(target, "three", () => false);
+        sync(target, "three", () => false);
 
         return "value";
       });
 
-      set(target, "two", () => "other value");
+      sync(target, "two", () => "other value");
       get(target, "one", spy);
       expect(spy).toHaveBeenCalledTimes(1);
     });
@@ -123,15 +123,15 @@ describe("cache:", () => {
 
       expect(spy).toHaveBeenCalledTimes(0);
 
-      set(target, "key", () => "value");
+      sync(target, "key", () => "value");
       get(target, "key", spy);
 
       expect(spy).toHaveBeenCalledTimes(0);
     });
 
     it("invalidates dependant properties", () => {
       get(target, "key", () => get(target, "otherKey", () => "value"));
-      set(target, "otherKey", () => "new value");
+      sync(target, "otherKey", () => "new value");
 
       get(target, "key", spy);
 
@@ -170,7 +170,7 @@ describe("cache:", () => {
       invalidate(target, "key");
       get(target, "key", () => "value");
 
-      set(target, "otherKey", () => "new value");
+      sync(target, "otherKey", () => "new value");
       get(target, "key", spy);
 
       expect(spy).toHaveBeenCalledTimes(0);

test/spec/store.js

@@ -2323,6 +2323,42 @@ describe("store:", () => {
         expect(args[0]).toEqual(["two"]);
       });
     });
+
+    it("invalidates listing model when item is changed", async () => {
+      storage = {};
+
+      const ListModel = {
+        id: true,
+        value: "",
+        [store.connect]: {
+          get: (id) => storage[id],
+          set: (id, values) => {
+            storage[values.id] = values;
+            return values;
+          },
+          list: ({ query }) =>
+            Object.values(storage).filter(({ value }) => value.includes(query)),
+          loose: true,
+        },
+      };
+
+      // get empty list
+      expect(store.get([ListModel], { query: "test" })).toEqual([]);
+      // get another empty list
+      expect(store.get([ListModel], { query: "other" })).toEqual([]);
+
+      // add item matching first query
+      await store.set(ListModel, { value: "test" });
+      await store.set(ListModel, { value: "other" });
+
+      // first list is updated
+      expect(store.get([ListModel], { query: "other" }).length).toBe(1);
+
+      await resolveTimeout(() => {
+        const list = store.get([ListModel], { query: "test" });
+        expect(list[0]?.value).toEqual("test");
+      });
+    });
   });
 
   describe("connected to async storage -", () => {