···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

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

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Add optional `logger` to the options, this allows you to filter out warnings or disable them all together

     

···

       
32
       
 
       
| `optimistic` | A mapping of mutation fields to resolvers that may be used to provide _Graphcache_ with an optimistic result for a given mutation field that should be applied to the cached data temporarily.                                |

     

       
33
       
 
       
| `schema`     | A serialized GraphQL schema that is used by _Graphcache_ to resolve partial data, interfaces, and enums. The schema also used to provide helpful warnings for [schema awareness](../graphcache/schema-awareness.md).          |

     

       
34
       
 
       
| `storage`    | A persisted storage interface that may be provided to preserve cache data for [offline support](../graphcache/offline.md).                                                                                                    |

     

       
0
       
 
       

     

       
35
       
 
       


     

       
36
       
 
       
The `@urql/exchange-graphcache` package also exports the `offlineExchange`; which is identical to

     

       
37
       
 
       
the `cacheExchange` but activates [offline support](../graphcache/offline.md) when the `storage` option is passed.

     

···

       
32
       
 
       
| `optimistic` | A mapping of mutation fields to resolvers that may be used to provide _Graphcache_ with an optimistic result for a given mutation field that should be applied to the cached data temporarily.                                |

     

       
33
       
 
       
| `schema`     | A serialized GraphQL schema that is used by _Graphcache_ to resolve partial data, interfaces, and enums. The schema also used to provide helpful warnings for [schema awareness](../graphcache/schema-awareness.md).          |

     

       
34
       
 
       
| `storage`    | A persisted storage interface that may be provided to preserve cache data for [offline support](../graphcache/offline.md).                                                                                                    |

     

       
35
       
+
       
| `logger`     | A function that will be invoked for warning/debug/... logs                                                                                                                                                                    |

     

       
36
       
 
       


     

       
37
       
 
       
The `@urql/exchange-graphcache` package also exports the `offlineExchange`; which is identical to

     

       
38
       
 
       
the `cacheExchange` but activates [offline support](../graphcache/offline.md) when the `storage` option is passed.

     

···

       
57
       
 
       


     

       
58
       
 
       
  it('should indicate nullability', () => {

     

       
59
       
 
       
    expect(

     

       
60
       
-
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'text')

     

       
61
       
 
       
    ).toBeFalsy();

     

       
62
       
 
       
    expect(

     

       
63
       
-
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'complete')

     

       
64
       
 
       
    ).toBeTruthy();

     

       
65
       
 
       
    expect(

     

       
66
       
-
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'author')

     

       
67
       
 
       
    ).toBeTruthy();

     

       
68
       
 
       
  });

     

       
69
       
 
       


     
···

       
89
       
 
       


     

       
90
       
 
       
  it('should throw if a requested type does not exist', () => {

     

       
91
       
 
       
    expect(() =>

     

       
92
       
-
       
      SchemaPredicates.isFieldNullable(schema, 'SomeInvalidType', 'complete')

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
93
       
 
       
    ).toThrow(

     

       
94
       
 
       
      'The type `SomeInvalidType` is not an object in the defined schema, but the GraphQL document is traversing it.\nhttps://bit.ly/2XbVrpR#3'

     

       
95
       
 
       
    );

     
···

       
97
       
 
       


     

       
98
       
 
       
  it('should warn in console if a requested field does not exist', () => {

     

       
99
       
 
       
    expect(

     

       
100
       
-
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'goof')

     

       
101
       
 
       
    ).toBeFalsy();

     

       
102
       
 
       


     

       
103
       
 
       
    expect(console.warn).toBeCalledTimes(1);

     

···

       
57
       
 
       


     

       
58
       
 
       
  it('should indicate nullability', () => {

     

       
59
       
 
       
    expect(

     

       
60
       
+
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'text', undefined)

     

       
61
       
 
       
    ).toBeFalsy();

     

       
62
       
 
       
    expect(

     

       
63
       
+
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'complete', undefined)

     

       
64
       
 
       
    ).toBeTruthy();

     

       
65
       
 
       
    expect(

     

       
66
       
+
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'author', undefined)

     

       
67
       
 
       
    ).toBeTruthy();

     

       
68
       
 
       
  });

     

       
