···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

       
2
       
+
       
'@urql/exchange-graphcache': minor

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Track list of entity keys for a given type name. This enables enumerating and invalidating all entities of a given type within the normalized cache.

     

···

       
490
       
 
       
mutation by enumerating all `todos` listing fields using `cache.inspectFields` and targetedly

     

       
491
       
 
       
invalidate only these fields, which causes all queries using these listing fields to be refetched.

     

       
492
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
493
       
 
       
## Optimistic updates

     

       
494
       
 
       


     

       
495
       
 
       
If we know what result a mutation may return, why wait for the GraphQL API to fulfill our mutations?

     

···

       
490
       
 
       
mutation by enumerating all `todos` listing fields using `cache.inspectFields` and targetedly

     

       
491
       
 
       
invalidate only these fields, which causes all queries using these listing fields to be refetched.

     

       
492
       
 
       


     

       
493
       
+
       
### Invalidating a type

     

       
494
       
+
       


     

       
495
       
+
       
We can also invalidate all the entities of a given type, this could be handy in the case of a

     

       
496
       
+
       
list update or when you aren't sure what entity is affected.

     

       
497
       
+
       


     

       
498
       
+
       
This can be done by only passing the relevant `__typename` to the `invalidate` function.

     

       
499
       
+
       


     

       
500
       
+
       
```js

     

       
501
       
+
       
cacheExchange({

     

       
502
       
+
       
  updates: {

     

       
503
       
+
       
    Mutation: {

     

       
504
       
+
       
      deleteTodo(_result, args, cache, _info) {

     

       
505
       
+
       
        cache.invalidate('Todo');

     

       
506
       
+
       
      },

     

       
507
       
+
       
    },

     

       
508
       
+
       
  },

     

       
509
       
+
       
});

     

       
510
       
+
       
```

     

       
511
       
+
       


     

       
512
       
 
       
## Optimistic updates

     

       
513
       
 
       


     

       
514
       
 
       
If we know what result a mutation may return, why wait for the GraphQL API to fulfill our mutations?

     

···

       
24
       
 
       
    }

     

       
25
       
 
       
  }

     

       
26
       
 
       
};

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
24
       
 
       
    }

     

       
25
       
 
       
  }

     

       
26
       
 
       
};

     

       
27
       
+
       


     

       
28
       
+
       
export const invalidateType = (typename: string) => {

     

       
29
       
+
       
  const types = InMemoryData.getEntitiesForType(typename);

     

       
30
       
+
       
  for (const entity of types) {

     

       
31
       
+
       
    invalidateEntity(entity);

     

       
32
       
+
       
  }

     

       
33
       
+
       
};

     

···

       
232
       
 
       
    return;

     

       
233
       
 
       
  } else if (!isRoot && entityKey) {

     

       
234
       
 
       
    InMemoryData.writeRecord(entityKey, '__typename', typename);

     

       
0
       
 
       

     

       
235
       
 
       
  }

     

       
236
       
 
       


     

       
237
       
 
       
  const updates = ctx.store.updates[typename];

     

···

       
232
       
 
       
    return;

     

       
233
       
 
       
  } else if (!isRoot && entityKey) {

     

       
234
       
 
       
    InMemoryData.writeRecord(entityKey, '__typename', typename);

     

       
235
       
+
       
    InMemoryData.writeType(typename, entityKey);

     

       
236
       
 
       
  }

     

       
237
       
 
       


     

       
238
       
 
       
  const updates = ctx.store.updates[typename];

     

···

       
16
       
 
       
    InMemoryData.writeRecord('Todo:2', '__typename', 'Todo');

     

       
17
       
 
       
    InMemoryData.writeRecord('Query', '__typename', 'Query');

     

       
18
       
 
       
    InMemoryData.writeLink('Query', 'todo', 'Todo:1');

     

       
0
       
 
       

     

       
19
       
 
       


     

       
20
       
 
       
    InMemoryData.gc();

     

       
21
       
 
       


     

       
22
       
 
       
    expect(InMemoryData.readLink('Query', 'todo')).toBe('Todo:1');

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
23
       
 
       


     

       
24
       
 
       
    InMemoryData.writeLink('Query', 'todo', undefined);

     

       
25
       
 
       
    InMemoryData.gc();

     

       
26
       
 
       


     

       
27
       
 
       
    expect(InMemoryData.readLink('Query', 'todo')).toBe(undefined);

     

       
