commit 6d2e736289a98e621992140135d1664f6ddaf246 · kitten.sh/urql

.changeset/moody-hats-attend.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       '@urql/core': patch

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Fix regression which would disallow `network-only` operations after `cache-and-network` completed.

+52

packages/core/src/client.test.ts

···

       648
       648
        
           expect(onOperation).toHaveBeenCalledTimes(1);

     

       649
       649
        
           expect(onResult).toHaveBeenCalledTimes(3);

     

       650
       650
        
         });

     

       651
       651
       +
       

     

       652
       652
       +
         it('does not deduplicate cache-and-network’s follow-up operations', () => {

     

       653
       653
       +
           const onOperation = vi.fn();

     

       654
       654
       +
           const onResult = vi.fn();

     

       655
       655
       +
       

     

       656
       656
       +
           const operationOne = makeOperation('query', queryOperation, {

     

       657
       657
       +
             ...queryOperation.context,

     

       658
       658
       +
             requestPolicy: 'cache-and-network',

     

       659
       659
       +
           });

     

       660
       660
       +
       

     

       661
       661
       +
           const operationTwo = makeOperation('query', queryOperation, {

     

       662
       662
       +
             ...queryOperation.context,

     

       663
       663
       +
             requestPolicy: 'network-only',

     

       664
       664
       +
           });

     

       665
       665
       +
       

     

       666
       666
       +
           let shouldSend = true;

     

       667
       667
       +
           const exchange: Exchange = () => ops$ =>

     

       668
       668
       +
             pipe(

     

       669
       669
       +
               ops$,

     

       670
       670
       +
               onPush(onOperation),

     

       671
       671
       +
               map(op => ({

     

       672
       672
       +
                 hasNext: false,

     

       673
       673
       +
                 stale: true,

     

       674
       674
       +
                 data: 'test',

     

       675
       675
       +
                 operation: op,

     

       676
       676
       +
               })),

     

       677
       677
       +
               filter(() => {

     

       678
       678
       +
                 if (shouldSend) {

     

       679
       679
       +
                   shouldSend = false;

     

       680
       680
       +
                   client.reexecuteOperation(operationTwo);

     

       681
       681
       +
                   return true;

     

       682
       682
       +
                 } else {

     

       683
       683
       +
                   return false;

     

       684
       684
       +
                 }

     

       685
       685
       +
               })

     

       686
       686
       +
             );

     

       687
       687
       +
       

     

       688
       688
       +
           const client = createClient({

     

       689
       689
       +
             url: 'test',

     

       690
       690
       +
             exchanges: [exchange],

     

       691
       691
       +
           });

     

       692
       692
       +
       

     

       693
       693
       +
           const operationThree = makeOperation('query', queryOperation, {

     

       694
       694
       +
             ...queryOperation.context,

     

       695
       695
       +
             requestPolicy: 'network-only',

     

       696
       696
       +
           });

     

       697
       697
       +
       

     

       698
       698
       +
           pipe(client.executeRequestOperation(operationOne), subscribe(onResult));

     

       699
       699
       +
           pipe(client.executeRequestOperation(operationThree), subscribe(onResult));

     

       700
       700
       +
       

     

       701
       701
       +
           expect(onOperation).toHaveBeenCalledTimes(2);

     

       702
       702
       +
         });

     

       651
       703
        
       });

     

       652
       704
        
       

     

       653
       705
        
       describe('shared sources behavior', () => {

+11 -1

packages/core/src/client.ts

···

       663
       663
        
               result$,

     

       664
       664
        
               // Store replay result

     

       665
       665
        
               onPush(result => {

     

       666
       666
       -
                 if (!result.hasNext && !result.stale)

     

       666
       666
       +
                 if (result.stale) {

     

       667
       667
       +
                   // If the current result has queued up an operation of the same

     

       668
       668
       +
                   // key, then `stale` refers to it

     

       669
       669
       +
                   for (const operation of queue) {

     

       670
       670
       +
                     if (operation.key === result.operation.key) {

     

       671
       671
       +
                       dispatched.delete(operation.key);

     

       672
       672
       +
                       break;

     

       673
       673
       +
                     }

     

       674
       674
       +
                   }

     

       675
       675
       +
                 } else if (!result.hasNext) {

     

       667
       676
        
                   dispatched.delete(operation.key);

     

       677
       677
       +
                 }

     

       668
       678
        
                 replays.set(operation.key, result);

     

       669
       679
        
               }),

     

       670
       680
        
               // Cleanup active states on end of source