69
       
 
       


     
···

       
89
       
 
       


     

       
90
       
 
       
  it('should throw if a requested type does not exist', () => {

     

       
91
       
 
       
    expect(() =>

     

       
92
       
+
       
      SchemaPredicates.isFieldNullable(

     

       
93
       
+
       
        schema,

     

       
94
       
+
       
        'SomeInvalidType',

     

       
95
       
+
       
        'complete',

     

       
96
       
+
       
        undefined

     

       
97
       
+
       
      )

     

       
98
       
 
       
    ).toThrow(

     

       
99
       
 
       
      'The type `SomeInvalidType` is not an object in the defined schema, but the GraphQL document is traversing it.\nhttps://bit.ly/2XbVrpR#3'

     

       
100
       
 
       
    );

     
···

       
102
       
 
       


     

       
103
       
 
       
  it('should warn in console if a requested field does not exist', () => {

     

       
104
       
 
       
    expect(

     

       
105
       
+
       
      SchemaPredicates.isFieldNullable(schema, 'Todo', 'goof', undefined)

     

       
106
       
 
       
    ).toBeFalsy();

     

       
107
       
 
       


     

       
108
       
 
       
    expect(console.warn).toBeCalledTimes(1);

     

···

       
12
       
 
       
  UpdatesConfig,

     

       
13
       
 
       
  ResolverConfig,

     

       
14
       
 
       
  OptimisticMutationConfig,

     

       
0
       
 
       

     

       
15
       
 
       
} from '../types';

     

       
16
       
 
       


     

       
17
       
 
       
const BUILTIN_NAME = '__';

     
···

       
19
       
 
       
export const isFieldNullable = (

     

       
20
       
 
       
  schema: SchemaIntrospector,

     

       
21
       
 
       
  typename: string,

     

       
22
       
-
       
  fieldName: string

     

       
0
       
 
       

     

       
23
       
 
       
): boolean => {

     

       
24
       
-
       
  const field = getField(schema, typename, fieldName);

     

       
25
       
 
       
  return !!field && field.type.kind !== 'NON_NULL';

     

       
26
       
 
       
};

     

       
27
       
 
       


     

       
28
       
 
       
export const isListNullable = (

     

       
29
       
 
       
  schema: SchemaIntrospector,

     

       
30
       
 
       
  typename: string,

     

       
31
       
-
       
  fieldName: string

     

       
0
       
 
       

     

       
32
       
 
       
): boolean => {

     

       
33
       
-
       
  const field = getField(schema, typename, fieldName);

     

       
34
       
 
       
  if (!field) return false;

     

       
35
       
 
       
  const ofType =

     

       
36
       
 
       
    field.type.kind === 'NON_NULL' ? field.type.ofType : field.type;

     
···

       
40
       
 
       
export const isFieldAvailableOnType = (

     

       
41
       
 
       
  schema: SchemaIntrospector,

     

       
42
       
 
       
  typename: string,

     

       
43
       
-
       
  fieldName: string

     

       
0
       
 
       

     

       
44
       
 
       
): boolean =>

     

       
45
       
 
       
  fieldName.indexOf(BUILTIN_NAME) === 0 ||

     

       
46
       
 
       
  typename.indexOf(BUILTIN_NAME) === 0 ||

     

       
47
       
-
       
  !!getField(schema, typename, fieldName);

     

       
48
       
 
       


     

       
49
       
 
       
export const isInterfaceOfType = (

     

       
50
       
 
       
  schema: SchemaIntrospector,

     
···

       
70
       
 
       
const getField = (

     

       
71
       
 
       
  schema: SchemaIntrospector,

     

       
72
       
 
       
  typename: string,

     

       
73
       
-
       
  fieldName: string

     

       
0
       
 
       

     

       
74
       
 
       
) => {

     

       
75
       
 
       
  if (

     

       
76
       
 
       
    fieldName.indexOf(BUILTIN_NAME) === 0 ||

     
···

       
90
       
 
       
        '`, ' +

     

       
91
       
 
       
        'but the GraphQL document expects it to exist.\n' +

     

       
92
       
 
       
        'Traversal will continue, however this may lead to undefined behavior!',

     

       
93
       
-
       
      4

     

       
0
       
 
       

     

       
94
       
 
       
    );

     

       
95
       
 
       
  }

     

       
96
       
 
       


     
···

       
124
       
 
       


     

       
125
       
 
       
export function expectValidKeyingConfig(

     

       
126
       
 
       
  schema: SchemaIntrospector,

     

       
127
       
-
       
  keys: KeyingConfig

     

       
0
       
 
       

     

       
128
       
 
       
): void {

     

       
129
       
 
       
  if (process.env.NODE_ENV !== 'production') {

     

       
130
       
 
       
    for (const key in keys) {

     
···

       
133
       
 
       
          'Invalid Object type: The type `' +

     

       
134
       
 
       
            key +

     

       
135
       
 
       
            '` is not an object in the defined schema, but the `keys` option is referencing it.',

     

       
136
       
-
       
          20

     

       
0
       
 
       

     

       
137
       
 
       
        );

     

       
138
       
 
       
      }

     

       
139
       
 
       
    }

     
···

       
142
       
 
       


     

       
143
       
 
       
export function expectValidUpdatesConfig(

     

       
144
       
 
       
  schema: SchemaIntrospector,

     

       
145
       
-
       
  updates: UpdatesConfig

     

       
0
       
 
       

     

       
146
       
 
       
): void {

     

       
147
       
 
       
  if (process.env.NODE_ENV === 'production') {

     

       
148
       
 
       
    return;

     
···

       
175
       
 
       
          typename +

     

       
176
       
 
       
          '` is not an object in the defined schema, but the `updates` config is referencing it.' +

     

       
177
       
 
       
          addition,

     

       
178
       
-
       
        21

     

       
0
       
 
       

     

       
179
       
 
       
      );

     

       
180
       
 
       
    }

     

       
181
       
 
       


     
···

       
188
       
 
       
            '` on `' +

     

       
189
       
 
       
            typename +

     

       
190
       
 
       
            '` is not in the defined schema, but the `updates` config is referencing it.',

     

       
191
       
-
       
          22

     

       
0
       
 
       

     

       
192
       
 
       
        );

     

       
193
       
 
       
      }

     

       
194
       
 
       
    }

     

       
195
       
 
       
  }

     

       
196
       
 
       
}

     

       
197
       
 
       


     

       
198
       
-
       
function warnAboutResolver(name: string): void {

     

       
199
       
 
       
  warn(

     

       
200
       
 
       
    `Invalid resolver: \`${name}\` is not in the defined schema, but the \`resolvers\` option is referencing it.`,

     

       
201
       
-
       
    23

     

       
0
       
 
       

     

       
202
       
 
       
  );

     

       
203
       
 
       
}

     

       
204
       
 
       


     

       
205
       
 
       
function warnAboutAbstractResolver(

     

       
206
       
 
       
  name: string,

     

       
207
       
-
       
  kind: 'UNION' | 'INTERFACE'

     

       
0
       
 
       

     

       
208
       
 
       
): void {

     

       
209
       
 
       
  warn(

     

       
210
       
 
       
    `Invalid resolver: \`${name}\` does not match to a concrete type in the schema, but the \`resolvers\` option is referencing it. Implement the resolver for the types that ${

     

       
211
       
 
       
      kind === 'UNION' ? 'make up the union' : 'implement the interface'

     

       
212
       
 
       
    } instead.`,

     

       
213
       
-
       
    26

     

       
0
       
 
       

     

       
214
       
 
       
  );

     

       
215
       
 
       
}

     

       
216
       
 
       


     

       
217
       
 
       
export function expectValidResolversConfig(

     

       
218
       
 
       
  schema: SchemaIntrospector,

     

       
219
       
-
       
  resolvers: ResolverConfig

     

       
0
       
 
       

     

       
220
       
 
       
): void {

     

       
221
       
 
       
  if (process.env.NODE_ENV === 'production') {

     

       
222
       
 
       
    return;

     
···

       
230
       
 
       
        ).fields();

     

       
231
       
 
       
        for (const resolverQuery in resolvers.Query || {}) {

     

       
232
       
 
       
          if (!validQueries[resolverQuery]) {

     

       
233
       
-
       
            warnAboutResolver('Query.' + resolverQuery);

     

       
234
       
 
       
          }

     

       
235
       
 
       
        }

     

       
236
       
 
       
      } else {

     

       
237
       
-
       
        warnAboutResolver('Query');

     

       
238
       
 
       
      }

     

       