28
       
 
       
    expect(InMemoryData.readRecord('Todo:1', 'id')).toBe(undefined);

     

       
0
       
 
       

     

       
29
       
 
       


     

       
30
       
 
       
    expect(InMemoryData.getCurrentDependencies()).toEqual(

     

       
31
       
 
       
      new Set(['Todo:1', 'Todo:2', 'Query.todo'])

     
···

       
39
       
 
       
    InMemoryData.writeLink('Query', 'todo', 'Todo:1');

     

       
40
       
 
       
    InMemoryData.writeLink('Query', 'todo', undefined);

     

       
41
       
 
       
    InMemoryData.writeLink('Query', 'newTodo', 'Todo:1');

     

       
0
       
 
       

     

       
42
       
 
       


     

       
43
       
 
       
    InMemoryData.gc();

     

       
44
       
 
       


     

       
45
       
 
       
    expect(InMemoryData.readLink('Query', 'newTodo')).toBe('Todo:1');

     

       
46
       
 
       
    expect(InMemoryData.readLink('Query', 'todo')).toBe(undefined);

     

       
47
       
 
       
    expect(InMemoryData.readRecord('Todo:1', 'id')).toBe('1');

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
48
       
 
       


     

       
49
       
 
       
    expect(InMemoryData.getCurrentDependencies()).toEqual(

     

       
50
       
 
       
      new Set(['Todo:1', 'Query.todo', 'Query.newTodo'])

     
···

       
101
       
 
       
    InMemoryData.writeRecord('Todo:1', '__typename', 'Todo');

     

       
102
       
 
       
    InMemoryData.writeRecord('Todo:1', 'id', '1');

     

       
103
       
 
       
    InMemoryData.writeLink('Query', 'todo', 'Todo:1');

     

       
0
       
 
       

     

       
0
       
 
       

     

       
104
       
 
       


     

       
105
       
 
       
    InMemoryData.writeLink('Query', 'todo', undefined);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
106
       
 
       
    InMemoryData.gc();

     

       
107
       
 
       


     

       
108
       
 
       
    expect(InMemoryData.readRecord('Todo:1', 'id')).toBe(undefined);

     

       
109
       
 
       
    expect(InMemoryData.readRecord('Author:1', 'id')).toBe(undefined);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
110
       
 
       


     

       
111
       
 
       
    expect(InMemoryData.getCurrentDependencies()).toEqual(

     

       
112
       
 
       
      new Set(['Author:1', 'Todo:1', 'Query.todo'])

     

···

       
16
       
 
       
    InMemoryData.writeRecord('Todo:2', '__typename', 'Todo');

     

       
17
       
 
       
    InMemoryData.writeRecord('Query', '__typename', 'Query');

     

       
18
       
 
       
    InMemoryData.writeLink('Query', 'todo', 'Todo:1');

     

       
19
       
+
       
    InMemoryData.writeType('Todo', 'Todo:1');

     

       
20
       
 
       


     

       
21
       
 
       
    InMemoryData.gc();

     

       
22
       
 
       


     

       
23
       
 
       
    expect(InMemoryData.readLink('Query', 'todo')).toBe('Todo:1');

     

       
24
       
+
       
    expect(InMemoryData.getEntitiesForType('Todo')).toEqual(

     

       
25
       
+
       
      new Set(['Todo:1'])

     

       
26
       
+
       
    );

     

       
27
       
 
       


     

       
28
       
 
       
    InMemoryData.writeLink('Query', 'todo', undefined);

     

       
29
       
 
       
    InMemoryData.gc();

     

       
30
       
 
       


     

       
31
       
 
       
    expect(InMemoryData.readLink('Query', 'todo')).toBe(undefined);

     

       
32
       
 
       
    expect(InMemoryData.readRecord('Todo:1', 'id')).toBe(undefined);

     

       
33
       
+
       
    expect(InMemoryData.getEntitiesForType('Todo')).toEqual(new Set());

     

       
34
       
 
       


     

       
35
       
 
       
    expect(InMemoryData.getCurrentDependencies()).toEqual(

     

       
36
       
 
       
      new Set(['Todo:1', 'Todo:2', 'Query.todo'])

     
···

       
44
       
 
       
    InMemoryData.writeLink('Query', 'todo', 'Todo:1');

     

       
45
       
 
       
    InMemoryData.writeLink('Query', 'todo', undefined);

     

       
46
       
 
       
    InMemoryData.writeLink('Query', 'newTodo', 'Todo:1');

     

       
47
       
+
       
    InMemoryData.writeType('Todo', 'Todo:1');

     

       
48
       
 
       


     

       
49
       
 
       
    InMemoryData.gc();

     

       
50
       
 
       


     

       
51
       
 
       
    expect(InMemoryData.readLink('Query', 'newTodo')).toBe('Todo:1');

     

       
52
       
 
       
    expect(InMemoryData.readLink('Query', 'todo')).toBe(undefined);

     

       
53
       
 
       
    expect(InMemoryData.readRecord('Todo:1', 'id')).toBe('1');

     

       
54
       
+
       
    expect(InMemoryData.getEntitiesForType('Todo')).toEqual(

     

       
55
       
+
       
      new Set(['Todo:1'])

     

       
56
       
+
       
    );

     

       
57
       
 
       


     

       
58
       
 
       
    expect(InMemoryData.getCurrentDependencies()).toEqual(

     

       
59
       
 
       
      new Set(['Todo:1', 'Query.todo', 'Query.newTodo'])

     
···

       
110
       
 
       
    InMemoryData.writeRecord('Todo:1', '__typename', 'Todo');

     

       
111
       
 
       
    InMemoryData.writeRecord('Todo:1', 'id', '1');

     

       
112
       
 
       
    InMemoryData.writeLink('Query', 'todo', 'Todo:1');

     

       
113
       
+
       
    InMemoryData.writeType('Todo', 'Todo:1');

     

       
114
       
+
       
    InMemoryData.writeType('Author', 'Author:1');

     

       
115
       
 
       


     

       
116
       
 
       
    InMemoryData.writeLink('Query', 'todo', undefined);

     

       
117
       
+
       
    expect(InMemoryData.getEntitiesForType('Todo')).toEqual(

     

       
118
       
+
       
      new Set(['Todo:1'])

     

       
119
       
+
       
    );

     

       
120
       
+
       
    expect(InMemoryData.getEntitiesForType('Author')).toEqual(

     

       
121
       
+
       
      new Set(['Author:1'])

     

       
122
       
+
       
    );

     

       
123
       
 
       
    InMemoryData.gc();

     

       
124
       
 
       


     

       
125
       
 
       
    expect(InMemoryData.readRecord('Todo:1', 'id')).toBe(undefined);

     

       
126
       
 
       
    expect(InMemoryData.readRecord('Author:1', 'id')).toBe(undefined);

     

       
127
       
+
       
    expect(InMemoryData.getEntitiesForType('Todo')).toEqual(new Set());

     

       
128
       
+
       
    expect(InMemoryData.getEntitiesForType('Author')).toEqual(new Set());

     

       
129
       
 
       


     

       
130
       
 
       
    expect(InMemoryData.getCurrentDependencies()).toEqual(

     

       
131
       
 
       
      new Set(['Author:1', 'Todo:1', 'Query.todo'])

     

···

       
47
       
 
       
  records: NodeMap<EntityField>;

     

       
48
       
 
       
  /** A map of entity links which are connections from one entity to another (key-value entries per entity) */

     

       
49
       
 
       
  links: NodeMap<Link>;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
50
       
 
       
  /** A set of Query operation keys that are in-flight and deferred/streamed */

     

       
51
       
 
       
  deferredKeys: Set<number>;

     

       
52
       
 
       
  /** A set of Query operation keys that are in-flight and awaiting a result */

     
···

       
234
       
 
       
  return currentDependencies;

     

       
235
       
 
       
};

     

       
236
       
 
       


     

       
0
       
 
       

     

       
237
       
 
       
export const make = (queryRootKey: string): InMemoryData => ({

     

       
238
       
 
       
  hydrating: false,

     

       
239
       
 
       
  defer: false,

     

       
240
       
 
       
  gc: new Set(),

     

       
0
       
 
       

     

       
241
       
 
       
  persist: new Set(),

     

       
242
       
 
       
  queryRootKey,

     

       
243
       
 
       
  refCount: new Map(),

     
···

       
409
       
 
       
    const rc = currentData!.refCount.get(entityKey) || 0;

     

       
410
       
 
       
    if (rc > 0) continue;

     

       
411
       
 
       


     

       
0
       
 
       

     

       
412
       
 
       
    // Delete the reference count, and delete the entity from the GC batch

     

       
413
       
 
       
    currentData!.refCount.delete(entityKey);

     

       
414
       
 
       
    currentData!.records.base.delete(entityKey);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
415
       
 
       
    const linkNode = currentData!.links.base.get(entityKey);

     

       
416
       
 
       
    if (linkNode) {

     

       
417
       
 
       
      currentData!.links.base.delete(entityKey);

     
···

       
450
       
 
       
): Link | undefined => {

     

       
451
       
 
       
  updateDependencies(entityKey, fieldKey);

     

       
452
       
 
       
  return getNode(currentData!.links, entityKey, fieldKey);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
453
       
 
       
};

     

       
454
       
 
       


     

       
455
       
 
       
/** Writes an entity's field (a "record") to data */

     

···

       
47
       
 
       
  records: NodeMap<EntityField>;

     

       
48
       
 
       
  /** A map of entity links which are connections from one entity to another (key-value entries per entity) */

     

       
49
       
 
       
  links: NodeMap<Link>;

     

       
50
       
+
       
  /** A map of typename to a list of entity-keys belonging to said type */

     

       
51
       
+
       
  types: Map<string, Set<string>>;

     

       
52
       
 
       
  /** A set of Query operation keys that are in-flight and deferred/streamed */

     

       
53
       
 
       
  deferredKeys: Set<number>;

     

       
54
       
 
       
  /** A set of Query operation keys that are in-flight and awaiting a result */

     
···

       
236
       
 
       
  return currentDependencies;

     

       
237
       
 
       
};

     

       
238
       
 
       


     

       
239
       
+
       
const DEFAULT_EMPTY_SET = new Set<string>();

     

       
240
       
 
       
export const make = (queryRootKey: string): InMemoryData => ({

     

       
241
       
 
       
  hydrating: false,

     

       
242
       
 
       
  defer: false,

     

       
243
       
 
       
  gc: new Set(),

     

       
244
       
+
       
  types: new Map(),

     

       
245
       
 
       
  persist: new Set(),

     

       
246
       
 
       
  queryRootKey,

     

       
247
       
 
       
  refCount: new Map(),

     
···

       
413
       
 
       
    const rc = currentData!.refCount.get(entityKey) || 0;

     

       
414
       
 
       
    if (rc > 0) continue;

     

       
415
       
 
       


     

       
416
       
+
       
    const record = currentData!.records.base.get(entityKey);

     

       
417
       
 
       
    // Delete the reference count, and delete the entity from the GC batch

     

       
418
       
 
       
    currentData!.refCount.delete(entityKey);

     

       
419
       
 
       
    currentData!.records.base.delete(entityKey);

     

       
420
       
+
       


     

       
421
       
+
       
    const typename = (record && record.__typename) as string | undefined;

     

       
422
       
+
       
    if (typename) {

     

       
423
       
+
       
      const type = currentData!.types.get(typename);

     

       
424
       
+
       
      if (type) type.delete(entityKey);

     

       
425
       
+
       
    }

     

       
426
       
+
       


     

       
427
       
 
       
    const linkNode = currentData!.links.base.get(entityKey);

     

       
428
       
 
       
    if (linkNode) {

     

       
429
       
 
       
      currentData!.links.base.delete(entityKey);

     
···

       
462
       
 
       
): Link | undefined => {

     

       
463
       
 
       
  updateDependencies(entityKey, fieldKey);

     

       
464
       
 
       
  return getNode(currentData!.links, entityKey, fieldKey);

     

       
465
       
+
       
};

     

       
466
       
+
       


     

       
467
       
+
       
export const getEntitiesForType = (typename: string): Set<string> =>

     

       
468
       
+
       
  currentData!.types.get(typename) || DEFAULT_EMPTY_SET;

     

       
469
       
+
       


     

       
470
       
+
       
export const writeType = (typename: string, entityKey: string) => {

     

       
471
       
+
       
  const existingTypes = currentData!.types.get(typename);

     

       
472
       
+
       
  if (!existingTypes) {

     

       
473
       
+
       
    const typeSet = new Set<string>();

     

       
474
       
+
       
    typeSet.add(entityKey);

     

       
475
       
+
       
    currentData!.types.set(typename, typeSet);

     

       
476
       
+
       
  } else {

     

       
477
       
+
       
    existingTypes.add(entityKey);

     

       
478
       
+
       
  }

     

       
479
       
 
       
};

     

       
480
       
 
       


     

       
481
       
 
       
/** Writes an entity's field (a "record") to data */

     

···

       
844
       
 
       
      expect(data).toBe(null);

     

       
845
       
 
       
    });

     

       
846
       
 
       
  });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
847
       
 
       
});

     

       
848
       
 
       


     

       
849
       
 
       
describe('Store with storage', () => {

     

···

       
844
       
 
       
      expect(data).toBe(null);

     

       
845
       
 
       
    });

     

       
846
       
 
       
  });

     

       
