Avoid warning about clobbering scalar fields.

While it is possible to write a field merge function that handles updates
for scalar field values, we should treat scalar data as opaque by default,
without displaying "Cache data may be lost..." warnings that nudge the
developer to write an unnecessary merge function.

None: because this code is inside of a process.env.NODE_ENV block, it will
not be executed or bundled in production.

Should fix #7071.

src/cache/inmemory/__tests__/__snapshots__/writeToStore.ts.snap

@@ -1,5 +1,39 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`writing to the store "Cache data maybe lost..." warnings should not warn when scalar fields are updated 1`] = `
+Object {
+  "ROOT_QUERY": Object {
+    "__typename": "Query",
+    "currentTime({\\"tz\\":\\"UTC-5\\"})": Object {
+      "localeString": "9/25/2020, 1:08:33 PM",
+    },
+    "someJSON": Object {
+      "foos": Array [
+        "bar",
+        "baz",
+      ],
+      "oyez": 3,
+    },
+  },
+}
+`;
+
+exports[`writing to the store "Cache data maybe lost..." warnings should not warn when scalar fields are updated 2`] = `
+Object {
+  "ROOT_QUERY": Object {
+    "__typename": "Query",
+    "currentTime({\\"tz\\":\\"UTC-5\\"})": Object {
+      "msSinceEpoch": 81,
+    },
+    "someJSON": Object {
+      "asdf": "middle",
+      "qwer": "upper",
+      "zxcv": "lower",
+    },
+  },
+}
+`;
+
 exports[`writing to the store user objects should be able to have { __typename: "Mutation" } 1`] = `
 Object {
   "Gene:{\\"id\\":\\"SLC45A2\\"}": Object {

src/cache/inmemory/__tests__/writeToStore.ts

@@ -1582,6 +1582,70 @@ describe('writing to the store', () => {
     });
   });
 
+  describe('"Cache data maybe lost..." warnings', () => {
+    const { warn } = console;
+    let warnings: any[][] = [];
+
+    beforeEach(() => {
+      warnings.length = 0;
+      console.warn = (...args: any[]) => {
+        warnings.push(args);
+      };
+    });
+
+    afterEach(() => {
+      console.warn = warn;
+    });
+
+    it("should not warn when scalar fields are updated", () => {
+      const cache = new InMemoryCache;
+
+      const query = gql`
+        query {
+          someJSON
+          currentTime(tz: "UTC-5")
+        }
+      `;
+
+      expect(warnings).toEqual([]);
+
+      const date = new Date(1601053713081);
+
+      cache.writeQuery({
+        query,
+        data: {
+          someJSON: {
+            oyez: 3,
+            foos: ["bar", "baz"],
+          },
+          currentTime: {
+            localeString: date.toLocaleString("en-US"),
+          },
+        },
+      });
+
+      expect(cache.extract()).toMatchSnapshot();
+      expect(warnings).toEqual([]);
+
+      cache.writeQuery({
+        query,
+        data: {
+          someJSON: {
+            qwer: "upper",
+            asdf: "middle",
+            zxcv: "lower",
+          },
+          currentTime: {
+            msSinceEpoch: date.getMilliseconds(),
+          },
+        },
+      });
+
+      expect(cache.extract()).toMatchSnapshot();
+      expect(warnings).toEqual([]);
+    });
+  });
+
   describe('writeResultToStore shape checking', () => {
     const query = gql`
       query {

src/cache/inmemory/writeToStore.ts

@@ -284,15 +284,27 @@ export class StoreWriter {
       }
 
       if (process.env.NODE_ENV !== "production") {
+        const hasSelectionSet = (storeFieldName: string) =>
+          fieldsWithSelectionSets.has(fieldNameFromStoreName(storeFieldName));
+        const fieldsWithSelectionSets = new Set<string>();
+        workSet.forEach(selection => {
+          if (isField(selection) && selection.selectionSet) {
+            fieldsWithSelectionSets.add(selection.name.value);
+          }
+        });
+
         const hasMergeFunction = (storeFieldName: string) => {
           const childTree = mergeTree.map.get(storeFieldName);
           return Boolean(childTree && childTree.info && childTree.info.merge);
         };
 
         Object.keys(incomingFields).forEach(storeFieldName => {
           // If a merge function was defined for this field, trust that it
-          // did the right thing about (not) clobbering data.
-          if (!hasMergeFunction(storeFieldName)) {
+          // did the right thing about (not) clobbering data. If the field
+          // has no selection set, it's a scalar field, so it doesn't need
+          // a merge function (even if it's an object, like JSON data).
+          if (hasSelectionSet(storeFieldName) &&
+              !hasMergeFunction(storeFieldName)) {
             warnAboutDataLoss(
               entityRef,
               incomingFields,