239
       
 
       
    } else {

     

       
240
       
 
       
      if (!schema.types!.has(key)) {

     

       
241
       
-
       
        warnAboutResolver(key);

     

       
242
       
 
       
      } else if (

     

       
243
       
 
       
        schema.types!.get(key)!.kind === 'INTERFACE' ||

     

       
244
       
 
       
        schema.types!.get(key)!.kind === 'UNION'

     

       
245
       
 
       
      ) {

     

       
246
       
 
       
        warnAboutAbstractResolver(

     

       
247
       
 
       
          key,

     

       
248
       
-
       
          schema.types!.get(key)!.kind as 'INTERFACE' | 'UNION'

     

       
0
       
 
       

     

       
249
       
 
       
        );

     

       
250
       
 
       
      } else {

     

       
251
       
 
       
        const validTypeProperties = (

     
···

       
253
       
 
       
        ).fields();

     

       
254
       
 
       
        for (const resolverProperty in resolvers[key] || {}) {

     

       
255
       
 
       
          if (!validTypeProperties[resolverProperty]) {

     

       
256
       
-
       
            warnAboutResolver(key + '.' + resolverProperty);

     

       
257
       
 
       
          }

     

       
258
       
 
       
        }

     

       
259
       
 
       
      }

     
···

       
263
       
 
       


     

       
264
       
 
       
export function expectValidOptimisticMutationsConfig(

     

       
265
       
 
       
  schema: SchemaIntrospector,

     

       
266
       
-
       
  optimisticMutations: OptimisticMutationConfig

     

       
0
       
 
       

     

       
267
       
 
       
): void {

     

       
268
       
 
       
  if (process.env.NODE_ENV === 'production') {

     

       
269
       
 
       
    return;

     
···

       
277
       
 
       
      if (!validMutations[mutation]) {

     

       
278
       
 
       
        warn(

     

       
279
       
 
       
          `Invalid optimistic mutation field: \`${mutation}\` is not a mutation field in the defined schema, but the \`optimistic\` option is referencing it.`,

     

       
280
       
-
       
          24

     

       
0
       
 
       

     

       
281
       
 
       
        );

     

       
282
       
 
       
      }

     

       
283
       
 
       
    }

     

···

       
12
       
 
       
  UpdatesConfig,

     

       
13
       
 
       
  ResolverConfig,

     

       
14
       
 
       
  OptimisticMutationConfig,

     

       
15
       
+
       
  Logger,

     

       
16
       
 
       
} from '../types';

     

       
17
       
 
       


     

       
18
       
 
       
const BUILTIN_NAME = '__';

     
···

       
20
       
 
       
export const isFieldNullable = (

     

       
21
       
 
       
  schema: SchemaIntrospector,

     

       
22
       
 
       
  typename: string,

     

       
23
       
+
       
  fieldName: string,

     

       
24
       
+
       
  logger: Logger | undefined

     

       
25
       
 
       
): boolean => {

     

       
26
       
+
       
  const field = getField(schema, typename, fieldName, logger);

     

       
27
       
 
       
  return !!field && field.type.kind !== 'NON_NULL';

     

       
28
       
 
       
};

     

       
29
       
 
       


     

       
30
       
 
       
export const isListNullable = (

     

       
31
       
 
       
  schema: SchemaIntrospector,

     

       
32
       
 
       
  typename: string,

     

       
33
       
+
       
  fieldName: string,

     

       
34
       
+
       
  logger: Logger | undefined

     

       
35
       
 
       
): boolean => {

     

       
36
       
+
       
  const field = getField(schema, typename, fieldName, logger);

     

       
37
       
 
       
  if (!field) return false;

     

       
38
       
 
       
  const ofType =

     

       
39
       
 
       
    field.type.kind === 'NON_NULL' ? field.type.ofType : field.type;

     
···

       
43
       
 
       
export const isFieldAvailableOnType = (

     

       
44
       
 
       
  schema: SchemaIntrospector,

     

       
45
       
 
       
  typename: string,

     

       
46
       
+
       
  fieldName: string,

     

       
47
       
+
       
  logger: Logger | undefined

     

       
48
       
 
       
): boolean =>

     

       
49
       
 
       
  fieldName.indexOf(BUILTIN_NAME) === 0 ||

     

       
50
       
 
       
  typename.indexOf(BUILTIN_NAME) === 0 ||

     

       
51
       
+
       
  !!getField(schema, typename, fieldName, logger);

     

       
52
       
 
       


     

       
53
       
 
       
export const isInterfaceOfType = (

     

       
54
       
 
       
  schema: SchemaIntrospector,

     
···

       
74
       
 
       
const getField = (

     

       
75
       
 
       
  schema: SchemaIntrospector,

     

       
76
       
 
       
  typename: string,

     

       
77
       
+
       
  fieldName: string,

     

       
78
       
+
       
  logger: Logger | undefined

     

       
79
       
 
       
) => {

     

       
80
       
 
       
  if (

     

       
81
       
 
       
    fieldName.indexOf(BUILTIN_NAME) === 0 ||

     
···

       
95
       
 
       
        '`, ' +

     

       
96
       
 
       
        'but the GraphQL document expects it to exist.\n' +

     

       
97
       
 
       
        'Traversal will continue, however this may lead to undefined behavior!',

     

       
98
       
+
       
      4,

     

       
99
       
+
       
      logger

     

       
100
       
 
       
    );

     

       
101
       
 
       
  }

     

       
102
       
 
       


     
···

       
130
       
 
       


     

       
131
       
 
       
export function expectValidKeyingConfig(

     

       
132
       
 
       
  schema: SchemaIntrospector,

     

       
133
       
+
       
  keys: KeyingConfig,

     

       
134
       
+
       
  logger: Logger | undefined

     

       
135
       
 
       
): void {

     

       
136
       
 
       
  if (process.env.NODE_ENV !== 'production') {

     

       
137
       
 
       
    for (const key in keys) {

     
···

       
140
       
 
       
          'Invalid Object type: The type `' +

     

       
141
       
 
       
            key +

     

       
142
       
 
       
            '` is not an object in the defined schema, but the `keys` option is referencing it.',

     

       
143
       
+
       
          20,

     

       
144
       
+
       
          logger

     

       
145
       
 
       
        );

     

       
146
       
 
       
      }

     

       
147
       
 
       
    }

     
···

       
150
       
 
       


     

       
151
       
 
       
export function expectValidUpdatesConfig(

     

       
152
       
 
       
  schema: SchemaIntrospector,

     

       
153
       
+
       
  updates: UpdatesConfig,

     

       
154
       
+
       
  logger: Logger | undefined

     

       
155
       
 
       
): void {

     

       
156
       
 
       
  if (process.env.NODE_ENV === 'production') {

     

       
157
       
 
       
    return;

     
···

       
184
       
 
       
          typename +

     

       
185
       
 
       
          '` is not an object in the defined schema, but the `updates` config is referencing it.' +

     

       
186
       
 
       
          addition,

     

       
187
       
+
       
        21,

     

       
188
       
+
       
        logger

     

       
189
       
 
       
      );

     

       
190
       
 
       
    }

     

       
191
       
 
       


     
···

       
198
       
 
       
            '` on `' +

     

       
199
       
 
       
            typename +

     

       
200
       
 
       
            '` is not in the defined schema, but the `updates` config is referencing it.',

     

       
201
       
+
       
          22,

     

       
202
       
+
       
          logger

     

       
203
       
 
       
        );

     

       
204
       
 
       
      }

     

       
205
       
 
       
    }

     

       