847
       
+
       


     

       
848
       
+
       
  describe('Invalidating a type', () => {

     

       
849
       
+
       
    it('removes an entity from a list.', () => {

     

       
850
       
+
       
      InMemoryData.initDataState('write', store.data, null);

     

       
851
       
+
       
      store.invalidate('Todo');

     

       
852
       
+
       
      const { data } = query(store, { query: Todos });

     

       
853
       
+
       
      expect(data).toBe(null);

     

       
854
       
+
       
    });

     

       
855
       
+
       
  });

     

       
856
       
 
       
});

     

       
857
       
 
       


     

       
858
       
 
       
describe('Store with storage', () => {

     

···

       
24
       
 
       
import { contextRef, ensureLink } from '../operations/shared';

     

       
25
       
 
       
import { _query, _queryFragment } from '../operations/query';

     

       
26
       
 
       
import { _write, _writeFragment } from '../operations/write';

     

       
27
       
-
       
import { invalidateEntity } from '../operations/invalidate';

     

       
28
       
 
       
import { keyOfField } from './keys';

     

       
29
       
 
       
import * as InMemoryData from './data';

     

       
30
       
 
       


     
···

       
170
       
 
       


     

       
171
       
 
       
  invalidate(entity: Entity, field?: string, args?: FieldArgs) {

     

       
172
       
 
       
    const entityKey = this.keyOfEntity(entity);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
173
       
 
       


     

       
174
       
-
       
    invariant(

     

       
175
       
-
       
      entityKey,

     

       
176
       
-
       
      "Can't generate a key for invalidate(...).\n" +

     

       
177
       
-
       
        'You have to pass an id or _id field or create a custom `keys` field for `' +

     

       
178
       
-
       
        (typeof entity === 'object'

     

       
179
       
-
       
          ? (entity as Data).__typename

     

       
180
       
-
       
          : entity + '`.'),

     

       
181
       
-
       
      19

     

       
182
       
-
       
    );

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
183
       
 
       


     

       
184
       
-
       
    invalidateEntity(entityKey, field, args);

     

       
0
       
 
       

     

       
185
       
 
       
  }

     

       
186
       
 
       


     

       
187
       
 
       
  inspectFields(entity: Entity): FieldInfo[] {

     

···

       
24
       
 
       
import { contextRef, ensureLink } from '../operations/shared';

     

       
25
       
 
       
import { _query, _queryFragment } from '../operations/query';

     

       
26
       
 
       
import { _write, _writeFragment } from '../operations/write';

     

       
27
       
+
       
import { invalidateEntity, invalidateType } from '../operations/invalidate';

     

       
28
       
 
       
import { keyOfField } from './keys';

     

       
29
       
 
       
import * as InMemoryData from './data';

     

       
30
       
 
       


     
···

       
170
       
 
       


     

       
171
       
 
       
  invalidate(entity: Entity, field?: string, args?: FieldArgs) {

     

       
172
       
 
       
    const entityKey = this.keyOfEntity(entity);

     

       
173
       
+
       
    const shouldInvalidateType =

     

       
174
       
+
       
      entity && typeof entity === 'string' && !field && !args;

     

       
175
       
 
       


     

       
176
       
+
       
    if (shouldInvalidateType) {

     

       
177
       
+
       
      invalidateType(entity);

     

       
178
       
+
       
    } else {

     

       
179
       
+
       
      invariant(

     

       
180
       
+
       
        entityKey,

     

       
181
       
+
       
        "Can't generate a key for invalidate(...).\n" +

     

       
182
       
+
       
          'You have to pass an id or _id field or create a custom `keys` field for `' +

     

       
183
       
+
       
          (typeof entity === 'object'

     

       
184
       
+
       
            ? (entity as Data).__typename

     

       
185
       
+
       
            : entity + '`.'),

     

       
186
       
+
       
        19

     

       
187
       
+
       
      );

     

       
188
       
 
       


     

       
189
       
+
       
      invalidateEntity(entityKey, field, args);

     

       
190
       
+
       
    }

     

       
191
       
 
       
  }

     

       
192
       
 
       


     

       
193
       
 
       
  inspectFields(entity: Entity): FieldInfo[] {