commit 022c7d22e87f6c75b774c8f5c185ee16155736c7 · kitten.sh/urql

.changeset/real-ducks-speak.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Fix a typo that caused an inverted condition, for checking owned data, to cause incorrect results when handling `null` values and encountering them first.

+70

exchanges/graphcache/src/operations/query.test.ts

···

       268
       268
        
           expect(console.error).not.toHaveBeenCalled();

     

       269
       269
        
         });

     

       270
       270
        
       

     

       271
       271
       +
         it('should not allow subsequent reads when first result was null (with resolvers)', () => {

     

       272
       272
       +
           const QUERY_WRITE = gql`

     

       273
       273
       +
             query writeTodos {

     

       274
       274
       +
               __typename

     

       275
       275
       +
               todos {

     

       276
       276
       +
                 __typename

     

       277
       277
       +
                 ...ValidRead

     

       278
       278
       +
               }

     

       279
       279
       +
             }

     

       280
       280
       +
       

     

       281
       281
       +
             fragment ValidRead on Todo {

     

       282
       282
       +
               id

     

       283
       283
       +
             }

     

       284
       284
       +
           `;

     

       285
       285
       +
       

     

       286
       286
       +
           const QUERY_READ = gql`

     

       287
       287
       +
             query getTodos {

     

       288
       288
       +
               __typename

     

       289
       289
       +
               todos {

     

       290
       290
       +
                 __typename

     

       291
       291
       +
                 ...MissingRead

     

       292
       292
       +
               }

     

       293
       293
       +
               todos {

     

       294
       294
       +
                 __typename

     

       295
       295
       +
                 id

     

       296
       296
       +
               }

     

       297
       297
       +
             }

     

       298
       298
       +
       

     

       299
       299
       +
             fragment MissingRead on Todo {

     

       300
       300
       +
               id

     

       301
       301
       +
               text

     

       302
       302
       +
             }

     

       303
       303
       +
           `;

     

       304
       304
       +
       

     

       305
       305
       +
           const store = new Store({

     

       306
       306
       +
             schema,

     

       307
       307
       +
             resolvers: {

     

       308
       308
       +
               Query: {

     

       309
       309
       +
                 todos: (_parent, _args, cache) => cache.resolve('Query', 'todos'),

     

       310
       310
       +
               },

     

       311
       311
       +
             },

     

       312
       312
       +
           });

     

       313
       313
       +
       

     

       314
       314
       +
           let { data } = query(store, { query: QUERY_READ });

     

       315
       315
       +
           expect(data).toEqual(null);

     

       316
       316
       +
       

     

       317
       317
       +
           write(

     

       318
       318
       +
             store,

     

       319
       319
       +
             { query: QUERY_WRITE },

     

       320
       320
       +
             {

     

       321
       321
       +
               todos: [

     

       322
       322
       +
                 {

     

       323
       323
       +
                   __typename: 'Todo',

     

       324
       324
       +
                   id: '0',

     

       325
       325
       +
                 },

     

       326
       326
       +
               ],

     

       327
       327
       +
               __typename: 'Query',

     

       328
       328
       +
             }

     

       329
       329
       +
           );

     

       330
       330
       +
       

     

       331
       331
       +
           ({ data } = query(store, { query: QUERY_READ }));

     

       332
       332
       +
           expect(data).toEqual({

     

       333
       333
       +
             __typename: 'Query',

     

       334
       334
       +
             todos: [null],

     

       335
       335
       +
           });

     

       336
       336
       +
       

     

       337
       337
       +
           expect(console.warn).not.toHaveBeenCalled();

     

       338
       338
       +
           expect(console.error).not.toHaveBeenCalled();

     

       339
       339
       +
         });

     

       340
       340
       +
       

     

       271
       341
        
         it('should not mix references', () => {

     

       272
       342
        
           const QUERY_WRITE = gql`

     

       273
       343
        
             query writeTodos {

+1 -1

exchanges/graphcache/src/operations/query.ts

···

       609
       609
        
           return hasChanged ? data : prevData;

     

       610
       610
        
         } else if (result === null || result === undefined) {

     

       611
       611
        
           return result;

     

       612
       612
       -
         } else if (!isOwnedData && prevData === null) {

     

       612
       612
       +
         } else if (isOwnedData && prevData === null) {

     

       613
       613
        
           return null;

     

       614
       614
        
         } else if (isDataOrKey(result)) {

     

       615
       615
        
           const data = (prevData || InMemoryData.makeData(prevData)) as Data;