206
       
 
       
  }

     

       
207
       
 
       
}

     

       
208
       
 
       


     

       
209
       
+
       
function warnAboutResolver(name: string, logger: Logger | undefined): void {

     

       
210
       
 
       
  warn(

     

       
211
       
 
       
    `Invalid resolver: \`${name}\` is not in the defined schema, but the \`resolvers\` option is referencing it.`,

     

       
212
       
+
       
    23,

     

       
213
       
+
       
    logger

     

       
214
       
 
       
  );

     

       
215
       
 
       
}

     

       
216
       
 
       


     

       
217
       
 
       
function warnAboutAbstractResolver(

     

       
218
       
 
       
  name: string,

     

       
219
       
+
       
  kind: 'UNION' | 'INTERFACE',

     

       
220
       
+
       
  logger: Logger | undefined

     

       
221
       
 
       
): void {

     

       
222
       
 
       
  warn(

     

       
223
       
 
       
    `Invalid resolver: \`${name}\` does not match to a concrete type in the schema, but the \`resolvers\` option is referencing it. Implement the resolver for the types that ${

     

       
224
       
 
       
      kind === 'UNION' ? 'make up the union' : 'implement the interface'

     

       
225
       
 
       
    } instead.`,

     

       
226
       
+
       
    26,

     

       
227
       
+
       
    logger

     

       
228
       
 
       
  );

     

       
229
       
 
       
}

     

       
230
       
 
       


     

       
231
       
 
       
export function expectValidResolversConfig(

     

       
232
       
 
       
  schema: SchemaIntrospector,

     

       
233
       
+
       
  resolvers: ResolverConfig,

     

       
234
       
+
       
  logger: Logger | undefined

     

       
235
       
 
       
): void {

     

       
236
       
 
       
  if (process.env.NODE_ENV === 'production') {

     

       
237
       
 
       
    return;

     
···

       
245
       
 
       
        ).fields();

     

       
246
       
 
       
        for (const resolverQuery in resolvers.Query || {}) {

     

       
247
       
 
       
          if (!validQueries[resolverQuery]) {

     

       
248
       
+
       
            warnAboutResolver('Query.' + resolverQuery, logger);

     

       
249
       
 
       
          }

     

       
250
       
 
       
        }

     

       
251
       
 
       
      } else {

     

       
252
       
+
       
        warnAboutResolver('Query', logger);

     

       
253
       
 
       
      }

     

       
254
       
 
       
    } else {

     

       
255
       
 
       
      if (!schema.types!.has(key)) {

     

       
256
       
+
       
        warnAboutResolver(key, logger);

     

       
257
       
 
       
      } else if (

     

       
258
       
 
       
        schema.types!.get(key)!.kind === 'INTERFACE' ||

     

       
259
       
 
       
        schema.types!.get(key)!.kind === 'UNION'

     

       
260
       
 
       
      ) {

     

       
261
       
 
       
        warnAboutAbstractResolver(

     

       
262
       
 
       
          key,

     

       
263
       
+
       
          schema.types!.get(key)!.kind as 'INTERFACE' | 'UNION',

     

       
264
       
+
       
          logger

     

       
265
       
 
       
        );

     

       
266
       
 
       
      } else {

     

       
267
       
 
       
        const validTypeProperties = (

     
···

       
269
       
 
       
        ).fields();

     

       
270
       
 
       
        for (const resolverProperty in resolvers[key] || {}) {

     

       
271
       
 
       
          if (!validTypeProperties[resolverProperty]) {

     

       
272
       
+
       
            warnAboutResolver(key + '.' + resolverProperty, logger);

     

       
273
       
 
       
          }

     

       
274
       
 
       
        }

     

       
275
       
 
       
      }

     
···

       
279
       
 
       


     

       
280
       
 
       
export function expectValidOptimisticMutationsConfig(

     

       
281
       
 
       
  schema: SchemaIntrospector,

     

       
282
       
+
       
  optimisticMutations: OptimisticMutationConfig,

     

       
283
       
+
       
  logger: Logger | undefined

     

       
284
       
 
       
): void {

     

       
285
       
 
       
  if (process.env.NODE_ENV === 'production') {

     

       
286
       
 
       
    return;

     
···

       
294
       
 
       
      if (!validMutations[mutation]) {

     

       
295
       
 
       
        warn(

     

       
296
       
 
       
          `Invalid optimistic mutation field: \`${mutation}\` is not a mutation field in the defined schema, but the \`optimistic\` option is referencing it.`,

     

       
297
       
+
       
          24,

     

       
298
       
+
       
          logger

     

       
299
       
 
       
        );

     

       
300
       
 
       
      }

     

       
301
       
 
       
    }

     

···

       
7
       
 
       
  ExecutableDefinitionNode,

     

       
8
       
 
       
  InlineFragmentNode,

     

       
9
       
 
       
} from '@0no-co/graphql.web';

     

       
0
       
 
       

     

       
10
       
 
       
import { Kind } from '@0no-co/graphql.web';

     

       
11
       
 
       


     

       
12
       
 
       
export type ErrorCode =

     
···

       
89
       
 
       
  }

     

       
90
       
 
       
}

     

       
91
       
 
       


     

       
92
       
-
       
export function warn(message: string, code: ErrorCode) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
93
       
 
       
  if (!cache.has(message)) {

     

       
94
       
-
       
    console.warn(message + getDebugOutput() + helpUrl + code);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
95
       
 
       
    cache.add(message);

     

       
96
       
 
       
  }

     

       
97
       
 
       
}

     

···

       
7
       
 
       
  ExecutableDefinitionNode,

     

       
8
       
 
       
  InlineFragmentNode,

     

       
9
       
 
       
} from '@0no-co/graphql.web';

     

       
10
       
+
       
import type { Logger } from '../types';

     

       
11
       
 
       
import { Kind } from '@0no-co/graphql.web';

     

       
12
       
 
       


     

       
13
       
 
       
export type ErrorCode =

     
···

       
90
       
 
       
  }

     

       
91
       
 
       
}

     

       
92
       
 
       


     

       
93
       
+
       
