Enable strict mode in tsconfig and fix type errors

src/__tests__/ApolloClient.ts

@@ -4,7 +4,6 @@ import {
   ApolloClient,
   ApolloError,
   DefaultOptions,
-  FetchPolicy,
   QueryOptions,
   makeReference,
 } from "../core";
@@ -2131,8 +2130,8 @@ describe("ApolloClient", () => {
           }
         `;
 
-        ["network-only", "cache-and-network"].forEach(
-          (fetchPolicy: FetchPolicy) => {
+        (["network-only", "cache-and-network"] as const).forEach(
+          (fetchPolicy) => {
             const observable = client.watchQuery({
               query,
               fetchPolicy,
@@ -2161,13 +2160,15 @@ describe("ApolloClient", () => {
           }
         `;
 
-        [
-          "cache-first",
-          "cache-and-network",
-          "network-only",
-          "cache-only",
-          "no-cache",
-        ].forEach((fetchPolicy: FetchPolicy) => {
+        (
+          [
+            "cache-first",
+            "cache-and-network",
+            "network-only",
+            "cache-only",
+            "no-cache",
+          ] as const
+        ).forEach((fetchPolicy) => {
           const observable = client.watchQuery({
             query,
             fetchPolicy,

src/__tests__/client.ts

@@ -1821,7 +1821,7 @@ describe("client", () => {
         link,
 
         cache: new InMemoryCache({
-          dataIdFromObject: (obj: { id: any }) => obj.id,
+          dataIdFromObject: (obj: any) => obj.id,
           addTypename: false,
         }),
       });
@@ -1870,7 +1870,7 @@ describe("client", () => {
         callback();
         throw new Error("not reached");
       } catch (thrown) {
-        expect(thrown.message).toBe(cacheAndNetworkError);
+        expect((thrown as Error).message).toBe(cacheAndNetworkError);
       }
     }
 

src/__tests__/graphqlSubscriptions.ts

@@ -495,7 +495,7 @@ describe("GraphQL Subscriptions", () => {
 
       client.subscribe(options).subscribe({
         next() {
-          expect(link.operation.getContext().someVar).toEqual(
+          expect(link.operation?.getContext().someVar).toEqual(
             options.context.someVar
           );
           resolve();

src/__tests__/local-state/general.ts

@@ -1208,7 +1208,7 @@ describe("Combining client and server state/operations", () => {
             watchCount += 1;
             client.mutate({
               mutation,
-              update(proxy, { data: { updateUser } }: { data: any }) {
+              update(proxy, { data: { updateUser } }) {
                 proxy.writeQuery({
                   query: userQuery,
                   data: {

src/__tests__/local-state/resolvers.ts

@@ -11,7 +11,7 @@ import {
   WatchQueryOptions,
 } from "../../core";
 
-import { InMemoryCache } from "../../cache";
+import { InMemoryCache, isReference } from "../../cache";
 import { Observable, Observer } from "../../utilities";
 import { ApolloLink } from "../../link/core";
 import { itAsync } from "../../testing";
@@ -747,10 +747,13 @@ describe("Writing cache data from resolvers", () => {
                 },
               },
             });
-            cache.modify({
+            cache.modify<{ field: { field2: number } }>({
               id: "Object:uniqueId",
               fields: {
-                field(value: { field2: number }) {
+                field(value) {
+                  if (isReference(value)) {
+                    fail("Should not be a reference");
+                  }
                   expect(value.field2).toBe(1);
                   return { ...value, field2: 2 };
                 },

src/__tests__/optimistic.ts

@@ -235,7 +235,7 @@ describe("optimistic mutation results", () => {
             await promise;
           } catch (err) {
             expect(err).toBeInstanceOf(Error);
-            expect(err.message).toBe("forbidden (test error)");
+            expect((err as Error).message).toBe("forbidden (test error)");
 
             const dataInStore = (client.cache as InMemoryCache).extract(true);
             expect((dataInStore["TodoList5"] as any).todos.length).toBe(3);
@@ -489,7 +489,7 @@ describe("optimistic mutation results", () => {
             await promise;
           } catch (err) {
             expect(err).toBeInstanceOf(Error);
-            expect(err.message).toBe("forbidden (test error)");
+            expect((err as Error).message).toBe("forbidden (test error)");
 
             const dataInStore = (client.cache as InMemoryCache).extract(true);
             expect((dataInStore["TodoList5"] as any).todos.length).toBe(3);
@@ -2019,11 +2019,12 @@ describe("optimistic mutation results", () => {
       const wrapReject = <TArgs extends any[], TResult>(
         fn: (...args: TArgs) => TResult
       ): typeof fn => {
-        return function () {
+        return function (this: unknown, ...args: TArgs) {
           try {
-            return fn.apply(this, arguments);
+            return fn.apply(this, args);
           } catch (e) {
             reject(e);
+            throw e;
           }
         };
       };

src/__tests__/subscribeToMore.ts

@@ -8,8 +8,10 @@ import { itAsync, mockSingleLink, mockObservableLink } from "../testing";
 
 const isSub = (operation: Operation) =>
   (operation.query as DocumentNode).definitions
-    .filter((x) => x.kind === "OperationDefinition")
-    .some((x: OperationDefinitionNode) => x.operation === "subscription");
+    .filter(
+      (x): x is OperationDefinitionNode => x.kind === "OperationDefinition"
+    )
+    .some((x) => x.operation === "subscription");
 
 describe("subscribeToMore", () => {
   const query = gql`

src/cache/core/types/Cache.ts

@@ -93,7 +93,7 @@ export namespace Cache {
       this: TCache,
       watch: Cache.WatchOptions,
       diff: Cache.DiffResult<any>,
-      lastDiff: Cache.DiffResult<any> | undefined
+      lastDiff?: Cache.DiffResult<any> | undefined
     ) => any;
   }
 

src/cache/inmemory/__tests__/cache.ts

@@ -3815,6 +3815,7 @@ describe("ReactiveVar and makeVar", () => {
     let broadcastCount = 0;
     cache["broadcastWatches"] = function () {
       ++broadcastCount;
+      // @ts-expect-error
       return broadcast.apply(this, arguments);
     };
 

src/cache/inmemory/__tests__/diffAgainstStore.ts

@@ -493,8 +493,8 @@ describe("diffing queries against the store", () => {
     };
 
     const cache = new InMemoryCache({
-      dataIdFromObject({ id }: { id: string }) {
-        return id;
+      dataIdFromObject(obj: any) {
+        return obj.id;
       },
     });
 
@@ -841,7 +841,7 @@ describe("diffing queries against the store", () => {
 
       const writer = new StoreWriter(
         new InMemoryCache({
-          dataIdFromObject: ({ id }: { id: string }) => id,
+          dataIdFromObject: (obj: any) => obj.id,
         })
       );
 
@@ -1067,7 +1067,7 @@ describe("diffing queries against the store", () => {
         });
         throw new Error("should have thrown");
       } catch (e) {
-        expect(e.message).toEqual(
+        expect((e as Error).message).toEqual(
           "Missing selection set for object of type Message returned for query field messageList"
         );
       }

src/cache/inmemory/__tests__/readFromStore.ts

@@ -1904,7 +1904,7 @@ describe("reading from the store", () => {
           );
           expect(value.__ref).toBe('Deity:{"name":"Zeus"}');
           // Interim ruler Apollo takes over for real.
-          return toReference(apolloRulerResult.ruler);
+          return toReference(apolloRulerResult.ruler)!;
         },
       },
     });

src/cache/inmemory/__tests__/roundtrip.ts

@@ -61,7 +61,7 @@ function storeRoundtrip(query: DocumentNode, result: any, variables = {}) {
       (immutableResult as any).illegal = "this should not work";
       throw new Error("unreached");
     } catch (e) {
-      expect(e.message).not.toMatch(/unreached/);
+      expect((e as Error).message).not.toMatch(/unreached/);
       expect(e).toBeInstanceOf(TypeError);
     }
     assertDeeplyFrozen(immutableResult);

src/cache/inmemory/__tests__/writeToStore.ts

@@ -26,8 +26,13 @@ import { InMemoryCache } from "../inMemoryCache";
 import { withErrorSpy, withWarningSpy } from "../../../testing";
 import { TypedDocumentNode } from "../../../core";
 import { extractFragmentContext } from "../helpers";
+import { KeyFieldsFunction } from "../policies";
+import { invariant } from "../../../utilities/globals";
 
-const getIdField = ({ id }: { id: string }) => id;
+const getIdField: KeyFieldsFunction = ({ id }) => {
+  invariant(typeof id === "string", "id is not a string");
+  return id;
+};
 
 describe("writing to the store", () => {
   const cache = new InMemoryCache({
@@ -1293,19 +1298,17 @@ describe("writing to the store", () => {
     }
 
     testData.forEach((data) => {
-      data.mutation.definitions.forEach(
-        (definition: OperationDefinitionNode) => {
-          if (isOperationDefinition(definition)) {
-            definition.selectionSet.selections.forEach((selection) => {
-              if (isField(selection)) {
-                expect(
-                  storeKeyNameFromField(selection, data.variables)
-                ).toEqual(data.expected);
-              }
-            });
-          }
+      data.mutation.definitions.forEach((definition) => {
+        if (isOperationDefinition(definition)) {
+          definition.selectionSet.selections.forEach((selection) => {
+            if (isField(selection)) {
+              expect(storeKeyNameFromField(selection, data.variables)).toEqual(
+                data.expected
+              );
+            }
+          });
         }
-      );
+      });
     });
   });
 
@@ -1357,7 +1360,7 @@ describe("writing to the store", () => {
       return value.kind === "OperationDefinition";
     }
 
-    mutation.definitions.map((def: OperationDefinitionNode) => {
+    mutation.definitions.map((def) => {
       if (isOperationDefinition(def)) {
         const writer = new StoreWriter(
           new InMemoryCache({

src/cache/inmemory/entityStore.ts

@@ -548,7 +548,7 @@ class CacheGroup {
 
   // Used by the EntityStore#makeCacheKey method to compute cache keys
   // specific to this CacheGroup.
-  public keyMaker: Trie<object>;
+  public keyMaker!: Trie<object>;
 
   constructor(
     public readonly caching: boolean,
@@ -755,7 +755,11 @@ class Layer extends EntityStore {
   public getStorage(): StorageType {
     let p: EntityStore = this.parent;
     while ((p as Layer).parent) p = (p as Layer).parent;
-    return p.getStorage.apply(p, arguments);
+    return p.getStorage.apply(
+      p,
+      // @ts-expect-error
+      arguments
+    );
   }
 }
 
@@ -778,20 +782,20 @@ class Stump extends Layer {
     return this;
   }
 
-  public merge() {
+  public merge(older: string | StoreObject, newer: string | StoreObject) {
     // We never want to write any data into the Stump, so we forward any merge
     // calls to the Root instead. Another option here would be to throw an
     // exception, but the toReference(object, true) function can sometimes
     // trigger Stump writes (which used to be Root writes, before the Stump
     // concept was introduced).
-    return this.parent.merge.apply(this.parent, arguments);
+    return this.parent.merge(older, newer);
   }
 }
 
 function storeObjectReconciler(
   existingObject: StoreObject,
   incomingObject: StoreObject,
-  property: string
+  property: string | number
 ): StoreValue {
   const existingValue = existingObject[property];
   const incomingValue = incomingObject[property];

src/cache/inmemory/fixPolyfills.native.ts

@@ -33,10 +33,10 @@ try {
   // https://github.com/apollographql/react-apollo/issues/2442#issuecomment-426489517
   testMap.set(frozen, frozen).delete(frozen);
 } catch {
-  const wrap = (method: <T>(obj: T) => T): typeof method => {
+  const wrap = <M extends <T>(obj: T) => T>(method: M): M => {
     return (
       method &&
-      ((obj) => {
+      (((obj) => {
         try {
           // If .set succeeds, also call .delete to avoid leaking memory.
           testMap.set(obj, obj).delete(obj);
@@ -45,7 +45,7 @@ try {
           // by this return-from-finally statement:
           return method.call(Object, obj);
         }
-      })
+      }) as M)
     );
   };
   Object.freeze = wrap(Object.freeze);