offlineExchange doesn't apply cyclic optimistic mutations

[jdkula]

urql version & exchanges:

• urql 2.2.1
• urql/exchange-graphcache 4.4.2

Using exchanges [dedupExchange, offlineExchange, fetchExchange]

Steps to reproduce

A minimal reproduction is available here: https://github.com/jdkula/urql-graphcache-layering-bug-reproduction

1. Use offlineExchange with optimistic mutations
2. Go offline
3. Mutate your data so it ends up in a cycle (e.g. set value to 0, set value to 1, set value to 0)
4. Note that any additional mutations on that data don't change state

Expected behavior

Cyclical mutations should be allowed (e.g. set value to 0, set value to 1, set value to 0, set value to 1, ...)

Actual behavior

Additional mutations once the cycle is established seem to be lost (it appears to be updating the resultant optimistic result somewhere deeper in the cache's optimistic layers, according to the calculated hash/key of the mutation/operation).

[kitten]

Hm, this could be a regression in regards to:

• Should custom updates triggered by optimistic mutation be repeated? #1079 (Fix: (graphcache) - Clear optimistic updates before retrying in offlineExchange #1080)
• Repeated calls to cache.updateQuery do not perform cumulative effects #1073 (Fix: (graphcache) - Reenable cumulative optimistic updates #1074)
  In regards to cumulative updates. It may be related to some changes in: fix(graphcache): Shift layers with future updates and improve layer behaviour #2419
  I suppose, the easiest way to fix this is to reproduce this issue in our test suite before (graphcache) - Reenable cumulative optimistic updates #1074's release, then testing that it succeeds after, then tracing the failure as a regression on the current version.

[JoviDeCroock]

I have managed to reproduce this in a test but generally this feels like it has never worked, it only happens when the second mutation has the same key

it('supports updating an optimisticly updated entity', () => {
  const store = new Store({
    optimistic: {
      updateTodo: (args) => ({
        __typename: 'Todo',
        id: args.id,
        complete: args.completed,
      }),
    },
  });

  const todosData = {
    __typename: 'Query',
    todos: [
      { id: '0', complete: false, text: '0', __typename: 'Todo' },
      { id: '1', complete: false, text: '1', __typename: 'Todo' },
    ],
  };

  write(store, { query: Todos }, todosData);

  const updateTodo = gql`
    mutation($id: ID!, $completed: Boolean!) {
      __typename
      updateTodo(id: $id, completed: $completed) {
        __typename
        complete
        id
      }
    }
  `;

  writeOptimistic(store, { query: updateTodo, variables: { id: '0', completed: true } }, 1);

  let queryRes = query(store, { query: Todos });
  expect(queryRes.partial).toBe(false);
  expect(queryRes.data.todos[0].complete).toEqual(true);

  writeOptimistic(store, { query: updateTodo, variables: { id: '0', completed: false } }, 2);

  queryRes = query(store, { query: Todos });

  expect(queryRes.partial).toBe(false);
  expect(queryRes.data.todos[0].complete).toEqual(false);

  writeOptimistic(store, { query: updateTodo, variables: { id: '0', completed: true } }, 1);
  queryRes = query(store, { query: Todos });
  expect(queryRes.partial).toBe(false);
  expect(queryRes.data.todos[0].complete).toEqual(true);
});