export function warn(

     

       
94
       
+
       
  message: string,

     

       
95
       
+
       
  code: ErrorCode,

     

       
96
       
+
       
  logger: Logger | undefined

     

       
97
       
+
       
) {

     

       
98
       
 
       
  if (!cache.has(message)) {

     

       
99
       
+
       
    if (logger) {

     

       
100
       
+
       
      logger('warn', message + getDebugOutput() + helpUrl + code);

     

       
101
       
+
       
    } else {

     

       
102
       
+
       
      console.warn(message + getDebugOutput() + helpUrl + code);

     

       
103
       
+
       
    }

     

       
104
       
 
       
    cache.add(message);

     

       
105
       
 
       
  }

     

       
106
       
 
       
}

     

···

       
235
       
 
       
          ' but could only find ' +

     

       
236
       
 
       
          Object.keys(fragments).join(', ') +

     

       
237
       
 
       
          '.',

     

       
238
       
-
       
        6

     

       
0
       
 
       

     

       
239
       
 
       
      );

     

       
240
       
 
       


     

       
241
       
 
       
      return null;

     
···

       
247
       
 
       
      warn(

     

       
248
       
 
       
        'readFragment(...) was called with an empty fragment.\n' +

     

       
249
       
 
       
          'You have to call it with at least one fragment in your GraphQL document.',

     

       
250
       
-
       
        6

     

       
0
       
 
       

     

       
251
       
 
       
      );

     

       
252
       
 
       


     

       
253
       
 
       
      return null;

     
···

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

     

       
265
       
 
       
        typename +

     

       
266
       
 
       
        '`.',

     

       
267
       
-
       
      7

     

       
0
       
 
       

     

       
268
       
 
       
    );

     

       
269
       
 
       


     

       
270
       
 
       
    return null;

     
···

       
327
       
 
       
  if (fieldResolver && directiveResolver) {

     

       
328
       
 
       
    warn(

     

       
329
       
 
       
      `A resolver and directive is being used at "${typename}.${fieldName}" simultaneously. Only the directive will apply.`,

     

       
330
       
-
       
      28

     

       
0
       
 
       

     

       
331
       
 
       
    );

     

       
332
       
 
       
  }

     

       
333
       
 
       


     
···

       
356
       
 
       
        ctx.store.rootFields.subscription +

     

       
357
       
 
       
        '` types are special ' +

     

       
358
       
 
       
        'Operation Root Types and cannot be read back from the cache.',

     

       
359
       
-
       
      25

     

       
0
       
 
       

     

       
360
       
 
       
    );

     

       
361
       
 
       
  }

     

       
362
       
 
       


     
···

       
373
       
 
       
        entityKey +

     

       
374
       
 
       
        '` returned an ' +

     

       
375
       
 
       
        'invalid typename that could not be reconciled with the cache.',

     

       
376
       
-
       
      8

     

       
0
       
 
       

     

       
377
       
 
       
    );

     

       
378
       
 
       


     

       
379
       
 
       
    return;

     
···

       
406
       
 
       
    const resultValue = result ? result[fieldName] : undefined;

     

       
407
       
 
       


     

       
408
       
 
       
    if (process.env.NODE_ENV !== 'production' && store.schema && typename) {

     

       
409
       
-
       
      isFieldAvailableOnType(store.schema, typename, fieldName);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
410
       
 
       
    }

     

       
411
       
 
       


     

       
412
       
 
       
    // Add the current alias to the walked path before processing the field's value

     
···

       
466
       
 
       
      if (

     

       
467
       
 
       
        store.schema &&

     

       
468
       
 
       
        dataFieldValue === null &&

     

       
469
       
-
       
        !isFieldNullable(store.schema, typename, fieldName)

     

       
470
       
 
       
      ) {

     

       
471
       
 
       
        // Special case for when null is not a valid value for the

     

       
472
       
 
       
        // current field

     
···

       
519
       
 
       
      dataFieldValue === undefined &&

     

       
520
       
 
       
      (directives.optional ||

     

       
521
       
 
       
        !!getFieldError(ctx) ||

     

       
522
       
-
       
        (store.schema && isFieldNullable(store.schema, typename, fieldName)))

     

       
0
       
 
       

     

       
523
       
 
       
    ) {

     

       
524
       
 
       
      // The field is uncached or has errored, so it'll be set to null and skipped

     

       
525
       
 
       
      ctx.partial = true;

     
···

       
570
       
 
       
    // Check whether values of the list may be null; for resolvers we assume

     

       
571
       
 
       
    // that they can be, since it's user-provided data

     

       
572
       
 
       
    const _isListNullable = store.schema

     

       
573
       
-
       
      ? isListNullable(store.schema, typename, fieldName)

     

       
574
       
 
       
      : false;

     

       
575
       
 
       
    const hasPartials = ctx.partial;

     

       
576
       
 
       
    const data = InMemoryData.makeData(prevData, true);

     
···

       
622
       
 
       
        key +

     

       
623
       
 
       
        '` is a scalar (number, boolean, etc)' +

     

       
624
       
 
       
        ', but the GraphQL query expects a selection set for this field.',

     

       
625
       
-
       
      9

     

       
0
       
 
       

     

       
626
       
 
       
    );

     

       
627
       
 
       


     

       
628
       
 
       
    return undefined;

     
···

       
641
       
 
       
  if (Array.isArray(link)) {

     

       
642
       
 
       
    const { store } = ctx;

     

       
643
       
 
       
    const _isListNullable = store.schema

     

       
644
       
-
       
      ? isListNullable(store.schema, typename, fieldName)

     

       
645
       
 
       
      : false;

     

       
646
       
 
       
    const newLink = InMemoryData.makeData(prevData, true);

     

       
647
       
 
       
    const hasPartials = ctx.partial;

     

···

       
235
       
 
       
          ' but could only find ' +

     

       
236
       
 
       
          Object.keys(fragments).join(', ') +

     

       
237
       
 
       
          '.',

     

       
238
       
+
       
        6,

     

       
239
       
+
       
        store.logger

     

       
240
       
 
       
      );

     

       
241
       
 
       


     

       
242
       
 
       
      return null;

     
···

       
248
       
 
       
      warn(

     

       
249
       
 
       
        'readFragment(...) was called with an empty fragment.\n' +

     

       
250
       
 
       
          'You have to call it with at least one fragment in your GraphQL document.',

     

       
251
       
+
       
        6,

     

       
252
       
+
       
        store.logger

     

       
253
       
 
       
      );

     

       
254
       
 
       


     

       
255
       
 
       
      return null;

     
···

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

     

       
267
       
 
       
        typename +

     

       
268
       
 
       
        '`.',

     

       
269
       
+
       
      7,

     

       
270
       
