Use reobserve everywhere that setOptions is used

Author: jerelmiller

src/__tests__/ApolloClient.ts

@@ -3206,12 +3206,12 @@ describe("ApolloClient", () => {
         UnmaskedQuery | undefined
       >();
 
-      const setOptionsResult = await observableQuery.setOptions({
+      const reobserveResult = await observableQuery.reobserve({
         variables: { id: "2" },
       });
 
-      expectTypeOf(setOptionsResult.data).toMatchTypeOf<Query | undefined>();
-      expectTypeOf(setOptionsResult.data).not.toMatchTypeOf<
+      expectTypeOf(reobserveResult.data).toMatchTypeOf<Query | undefined>();
+      expectTypeOf(reobserveResult.data).not.toMatchTypeOf<
         UnmaskedQuery | undefined
       >();
 

src/__tests__/client.ts

@@ -1893,7 +1893,7 @@ describe("client", () => {
       await expect(stream).toEmitMatchedValue({ data });
 
       await expect(
-        obs.setOptions({ query, fetchPolicy: "standby" })
+        obs.reobserve({ query, fetchPolicy: "standby" })
         // TODO: Update this behavior
       ).rejects.toThrow(new EmptyError());
       // this write should be completely ignored by the standby query
@@ -1923,13 +1923,13 @@ describe("client", () => {
       await expect(stream).toEmitMatchedValue({ data });
 
       await expect(
-        obs.setOptions({ query, fetchPolicy: "standby" })
+        obs.reobserve({ query, fetchPolicy: "standby" })
         // TODO: Update this behavior
       ).rejects.toThrow(new EmptyError());
       // this write should be completely ignored by the standby query
       client.writeQuery({ query, data: data2 });
       setTimeout(() => {
-        void obs.setOptions({ query, fetchPolicy: "cache-first" });
+        void obs.reobserve({ query, fetchPolicy: "cache-first" });
       }, 10);
 
       await expect(stream).toEmitMatchedValue({ data: data2 });
@@ -3639,7 +3639,7 @@ describe("@connection", () => {
       });
       expect(fetchPolicyRecord).toEqual(["cache-first", "network-only"]);
 
-      const finalResult = await observable.setOptions({
+      const finalResult = await observable.reobserve({
         // Allow delivery of loading:true result.
         notifyOnNetworkStatusChange: true,
         // Force a network request in addition to loading:true cache result.
@@ -5454,7 +5454,7 @@ describe("custom document transforms", () => {
     });
   });
 
-  it("re-runs custom document transforms when calling `setOptions`", async () => {
+  it("re-runs custom document transforms when calling `reobserve`", async () => {
     const query = gql`
       query TestQuery($id: ID!) {
         product(id: $id) {
@@ -5550,7 +5550,7 @@ describe("custom document transforms", () => {
 
     enabled = false;
 
-    const { data } = await observable.setOptions({ variables: { id: 2 } });
+    const { data } = await observable.reobserve({ variables: { id: 2 } });
 
     expect(document!).toMatchDocument(disabledQuery);
     expect(observable.options.query).toMatchDocument(query);
@@ -5570,7 +5570,7 @@ describe("custom document transforms", () => {
     });
   });
 
-  it("runs custom document transforms when passing a new query to `setOptions`", async () => {
+  it("runs custom document transforms when passing a new query to `reobserve`", async () => {
     const query = gql`
       query TestQuery($id: ID!) {
         product(id: $id) {
@@ -5673,7 +5673,7 @@ describe("custom document transforms", () => {
       expect(observable.query).toMatchDocument(transformedQuery);
     });
 
-    const { data } = await observable.setOptions({ query: updatedQuery });
+    const { data } = await observable.reobserve({ query: updatedQuery });
 
     expect(document!).toMatchDocument(transformedUpdatedQuery);
     expect(observable.options.query).toMatchDocument(updatedQuery);

src/__tests__/dataMasking.ts

@@ -1722,7 +1722,7 @@ describe("client.watchQuery", () => {
     );
   });
 
-  test("masks result of setOptions", async () => {
+  test("masks result of reobserve", async () => {
     type UserFieldsFragment = {
       age: number;
     } & { " $fragmentName"?: "UserFieldsFragment" };
@@ -1803,7 +1803,7 @@ describe("client.watchQuery", () => {
       });
     }
 
-    const result = await observable.setOptions({ variables: { id: 2 } });
+    const result = await observable.reobserve({ variables: { id: 2 } });
 
     expect(result?.data).toEqual({
       user: {

src/core/ObservableQuery.ts

@@ -802,7 +802,7 @@ Did you mean to call refetch(variables) instead of refetch({ variables })?`,
         // requests to be triggered only if the cache result is incomplete. To
         // that end, the options.nextFetchPolicy option provides an easy way to
         // update options.fetchPolicy after the initial network request, without
-        // having to call observableQuery.setOptions.
+        // having to call observableQuery.reobserve.
         options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {
           reason,
           options,
@@ -1166,7 +1166,7 @@ export function reobserveCacheFirst<TData, TVars extends OperationVariables>(
   const { fetchPolicy, nextFetchPolicy } = obsQuery.options;
 
   if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
-    return obsQuery.setOptions({
+    return obsQuery.reobserve({
       fetchPolicy: "cache-first",
       // Use a temporary nextFetchPolicy function that replaces itself with the
       // previous nextFetchPolicy value and returns the original fetchPolicy.
@@ -1189,7 +1189,7 @@ export function reobserveCacheFirst<TData, TVars extends OperationVariables>(
     });
   }
 
-  return obsQuery.rerun();
+  return obsQuery.reobserve();
 }
 
 export function logMissingFieldErrors(

src/core/__tests__/ApolloClient/general.test.ts

@@ -546,7 +546,7 @@ describe("ApolloClient", () => {
 
     // Kick off another request while the other is still pending
     await wait(10);
-    void observableQuery.setOptions({ variables: { offset: 20 } });
+    void observableQuery.reobserve({ variables: { offset: 20 } });
 
     expect(onRequestSubscribe).toHaveBeenCalledTimes(2);
 
@@ -618,7 +618,7 @@ describe("ApolloClient", () => {
 
     // Kick off another request while the other is still pending
     await wait(10);
-    void observableQuery.setOptions({ variables: { id: 2 } });
+    void observableQuery.reobserve({ variables: { id: 2 } });
 
     await expect(stream).toEmitApolloQueryResult({
       data: {
@@ -3114,7 +3114,7 @@ describe("ApolloClient", () => {
       // fetchQueryByPolicy, but it should just read from cache and not
       // update "queryInfo.lastRequestId". For more information, see
       // https://github.com/apollographql/apollo-client/pull/7956#issue-610298427
-      await observable.setOptions({
+      await observable.reobserve({
         ...queryOptions,
         fetchPolicy: "cache-first",
       });
@@ -6345,7 +6345,7 @@ describe("ApolloClient", () => {
 
         onQueryUpdated(obsQuery) {
           expect(obsQuery.options.query).toBe(query);
-          return obsQuery.setOptions({
+          return obsQuery.reobserve({
             fetchPolicy: "network-only",
             context: {
               ...obsQuery.options.context,

src/core/__tests__/ObservableQuery.ts

@@ -90,7 +90,7 @@ describe("ObservableQuery", () => {
   ]);
   const wrappedError = new CombinedGraphQLErrors([error]);
 
-  describe("setOptions", () => {
+  describe("reobserve", () => {
     describe("to change pollInterval", () => {
       it("starts polling if goes from 0 -> something", async () => {
         const client = new ApolloClient({
@@ -126,7 +126,7 @@ describe("ObservableQuery", () => {
           partial: false,
         });
 
-        await observable.setOptions({ query, pollInterval: 10 });
+        await observable.reobserve({ query, pollInterval: 10 });
 
         await expect(stream).toEmitApolloQueryResult({
           data: dataTwo,
@@ -174,7 +174,7 @@ describe("ObservableQuery", () => {
           partial: false,
         });
 
-        await observable.setOptions({ query, pollInterval: 0 });
+        await observable.reobserve({ query, pollInterval: 0 });
 
         await expect(stream).not.toEmitAnything();
       });
@@ -214,7 +214,7 @@ describe("ObservableQuery", () => {
           partial: false,
         });
 
-        await observable.setOptions({ query, pollInterval: 10 });
+        await observable.reobserve({ query, pollInterval: 10 });
 
         await expect(stream).toEmitApolloQueryResult({
           data: dataTwo,
@@ -413,7 +413,7 @@ describe("ObservableQuery", () => {
         partial: false,
       });
 
-      await observable.setOptions({
+      await observable.reobserve({
         variables: variables2,
         notifyOnNetworkStatusChange: true,
       });
@@ -433,7 +433,7 @@ describe("ObservableQuery", () => {
       });
 
       // go back to first set of variables
-      const current = await observable.setOptions({ variables });
+      const current = await observable.reobserve({ variables });
       expect(current).toEqualApolloQueryResult({
         data,
         loading: false,
@@ -533,7 +533,7 @@ describe("ObservableQuery", () => {
         partial: false,
       });
 
-      await observable.setOptions({ fetchPolicy: "network-only" });
+      await observable.reobserve({ fetchPolicy: "network-only" });
 
       await expect(stream).toEmitApolloQueryResult({
         data: dataTwo,
@@ -591,7 +591,7 @@ describe("ObservableQuery", () => {
 
       expect(timesFired).toBe(1);
 
-      await observable.setOptions({ fetchPolicy: "cache-only" });
+      await observable.reobserve({ fetchPolicy: "cache-only" });
       await client.resetStore();
 
       await expect(stream).toEmitApolloQueryResult({
@@ -654,7 +654,7 @@ describe("ObservableQuery", () => {
       });
       expect(timesFired).toBe(0);
 
-      await observable.setOptions({ fetchPolicy: "cache-first" });
+      await observable.reobserve({ fetchPolicy: "cache-first" });
 
       await expect(stream).toEmitApolloQueryResult({
         data,
@@ -714,7 +714,7 @@ describe("ObservableQuery", () => {
       expect(timesFired).toBe(1);
 
       await expect(
-        observable.setOptions({ query, fetchPolicy: "standby" })
+        observable.reobserve({ query, fetchPolicy: "standby" })
       ).rejects.toThrow(new EmptyError());
 
       // make sure the query didn't get fired again.
@@ -774,7 +774,7 @@ describe("ObservableQuery", () => {
       expect(timesFired).toBe(1);
 
       await expect(
-        observable.setOptions({ query, fetchPolicy: "standby" })
+        observable.reobserve({ query, fetchPolicy: "standby" })
         // TODO: Dertermine how we want to handle this. We likely should swallow
         // the error since standby currently does not emit a value but completes
         // instead.
@@ -809,7 +809,7 @@ describe("ObservableQuery", () => {
         partial: false,
       });
 
-      const res = await observable.setOptions({
+      const res = await observable.reobserve({
         fetchPolicy: "cache-and-network",
       });
 
@@ -1711,7 +1711,7 @@ describe("ObservableQuery", () => {
       expect(observable.options.fetchPolicy).toBe("cache-first");
 
       {
-        const result = await observable.setOptions({ variables: variables1 });
+        const result = await observable.reobserve({ variables: variables1 });
 
         expect(result).toEqualApolloQueryResult({
           data,
@@ -1739,7 +1739,7 @@ describe("ObservableQuery", () => {
       expect(observable.options.fetchPolicy).toBe("cache-first");
 
       {
-        const result = await observable.setOptions({ variables: variables2 });
+        const result = await observable.reobserve({ variables: variables2 });
 
         expect(result).toEqualApolloQueryResult({
           data: data2,
@@ -3481,7 +3481,7 @@ describe("ObservableQuery", () => {
       expect(observable.query).toBe(result);
     });
 
-    it("is updated with transformed query when `setOptions` changes the query", async () => {
+    it("is updated with transformed query when `reobserve` changes the query", async () => {
       const query = gql`
         query {
           currentUser {
@@ -3514,7 +3514,7 @@ describe("ObservableQuery", () => {
         }
       `);
 
-      await observable.setOptions({ query: updatedQuery });
+      await observable.reobserve({ query: updatedQuery });
 
       expect(observable.query).toMatchDocument(gql`
         query {
@@ -3897,9 +3897,9 @@ test("handles changing variables in rapid succession before other request is com
     });
   });
 
-  void observable.setOptions({ variables: { department: "HR" } });
+  void observable.reobserve({ variables: { department: "HR" } });
   await wait(10);
-  void observable.setOptions({ variables: { department: null } });
+  void observable.reobserve({ variables: { department: null } });
 
   // Wait for request to finish
   await wait(50);

src/core/__tests__/fetchPolicies.ts

@@ -965,7 +965,7 @@ describe("nextFetchPolicy", () => {
     expect(observable.options.fetchPolicy).toBe("cache-first");
 
     {
-      const result = await observable.setOptions({
+      const result = await observable.reobserve({
         variables: {
           refetching: false,
         },
@@ -1115,7 +1115,7 @@ describe("nextFetchPolicy", () => {
     expect(observable.options.fetchPolicy).toBe("cache-first");
 
     {
-      const result = await observable.setOptions({
+      const result = await observable.reobserve({
         variables: {
           refetching: false,
         },
@@ -1285,7 +1285,7 @@ describe("nextFetchPolicy", () => {
     expect(observable.options.fetchPolicy).toBe("cache-first");
 
     {
-      const result = await observable.setOptions({
+      const result = await observable.reobserve({
         variables: {
           refetching: false,
         },

src/react/hooks/__tests__/useMutation.test.tsx

@@ -1959,7 +1959,7 @@ describe("useMutation Hook", () => {
         void createTodo({
           variables,
           async onQueryUpdated(obsQuery, diff) {
-            const result = await obsQuery.rerun();
+            const result = await obsQuery.reobserve();
             finishedReobserving = true;
             resolveOnUpdate({ obsQuery, diff, result });
             return result;

src/react/hooks/__tests__/useQuery.test.tsx

@@ -1755,7 +1755,7 @@ describe("useQuery Hook", () => {
       checkObservableQueries(1);
 
       await expect(
-        getCurrentSnapshot().observable.rerun()
+        getCurrentSnapshot().observable.reobserve()
       ).resolves.toEqualApolloQueryResult({
         data: { linkCount: 2 },
         loading: false,
@@ -4926,7 +4926,7 @@ describe("useQuery Hook", () => {
               // Intentionally use rerun here as opposed to refetch to
               // ensure we check against reported cache results with cache-first
               // and notifyOnNetworkStatusChange
-              void useQueryResult.observable.rerun();
+              void useQueryResult.observable.reobserve();
             }}
           >
             Reload 1st query
@@ -7297,7 +7297,7 @@ describe("useQuery Hook", () => {
 
       const reasons: string[] = [];
 
-      const result = await getCurrentSnapshot().observable.setOptions({
+      const result = await getCurrentSnapshot().observable.reobserve({
         variables: {
           newVar: true,
         },
@@ -8156,7 +8156,7 @@ describe("useQuery Hook", () => {
         variables: {},
       });
 
-      const result = await getCurrentSnapshot().observable.rerun();
+      const result = await getCurrentSnapshot().observable.reobserve();
 
       expect(result).toEqualApolloQueryResult({
         data: { a: "aaa", b: 2 },