static mergeStrategy method on Resource

Will clone the existing entity, and assign the new value to only the fields that should be overridden.

src/resource/Resource.ts

@@ -27,6 +27,22 @@ const getEntitySchema: <T extends typeof Resource>(M: T) => schemas.Entity<Abstr
     return e;
   },
 ) as any;
+
+function filterObject<T extends object>(
+  obj: T,
+  predicate: (key: string, value: any) => boolean,
+): Partial<T> {
+  return Object.keys(obj)
+    .filter(key => predicate(key, obj[key as keyof T]))
+    .reduce(
+      (ret, key) => {
+        ret[key as keyof T] = obj[key as keyof T];
+        return ret;
+      },
+      {} as Partial<T>
+    );
+}
+
 /** Represents an entity to be retrieved from a server. Typically 1:1 with a url endpoint. */
 export default abstract class Resource {
   // typescript todo: require subclasses to implement
@@ -55,6 +71,36 @@ export default abstract class Resource {
     return instance;
   }
 
+  /** Merge strategy used when merging normalized response entities into existing entities in cache. */
+  static mergeStrategy<T extends typeof Resource>(
+    this: T,
+    a: Partial<AbstractInstanceType<T>>,
+    b: Partial<AbstractInstanceType<T>>,
+    shouldOverrideField: (
+      fieldname: string,
+      newValue: any,
+      oldValue: any,
+    ) => boolean = (k, n, o) => n !== undefined && n !== o,
+  ) {
+    const bToMerge = filterObject(b, (k, v) =>
+      shouldOverrideField(k, v, a[k as keyof AbstractInstanceType<T>])
+    );
+
+    if (Object.keys(bToMerge).length === 0) {
+      // Nothing to merge to a
+      return a;
+    }
+    if (Object.keys(bToMerge).length === Object.keys(b).length) {
+      // Nothing to keep from a
+      return b;
+    }
+
+    const aClone = this.fromJS(a);
+    const merged = Object.assign(aClone, bToMerge);
+
+    return merged;
+  }
+
   static toString<T extends typeof Resource>(this: T) {
     return `${this.name}::${this.urlRoot}`;
   }

src/state/reducer.ts

@@ -14,9 +14,9 @@ type Writable<T> = {
 }
 
 function resourceCustomizer(a: any, b: any): any {
-  if (b instanceof Resource) {
-    const merged = mergeWith({ ...a }, b, resourceCustomizer);
-    return Object.assign(b, merged);
+  if ((b instanceof Resource) && a !== undefined && b !== undefined) {
+    const S = b.constructor as typeof Resource;
+    return S.mergeStrategy(a, b);
   }
 }