+
       
      store.logger

     

       
271
       
 
       
    );

     

       
272
       
 
       


     

       
273
       
 
       
    return null;

     
···

       
330
       
 
       
  if (fieldResolver && directiveResolver) {

     

       
331
       
 
       
    warn(

     

       
332
       
 
       
      `A resolver and directive is being used at "${typename}.${fieldName}" simultaneously. Only the directive will apply.`,

     

       
333
       
+
       
      28,

     

       
334
       
+
       
      ctx.store.logger

     

       
335
       
 
       
    );

     

       
336
       
 
       
  }

     

       
337
       
 
       


     
···

       
360
       
 
       
        ctx.store.rootFields.subscription +

     

       
361
       
 
       
        '` types are special ' +

     

       
362
       
 
       
        'Operation Root Types and cannot be read back from the cache.',

     

       
363
       
+
       
      25,

     

       
364
       
+
       
      store.logger

     

       
365
       
 
       
    );

     

       
366
       
 
       
  }

     

       
367
       
 
       


     
···

       
378
       
 
       
        entityKey +

     

       
379
       
 
       
        '` returned an ' +

     

       
380
       
 
       
        'invalid typename that could not be reconciled with the cache.',

     

       
381
       
+
       
      8,

     

       
382
       
+
       
      store.logger

     

       
383
       
 
       
    );

     

       
384
       
 
       


     

       
385
       
 
       
    return;

     
···

       
412
       
 
       
    const resultValue = result ? result[fieldName] : undefined;

     

       
413
       
 
       


     

       
414
       
 
       
    if (process.env.NODE_ENV !== 'production' && store.schema && typename) {

     

       
415
       
+
       
      isFieldAvailableOnType(

     

       
416
       
+
       
        store.schema,

     

       
417
       
+
       
        typename,

     

       
418
       
+
       
        fieldName,

     

       
419
       
+
       
        ctx.store.logger

     

       
420
       
+
       
      );

     

       
421
       
 
       
    }

     

       
422
       
 
       


     

       
423
       
 
       
    // Add the current alias to the walked path before processing the field's value

     
···

       
477
       
 
       
      if (

     

       
478
       
 
       
        store.schema &&

     

       
479
       
 
       
        dataFieldValue === null &&

     

       
480
       
+
       
        !isFieldNullable(store.schema, typename, fieldName, ctx.store.logger)

     

       
481
       
 
       
      ) {

     

       
482
       
 
       
        // Special case for when null is not a valid value for the

     

       
483
       
 
       
        // current field

     
···

       
530
       
 
       
      dataFieldValue === undefined &&

     

       
531
       
 
       
      (directives.optional ||

     

       
532
       
 
       
        !!getFieldError(ctx) ||

     

       
533
       
+
       
        (store.schema &&

     

       
534
       
+
       
          isFieldNullable(store.schema, typename, fieldName, ctx.store.logger)))

     

       
535
       
 
       
    ) {

     

       
536
       
 
       
      // The field is uncached or has errored, so it'll be set to null and skipped

     

       
537
       
 
       
      ctx.partial = true;

     
···

       
582
       
 
       
    // Check whether values of the list may be null; for resolvers we assume

     

       
583
       
 
       
    // that they can be, since it's user-provided data

     

       
584
       
 
       
    const _isListNullable = store.schema

     

       
585
       
+
       
      ? isListNullable(store.schema, typename, fieldName, ctx.store.logger)

     

       
586
       
 
       
      : false;

     

       
587
       
 
       
    const hasPartials = ctx.partial;

     

       
588
       
 
       
    const data = InMemoryData.makeData(prevData, true);

     
···

       
634
       
 
       
        key +

     

       
635
       
 
       
        '` is a scalar (number, boolean, etc)' +

     

       
636
       
 
       
        ', but the GraphQL query expects a selection set for this field.',

     

       
637
       
+
       
      9,

     

       
638
       
+
       
      ctx.store.logger

     

       
639
       
 
       
    );

     

       
640
       
 
       


     

       
641
       
 
       
    return undefined;

     
···

       
654
       
 
       
  if (Array.isArray(link)) {

     

       
655
       
 
       
    const { store } = ctx;

     

       
656
       
 
       
    const _isListNullable = store.schema

     

       
657
       
+
       
      ? isListNullable(store.schema, typename, fieldName, ctx.store.logger)

     

       
658
       
 
       
      : false;

     

       
659
       
 
       
    const newLink = InMemoryData.makeData(prevData, true);

     

       
660
       
 
       
    const hasPartials = ctx.partial;

     

···

       
25
       
 
       
  Link,

     

       
26
       
 
       
  Entity,

     

       
27
       
 
       
  Data,

     

       
0
       
 
       

     

       
28
       
 
       
} from '../types';

     

       
29
       
 
       


     

       
30
       
 
       
export interface Context {

     
···

       
117
       
 
       
  node: FormattedNode<InlineFragmentNode | FragmentDefinitionNode>,

     

       
118
       
 
       
  typename: void | string,

     

       
119
       
 
       
  entityKey: string,

     

       
120
       
-
       
  vars: Variables

     

       
0
       
 
       

     

       
121
       
 
       
) => {

     

       
122
       
 
       
  if (!typename) return false;

     

       
123
       
 
       
  const typeCondition = getTypeCondition(node);

     
···

       
134
       
 
       
      '` may be an ' +

     

       
135
       
 
       
      'interface.\nA schema needs to be defined for this match to be deterministic, ' +

     

       
136
       
 
       
      'otherwise the fragment will be matched heuristically!',

     

       
137
       
-
       
    16

     

       
0
       
 
       

     

       
138
       
 
       
  );

     

       
139
       
 
       


     

       
140
       
 
       
  return (

     
···

       
192
       
 
       
                    fragment,

     

       
193
       
 
       
                    typename,

     

       
194
       
 
       
                    entityKey,

     

       
195
       
-
       
                    ctx.variables

     

       
0
       
 
       

     

       
196
       
 
       
                  ));

     

       
197
       
 
       
            if (isMatching) {

     

       
198
       
 
       
              if (process.env.NODE_ENV !== 'production')

     
···

       
234
       
 
       
        '\nYou have to pass an `id` or `_id` field or create a custom `keys` config for `' +

     

       
235
       
 
       
        ref.__typename +

     

       
236
       
 
       
        '`.',

     

       
237
       
-
       
      12

     

       
0
       
 
       

     

       
238
       
 
       
    );

     

       
239
       
 
       
  }

     

       
240
       
 
       


     

···

       
25
       
 
       
  Link,

     

       
26
       
 
       
  Entity,

     

       
