@isograph/react 0.4.3 → 0.5.1

package/src/tests/optimisticProxy.test.ts

@@ -0,0 +1,862 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+import { type EncounteredIds } from '../core/cache';
+import {
+  createIsographStore,
+  type IsographEnvironment,
+  type StoreLayerData,
+} from '../core/IsographEnvironment';
+import {
+  addNetworkResponseStoreLayer as addNetworkResponseStoreLayerInner,
+  addOptimisticUpdaterStoreLayer as addOptimisticStoreLayerInner,
+  addStartUpdateStoreLayer as addStartUpdateStoreLayerInner,
+  getStoreRecordProxy,
+  revertOptimisticStoreLayerAndMaybeReplace,
+  type OptimisticStoreLayer,
+  type StoreLayer,
+} from '../core/optimisticProxy';
+import { callSubscriptions } from '../core/subscribe';
+import { createIsographEnvironment } from '../react/createIsographEnvironment';
+
+vi.mock(import('../core/subscribe'), { spy: true });
+
+const CHANGES = new Map([['Query', new Set(['__ROOT'])]]);
+const NO_CHANGES = new Map();
+
+describe('optimisticLayer', () => {
+  let environment: ReturnType<typeof createIsographEnvironment>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const networkFunction = vi
+      .fn()
+      .mockRejectedValue(new Error('Fetch failed'));
+    environment = createIsographEnvironment(
+      createIsographStore(),
+      networkFunction,
+    );
+    addNetworkResponseStoreLayer(environment, 0);
+  });
+
+  describe('addNetworkResponseStoreLayer', () => {
+    test('has parent BaseStoreLayer', () => {
+      expect(environment.store).toMatchObject({
+        kind: 'BaseStoreLayer',
+      });
+    });
+
+    test('merge', () => {
+      addOptimisticStoreLayer(environment, (counter) => counter + 1);
+      addNetworkResponseStoreLayer(environment, 3);
+      addNetworkResponseStoreLayer(environment, 4);
+
+      expect(environment.store).toMatchObject({
+        kind: 'NetworkResponseStoreLayer',
+        parentStoreLayer: {
+          kind: 'OptimisticUpdaterStoreLayer',
+          parentStoreLayer: {
+            kind: 'BaseStoreLayer',
+          },
+        },
+      });
+
+      expect(
+        getStoreRecordProxy(environment.store, {
+          __link: '__ROOT',
+          __typename: 'Query',
+        })?.counter,
+      ).toBe(4);
+    });
+  });
+
+  describe('addStartUpdateStoreLayer', () => {
+    test('merge', () => {
+      addOptimisticStoreLayer(environment, () => 1);
+      addStartUpdateStoreLayer(environment, (counter) => counter + 1);
+      addStartUpdateStoreLayer(environment, (counter) => counter + 1);
+
+      expect(environment.store).toMatchObject({
+        kind: 'StartUpdateStoreLayer',
+        parentStoreLayer: {
+          kind: 'OptimisticUpdaterStoreLayer',
+          parentStoreLayer: {
+            kind: 'BaseStoreLayer',
+          },
+        },
+      });
+      expect(
+        getStoreRecordProxy(environment.store, {
+          __link: '__ROOT',
+          __typename: 'Query',
+        })?.counter,
+      ).toBe(3);
+    });
+  });
+
+  describe('addOptimisticStoreLayer', () => {
+    test('add tree nodes', () => {
+      addOptimisticStoreLayer(environment, (counter) => counter + 1);
+      addOptimisticStoreLayer(environment, (counter) => counter + 1);
+      addOptimisticStoreLayer(environment, (counter) => counter + 1);
+
+      expect(
+        getStoreRecordProxy(environment.store, {
+          __link: '__ROOT',
+          __typename: 'Query',
+        })?.counter,
+      ).toBe(3);
+    });
+  });
+
+  describe('replaceOptimisticStoreLayerWithNetworkResponseStoreLayer', () => {
+    describe('subscriptions', () => {
+      test('calls if network response differs', () => {
+        const revert = addOptimisticStoreLayer(environment, () => 1);
+
+        revert(2);
+
+        expect(callSubscriptions).toHaveBeenCalledTimes(1);
+        expect(callSubscriptions).toHaveBeenNthCalledWith(
+          1,
+          expect.anything(),
+          CHANGES,
+        );
+      });
+
+      test("doesn't call subscriptions if no changes", () => {
+        const revert = addOptimisticStoreLayer(environment, () => 1);
+
+        revert(1);
+
+        expect(callSubscriptions).toHaveBeenCalledTimes(1);
+        expect(callSubscriptions).toHaveBeenNthCalledWith(
+          1,
+          expect.anything(),
+          NO_CHANGES,
+        );
+      });
+
+      test('calls subscriptions if nodes update different fields', () => {
+        const node = addOptimisticStoreLayerInner(
+          environment.store,
+          (storeLayer) => {
+            ignoreReadonly(storeLayer).data = {
+              Query: {
+                __ROOT: {
+                  surname: 'foo',
+                },
+              },
+            };
+            return CHANGES;
+          },
+        );
+        environment.store = node;
+        environment.store = addNetworkResponseStoreLayerInner(
+          environment.store,
+        );
+        ignoreReadonly(environment.store).data = {
+          Query: {
+            __ROOT: {
+              name: 'foo',
+            },
+          },
+        };
+
+        revertOptimisticStoreLayerAndMaybeReplace(
+          environment,
+          node,
+          (storeLayer) => {
+            ignoreReadonly(storeLayer).data = {
+              Query: { __ROOT: { surname: 'bar' } },
+            };
+            return CHANGES;
+          },
+        );
+
+        expect(callSubscriptions).toHaveBeenCalledTimes(1);
+        expect(callSubscriptions).toHaveBeenNthCalledWith(
+          1,
+          expect.anything(),
+          CHANGES,
+        );
+      });
+
+      test('calls subscriptions if reverted unrelated field', () => {
+        const node = addOptimisticStoreLayerInner(
+          environment.store,
+          (storeLayer) => {
+            ignoreReadonly(storeLayer).data = {
+              Pet: { 1: { surname: 'foo' } },
+            };
+            return new Map([['Pet', new Set(['1'])]]);
+          },
+        );
+        environment.store = node;
+
+        environment.store = addNetworkResponseStoreLayerInner(
+          environment.store,
+        );
+        ignoreReadonly(environment.store).data = {
+          Query: { __ROOT: { name: 'foo' } },
+        };
+
+        revertOptimisticStoreLayerAndMaybeReplace(
+          environment,
+          node,
+          (storeLayer) => {
+            ignoreReadonly(storeLayer).data = {};
+            return new Map();
+          },
+        );
+
+        expect(callSubscriptions).toHaveBeenCalledTimes(1);
+        expect(callSubscriptions).toHaveBeenNthCalledWith(
+          1,
+          expect.anything(),
+          new Map([['Pet', new Set(['1'])]]),
+        );
+      });
+    });
+
+    describe('with parent BaseStoreLayer', () => {
+      test('merges ', () => {
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'BaseStoreLayer',
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(5);
+      });
+
+      test('merges children', () => {
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addNetworkResponseStoreLayer(environment, 12);
+
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'BaseStoreLayer',
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(12);
+      });
+
+      test('merges children and stops at optimistic child node', () => {
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addStartUpdateStoreLayer(environment, (counter) => counter + 1);
+        addNetworkResponseStoreLayer(environment, 12);
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+
+        revert(4);
+
+        expect(environment.store).toMatchObject({
+          kind: 'OptimisticUpdaterStoreLayer',
+          parentStoreLayer: {
+            kind: 'BaseStoreLayer',
+          },
+        });
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(13);
+      });
+
+      test('reexecutes updates while merging children', () => {
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addStartUpdateStoreLayer(environment, (counter) => counter * 2);
+        addStartUpdateStoreLayer(environment, (counter) => counter + 7);
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+
+        revert(4);
+
+        expect(environment.store).toMatchObject({
+          kind: 'OptimisticUpdaterStoreLayer',
+          parentStoreLayer: {
+            kind: 'BaseStoreLayer',
+          },
+        });
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(16);
+      });
+
+      test('stops at optimistic child node', () => {
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'OptimisticUpdaterStoreLayer',
+          parentStoreLayer: {
+            kind: 'BaseStoreLayer',
+          },
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(6);
+      });
+    });
+
+    describe('adjacent with NetworkResponseStoreLayer', () => {
+      test('merges with parent NetworkResponseStoreLayer', () => {
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+        addNetworkResponseStoreLayer(environment, 10);
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addNetworkResponseStoreLayer(environment, 12);
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'NetworkResponseStoreLayer',
+          parentStoreLayer: {
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          },
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(12);
+      });
+
+      test('merges child NetworkResponseStoreLayer', () => {
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addNetworkResponseStoreLayer(environment, 12);
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'NetworkResponseStoreLayer',
+          parentStoreLayer: {
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          },
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(12);
+      });
+
+      test('merges between two NetworkResponseStoreLayers', () => {
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+        addNetworkResponseStoreLayer(environment, 10);
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addNetworkResponseStoreLayer(environment, 12);
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'NetworkResponseStoreLayer',
+          parentStoreLayer: {
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          },
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(12);
+      });
+    });
+
+    describe('has parent OptimisticStoreLayer', () => {
+      test('replaces self with network response', () => {
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'NetworkResponseStoreLayer',
+          parentStoreLayer: {
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          },
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(5);
+      });
+      test("doesn't merge child nodes if has parent nodes", () => {
+        addOptimisticStoreLayer(environment, (counter) => counter + 1);
+        const revert = addOptimisticStoreLayer(
+          environment,
+          (counter) => counter + 1,
+        );
+        addStartUpdateStoreLayer(environment, (counter) => counter + 1);
+
+        revert(5);
+
+        expect(environment.store).toMatchObject({
+          kind: 'StartUpdateStoreLayer',
+          parentStoreLayer: {
+            kind: 'NetworkResponseStoreLayer',
+            parentStoreLayer: {
+              kind: 'OptimisticUpdaterStoreLayer',
+              parentStoreLayer: {
+                kind: 'BaseStoreLayer',
+              },
+            },
+          },
+        });
+
+        expect(
+          getStoreRecordProxy(environment.store, {
+            __link: '__ROOT',
+            __typename: 'Query',
+          })?.counter,
+        ).toBe(6);
+      });
+    });
+
+    describe('network error', () => {
+      describe('subscriptions', () => {
+        test('calls if network response differs', () => {
+          const revert = addOptimisticStoreLayer(environment, () => 1);
+
+          revert(null);
+
+          expect(callSubscriptions).toHaveBeenCalledTimes(1);
+          expect(callSubscriptions).toHaveBeenNthCalledWith(
+            1,
+            expect.anything(),
+            CHANGES,
+          );
+        });
+
+        test('calls subscriptions if reverted unrelated field', () => {
+          const node = addOptimisticStoreLayerInner(
+            environment.store,
+            (storeLayer) => {
+              ignoreReadonly(storeLayer).data = {
+                Pet: { 1: { surname: 'foo' } },
+              };
+              return new Map([['Pet', new Set(['1'])]]);
+            },
+          );
+          environment.store = node;
+
+          environment.store = addNetworkResponseStoreLayerInner(
+            environment.store,
+          );
+          ignoreReadonly(environment.store).data = {
+            Query: { __ROOT: { name: 'foo' } },
+          };
+
+          revert(environment, node, null);
+
+          expect(callSubscriptions).toHaveBeenCalledTimes(1);
+          expect(callSubscriptions).toHaveBeenNthCalledWith(
+            1,
+            expect.anything(),
+            new Map([['Pet', new Set(['1'])]]),
+          );
+        });
+      });
+
+      describe('with parent BaseStoreLayer', () => {
+        test('removes self ', () => {
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'BaseStoreLayer',
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(0);
+        });
+
+        test('merges children', () => {
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addNetworkResponseStoreLayer(environment, 12);
+
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'BaseStoreLayer',
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(12);
+        });
+
+        test('merges children and stops at optimistic child node', () => {
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addStartUpdateStoreLayer(environment, (counter) => counter + 1);
+          addNetworkResponseStoreLayer(environment, 12);
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          });
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(13);
+        });
+
+        test('reexecutes updates while merging children', () => {
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addStartUpdateStoreLayer(environment, (counter) => counter + 2);
+          addStartUpdateStoreLayer(environment, (counter) => counter * 7);
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          });
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(15);
+        });
+
+        test('stops at optimistic child node', () => {
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(1);
+        });
+      });
+
+      describe('adjacent with NetworkResponseStoreLayer', () => {
+        test('merges with parent NetworkResponseStoreLayer', () => {
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+          addNetworkResponseStoreLayer(environment, 10);
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addNetworkResponseStoreLayer(environment, 12);
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'NetworkResponseStoreLayer',
+            parentStoreLayer: {
+              kind: 'OptimisticUpdaterStoreLayer',
+              parentStoreLayer: {
+                kind: 'BaseStoreLayer',
+              },
+            },
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(12);
+        });
+
+        test('merges child NetworkResponseStoreLayer', () => {
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addNetworkResponseStoreLayer(environment, 12);
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'NetworkResponseStoreLayer',
+            parentStoreLayer: {
+              kind: 'OptimisticUpdaterStoreLayer',
+              parentStoreLayer: {
+                kind: 'BaseStoreLayer',
+              },
+            },
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(12);
+        });
+
+        test('removes self and merges two adjacent NetworkResponseStoreLayers', () => {
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+          addNetworkResponseStoreLayer(environment, 10);
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addNetworkResponseStoreLayer(environment, 12);
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'NetworkResponseStoreLayer',
+            parentStoreLayer: {
+              kind: 'OptimisticUpdaterStoreLayer',
+              parentStoreLayer: {
+                kind: 'BaseStoreLayer',
+              },
+            },
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(12);
+        });
+      });
+
+      describe('has parent OptimisticStoreLayer', () => {
+        test('removes self', () => {
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'OptimisticUpdaterStoreLayer',
+            parentStoreLayer: {
+              kind: 'BaseStoreLayer',
+            },
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(1);
+        });
+
+        test("doesn't merge child nodes if has parent nodes", () => {
+          addOptimisticStoreLayer(environment, (counter) => counter + 1);
+          const revert = addOptimisticStoreLayer(
+            environment,
+            (counter) => counter + 1,
+          );
+          addStartUpdateStoreLayer(environment, (counter) => counter + 1);
+
+          revert(null);
+
+          expect(environment.store).toMatchObject({
+            kind: 'StartUpdateStoreLayer',
+            parentStoreLayer: {
+              kind: 'OptimisticUpdaterStoreLayer',
+              parentStoreLayer: {
+                kind: 'BaseStoreLayer',
+              },
+            },
+          });
+
+          expect(
+            getStoreRecordProxy(environment.store, {
+              __link: '__ROOT',
+              __typename: 'Query',
+            })?.counter,
+          ).toBe(2);
+        });
+      });
+    });
+  });
+
+  // utils
+  function addNetworkResponseStoreLayer(
+    environment: IsographEnvironment,
+    counter: number,
+  ) {
+    environment.store = addNetworkResponseStoreLayerInner(environment.store);
+    update(environment.store, () => counter);
+  }
+
+  function addOptimisticStoreLayer(
+    environment: IsographEnvironment,
+    updater: (prev: number) => number,
+  ) {
+    const node = addOptimisticStoreLayerInner(
+      environment.store,
+      (storeLayer) => {
+        return update(storeLayer, updater);
+      },
+    );
+    environment.store = node;
+    return (counter: null | number) => {
+      revert(environment, node, counter);
+    };
+  }
+
+  function revert(
+    environment: IsographEnvironment,
+    node: OptimisticStoreLayer,
+    counter: null | number,
+  ) {
+    return revertOptimisticStoreLayerAndMaybeReplace(
+      environment,
+      node,
+      counter == null
+        ? counter
+        : (storeLayer) => update(storeLayer, () => counter),
+    );
+  }
+
+  function addStartUpdateStoreLayer(
+    environment: IsographEnvironment,
+    updater: (prev: number) => number,
+  ) {
+    const node = addStartUpdateStoreLayerInner(
+      environment.store,
+      (storeLayer) => {
+        return update(storeLayer, updater);
+      },
+    );
+    environment.store = node;
+  }
+
+  const update = (
+    storeLayer: StoreLayer,
+    value: (counter: number) => number,
+  ): EncounteredIds => {
+    const { counter } =
+      getStoreRecordProxy(storeLayer, {
+        __link: '__ROOT',
+        __typename: 'Query',
+      }) ?? {};
+    const nextCounter = value(Number(counter));
+
+    ignoreReadonly(storeLayer).data = {
+      Query: {
+        __ROOT: {
+          counter: nextCounter,
+        },
+      },
+    };
+
+    return counter !== nextCounter ? CHANGES : NO_CHANGES;
+  };
+
+  function ignoreReadonly(value: StoreLayer): { data: StoreLayerData } {
+    return value;
+  }
+});