Why does my query operation get upgraded to "cache-first", despite explicitly setting it to "cache-only"?

[IsaacAderogba]

Love the work that's being done with URQL, though I seem to be hitting a wall with request policies.

I'm using GraphQL Code Generator to turn the following:

const getFeedback = gql`
  query getFeedback($id: ID!) {
    feedback(id: $id) {
      ...connectedFeedback // (a fragment that contains relational data such as comments)
    }
  }
`;

into a URQL query which I then use in my component as follows:

const [{ data: d, error, ...props }, exec] = useGetFeedbackQuery({
    variables: { id },
    requestPolicy: "cache-only"
  });

Creating a mutation at some later point

export const updateFeedbackTitle = gql`
  mutation updateFeedbackTitle($id: ID!, $input: FeedbackUpdateInput!) {
    feedbackUpdate(id: $id, input: $input) {
      change
      feedback {
        ...feedbackAttributes
      }
    }
  }
`;

causes the query to execute a network call, despite explicitly setting the request policy as cache-only (My default request policy is also cache-only as is set via the createClient call). This can be seen through the following logs, where you can observe stale gets set to true and the request policy gets upgraded to cache-first:

.

Can also be seen in the network logs where the mutation is the first request and the query is the second:

I'm new to URQL so I've defaulted to assume I'm doing something wrong. If not, am I missing something about how request policies work?

---

From more testing, if I isolate what the feedback query selects, then a network request is no longer made as the stale flag stays as false. Still noticing, however, that the requestPolicy still gets upgraded to cache-first:

export const getFeedback = gql`
  query getFeedback($id: ID!) {
    feedback(id: $id) {
      ...feedbackAttributes // <- select feedbackAttributes instead of connectedFeedback which contains the relational data
    }
  }
`;

[JoviDeCroock]

Hey,

The mutation causes the default document-based cache to invalidate the entity, this isn't on a query-level, it will just refetch the query if it's being watched as this mutation could have invalidated this entity.
It sees your mutation returning something of __typename Feedback and it sees that getFeedback observers entities with __typename Feedback this means that this naive cache has no other option then to refetch this entity as it could be stale.

More about this here

If you really want to stay on the client and do something locally with the response of your mutation we'll find ourselves in a normalized caching world.

More about this here

[IsaacAderogba]

Thank you for the reply! I should have clarified that I'm using cacheExchange from the @urql/exchange-graphcache package:

const cache = cacheExchange({
  schema: (schema as unknown) as IntrospectionQuery,
  optimistic: merge(
    note.optimistic,
    person.optimistic,
    topic.optimistic,
    workspace.optimistic,
    feedback.optimistic,
    quote.optimistic,
    insight.optimistic,
    topicInsight.optimistic
  ),
  resolvers: merge(
    note.resolvers,
    topic.resolvers,
    feedback.resolvers,
    quote.resolvers,
    topicInsight.resolvers,
    insight.resolvers
  ),
  updates: merge(
    note.updates,
    person.updates,
    topic.updates,
    workspace.updates,
    feedback.updates,
    quote.updates,
    insight.updates,
    topicInsight.updates,
    subscriptionHandler
  ),
});

Could the default document based cache still be interfering?

[JoviDeCroock]

Well for that I'd need to see your whole client, the reason a request would get upgraded with this is if your data is partial. This is when graphCache sees that your emdata is incomplete, you're asking for an attribute that is non-nullable according to the schema.

[IsaacAderogba]

Yeah that might have been it. I went through all of my local resolvers and commented out the relational field information:

Feedback: {
    // assignee: (parent) => ({ __typename: "User", id: parent.assigneeId }),
    // notes: (parent) => ({
    //   __typename: "NoteConnection",
    //   id: `Feedback:${parent.id}`,
    // }),
    // quotes: (parent) => ({
    //   __typename: "QuoteConnection",
    //   id: `Feedback:${parent.id}`,
    // }),
  },

It now seems to be working as expected. I'll review my schema to see what information is declared as non-nullable to fully get to the bottom of it. Thank you so much for your help!