27
       
 
       
  Data,

     

       
28
       
+
       
  Logger,

     

       
29
       
 
       
} from '../types';

     

       
30
       
 
       


     

       
31
       
 
       
export interface Context {

     
···

       
118
       
 
       
  node: FormattedNode<InlineFragmentNode | FragmentDefinitionNode>,

     

       
119
       
 
       
  typename: void | string,

     

       
120
       
 
       
  entityKey: string,

     

       
121
       
+
       
  vars: Variables,

     

       
122
       
+
       
  logger?: Logger

     

       
123
       
 
       
) => {

     

       
124
       
 
       
  if (!typename) return false;

     

       
125
       
 
       
  const typeCondition = getTypeCondition(node);

     
···

       
136
       
 
       
      '` may be an ' +

     

       
137
       
 
       
      'interface.\nA schema needs to be defined for this match to be deterministic, ' +

     

       
138
       
 
       
      'otherwise the fragment will be matched heuristically!',

     

       
139
       
+
       
    16,

     

       
140
       
+
       
    logger

     

       
141
       
 
       
  );

     

       
142
       
 
       


     

       
143
       
 
       
  return (

     
···

       
195
       
 
       
                    fragment,

     

       
196
       
 
       
                    typename,

     

       
197
       
 
       
                    entityKey,

     

       
198
       
+
       
                    ctx.variables,

     

       
199
       
+
       
                    ctx.store.logger

     

       
200
       
 
       
                  ));

     

       
201
       
 
       
            if (isMatching) {

     

       
202
       
 
       
              if (process.env.NODE_ENV !== 'production')

     
···

       
238
       
 
       
        '\nYou have to pass an `id` or `_id` field or create a custom `keys` config for `' +

     

       
239
       
 
       
        ref.__typename +

     

       
240
       
 
       
        '`.',

     

       
241
       
+
       
      12,

     

       
242
       
+
       
      store.logger

     

       
243
       
 
       
    );

     

       
244
       
 
       
  }

     

       
245
       
 
       


     

···

       
147
       
 
       
          ' but could only find ' +

     

       
148
       
 
       
          Object.keys(fragments).join(', ') +

     

       
149
       
 
       
          '.',

     

       
150
       
-
       
        11

     

       
0
       
 
       

     

       
151
       
 
       
      );

     

       
152
       
 
       


     

       
153
       
 
       
      return null;

     
···

       
159
       
 
       
      warn(

     

       
160
       
 
       
        'writeFragment(...) was called with an empty fragment.\n' +

     

       
161
       
 
       
          'You have to call it with at least one fragment in your GraphQL document.',

     

       
162
       
-
       
        11

     

       
0
       
 
       

     

       
163
       
 
       
      );

     

       
164
       
 
       


     

       
165
       
 
       
      return null;

     
···

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

     

       
176
       
 
       
        typename +

     

       
177
       
 
       
        '`.',

     

       
178
       
-
       
      12

     

       
0
       
 
       

     

       
179
       
 
       
    );

     

       
180
       
 
       
  }

     

       
181
       
 
       


     
···

       
223
       
 
       
    warn(

     

       
224
       
 
       
      "Couldn't find __typename when writing.\n" +

     

       
225
       
 
       
        "If you're writing to the cache manually have to pass a `__typename` property on each entity in your data.",

     

       
226
       
-
       
      14

     

       
0
       
 
       

     

       
227
       
 
       
    );

     

       
228
       
 
       
    return;

     

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

     
···

       
260
       
 
       


     

       
261
       
 
       
    if (process.env.NODE_ENV !== 'production') {

     

       
262
       
 
       
      if (ctx.store.schema && typename && fieldName !== '__typename') {

     

       
263
       
-
       
        isFieldAvailableOnType(ctx.store.schema, typename, fieldName);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
264
       
 
       
      }

     

       
265
       
 
       
    }

     

       
266
       
 
       


     
···

       
309
       
 
       
              '` is `undefined`, but the GraphQL query expects a ' +

     

       
310
       
 
       
              expected +

     

       
311
       
 
       
              ' for this field.',

     

       
312
       
-
       
            13

     

       
0
       
 
       

     

       
313
       
 
       
          );

     

       
314
       
 
       
        }

     

       
315
       
 
       
      }

     
···

       
426
       
 
       
        'If this is intentional, create a `keys` config for `' +

     

       
427
       
 
       
        typename +

     

       
428
       
 
       
        '` that always returns null.',

     

       
429
       
-
       
      15

     

       
0
       
 
       

     

       
430
       
 
       
    );

     

       
431
       
 
       
  }

     

       
432
       
 
       


     

···

       
147
       
 
       
          ' but could only find ' +

     

       
148
       
 
       
          Object.keys(fragments).join(', ') +

     

       
149
       
 
       
          '.',

     

       
150
       
+
       
        11,

     

       
151
       
+
       
        store.logger

     

       
152
       
 
       
      );

     

       
153
       
 
       


     

       
154
       
 
       
      return null;

     
···

       
160
       
 
       
      warn(

     

       
161
       
 
       
        'writeFragment(...) was called with an empty fragment.\n' +

     

       
162
       
 
       
          'You have to call it with at least one fragment in your GraphQL document.',

     

       
163
       
+
       
        11,

     

       
164
       
+
       
        store.logger

     

       
165
       
 
       
      );

     

       
166
       
 
       


     

       
167
       
 
       
      return null;

     
···

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

     

       
178
       
 
       
        typename +

     

       
179
       
 
       
        '`.',

     

       
180
       
+
       
      12,

     

       
181
       
+
       
      store.logger

     

       
182
       
 
       
    );

     

       
183
       
 
       
  }

     

       
184
       
 
       


     
···

       
226
       
 
       
    warn(

     

       
227
       
 
       
      "Couldn't find __typename when writing.\n" +

     

       
228
       
 
       
        "If you're writing to the cache manually have to pass a `__typename` property on each entity in your data.",

     

       
229
       
+
       
      14,

     

       
230
       
+
       
      ctx.store.logger

     

       
231
       
 
       
    );

     

       
232
       
 
       
    return;

     

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

     
···

       
264
       
 
       


     

       
265
       
 
       
    if (process.env.NODE_ENV !== 'production') {

     

       
266
       
 
       
      if (ctx.store.schema && typename && fieldName !== '__typename') {

     

       
267
       
+
       
        isFieldAvailableOnType(

     

       
268
       
+
       
          ctx.store.schema,

     

       
269
       
+
       
          typename,

     

       
270
       
+
       
          fieldName,

     

       
271
       
+
       
          ctx.store.logger

     

       
272
       
+
       
        );

     

       
273
       
 
       
      }

     

       
274
       
 
       
    }

     

       
