@nymphjs/client 1.0.0-beta.132 → 1.0.0-beta.134

package/src/Nymph.types.ts

@@ -30,24 +30,43 @@ export type NymphOptions = {
    */
   noAutoconnect?: boolean;
   /**
-   * Use a WeakRef based cache of entities.
+   * Use a WeakRef based cache of entities and queries.
    *
    * This ensures all entities returned are the same instance if they have the
    * same class and GUID. This also means that whenever an entity is returned
    * from the server, the single instance in memory will be refreshed. This
    * could have annoying results, like destroying dirty data (the dreaded
-   * triple-D).
+   * triple-D). The dirty data problem can be partially mitigated with
+   * weakCacheKeepDirtyData.
    *
    * This could also be a potential source of memory leaks. Although the
    * entities themselves are referenced weakly so they get garbage collected,
    * the GUID used as a key and the WeakRef object itself are not weak
    * references, so not destroyed when the instance is garbage collected.
    *
+   * Queries are also cached with weak references. Practically, what this means
+   * is that if you make two identical queries (getEntity, getEntities, or
+   * getUID) at the same time, only one request will be sent to the server, and
+   * both queries will resolve with the same result. This is particularly useful
+   * if you tend to wake a lot of copies of the same entity (like a user) at the
+   * same time.
+   *
    * However, even with these caveats, this might help you if you have a big app
    * with the same entities stored in several different places in memory. This
    * can help to synchronize them correctly and avoid data conflicts.
    */
   weakCache?: boolean;
+  /**
+   * Keep dirty data after receiving unrelated updates from the server.
+   *
+   * When an entity in the weak cache is updated from the server due to an
+   * unrelated query (ie, not because it was just saved), all of the properties
+   * that are currently marked dirty will not be overwritten by the new data.
+   *
+   * This could potentially have negative consequences if your data is
+   * complicated and interrelated.
+   */
+  weakCacheKeepDirtyData?: boolean;
   /**
    * Whether to renew tokens when a request is made.
    *

package/src/PubSub.ts

@@ -3,6 +3,7 @@ import type { NymphOptions, Options, Selector } from './Nymph.types.js';
 import type { EntityInstanceType } from './Entity.js';
 import type {
   EntityConstructor,
+  EntityData,
   EntityInterface,
   EntityJson,
 } from './Entity.types.js';
@@ -219,7 +220,7 @@ export default class PubSub {
     const newResolve = (args: any) => {
       if (Array.isArray(args)) {
         if (args.length) {
-          entity.$init(args[0].toJSON());
+          entity.$init(args[0].toJSON(), false);
         } else {
           entity.guid = null;
         }
@@ -231,7 +232,7 @@ export default class PubSub {
         if ('removed' in update) {
           entity.guid = null;
         } else {
-          entity.$init(update.data);
+          entity.$init(update.data, false);
         }
       }
 
@@ -387,7 +388,9 @@ export default class PubSub {
           if (typeof callback === 'function') {
             callback(
               set
-                ? data.data.map((e: EntityJson) => this.nymph.initEntity(e))
+                ? data.data.map((e: EntityJson) =>
+                    this.nymph.initEntity(e, false),
+                  )
                 : data,
             );
           }
@@ -629,8 +632,8 @@ export default class PubSub {
   }
 
   public updateArray(
-    current: EntityInterface[],
-    update: PubSubUpdate<EntityInterface[]>,
+    current: (EntityInterface & EntityData)[],
+    update: PubSubUpdate<(EntityInterface & EntityData)[]>,
   ) {
     if (Array.isArray(update)) {
       const newArr = [...update];
@@ -641,8 +644,8 @@ export default class PubSub {
         return;
       }
 
-      const idMap: { [k: string]: EntityInterface } = {};
-      const newEntities: EntityInterface[] = [];
+      const idMap: { [k: string]: EntityInterface & EntityData } = {};
+      const newEntities: (EntityInterface & EntityData)[] = [];
       while (current.length) {
         const first = current.shift();
         if (!first) {
@@ -668,7 +671,10 @@ export default class PubSub {
           current.push(entity);
         } else if (idMap[guid].mdate !== entity.mdate) {
           // It was modified.
-          idMap[guid].$init(entity.toJSON());
+          const json = entity.toJSON();
+          if (!Array.isArray(json)) {
+            idMap[guid].$init(json, false);
+          }
           current.push(idMap[guid]);
         } else {
           // Item wasn't modified.
@@ -691,24 +697,24 @@ export default class PubSub {
         }
 
         // Get the entity.
-        let entity: EntityInterface | null = null;
+        let entity: (EntityInterface & EntityData) | null = null;
         if ('added' in curUpdate) {
           // Check for it in the array already.
           for (let i = 0; i < current.length; i++) {
             if (current[i] != null && current[i].guid === curUpdate.added) {
-              entity = current.splice(i, 1)[0].$init(curUpdate.data);
+              entity = current.splice(i, 1)[0].$init(curUpdate.data, false);
             }
           }
           if (entity == null) {
             // A new entity.
-            entity = this.nymph.initEntity(curUpdate.data);
+            entity = this.nymph.initEntity(curUpdate.data, false);
           }
         }
         if ('updated' in curUpdate) {
           // Extract it from the array.
           for (let i = 0; i < current.length; i++) {
             if (current[i] != null && current[i].guid === curUpdate.updated) {
-              entity = current.splice(i, 1)[0].$init(curUpdate.data);
+              entity = current.splice(i, 1)[0].$init(curUpdate.data, false);
             }
           }
         }

package/src/QueryWeakCache.ts

@@ -0,0 +1,35 @@
+export class QueryWeakCache {
+  private queries: Map<string, WeakRef<Promise<any>>> = new Map();
+
+  get(queryJSON: string): Promise<any> | null {
+    const weakRef = this.queries.get(queryJSON);
+    const deref = weakRef && weakRef.deref();
+    if (deref != null) {
+      return deref;
+    } else {
+      this.queries.delete(queryJSON);
+    }
+    return null;
+  }
+
+  set(queryJSON: string, promise: Promise<any>) {
+    this.clean();
+
+    if (!(promise instanceof Promise)) {
+      return;
+    }
+
+    const weakRef = new WeakRef(promise);
+
+    this.queries.set(queryJSON, weakRef);
+  }
+
+  clean() {
+    this.queries.forEach((value, key) => {
+      const deref = value && value.deref();
+      if (deref == null) {
+        this.queries.delete(key);
+      }
+    });
+  }
+}