Garbage collection not removing references edited by writeFragment

[patrikniebur]

Intended outcome:

When references are not reachable via normal query, running cache.gc() will remove the objects from cache regardless of the reference being edited using writeFragment

Actual outcome:

References that were edited using writeFragment are not deleted even though they are otherwise unreachable via normal query calling cache.gc() will not remove them.

How to reproduce the issue:

Reproduced sandbox

1. Write couple of objects into the cache using writeQuery
2. Edit one of them using writeFragment
3. Remove references from query by overwriting them with an empty array
4. Run garbage collection
5. Observe that reference that has been edited using writeFragment has not been removed.

Versions

  System:
    OS: macOS 13.0.1
  Binaries:
    Node: 16.13.0 - ~/.nvm/versions/node/v16.13.0/bin/node
    npm: 8.1.0 - ~/.nvm/versions/node/v16.13.0/bin/npm
  Browsers:
    Chrome: 107.0.5304.110
    Firefox: 104.0.1
    Safari: 16.1
  "dependencies": {
    "@apollo/client": "3.7.1",
    "graphql": "16.6.0",
  }

[patrikniebur]

Using writeFragment adds new root __META with extraRootIds property containing reference to edited object. This explains why calling gc does not delete the object but it seem to be unexpected side-effect.

[hwride]

The default mutation example in the client docs suggests using cache.writeFragment inside update to get a reference to an object so you can do things like manually update lists in the cache, see https://www.apollographql.com/docs/react/data/mutations/#the-update-function:

update(cache, { data: { addTodo } }) {
  cache.modify({
    fields: {
      todos(existingTodos = []) {
        const newTodoRef = cache.writeFragment({
          data: addTodo,
          fragment: gql`
              fragment NewTodo on Todo {
                  id
                  type
              }
          `
        });
        return [...existingTodos, newTodoRef];
      }
    }
  });
}

This seems to mean that if we use the default recommended example for these kind of updates, those objects will be always immune to garbage collection. I found this when trying to expand on the getting started example to remove things and then found they didn't disappear when running cache.gc(). I wonder if this is worth calling out in the docs?

[nathanjcochran]

I ran into this too. One workaround is to call cache.release() (see docs) after calling cache.writeFragment(), which effectively removes the reference from __META.extraRootIds and allows the object to be garbage collected if it's no longer reachable.

Using @hwride's code above as an example:

update(cache, { data: { addTodo } }) {
  cache.modify({
    fields: {
      todos(existingTodos = []) {
        const newTodoRef = cache.writeFragment({
          data: addTodo,
          fragment: gql`
              fragment NewTodo on Todo {
                  id
                  type
              }
          `
        });
        
        if (cache instanceof InMemoryCache && newTodoRef) {
          const newTodoId = cache.identify(newTodoRef);
          if (newTodoId) {
            apolloClient.cache.release(newTodoId);
          }
        }
        
        return [...existingTodos, newTodoRef];
      }
    }
  });
}

Note that cache.release() is only available on InMemoryCache (see #7563), which is the reason for the cache instanceof InMemoryCache check.