275
       
 
       


     
···

       
318
       
 
       
              '` is `undefined`, but the GraphQL query expects a ' +

     

       
319
       
 
       
              expected +

     

       
320
       
 
       
              ' for this field.',

     

       
321
       
+
       
            13,

     

       
322
       
+
       
            ctx.store.logger

     

       
323
       
 
       
          );

     

       
324
       
 
       
        }

     

       
325
       
 
       
      }

     
···

       
436
       
 
       
        'If this is intentional, create a `keys` config for `' +

     

       
437
       
 
       
        typename +

     

       
438
       
 
       
        '` that always returns null.',

     

       
439
       
+
       
      15,

     

       
440
       
+
       
      ctx.store.logger

     

       
441
       
 
       
    );

     

       
442
       
 
       
  }

     

       
443
       
 
       


     

···

       
17
       
 
       
  Entity,

     

       
18
       
 
       
  CacheExchangeOpts,

     

       
19
       
 
       
  DirectivesConfig,

     

       
0
       
 
       

     

       
20
       
 
       
} from '../types';

     

       
21
       
 
       


     

       
22
       
 
       
import { invariant } from '../helpers/help';

     
···

       
48
       
 
       
{

     

       
49
       
 
       
  data: InMemoryData.InMemoryData;

     

       
50
       
 
       


     

       
0
       
 
       

     

       
51
       
 
       
  directives: DirectivesConfig;

     

       
52
       
 
       
  resolvers: ResolverConfig;

     

       
53
       
 
       
  updates: UpdatesConfig;

     
···

       
62
       
 
       
  constructor(opts?: C) {

     

       
63
       
 
       
    if (!opts) opts = {} as C;

     

       
64
       
 
       


     

       
0
       
 
       

     

       
65
       
 
       
    this.resolvers = opts.resolvers || {};

     

       
66
       
 
       
    this.directives = opts.directives || {};

     

       
67
       
 
       
    this.optimisticMutations = opts.optimistic || {};

     
···

       
100
       
 
       
    this.data = InMemoryData.make(queryName);

     

       
101
       
 
       


     

       
102
       
 
       
    if (this.schema && process.env.NODE_ENV !== 'production') {

     

       
103
       
-
       
      expectValidKeyingConfig(this.schema, this.keys);

     

       
104
       
-
       
      expectValidUpdatesConfig(this.schema, this.updates);

     

       
105
       
-
       
      expectValidResolversConfig(this.schema, this.resolvers);

     

       
106
       
 
       
      expectValidOptimisticMutationsConfig(

     

       
107
       
 
       
        this.schema,

     

       
108
       
-
       
        this.optimisticMutations

     

       
0
       
 
       

     

       
109
       
 
       
      );

     

       
110
       
 
       
    }

     

       
111
       
 
       
  }

     

···

       
17
       
 
       
  Entity,

     

       
18
       
 
       
  CacheExchangeOpts,

     

       
19
       
 
       
  DirectivesConfig,

     

       
20
       
+
       
  Logger,

     

       
21
       
 
       
} from '../types';

     

       
22
       
 
       


     

       
23
       
 
       
import { invariant } from '../helpers/help';

     
···

       
49
       
 
       
{

     

       
50
       
 
       
  data: InMemoryData.InMemoryData;

     

       
51
       
 
       


     

       
52
       
+
       
  logger?: Logger;

     

       
53
       
 
       
  directives: DirectivesConfig;

     

       
54
       
 
       
  resolvers: ResolverConfig;

     

       
55
       
 
       
  updates: UpdatesConfig;

     
···

       
64
       
 
       
  constructor(opts?: C) {

     

       
65
       
 
       
    if (!opts) opts = {} as C;

     

       
66
       
 
       


     

       
67
       
+
       
    this.logger = opts.logger;

     

       
68
       
 
       
    this.resolvers = opts.resolvers || {};

     

       
69
       
 
       
    this.directives = opts.directives || {};

     

       
70
       
 
       
    this.optimisticMutations = opts.optimistic || {};

     
···

       
103
       
 
       
    this.data = InMemoryData.make(queryName);

     

       
104
       
 
       


     

       
105
       
 
       
    if (this.schema && process.env.NODE_ENV !== 'production') {

     

       
106
       
+
       
      expectValidKeyingConfig(this.schema, this.keys, this.logger);

     

       
107
       
+
       
      expectValidUpdatesConfig(this.schema, this.updates, this.logger);

     

       
108
       
+
       
      expectValidResolversConfig(this.schema, this.resolvers, this.logger);

     

       
109
       
 
       
      expectValidOptimisticMutationsConfig(

     

       
110
       
 
       
        this.schema,

     

       
111
       
+
       
        this.optimisticMutations,

     

       
112
       
+
       
        this.logger

     

       
113
       
 
       
      );

     

       
114
       
 
       
    }

     

       
115
       
 
       
  }

     

···

       
541
       
 
       
  | null

     

       
542
       
 
       
  | undefined;

     

       
543
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
544
       
 
       
/** Input parameters for the {@link cacheExchange}. */

     

       
545
       
 
       
export type CacheExchangeOpts = {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
546
       
 
       
  /** Configures update functions which are called when the mapped fields are written to the cache.

     

       
547
       
 
       
   *

     

       
548
       
 
       
   * @remarks

     

···

       
541
       
 
       
  | null

     

       
542
       
 
       
  | undefined;

     

       
543
       
 
       


     

       
544
       
+
       
export type Logger = (

     

       
545
       
+
       
  severity: 'debug' | 'error' | 'warn',

     

       
546
       
+
       
  message: string

     

       
547
       
+
       
) => void;

     

       
548
       
+
       


     

       
549
       
 
       
/** Input parameters for the {@link cacheExchange}. */

     

       
550
       
 
       
export type CacheExchangeOpts = {

     

       
551
       
+
       
  /** Configure a custom-logger for graphcache, this function wll be called with a severity and a message.

     

       
552
       
+
       
   *

     

       
553
       
+
       
   * @remarks

     

       
554
       
+
       
   * By default we will invoke `console.warn` for warnings during development, however you might want to opt

     

       
555
       
+
       
   * out of this because you are re-using urql for a different library. This setting allows you to stub the logger

     

       
556
       
+
       
   * function or filter to only logs you want.

     

       
557
       
+
       
   */

     

       
558
       
+
       
  logger?: Logger;

     

       
559
       
 
       
  /** Configures update functions which are called when the mapped fields are written to the cache.

     

       
560
       
 
       
   *

     

       
561
       
 
       
   * @remarks