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

package/__cjs/cache/inmemory/entityStore.cjs

@@ -77,12 +77,17 @@ class EntityStore {
         if ((0, utilities_1.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;
-        (0, invariant_1.invariant)(typeof dataId === "string", 104);
+        (0, invariant_1.invariant)(typeof dataId === "string", 107);
+        // 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 internal_1.DeepMerger({
             reconciler: storeObjectReconciler,
         }).merge(existing, incoming);
@@ -184,7 +189,7 @@ class EntityStore {
                             if (environment_1.__DEV__) {
                                 const checkReference = (ref) => {
                                     if (this.lookup(ref.__ref) === undefined) {
-                                        __DEV__ && invariant_1.invariant.warn(105, ref);
+                                        __DEV__ && invariant_1.invariant.warn(108, ref);
                                         return true;
                                     }
                                 };
@@ -213,7 +218,7 @@ class EntityStore {
                                             }
                                         }
                                         if (seenReference && someNonReference !== undefined) {
-                                            __DEV__ && invariant_1.invariant.warn(106, someNonReference);
+                                            __DEV__ && invariant_1.invariant.warn(109, someNonReference);
                                             break;
                                         }
                                     }
@@ -286,7 +291,14 @@ 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 (!helpers_js_1.hasOwn.call(this.policies.rootTypenamesById, id)) {
@@ -298,6 +310,37 @@ 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, (0, helpers_js_1.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 ((0, internal_1.isPlainObject)(value) && "__typename" in value) {
+            return this.coerceStoreObject(value, coerce);
+        }
+        return value;
+    }
     replace(newData) {
         Object.keys(this.data).forEach((dataId) => {
             if (!(newData && helpers_js_1.hasOwn.call(newData, dataId))) {