@apollo/client 4.3.0-alpha.1 → 4.3.0-alpha.3

package/cache/inmemory/entityStore.js

@@ -3,7 +3,7 @@ import { Trie } from "@wry/trie";
 import { dep } from "optimism";
 import { isReference } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { DeepMerger, isNonNullObject, makeReference, maybeDeepFreeze, } from "@apollo/client/utilities/internal";
+import { DeepMerger, isNonNullObject, isPlainObject, makeReference, maybeDeepFreeze, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { fieldNameFromStoreName, hasOwn } from "./helpers.js";
 const DELETE = {};
@@ -68,12 +68,17 @@ export class EntityStore {
         if (isReference(newer))
             newer = newer.__ref;
         const existing = typeof older === "string" ? this.lookup((dataId = older)) : older;
-        const incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
+        let incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
         // If newer was a string ID, but that ID was not defined in this store,
         // then there are no fields to be merged, so we're done.
         if (!incoming)
             return;
         invariant(typeof dataId === "string", 104);
+        // Parse all scalars before merging so that the storeObjectReconciler can
+        // deep compare the parsed value with the existing value
+        incoming = this.coerceStoreObject(incoming, (scalar, value) => scalar.coerceToParsed(value), incoming.__typename ||
+            existing?.__typename ||
+            this.policies.rootTypenamesById[dataId]);
         const merged = new DeepMerger({
             reconciler: storeObjectReconciler,
         }).merge(existing, incoming);
@@ -277,7 +282,14 @@ export class EntityStore {
         this.replace(null);
     }
     extract() {
-        const obj = this.toObject();
+        let obj = this.toObject();
+        if (this.hasScalarConfig()) {
+            obj = Object.fromEntries(Object.entries(obj).map(([dataId, storeObject]) => [
+                dataId,
+                storeObject &&
+                    this.coerceStoreObject(storeObject, (scalar, value) => scalar.coerceToSerialized(value), storeObject?.__typename || this.policies.rootTypenamesById[dataId]),
+            ]));
+        }
         const extraRootIds = [];
         this.getRootIdSet().forEach((id) => {
             if (!hasOwn.call(this.policies.rootTypenamesById, id)) {
@@ -289,6 +301,37 @@ export class EntityStore {
         }
         return obj;
     }
+    hasScalarConfig() {
+        return !!this.policies.cache["config"].scalars;
+    }
+    coerceStoreObject(obj, coerce, typename = obj.__typename) {
+        if (!typename || !this.hasScalarConfig()) {
+            return obj;
+        }
+        let changed = false;
+        const entries = Object.entries(obj).map(([storeFieldName, value]) => {
+            const scalar = this.policies.getScalarForField(typename, fieldNameFromStoreName(storeFieldName));
+            const newValue = this.coerceValue(value, coerce, scalar);
+            changed ||= newValue !== value;
+            return [storeFieldName, newValue];
+        });
+        return changed ? Object.fromEntries(entries) : obj;
+    }
+    coerceValue(value, coerce, scalar) {
+        if (value == null) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.coerceValue(item, coerce, scalar));
+        }
+        if (scalar) {
+            return coerce(scalar, value);
+        }
+        if (isPlainObject(value) && "__typename" in value) {
+            return this.coerceStoreObject(value, coerce);
+        }
+        return value;
+    }
     replace(newData) {
         Object.keys(this.data).forEach((dataId) => {
             if (!(newData && hasOwn.call(newData, dataId))) {