TypePolicy on a request level

With the deprecation of updateQuery on a fetchMore, there doesn’t seem to be a way to specify its replacement, a TypePolicy, in the same place. I understand that you can specify it on specific entities as seen in the docs and below:

const cache = new InMemoryCache({
  typePolicies: {
    Person: {
      fields: {
...

But in my use-case, I have a helper method used by various entities with the list query passed in:

import {useQuery} from "@apollo/client";
import {useEffect, useState} from "react";
import {nameFromQuery} from "lib/graphql/helpers";

export default function useFetchAll(query) {
  const [error, setError] = useState(null);
  const [loading, setLoading] = useState(true);
  const {data, fetchMore} = useQuery(query, {
    onError: setError,
    variables: {first: 100}
  });

  useEffect(() => {
    if(!data) { return; }

    const name = nameFromQuery(query);
    const {endCursor, hasNextPage} = data[name].pageInfo;

    if(hasNextPage) {
      fetchMore({
        updateQuery: (oldData, {fetchMoreResult: newData}) => ({
          ...newData,
          [name]: {
            ...newData[name],
            edges: [
              ...oldData[name].edges,
              ...newData[name].edges
            ]
          }
        }),
        variables: {after: endCursor}
      });
    } else {
      setLoading(false);
    }
  }, [data]);

  return {data, error, loading};
}

I’m not sure how I can convert this method to using type policies instead. There are a couple of ways to avoid this issue:

• Type Policies for everything that uses this - but it would make the method unreliable
• Skipping the cache - but it’d then it’d making a lot of extra calls if used multiple times

It’d make more sense to me if useQuery or fetchMore accepted a typePolicy, similar to how it accepts a fetchPolicy. That may be a naive statement, but there just seems like there should be an equivalent way of handling the issue if updateQuery is going away.

[heyrict]

I have a similar issue on migrating from v2 to v3 on cache updating. I used the same query while with different view types in my chat application.

Here is the sample query

query Chatmessages(...) {
  chatmessages(filter: $filter, limit: $limit, offset: $offset, order: $order) {
    ...Chatmessage
  }
}

The main part displays all messages in an infinite-scrolling method, where the following policy works great.

typePolicies: {
  Query: {
    fields: {
      chatmessages: offsetLimitPagination({keyArgs: ['filter', 'order']}),
    },
  },
},

While the other part displays logs of messages in a pages, where only $limit number of records are shown at a time. I have to use the following policy to make this part work.

typePolicies: {
  Query: {
    fields: {
      chatmessages: { keyArgs: ['filter', 'order', 'limit', 'offset'] },
    },
  },
},

As updateQuery is deprecated, is there a workaround for making both work now in v3?

[pontusab]

@michel Yeah I solved my issue by:

typePolicies: {
  Project: {
          fields: {
            postsConnection: relayStylePagination(),
          },
        },
 },