···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

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

     

       
3
       
+
       
'@urql/svelte': major

     

       
4
       
+
       
'@urql/core': major

     

       
5
       
+
       
---

     

       
6
       
+
       


     

       
7
       
+
       
Update `OperationResult.hasNext` and `OperationResult.stale` to be required fields. If you have a custom exchange creating results, you'll have to add these fields or use the `makeResult`, `mergeResultPatch`, or `makeErrorResult` helpers.

     

···

       
21
       
 
       


     

       
22
       
 
       
import { vi, expect, it } from 'vitest';

     

       
23
       
 
       
import { print } from 'graphql';

     

       
24
       
-
       
import { queryOperation } from '../../../packages/core/src/test-utils';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
25
       
 
       
import { authExchange } from './authExchange';

     

       
26
       
 
       


     

       
27
       
 
       
const makeExchangeArgs = () => {

     

       
28
       
 
       
  const operations: Operation[] = [];

     

       
29
       
 
       
  const result = vi.fn(

     

       
30
       
-
       
    (operation: Operation): OperationResult => ({ operation })

     

       
31
       
 
       
  );

     

       
32
       
 
       


     

       
33
       
 
       
  return {

     
···

       
247
       
 
       
  await new Promise(resolve => setTimeout(resolve));

     

       
248
       
 
       


     

       
249
       
 
       
  result.mockReturnValueOnce({

     

       
0
       
 
       

     

       
250
       
 
       
    operation: queryOperation,

     

       
0
       
 
       

     

       
251
       
 
       
    error: new CombinedError({

     

       
252
       
 
       
      graphQLErrors: [{ message: 'Oops' }],

     

       
253
       
 
       
    }),

     

···

       
21
       
 
       


     

       
22
       
 
       
import { vi, expect, it } from 'vitest';

     

       
23
       
 
       
import { print } from 'graphql';

     

       
24
       
+
       
import {

     

       
25
       
+
       
  queryResponse,

     

       
26
       
+
       
  queryOperation,

     

       
27
       
+
       
} from '../../../packages/core/src/test-utils';

     

       
28
       
 
       
import { authExchange } from './authExchange';

     

       
29
       
 
       


     

       
30
       
 
       
const makeExchangeArgs = () => {

     

       
31
       
 
       
  const operations: Operation[] = [];

     

       
32
       
 
       
  const result = vi.fn(

     

       
33
       
+
       
    (operation: Operation): OperationResult => ({ ...queryResponse, operation })

     

       
34
       
 
       
  );

     

       
35
       
 
       


     

       
36
       
 
       
  return {

     
···

       
250
       
 
       
  await new Promise(resolve => setTimeout(resolve));

     

       
251
       
 
       


     

       
252
       
 
       
  result.mockReturnValueOnce({

     

       
253
       
+
       
    ...queryResponse,

     

       
254
       
 
       
    operation: queryOperation,

     

       
255
       
+
       
    data: undefined,

     

       
256
       
 
       
    error: new CombinedError({

     

       
257
       
 
       
      graphQLErrors: [{ message: 'Oops' }],

     

       
258
       
 
       
    }),

     

···

       
9
       
 
       
  ExchangeIO,

     

       
10
       
 
       
} from '@urql/core';

     

       
11
       
 
       


     

       
0
       
 
       

     

       
12
       
 
       
import { contextExchange } from './context';

     

       
13
       
 
       


     

       
14
       
 
       
const queryOne = gql`

     
···

       
48
       
 
       
  const response = vi.fn(

     

       
49
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
50
       
 
       
      return {

     

       
0
       
 
       

     

       
51
       
 
       
        operation: forwardOp,

     

       
52
       
 
       
        data: queryOneData,

     

       
53
       
 
       
      };

     
···

       
83
       
 
       
  const response = vi.fn(

     

       
84
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
85
       
 
       
      return {

     

       
0
       
 
       

     

       
86
       
 
       
        operation: forwardOp,

     

       
87
       
 
       
        data: queryOneData,

     

       
88
       
 
       
      };

     

···

       
9
       
 
       
  ExchangeIO,

     

       
10
       
 
       
} from '@urql/core';

     

       
11
       
 
       


     

       
12
       
+
       
import { queryResponse } from '../../../packages/core/src/test-utils';

     

       
13
       
 
       
import { contextExchange } from './context';

     

       
14
       
 
       


     

       
15
       
 
       
const queryOne = gql`

     
···

       
49
       
 
       
  const response = vi.fn(

     

       
50
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
51
       
 
       
      return {

     

       
52
       
+
       
        ...queryResponse,

     

       
53
       
 
       
        operation: forwardOp,

     

       
54
       
 
       
        data: queryOneData,

     

       
55
       
 
       
      };

     
···

       
85
       
 
       
  const response = vi.fn(

     

       
86
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
87
       
 
       
      return {

     

       
88
       
+
       
        ...queryResponse,

     

       
89
       
 
       
        operation: forwardOp,

     

       
90
       
 
       
        data: queryOneData,

     

       
91
       
 
       
      };

     

···

       
272
       
 
       
      operation: queryOperation,

     

       
273
       
 
       
      data: mockHttpResponseData,

     

       
274
       
 
       
      hasNext: false,

     

       
0
       
 
       

     

       
275
       
 
       
    });

     

       
276
       
 
       
  });

     

       
277
       
 
       
});

     

···

       
272
       
 
       
      operation: queryOperation,

     

       
273
       
 
       
      data: mockHttpResponseData,

     

       
274
       
 
       
      hasNext: false,

     

       
275
       
+
       
      stale: false,

     

       
276
       
 
       
    });

     

       
277
       
 
       
  });

     

       
278
       
 
       
});

     

···

       
6
       
 
       
  OperationResult,

     

       
7
       
 
       
  CombinedError,

     

       
8
       
 
       
} from '@urql/core';

     

       
0
       
 
       

     

       
9
       
 
       
import { vi, expect, it, describe } from 'vitest';

     

       
10
       
 
       


     

       
11
       
 
       
import {

     
···

       
23
       
 
       
} from 'wonka';

     

       
24
       
 
       


     

       
25
       
 
       
import { minifyIntrospectionQuery } from '@urql/introspection';

     

       
0
       
 
       

     

       
26
       
 
       
import { cacheExchange } from './cacheExchange';

     

       
27
       
 
       


     

       
28
       
 
       
const queryOne = gql`

     
···

       
80
       
 
       
    const response = vi.fn(

     

       
81
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
82
       
 
       
        expect(forwardOp.key).toBe(op.key);

     

       
83
       
-
       
        return { operation: forwardOp, data: expected };

     

       
84
       
 
       
      }

     

       
85
       
 
       
    );

     

       
86
       
 
       


     
···

       
133
       
 
       
    const response = vi.fn(

     

       
134
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
135
       
 
       
        expect(forwardOp.key).toBe(op.key);

     

       
136
       
-
       
        return { operation: forwardOp, data: queryOneData };

     

       
137
       
 
       
      }

     

       
138
       
 
       
    );

     

       
139
       
 
       


     
···

       
205
       
 
       
    const response = vi.fn(

     

       
206
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
207
       
 
       
        if (forwardOp.key === 1) {

     

       
208
       
-
       
          return { operation: opOne, data: queryOneData };

     

       
209
       
 
       
        } else if (forwardOp.key === 2) {

     

       
210
       
-
       
          return { operation: opMultiple, data: queryMultipleData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
211
       
 
       
        }

     

       
212
       
 
       


     

       
213
       
 
       
        return undefined as any;

     
···

       
344
       
 
       
    const response = vi.fn(

     

       
345
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
346
       
 
       
        if (forwardOp.key === 1) {

     

       
347
       
-
       
          return { operation: opOne, data: queryByIdDataA };

     

       
348
       
 
       
        } else if (forwardOp.key === 2) {

     

       
349
       
-
       
          return { operation: opTwo, data: queryByIdDataB };

     

       
350
       
 
       
        } else if (forwardOp.key === 3) {

     

       
351
       
-
       
          return { operation: opMutation, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
352
       
 
       
        }

     

       
353
       
 
       


     

       
354
       
 
       
        return undefined as any;

     
···

       
446
       
 
       
    const response = vi.fn(

     

       
447
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
448
       
 
       
        if (forwardOp.key === 1) {

     

       
449
       
-
       
          return { operation: opOne, data: queryOneData };

     

       
450
       
 
       
        } else if (forwardOp.key === 2) {

     

       
451
       
-
       
          return { operation: opUnrelated, data: queryUnrelatedData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
452
       
 
       
        }

     

       
453
       
 
       


     

       
454
       
 
       
        return undefined as any;

     
···

       
505
       
 
       
    const response = vi.fn(

     

       
506
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
507
       
 
       
        if (forwardOp.key === 1) {

     

       
508
       
-
       
          return { operation: opMutation, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
509
       
 
       
        }

     

       
510
       
 
       


     

       
511
       
 
       
        return undefined as any;

     
···

       
565
       
 
       
    const response = vi.fn(

     

       
566
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
567
       
 
       
        if (forwardOp.key === 1) {

     

       
568
       
-
       
          return { operation: opMutation, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
569
       
 
       
        }

     

       
570
       
 
       


     

       
571
       
 
       
        return undefined as any;

     
···

       
626
       
 
       
    });

     

       
627
       
 
       


     

       
628
       
 
       
    const queryResult: OperationResult = {

     

       
0
       
 
       

     

       
629
       
 
       
      operation,

     

       
630
       
 
       
      data: {

     

       
631
       
 
       
        __typename: 'Query',

     
···

       
729
       
 
       
    const response = vi.fn(

     

       
730
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
731
       
 
       
        if (forwardOp.key === 1) {

     

       
732
       
-
       
          return { operation: opOne, data: queryOneData };

     

       
733
       
 
       
        } else if (forwardOp.key === 2) {

     

       
734
       
-
       
          return { operation: opMutation, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
735
       
 
       
        }

     

       
736
       
 
       


     

       
737
       
 
       
        return undefined as any;

     
···

       
831
       
 
       
    const response = vi.fn(

     

       
832
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
833
       
 
       
        if (forwardOp.key === 1) {

     

       
834
       
-
       
          return { operation: opOne, data: queryOneData };

     

       
835
       
 
       
        } else if (forwardOp.key === 2) {

     

       
836
       
-
       
          return { operation: opMutationOne, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
837
       
 
       
        } else if (forwardOp.key === 3) {

     

       
838
       
-
       
          return { operation: opMutationTwo, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
839
       
 
       
        }

     

       
840
       
 
       


     

       
841
       
 
       
        return undefined as any;

     
···

       
931
       
 
       
    const response = vi.fn(

     

       
932
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
933
       
 
       
        if (forwardOp.key === 1) {

     

       
934
       
-
       
          return { operation: opOne, data: queryOneData };

     

       
935
       
 
       
        }

     

       
936
       
 
       


     

       
937
       
 
       
        return undefined as any;

     
···

       
1045
       
 
       
    const response = vi.fn(

     

       
1046
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1047
       
 
       
        if (forwardOp.key === 1) {

     

       
1048
       
-
       
          return { operation: opOne, data: authorsQueryData };

     

       
1049
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1050
       
 
       
          return {

     

       
0
       
 
       

     

       
1051
       
 
       
            operation: opMutation,

     

       
1052
       
 
       
            error: 'error' as any,

     

       
1053
       
 
       
            data: { __typename: 'Mutation', addAuthor: null },

     
···

       
1121
       
 
       
    const response = vi.fn(

     

       
1122
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1123
       
 
       
        if (forwardOp.key === 1) {

     

       
1124
       
-
       
          return { operation: opOne, data: queryOneData };

     

       
1125
       
 
       
        }

     

       
1126
       
 
       


     

       
1127
       
 
       
        return undefined as any;

     
···

       
1203
       
 
       
    const response = vi.fn(

     

       
1204
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1205
       
 
       
        if (forwardOp.key === 1) {

     

       
1206
       
-
       
          return { operation: opOne, data: queryOneData };

     

       
1207
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1208
       
-
       
          return { operation: opMutation, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1209
       
 
       
        }

     

       
1210
       
 
       


     

       
1211
       
 
       
        return undefined as any;

     
···

       
1349
       
 
       
    const response = vi.fn(

     

       
1350
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1351
       
 
       
        if (forwardOp.key === 1) {

     

       
1352
       
-
       
          return { operation: queryOperation, data: queryData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1353
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1354
       
-
       
          return { operation: mutationOperation, data: mutationData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1355
       
 
       
        }

     

       
1356
       
 
       


     

       
1357
       
 
       
        return undefined as any;

     
···

       
1506
       
 
       
    const response = vi.fn(

     

       
1507
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1508
       
 
       
        if (forwardOp.key === 1) {

     

       
1509
       
-
       
          return { operation: initialQueryOperation, data: queryData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1510
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1511
       
-
       
          return { operation: queryOperation, data: queryData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1512
       
 
       
        }

     

       
1513
       
 
       


     

       
1514
       
 
       
        return undefined as any;

     
···

       
1643
       
 
       
    const response = vi.fn(

     

       
1644
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1645
       
 
       
        if (forwardOp.key === 1) {

     

       
1646
       
-
       
          return { operation: initialQueryOperation, data: queryData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1647
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1648
       
-
       
          return { operation: queryOperation, data: queryData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1649
       
 
       
        }

     

       
1650
       
 
       


     

       
1651
       
 
       
        return undefined as any;

     
···

       
1724
       
 
       
    const result = (operation: Operation): Source<OperationResult> =>

     

       
1725
       
 
       
      pipe(

     

       
1726
       
 
       
        fromValue({

     

       
0
       
 
       

     

       
1727
       
 
       
          operation,

     

       
1728
       
 
       
          data: {

     

       
1729
       
 
       
            __typename: 'Query',

     
···

       
1871
       
 
       
    nextOp(queryOpA);

     

       
1872
       
 
       


     

       
1873
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
1874
       
 
       
      operation: queryOpA,

     

       
1875
       
 
       
      data: {

     

       
1876
       
 
       
        __typename: 'Query',

     
···

       
1964
       
 
       
    nextOp(queryOpB);

     

       
1965
       
 
       


     

       
1966
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
1967
       
 
       
      operation: queryOpA,

     

       
1968
       
 
       
      data: {

     

       
1969
       
 
       
        __typename: 'Query',

     
···

       
1978
       
 
       
    expect(data).toHaveProperty('node.name', 'query a');

     

       
1979
       
 
       


     

       
1980
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
1981
       
 
       
      operation: mutationOp,

     

       
1982
       
 
       
      data: {

     

       
1983
       
 
       
        __typename: 'Mutation',

     
···

       
1993
       
 
       
    expect(data).toHaveProperty('node.name', 'mutation');

     

       
1994
       
 
       


     

       
1995
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
1996
       
 
       
      operation: queryOpB,

     

       
1997
       
 
       
      data: {

     

       
1998
       
 
       
        __typename: 'Query',

     
···

       
2082
       
 
       
    nextOp(mutationOp);

     

       
2083
       
 
       


     

       
2084
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2085
       
 
       
      operation: queryOp,

     

       
2086
       
 
       
      data: {

     

       
2087
       
 
       
        __typename: 'Query',

     
···

       
2096
       
 
       
    expect(data).toHaveProperty('node.name', 'optimistic');

     

       
2097
       
 
       


     

       
2098
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2099
       
 
       
      operation: mutationOp,

     

       
2100
       
 
       
      data: {

     

       
2101
       
 
       
        __typename: 'Query',

     
···

       
2183
       
 
       
    nextOp(subscriptionOp);

     

       
2184
       
 
       


     

       
2185
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2186
       
 
       
      operation: queryOpA,

     

       
2187
       
 
       
      data: {

     

       
2188
       
 
       
        __typename: 'Query',

     
···

       
2195
       
 
       
    });

     

       
2196
       
 
       


     

       
2197
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2198
       
 
       
      operation: subscriptionOp,

     

       
2199
       
 
       
      data: {

     

       
2200
       
 
       
        node: {

     
···

       
2296
       
 
       
    nextOp(subscriptionOp);

     

       
2297
       
 
       


     

       
2298
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2299
       
 
       
      operation: queryOpA,

     

       
2300
       
 
       
      data: {

     

       
2301
       
 
       
        __typename: 'Query',

     
···

       
2310
       
 
       
    nextOp(mutationOp);

     

       
2311
       
 
       


     

       
2312
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2313
       
 
       
      operation: mutationOp,

     

       
2314
       
 
       
      data: {

     

       
2315
       
 
       
        node: {

     
···

       
2321
       
 
       
    });

     

       
2322
       
 
       


     

       
2323
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2324
       
 
       
      operation: subscriptionOp,

     

       
2325
       
 
       
      data: {

     

       
2326
       
 
       
        node: {

     
···

       
2332
       
 
       
    });

     

       
2333
       
 
       


     

       
2334
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2335
       
 
       
      operation: subscriptionOp,

     

       
2336
       
 
       
      data: {

     

       
2337
       
 
       
        node: {

     
···

       
2440
       
 
       
    nextOp(normalOp);

     

       
2441
       
 
       


     

       
2442
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2443
       
 
       
      operation: deferredOp,

     

       
2444
       
 
       
      data: {

     

       
2445
       
 
       
        __typename: 'Query',

     
···

       
2450
       
 
       
    expect(deferredData).not.toHaveProperty('deferred');

     

       
2451
       
 
       


     

       
2452
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2453
       
 
       
      operation: normalOp,

     

       
2454
       
 
       
      data: {

     

       
2455
       
 
       
        __typename: 'Query',

     
···

       
2466
       
 
       
    expect(combinedData).toHaveProperty('node.id', 2);

     

       
2467
       
 
       


     

       
2468
       
 
       
    nextRes({

     

       
0
       
 
       

     

       
2469
       
 
       
      operation: deferredOp,

     

       
2470
       
 
       
      data: {

     

       
2471
       
 
       
        __typename: 'Query',

     

···

       
6
       
 
       
  OperationResult,

     

       
7
       
 
       
  CombinedError,

     

       
8
       
 
       
} from '@urql/core';

     

       
9
       
+
       


     

       
10
       
 
       
import { vi, expect, it, describe } from 'vitest';

     

       
11
       
 
       


     

       
12
       
 
       
import {

     
···

       
24
       
 
       
} from 'wonka';

     

       
25
       
 
       


     

       
26
       
 
       
import { minifyIntrospectionQuery } from '@urql/introspection';

     

       
27
       
+
       
import { queryResponse } from '../../../packages/core/src/test-utils';

     

       
28
       
 
       
import { cacheExchange } from './cacheExchange';

     

       
29
       
 
       


     

       
30
       
 
       
const queryOne = gql`

     
···

       
82
       
 
       
    const response = vi.fn(

     

       
83
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
84
       
 
       
        expect(forwardOp.key).toBe(op.key);

     

       
85
       
+
       
        return { ...queryResponse, operation: forwardOp, data: expected };

     

       
86
       
 
       
      }

     

       
87
       
 
       
    );

     

       
88
       
 
       


     
···

       
135
       
 
       
    const response = vi.fn(

     

       
136
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
137
       
 
       
        expect(forwardOp.key).toBe(op.key);

     

       
138
       
+
       
        return { ...queryResponse, operation: forwardOp, data: queryOneData };

     

       
139
       
 
       
      }

     

       
140
       
 
       
    );

     

       
141
       
 
       


     
···

       
207
       
 
       
    const response = vi.fn(

     

       
208
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
209
       
 
       
        if (forwardOp.key === 1) {

     

       
210
       
+
       
          return { ...queryResponse, operation: opOne, data: queryOneData };

     

       
211
       
 
       
        } else if (forwardOp.key === 2) {

     

       
212
       
+
       
          return {

     

       
213
       
+
       
            ...queryResponse,

     

       
214
       
+
       
            operation: opMultiple,

     

       
215
       
+
       
            data: queryMultipleData,

     

       
216
       
+
       
          };

     

       
217
       
 
       
        }

     

       
218
       
 
       


     

       
219
       
 
       
        return undefined as any;

     
···

       
350
       
 
       
    const response = vi.fn(

     

       
351
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
352
       
 
       
        if (forwardOp.key === 1) {

     

       
353
       
+
       
          return { ...queryResponse, operation: opOne, data: queryByIdDataA };

     

       
354
       
 
       
        } else if (forwardOp.key === 2) {

     

       
355
       
+
       
          return { ...queryResponse, operation: opTwo, data: queryByIdDataB };

     

       
356
       
 
       
        } else if (forwardOp.key === 3) {

     

       
357
       
+
       
          return {

     

       
358
       
+
       
            ...queryResponse,

     

       
359
       
+
       
            operation: opMutation,

     

       
360
       
+
       
            data: mutationData,

     

       
361
       
+
       
          };

     

       
362
       
 
       
        }

     

       
363
       
 
       


     

       
364
       
 
       
        return undefined as any;

     
···

       
456
       
 
       
    const response = vi.fn(

     

       
457
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
458
       
 
       
        if (forwardOp.key === 1) {

     

       
459
       
+
       
          return { ...queryResponse, operation: opOne, data: queryOneData };

     

       
460
       
 
       
        } else if (forwardOp.key === 2) {

     

       
461
       
+
       
          return {

     

       
462
       
+
       
            ...queryResponse,

     

       
463
       
+
       
            operation: opUnrelated,

     

       
464
       
+
       
            data: queryUnrelatedData,

     

       
465
       
+
       
          };

     

       
466
       
 
       
        }

     

       
467
       
 
       


     

       
468
       
 
       
        return undefined as any;

     
···

       
519
       
 
       
    const response = vi.fn(

     

       
520
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
521
       
 
       
        if (forwardOp.key === 1) {

     

       
522
       
+
       
          return {

     

       
523
       
+
       
            ...queryResponse,

     

       
524
       
+
       
            operation: opMutation,

     

       
525
       
+
       
            data: mutationData,

     

       
526
       
+
       
          };

     

       
527
       
 
       
        }

     

       
528
       
 
       


     

       
529
       
 
       
        return undefined as any;

     
···

       
583
       
 
       
    const response = vi.fn(

     

       
584
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
585
       
 
       
        if (forwardOp.key === 1) {

     

       
586
       
+
       
          return {

     

       
587
       
+
       
            ...queryResponse,

     

       
588
       
+
       
            operation: opMutation,

     

       
589
       
+
       
            data: mutationData,

     

       
590
       
+
       
          };

     

       
591
       
 
       
        }

     

       
592
       
 
       


     

       
593
       
 
       
        return undefined as any;

     
···

       
648
       
 
       
    });

     

       
649
       
 
       


     

       
650
       
 
       
    const queryResult: OperationResult = {

     

       
651
       
+
       
      ...queryResponse,

     

       
652
       
 
       
      operation,

     

       
653
       
 
       
      data: {

     

       
654
       
 
       
        __typename: 'Query',

     
···

       
752
       
 
       
    const response = vi.fn(

     

       
753
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
754
       
 
       
        if (forwardOp.key === 1) {

     

       
755
       
+
       
          return { ...queryResponse, operation: opOne, data: queryOneData };

     

       
756
       
 
       
        } else if (forwardOp.key === 2) {

     

       
757
       
+
       
          return {

     

       
758
       
+
       
            ...queryResponse,

     

       
759
       
+
       
            operation: opMutation,

     

       
760
       
+
       
            data: mutationData,

     

       
761
       
+
       
          };

     

       
762
       
 
       
        }

     

       
763
       
 
       


     

       
764
       
 
       
        return undefined as any;

     
···

       
858
       
 
       
    const response = vi.fn(

     

       
859
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
860
       
 
       
        if (forwardOp.key === 1) {

     

       
861
       
+
       
          return { ...queryResponse, operation: opOne, data: queryOneData };

     

       
862
       
 
       
        } else if (forwardOp.key === 2) {

     

       
863
       
+
       
          return {

     

       
864
       
+
       
            ...queryResponse,

     

       
865
       
+
       
            operation: opMutationOne,

     

       
866
       
+
       
            data: mutationData,

     

       
867
       
+
       
          };

     

       
868
       
 
       
        } else if (forwardOp.key === 3) {

     

       
869
       
+
       
          return {

     

       
870
       
+
       
            ...queryResponse,

     

       
871
       
+
       
            operation: opMutationTwo,

     

       
872
       
+
       
            data: mutationData,

     

       
873
       
+
       
          };

     

       
874
       
 
       
        }

     

       
875
       
 
       


     

       
876
       
 
       
        return undefined as any;

     
···

       
966
       
 
       
    const response = vi.fn(

     

       
967
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
968
       
 
       
        if (forwardOp.key === 1) {

     

       
969
       
+
       
          return { ...queryResponse, operation: opOne, data: queryOneData };

     

       
970
       
 
       
        }

     

       
971
       
 
       


     

       
972
       
 
       
        return undefined as any;

     
···

       
1080
       
 
       
    const response = vi.fn(

     

       
1081
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1082
       
 
       
        if (forwardOp.key === 1) {

     

       
1083
       
+
       
          return { ...queryResponse, operation: opOne, data: authorsQueryData };

     

       
1084
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1085
       
 
       
          return {

     

       
1086
       
+
       
            ...queryResponse,

     

       
1087
       
 
       
            operation: opMutation,

     

       
1088
       
 
       
            error: 'error' as any,

     

       
1089
       
 
       
            data: { __typename: 'Mutation', addAuthor: null },

     
···

       
1157
       
 
       
    const response = vi.fn(

     

       
1158
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1159
       
 
       
        if (forwardOp.key === 1) {

     

       
1160
       
+
       
          return { ...queryResponse, operation: opOne, data: queryOneData };

     

       
1161
       
 
       
        }

     

       
1162
       
 
       


     

       
1163
       
 
       
        return undefined as any;

     
···

       
1239
       
 
       
    const response = vi.fn(

     

       
1240
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1241
       
 
       
        if (forwardOp.key === 1) {

     

       
1242
       
+
       
          return { ...queryResponse, operation: opOne, data: queryOneData };

     

       
1243
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1244
       
+
       
          return {

     

       
1245
       
+
       
            ...queryResponse,

     

       
1246
       
+
       
            operation: opMutation,

     

       
1247
       
+
       
            data: mutationData,

     

       
1248
       
+
       
          };

     

       
1249
       
 
       
        }

     

       
1250
       
 
       


     

       
1251
       
 
       
        return undefined as any;

     
···

       
1389
       
 
       
    const response = vi.fn(

     

       
1390
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1391
       
 
       
        if (forwardOp.key === 1) {

     

       
1392
       
+
       
          return {

     

       
1393
       
+
       
            ...queryResponse,

     

       
1394
       
+
       
            operation: queryOperation,

     

       
1395
       
+
       
            data: queryData,

     

       
1396
       
+
       
          };

     

       
1397
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1398
       
+
       
          return {

     

       
1399
       
+
       
            ...queryResponse,

     

       
1400
       
+
       
            operation: mutationOperation,

     

       
1401
       
+
       
            data: mutationData,

     

       
1402
       
+
       
          };

     

       
1403
       
 
       
        }

     

       
1404
       
 
       


     

       
1405
       
 
       
        return undefined as any;

     
···

       
1554
       
 
       
    const response = vi.fn(

     

       
1555
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1556
       
 
       
        if (forwardOp.key === 1) {

     

       
1557
       
+
       
          return {

     

       
1558
       
+
       
            ...queryResponse,

     

       
1559
       
+
       
            operation: initialQueryOperation,

     

       
1560
       
+
       
            data: queryData,

     

       
1561
       
+
       
          };

     

       
1562
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1563
       
+
       
          return {

     

       
1564
       
+
       
            ...queryResponse,

     

       
1565
       
+
       
            operation: queryOperation,

     

       
1566
       
+
       
            data: queryData,

     

       
1567
       
+
       
          };

     

       
1568
       
 
       
        }

     

       
1569
       
 
       


     

       
1570
       
 
       
        return undefined as any;

     
···

       
1699
       
 
       
    const response = vi.fn(

     

       
1700
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
1701
       
 
       
        if (forwardOp.key === 1) {

     

       
1702
       
+
       
          return {

     

       
1703
       
+
       
            ...queryResponse,

     

       
1704
       
+
       
            operation: initialQueryOperation,

     

       
1705
       
+
       
            data: queryData,

     

       
1706
       
+
       
          };

     

       
1707
       
 
       
        } else if (forwardOp.key === 2) {

     

       
1708
       
+
       
          return {

     

       
1709
       
+
       
            ...queryResponse,

     

       
1710
       
+
       
            operation: queryOperation,

     

       
1711
       
+
       
            data: queryData,

     

       
1712
       
+
       
          };

     

       
1713
       
 
       
        }

     

       
1714
       
 
       


     

       
1715
       
 
       
        return undefined as any;

     
···

       
1788
       
 
       
    const result = (operation: Operation): Source<OperationResult> =>

     

       
1789
       
 
       
      pipe(

     

       
1790
       
 
       
        fromValue({

     

       
1791
       
+
       
          ...queryResponse,

     

       
1792
       
 
       
          operation,

     

       
1793
       
 
       
          data: {

     

       
1794
       
 
       
            __typename: 'Query',

     
···

       
1936
       
 
       
    nextOp(queryOpA);

     

       
1937
       
 
       


     

       
1938
       
 
       
    nextRes({

     

       
1939
       
+
       
      ...queryResponse,

     

       
1940
       
 
       
      operation: queryOpA,

     

       
1941
       
 
       
      data: {

     

       
1942
       
 
       
        __typename: 'Query',

     
···

       
2030
       
 
       
    nextOp(queryOpB);

     

       
2031
       
 
       


     

       
2032
       
 
       
    nextRes({

     

       
2033
       
+
       
      ...queryResponse,

     

       
2034
       
 
       
      operation: queryOpA,

     

       
2035
       
 
       
      data: {

     

       
2036
       
 
       
        __typename: 'Query',

     
···

       
2045
       
 
       
    expect(data).toHaveProperty('node.name', 'query a');

     

       
2046
       
 
       


     

       
2047
       
 
       
    nextRes({

     

       
2048
       
+
       
      ...queryResponse,

     

       
2049
       
 
       
      operation: mutationOp,

     

       
2050
       
 
       
      data: {

     

       
2051
       
 
       
        __typename: 'Mutation',

     
···

       
2061
       
 
       
    expect(data).toHaveProperty('node.name', 'mutation');

     

       
2062
       
 
       


     

       
2063
       
 
       
    nextRes({

     

       
2064
       
+
       
      ...queryResponse,

     

       
2065
       
 
       
      operation: queryOpB,

     

       
2066
       
 
       
      data: {

     

       
2067
       
 
       
        __typename: 'Query',

     
···

       
2151
       
 
       
    nextOp(mutationOp);

     

       
2152
       
 
       


     

       
2153
       
 
       
    nextRes({

     

       
2154
       
+
       
      ...queryResponse,

     

       
2155
       
 
       
      operation: queryOp,

     

       
2156
       
 
       
      data: {

     

       
2157
       
 
       
        __typename: 'Query',

     
···

       
2166
       
 
       
    expect(data).toHaveProperty('node.name', 'optimistic');

     

       
2167
       
 
       


     

       
2168
       
 
       
    nextRes({

     

       
2169
       
+
       
      ...queryResponse,

     

       
2170
       
 
       
      operation: mutationOp,

     

       
2171
       
 
       
      data: {

     

       
2172
       
 
       
        __typename: 'Query',

     
···

       
2254
       
 
       
    nextOp(subscriptionOp);

     

       
2255
       
 
       


     

       
2256
       
 
       
    nextRes({

     

       
2257
       
+
       
      ...queryResponse,

     

       
2258
       
 
       
      operation: queryOpA,

     

       
2259
       
 
       
      data: {

     

       
2260
       
 
       
        __typename: 'Query',

     
···

       
2267
       
 
       
    });

     

       
2268
       
 
       


     

       
2269
       
 
       
    nextRes({

     

       
2270
       
+
       
      ...queryResponse,

     

       
2271
       
 
       
      operation: subscriptionOp,

     

       
2272
       
 
       
      data: {

     

       
2273
       
 
       
        node: {

     
···

       
2369
       
 
       
    nextOp(subscriptionOp);

     

       
2370
       
 
       


     

       
2371
       
 
       
    nextRes({

     

       
2372
       
+
       
      ...queryResponse,

     

       
2373
       
 
       
      operation: queryOpA,

     

       
2374
       
 
       
      data: {

     

       
2375
       
 
       
        __typename: 'Query',

     
···

       
2384
       
 
       
    nextOp(mutationOp);

     

       
2385
       
 
       


     

       
2386
       
 
       
    nextRes({

     

       
2387
       
+
       
      ...queryResponse,

     

       
2388
       
 
       
      operation: mutationOp,

     

       
2389
       
 
       
      data: {

     

       
2390
       
 
       
        node: {

     
···

       
2396
       
 
       
    });

     

       
2397
       
 
       


     

       
2398
       
 
       
    nextRes({

     

       
2399
       
+
       
      ...queryResponse,

     

       
2400
       
 
       
      operation: subscriptionOp,

     

       
2401
       
 
       
      data: {

     

       
2402
       
 
       
        node: {

     
···

       
2408
       
 
       
    });

     

       
2409
       
 
       


     

       
2410
       
 
       
    nextRes({

     

       
2411
       
+
       
      ...queryResponse,

     

       
2412
       
 
       
      operation: subscriptionOp,

     

       
2413
       
 
       
      data: {

     

       
2414
       
 
       
        node: {

     
···

       
2517
       
 
       
    nextOp(normalOp);

     

       
2518
       
 
       


     

       
2519
       
 
       
    nextRes({

     

       
2520
       
+
       
      ...queryResponse,

     

       
2521
       
 
       
      operation: deferredOp,

     

       
2522
       
 
       
      data: {

     

       
2523
       
 
       
        __typename: 'Query',

     
···

       
2528
       
 
       
    expect(deferredData).not.toHaveProperty('deferred');

     

       
2529
       
 
       


     

       
2530
       
 
       
    nextRes({

     

       
2531
       
+
       
      ...queryResponse,

     

       
2532
       
 
       
      operation: normalOp,

     

       
2533
       
 
       
      data: {

     

       
2534
       
 
       
        __typename: 'Query',

     
···

       
2545
       
 
       
    expect(combinedData).toHaveProperty('node.id', 2);

     

       
2546
       
 
       


     

       
2547
       
 
       
    nextRes({

     

       
2548
       
+
       
      ...queryResponse,

     

       
2549
       
 
       
      operation: deferredOp,

     

       
2550
       
 
       
      data: {

     

       
2551
       
 
       
        __typename: 'Query',

     

···

       
26
       
 
       
import { Store, noopDataState, hydrateData, reserveLayer } from './store';

     

       
27
       
 
       
import { Data, Dependencies, CacheExchangeOpts } from './types';

     

       
28
       
 
       


     

       
29
       
-
       
type OperationResultWithMeta = OperationResult & {

     

       
0
       
 
       

     

       
30
       
 
       
  outcome: CacheOutcome;

     

       
31
       
 
       
  dependencies: Dependencies;

     

       
32
       
-
       
};

     

       
33
       
 
       


     

       
34
       
 
       
type Operations = Set<number>;

     

       
35
       
 
       
type OperationMap = Map<number, Operation>;

     

···

       
26
       
 
       
import { Store, noopDataState, hydrateData, reserveLayer } from './store';

     

       
27
       
 
       
import { Data, Dependencies, CacheExchangeOpts } from './types';

     

       
28
       
 
       


     

       
29
       
+
       
interface OperationResultWithMeta extends Partial<OperationResult> {

     

       
30
       
+
       
  operation: Operation;

     

       
31
       
 
       
  outcome: CacheOutcome;

     

       
32
       
 
       
  dependencies: Dependencies;

     

       
33
       
+
       
}

     

       
34
       
 
       


     

       
35
       
 
       
type Operations = Set<number>;

     

       
36
       
 
       
type OperationMap = Map<number, Operation>;

     

···

       
9
       
 
       
import { vi, expect, it, describe } from 'vitest';

     

       
10
       
 
       


     

       
11
       
 
       
import { pipe, map, makeSubject, tap, publish } from 'wonka';

     

       
0
       
 
       

     

       
12
       
 
       
import { offlineExchange } from './offlineExchange';

     

       
13
       
 
       


     

       
14
       
 
       
const mutationOne = gql`

     
···

       
79
       
 
       
    const response = vi.fn(

     

       
80
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
81
       
 
       
        expect(forwardOp.key).toBe(op.key);

     

       
82
       
-
       
        return { operation: forwardOp, data: mutationOneData };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
83
       
 
       
      }

     

       
84
       
 
       
    );

     

       
85
       
 
       


     
···

       
125
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
126
       
 
       
        if (forwardOp.key === queryOp.key) {

     

       
127
       
 
       
          onlineSpy.mockReturnValueOnce(true);

     

       
128
       
-
       
          return { operation: forwardOp, data: queryOneData };

     

       
129
       
 
       
        } else {

     

       
130
       
 
       
          onlineSpy.mockReturnValueOnce(false);

     

       
131
       
 
       
          return {

     

       
0
       
 
       

     

       
132
       
 
       
            operation: forwardOp,

     

       
133
       
 
       
            // @ts-ignore

     

       
134
       
 
       
            error: { networkError: new Error('failed to fetch') },

     

···

       
9
       
 
       
import { vi, expect, it, describe } from 'vitest';

     

       
10
       
 
       


     

       
11
       
 
       
import { pipe, map, makeSubject, tap, publish } from 'wonka';

     

       
12
       
+
       
import { queryResponse } from '../../../packages/core/src/test-utils';

     

       
13
       
 
       
import { offlineExchange } from './offlineExchange';

     

       
14
       
 
       


     

       
15
       
 
       
const mutationOne = gql`

     
···

       
80
       
 
       
    const response = vi.fn(

     

       
81
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
82
       
 
       
        expect(forwardOp.key).toBe(op.key);

     

       
83
       
+
       
        return {

     

       
84
       
+
       
          ...queryResponse,

     

       
85
       
+
       
          operation: forwardOp,

     

       
86
       
+
       
          data: mutationOneData,

     

       
87
       
+
       
        };

     

       
88
       
 
       
      }

     

       
89
       
 
       
    );

     

       
90
       
 
       


     
···

       
130
       
 
       
      (forwardOp: Operation): OperationResult => {

     

       
131
       
 
       
        if (forwardOp.key === queryOp.key) {

     

       
132
       
 
       
          onlineSpy.mockReturnValueOnce(true);

     

       
133
       
+
       
          return { ...queryResponse, operation: forwardOp, data: queryOneData };

     

       
134
       
 
       
        } else {

     

       
135
       
 
       
          onlineSpy.mockReturnValueOnce(false);

     

       
136
       
 
       
          return {

     

       
137
       
+
       
            ...queryResponse,

     

       
138
       
 
       
            operation: forwardOp,

     

       
139
       
 
       
            // @ts-ignore

     

       
140
       
 
       
            error: { networkError: new Error('failed to fetch') },

     

···

       
5
       
 
       
  "data": undefined,

     

       
6
       
 
       
  "error": [CombinedError: [Network] No Content],

     

       
7
       
 
       
  "extensions": undefined,

     

       
0
       
 
       

     

       
8
       
 
       
  "operation": {

     

       
9
       
 
       
    "context": {

     

       
10
       
 
       
      "fetchOptions": {

     
···

       
141
       
 
       
      "name": "Clara",

     

       
142
       
 
       
    },

     

       
143
       
 
       
  },

     

       
0
       
 
       

     

       
144
       
 
       
}

     

       
145
       
 
       
`;

     

       
146
       
 
       


     
···

       
149
       
 
       
  "data": undefined,

     

       
150
       
 
       
  "error": [CombinedError: [Network] No Content],

     

       
151
       
 
       
  "extensions": undefined,

     

       
0
       
 
       

     

       
152
       
 
       
  "operation": {

     

       
153
       
 
       
    "context": {

     

       
154
       
 
       
      "fetchOptions": [MockFunction spy] {

     
···

       
295
       
 
       
      "name": "Clara",

     

       
296
       
 
       
    },

     

       
297
       
 
       
  },

     

       
0
       
 
       

     

       
298
       
 
       
}

     

       
299
       
 
       
`;

     

       
300
       
 
       


     
···

       
452
       
 
       
      "name": "Clara",

     

       
453
       
 
       
    },

     

       
454
       
 
       
  },

     

       
0
       
 
       

     

       
455
       
 
       
}

     

       
456
       
 
       
`;

     

       
457
       
 
       


     
···

       
587
       
 
       
      "picture": File {},

     

       
588
       
 
       
    },

     

       
589
       
 
       
  },

     

       
0
       
 
       

     

       
590
       
 
       
}

     

       
591
       
 
       
`;

     

       
592
       
 
       


     
···

       
728
       
 
       
      ],

     

       
729
       
 
       
    },

     

       
730
       
 
       
  },

     

       
0
       
 
       

     

       
731
       
 
       
}

     

       
732
       
 
       
`;

     

       
733
       
 
       


     

···

       
5
       
 
       
  "data": undefined,

     

       
6
       
 
       
  "error": [CombinedError: [Network] No Content],

     

       
7
       
 
       
  "extensions": undefined,

     

       
8
       
+
       
  "hasNext": false,

     

       
9
       
 
       
  "operation": {

     

       
10
       
 
       
    "context": {

     

       
11
       
 
       
      "fetchOptions": {

     
···

       
142
       
 
       
      "name": "Clara",

     

       
143
       
 
       
    },

     

       
144
       
 
       
  },

     

       
145
       
+
       
  "stale": false,

     

       
146
       
 
       
}

     

       
147
       
 
       
`;

     

       
148
       
 
       


     
···

       
151
       
 
       
  "data": undefined,

     

       
152
       
 
       
  "error": [CombinedError: [Network] No Content],

     

       
153
       
 
       
  "extensions": undefined,

     

       
154
       
+
       
  "hasNext": false,

     

       
155
       
 
       
  "operation": {

     

       
156
       
 
       
    "context": {

     

       
157
       
 
       
      "fetchOptions": [MockFunction spy] {

     
···

       
298
       
 
       
      "name": "Clara",

     

       
299
       
 
       
    },

     

       
300
       
 
       
  },

     

       
301
       
+
       
  "stale": false,

     

       
302
       
 
       
}

     

       
303
       
 
       
`;

     

       
304
       
 
       


     
···

       
456
       
 
       
      "name": "Clara",

     

       
457
       
 
       
    },

     

       
458
       
 
       
  },

     

       
459
       
+
       
  "stale": false,

     

       
460
       
 
       
}

     

       
461
       
 
       
`;

     

       
462
       
 
       


     
···

       
592
       
 
       
      "picture": File {},

     

       
593
       
 
       
    },

     

       
594
       
 
       
  },

     

       
595
       
+
       
  "stale": false,

     

       
596
       
 
       
}

     

       
597
       
 
       
`;

     

       
598
       
 
       


     
···

       
734
       
 
       
      ],

     

       
735
       
 
       
    },

     

       
736
       
 
       
  },

     

       
737
       
+
       
  "stale": false,

     

       
738
       
 
       
}

     

       
739
       
 
       
`;

     

       
740
       
 
       


     

···

       
9
       
 
       
  ExchangeIO,

     

       
10
       
 
       
} from '@urql/core';

     

       
11
       
 
       


     

       
0
       
 
       

     

       
12
       
 
       
import { refocusExchange } from './refocusExchange';

     

       
13
       
 
       


     

       
14
       
 
       
const dispatchDebug = vi.fn();

     
···

       
49
       
 
       
  const response = vi.fn(

     

       
50
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
51
       
 
       
      return {

     

       
0
       
 
       

     

       
52
       
 
       
        operation: forwardOp,

     

       
53
       
 
       
        data: queryOneData,

     

       
54
       
 
       
      };

     

···

       
9
       
 
       
  ExchangeIO,

     

       
10
       
 
       
} from '@urql/core';

     

       
11
       
 
       


     

       
12
       
+
       
import { queryResponse } from '../../../packages/core/src/test-utils';

     

       
13
       
 
       
import { refocusExchange } from './refocusExchange';

     

       
14
       
 
       


     

       
15
       
 
       
const dispatchDebug = vi.fn();

     
···

       
50
       
 
       
  const response = vi.fn(

     

       
51
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
52
       
 
       
      return {

     

       
53
       
+
       
        ...queryResponse,

     

       
54
       
 
       
        operation: forwardOp,

     

       
55
       
 
       
        data: queryOneData,

     

       
56
       
 
       
      };

     

···

       
9
       
 
       
  ExchangeIO,

     

       
10
       
 
       
} from '@urql/core';

     

       
11
       
 
       


     

       
0
       
 
       

     

       
12
       
 
       
import { requestPolicyExchange } from './requestPolicyExchange';

     

       
13
       
 
       


     

       
14
       
 
       
const dispatchDebug = vi.fn();

     
···

       
53
       
 
       
  const response = vi.fn(

     

       
54
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
55
       
 
       
      return {

     

       
0
       
 
       

     

       
56
       
 
       
        operation: forwardOp,

     

       
57
       
 
       
        data: queryOneData,

     

       
58
       
 
       
      };

     
···

       
99
       
 
       
  const response = vi.fn(

     

       
100
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
101
       
 
       
      return {

     

       
0
       
 
       

     

       
102
       
 
       
        operation: forwardOp,

     

       
103
       
 
       
        data: queryOneData,

     

       
104
       
 
       
      };

     

···

       
9
       
 
       
  ExchangeIO,

     

       
10
       
 
       
} from '@urql/core';

     

       
11
       
 
       


     

       
12
       
+
       
import { queryResponse } from '../../../packages/core/src/test-utils';

     

       
13
       
 
       
import { requestPolicyExchange } from './requestPolicyExchange';

     

       
14
       
 
       


     

       
15
       
 
       
const dispatchDebug = vi.fn();

     
···

       
54
       
 
       
  const response = vi.fn(

     

       
55
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
56
       
 
       
      return {

     

       
57
       
+
       
        ...queryResponse,

     

       
58
       
 
       
        operation: forwardOp,

     

       
59
       
 
       
        data: queryOneData,

     

       
60
       
 
       
      };

     
···

       
101
       
 
       
  const response = vi.fn(

     

       
102
       
 
       
    (forwardOp: Operation): OperationResult => {

     

       
103
       
 
       
      return {

     

       
104
       
+
       
        ...queryResponse,

     

       
105
       
 
       
        operation: forwardOp,

     

       
106
       
 
       
        data: queryOneData,

     

       
107
       
 
       
      };

     

···

       
375
       
 
       
          }

     

       
376
       
 
       
        }),

     

       
377
       
 
       
        map(op => ({

     

       
0
       
 
       

     

       
0
       
 
       

     

       
378
       
 
       
          data: op.key,

     

       
379
       
 
       
          operation: op,

     

       
380
       
 
       
        }))

     
···

       
430
       
 
       
          ops$,

     

       
431
       
 
       
          filter(op => op.kind !== 'teardown'),

     

       
432
       
 
       
          map(op => ({

     

       
0
       
 
       

     

       
0
       
 
       

     

       
433
       
 
       
            data: ++countRes,

     

       
434
       
 
       
            operation: op,

     

       
435
       
 
       
          })),

     
···

       
482
       
 
       


     

       
483
       
 
       
    expect(output.length).toBe(3);

     

       
484
       
 
       
    expect(output[2]).toHaveProperty('data', 2);

     

       
485
       
-
       
    expect(output[2]).not.toHaveProperty('stale');

     

       
486
       
 
       
    expect(output[2]).toHaveProperty('operation.key', queryOperation.key);

     

       
487
       
 
       
    expect(output[2]).toHaveProperty(

     

       
488
       
 
       
      'operation.context.requestPolicy',

     
···

       
502
       
 
       
          data: 1,

     

       
503
       
 
       
          operation: op,

     

       
504
       
 
       
          stale: true,

     

       
0
       
 
       

     

       
505
       
 
       
        })),

     

       
506
       
 
       
        delay(1)

     

       
507
       
 
       
      );

     
···

       
565
       
 
       
      return pipe(

     

       
566
       
 
       
        ops$,

     

       
567
       
 
       
        map(op => ({

     

       
0
       
 
       

     

       
0
       
 
       

     

       
568
       
 
       
          data: ++i,

     

       
569
       
 
       
          operation: op,

     

       
570
       
 
       
        })),

     
···

       
590
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
591
       
 
       
      data: 1,

     

       
592
       
 
       
      operation: queryOperation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
593
       
 
       
    });

     

       
594
       
 
       


     

       
595
       
 
       
    pipe(client.executeRequestOperation(queryOperation), subscribe(resultTwo));

     
···

       
597
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
598
       
 
       
      data: 1,

     

       
599
       
 
       
      operation: queryOperation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
600
       
 
       
    });

     

       
601
       
 
       


     

       
602
       
 
       
    vi.advanceTimersByTime(1);

     
···

       
611
       
 
       
      return pipe(

     

       
612
       
 
       
        ops$,

     

       
613
       
 
       
        map(op => ({

     

       
0
       
 
       

     

       
0
       
 
       

     

       
614
       
 
       
          data: ++i,

     

       
615
       
 
       
          operation: op,

     

       
616
       
 
       
        })),

     
···

       
644
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
645
       
 
       
      data: 1,

     

       
646
       
 
       
      operation: operationOne,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
647
       
 
       
    });

     

       
648
       
 
       


     

       
649
       
 
       
    pipe(client.executeRequestOperation(operationTwo), subscribe(resultTwo));

     
···

       
652
       
 
       
      data: 1,

     

       
653
       
 
       
      operation: operationOne,

     

       
654
       
 
       
      stale: true,

     

       
0
       
 
       

     

       
655
       
 
       
    });

     

       
656
       
 
       


     

       
657
       
 
       
    vi.advanceTimersByTime(1);

     
···

       
659
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
660
       
 
       
      data: 2,

     

       
661
       
 
       
      operation: operationTwo,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
662
       
 
       
    });

     

       
663
       
 
       
  });

     

       
664
       
 
       


     
···

       
668
       
 
       
      return pipe(

     

       
669
       
 
       
        ops$,

     

       
670
       
 
       
        map(op => ({

     

       
0
       
 
       

     

       
0
       
 
       

     

       
671
       
 
       
          data: ++i,

     

       
672
       
 
       
          operation: op,

     

       
673
       
 
       
        })),

     
···

       
698
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
699
       
 
       
      data: 1,

     

       
700
       
 
       
      operation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
701
       
 
       
    });

     

       
702
       
 
       


     

       
703
       
 
       
    pipe(client.executeRequestOperation(operation), subscribe(resultTwo));

     
···

       
706
       
 
       
      data: 1,

     

       
707
       
 
       
      operation,

     

       
708
       
 
       
      stale: true,

     

       
0
       
 
       

     

       
709
       
 
       
    });

     

       
710
       
 
       


     

       
711
       
 
       
    vi.advanceTimersByTime(1);

     
···

       
716
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
717
       
 
       
      data: 2,

     

       
718
       
 
       
      operation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
719
       
 
       
    });

     

       
720
       
 
       
  });

     

       
721
       
 
       


     
···

       
726
       
 
       
        ops$,

     

       
727
       
 
       
        filter(op => op.kind !== 'teardown'),

     

       
728
       
 
       
        map(op => ({

     

       
0
       
 
       

     

       
0
       
 
       

     

       
729
       
 
       
          data: ++i,

     

       
730
       
 
       
          operation: op,

     

       
731
       
 
       
        })),

     
···

       
751
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
752
       
 
       
      data: 1,

     

       
753
       
 
       
      operation: queryOperation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
754
       
 
       
    });

     

       
755
       
 
       


     

       
756
       
 
       
    subscription.unsubscribe();

     
···

       
763
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
764
       
 
       
      data: 2,

     

       
765
       
 
       
      operation: queryOperation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
766
       
 
       
    });

     

       
767
       
 
       
  });

     

       
768
       
 
       


     
···

       
774
       
 
       
        map(op => ({

     

       
775
       
 
       
          data: ++i,

     

       
776
       
 
       
          operation: op,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
777
       
 
       
        })),

     

       
778
       
 
       
        take(1)

     

       
779
       
 
       
      );

     
···

       
800
       
 
       
      data: 1,

     

       
801
       
 
       
      operation,

     

       
802
       
 
       
      stale: true,

     

       
0
       
 
       

     

       
803
       
 
       
    });

     

       
804
       
 
       
  });

     

       
805
       
 
       


     
···

       
807
       
 
       
    const exchange: Exchange = () => ops$ => {

     

       
808
       
 
       
      return pipe(

     

       
809
       
 
       
        ops$,

     

       
810
       
-
       
        map(op => ({ data: 1, operation: op })),

     

       
811
       
 
       
        filter(() => false)

     

       
812
       
 
       
      );

     

       
813
       
 
       
    };

     
···

       
833
       
 
       
      let i = 0;

     

       
834
       
 
       
      return pipe(

     

       
835
       
 
       
        ops$,

     

       
836
       
-
       
        map(op => ({ data: ++i, operation: op }))

     

       
837
       
 
       
      );

     

       
838
       
 
       
    };

     

       
839
       
 
       


     
···

       
855
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
856
       
 
       
      data: 1,

     

       
857
       
 
       
      operation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
858
       
 
       
    });

     

       
859
       
 
       


     

       
860
       
 
       
    pipe(client.executeRequestOperation(operation), subscribe(resultTwo));

     
···

       
862
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
863
       
 
       
      data: 2,

     

       
864
       
 
       
      operation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
865
       
 
       
    });

     

       
866
       
 
       


     

       
867
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
868
       
 
       
      data: 2,

     

       
869
       
 
       
      operation,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
870
       
 
       
    });

     

       
871
       
 
       
  });

     

       
872
       
 
       


     
···

       
874
       
 
       
    const exchange: Exchange = () => ops$ => {

     

       
875
       
 
       
      return pipe(

     

       
876
       
 
       
        ops$,

     

       
877
       
-
       
        map(op => ({ stale: true, data: 1, operation: op })),

     

       
878
       
 
       
        take(1)

     

       
879
       
 
       
      );

     

       
880
       
 
       
    };

     
···

       
893
       
 
       
      data: 1,

     

       
894
       
 
       
      operation: queryOperation,

     

       
895
       
 
       
      stale: true,

     

       
0
       
 
       

     

       
896
       
 
       
    });

     

       
897
       
 
       


     

       
898
       
 
       
    pipe(client.executeRequestOperation(queryOperation), subscribe(resultTwo));

     
···

       
901
       
 
       
      data: 1,

     

       
902
       
 
       
      operation: queryOperation,

     

       
903
       
 
       
      stale: true,

     

       
0
       
 
       

     

       
904
       
 
       
    });

     

       
905
       
 
       
  });

     

       
906
       
 
       


     
···

       
941
       
 
       
    const exchange: Exchange = () => ops$ => {

     

       
942
       
 
       
      return pipe(

     

       
943
       
 
       
        ops$,

     

       
944
       
-
       
        map(op => ({ stale: true, data: 1, operation: op }))

     

       
945
       
 
       
      );

     

       
946
       
 
       
    };

     

       
947
       
 
       


     
···

       
960
       
 
       
      data: 1,

     

       
961
       
 
       
      operation: queryOperation,

     

       
962
       
 
       
      stale: true,

     

       
0
       
 
       

     

       
963
       
 
       
    });

     

       
964
       
 
       
  });

     

       
965
       
 
       
});

     

···

       
375
       
 
       
          }

     

       
376
       
 
       
        }),

     

       
377
       
 
       
        map(op => ({

     

       
378
       
+
       
          stale: false,

     

       
379
       
+
       
          hasNext: false,

     

       
380
       
 
       
          data: op.key,

     

       
381
       
 
       
          operation: op,

     

       
382
       
 
       
        }))

     
···

       
432
       
 
       
          ops$,

     

       
433
       
 
       
          filter(op => op.kind !== 'teardown'),

     

       
434
       
 
       
          map(op => ({

     

       
435
       
+
       
            hasNext: false,

     

       
436
       
+
       
            stale: false,

     

       
437
       
 
       
            data: ++countRes,

     

       
438
       
 
       
            operation: op,

     

       
439
       
 
       
          })),

     
···

       
486
       
 
       


     

       
487
       
 
       
    expect(output.length).toBe(3);

     

       
488
       
 
       
    expect(output[2]).toHaveProperty('data', 2);

     

       
489
       
+
       
    expect(output[2]).toHaveProperty('stale', false);

     

       
490
       
 
       
    expect(output[2]).toHaveProperty('operation.key', queryOperation.key);

     

       
491
       
 
       
    expect(output[2]).toHaveProperty(

     

       
492
       
 
       
      'operation.context.requestPolicy',

     
···

       
506
       
 
       
          data: 1,

     

       
507
       
 
       
          operation: op,

     

       
508
       
 
       
          stale: true,

     

       
509
       
+
       
          hasNext: false,

     

       
510
       
 
       
        })),

     

       
511
       
 
       
        delay(1)

     

       
512
       
 
       
      );

     
···

       
570
       
 
       
      return pipe(

     

       
571
       
 
       
        ops$,

     

       
572
       
 
       
        map(op => ({

     

       
573
       
+
       
          hasNext: false,

     

       
574
       
+
       
          stale: false,

     

       
575
       
 
       
          data: ++i,

     

       
576
       
 
       
          operation: op,

     

       
577
       
 
       
        })),

     
···

       
597
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
598
       
 
       
      data: 1,

     

       
599
       
 
       
      operation: queryOperation,

     

       
600
       
+
       
      stale: false,

     

       
601
       
+
       
      hasNext: false,

     

       
602
       
 
       
    });

     

       
603
       
 
       


     

       
604
       
 
       
    pipe(client.executeRequestOperation(queryOperation), subscribe(resultTwo));

     
···

       
606
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
607
       
 
       
      data: 1,

     

       
608
       
 
       
      operation: queryOperation,

     

       
609
       
+
       
      stale: false,

     

       
610
       
+
       
      hasNext: false,

     

       
611
       
 
       
    });

     

       
612
       
 
       


     

       
613
       
 
       
    vi.advanceTimersByTime(1);

     
···

       
622
       
 
       
      return pipe(

     

       
623
       
 
       
        ops$,

     

       
624
       
 
       
        map(op => ({

     

       
625
       
+
       
          hasNext: false,

     

       
626
       
+
       
          stale: false,

     

       
627
       
 
       
          data: ++i,

     

       
628
       
 
       
          operation: op,

     

       
629
       
 
       
        })),

     
···

       
657
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
658
       
 
       
      data: 1,

     

       
659
       
 
       
      operation: operationOne,

     

       
660
       
+
       
      hasNext: false,

     

       
661
       
+
       
      stale: false,

     

       
662
       
 
       
    });

     

       
663
       
 
       


     

       
664
       
 
       
    pipe(client.executeRequestOperation(operationTwo), subscribe(resultTwo));

     
···

       
667
       
 
       
      data: 1,

     

       
668
       
 
       
      operation: operationOne,

     

       
669
       
 
       
      stale: true,

     

       
670
       
+
       
      hasNext: false,

     

       
671
       
 
       
    });

     

       
672
       
 
       


     

       
673
       
 
       
    vi.advanceTimersByTime(1);

     
···

       
675
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
676
       
 
       
      data: 2,

     

       
677
       
 
       
      operation: operationTwo,

     

       
678
       
+
       
      stale: false,

     

       
679
       
+
       
      hasNext: false,

     

       
680
       
 
       
    });

     

       
681
       
 
       
  });

     

       
682
       
 
       


     
···

       
686
       
 
       
      return pipe(

     

       
687
       
 
       
        ops$,

     

       
688
       
 
       
        map(op => ({

     

       
689
       
+
       
          hasNext: false,

     

       
690
       
+
       
          stale: false,

     

       
691
       
 
       
          data: ++i,

     

       
692
       
 
       
          operation: op,

     

       
693
       
 
       
        })),

     
···

       
718
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
719
       
 
       
      data: 1,

     

       
720
       
 
       
      operation,

     

       
721
       
+
       
      stale: false,

     

       
722
       
+
       
      hasNext: false,

     

       
723
       
 
       
    });

     

       
724
       
 
       


     

       
725
       
 
       
    pipe(client.executeRequestOperation(operation), subscribe(resultTwo));

     
···

       
728
       
 
       
      data: 1,

     

       
729
       
 
       
      operation,

     

       
730
       
 
       
      stale: true,

     

       
731
       
+
       
      hasNext: false,

     

       
732
       
 
       
    });

     

       
733
       
 
       


     

       
734
       
 
       
    vi.advanceTimersByTime(1);

     
···

       
739
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
740
       
 
       
      data: 2,

     

       
741
       
 
       
      operation,

     

       
742
       
+
       
      stale: false,

     

       
743
       
+
       
      hasNext: false,

     

       
744
       
 
       
    });

     

       
745
       
 
       
  });

     

       
746
       
 
       


     
···

       
751
       
 
       
        ops$,

     

       
752
       
 
       
        filter(op => op.kind !== 'teardown'),

     

       
753
       
 
       
        map(op => ({

     

       
754
       
+
       
          hasNext: false,

     

       
755
       
+
       
          stale: false,

     

       
756
       
 
       
          data: ++i,

     

       
757
       
 
       
          operation: op,

     

       
758
       
 
       
        })),

     
···

       
778
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
779
       
 
       
      data: 1,

     

       
780
       
 
       
      operation: queryOperation,

     

       
781
       
+
       
      hasNext: false,

     

       
782
       
+
       
      stale: false,

     

       
783
       
 
       
    });

     

       
784
       
 
       


     

       
785
       
 
       
    subscription.unsubscribe();

     
···

       
792
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
793
       
 
       
      data: 2,

     

       
794
       
 
       
      operation: queryOperation,

     

       
795
       
+
       
      stale: false,

     

       
796
       
+
       
      hasNext: false,

     

       
797
       
 
       
    });

     

       
798
       
 
       
  });

     

       
799
       
 
       


     
···

       
805
       
 
       
        map(op => ({

     

       
806
       
 
       
          data: ++i,

     

       
807
       
 
       
          operation: op,

     

       
808
       
+
       
          hasNext: false,

     

       
809
       
+
       
          stale: false,

     

       
810
       
 
       
        })),

     

       
811
       
 
       
        take(1)

     

       
812
       
 
       
      );

     
···

       
833
       
 
       
      data: 1,

     

       
834
       
 
       
      operation,

     

       
835
       
 
       
      stale: true,

     

       
836
       
+
       
      hasNext: false,

     

       
837
       
 
       
    });

     

       
838
       
 
       
  });

     

       
839
       
 
       


     
···

       
841
       
 
       
    const exchange: Exchange = () => ops$ => {

     

       
842
       
 
       
      return pipe(

     

       
843
       
 
       
        ops$,

     

       
844
       
+
       
        map(op => ({ hasNext: false, stale: false, data: 1, operation: op })),

     

       
845
       
 
       
        filter(() => false)

     

       
846
       
 
       
      );

     

       
847
       
 
       
    };

     
···

       
867
       
 
       
      let i = 0;

     

       
868
       
 
       
      return pipe(

     

       
869
       
 
       
        ops$,

     

       
870
       
+
       
        map(op => ({ hasNext: false, stale: false, data: ++i, operation: op }))

     

       
871
       
 
       
      );

     

       
872
       
 
       
    };

     

       
873
       
 
       


     
···

       
889
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
890
       
 
       
      data: 1,

     

       
891
       
 
       
      operation,

     

       
892
       
+
       
      hasNext: false,

     

       
893
       
+
       
      stale: false,

     

       
894
       
 
       
    });

     

       
895
       
 
       


     

       
896
       
 
       
    pipe(client.executeRequestOperation(operation), subscribe(resultTwo));

     
···

       
898
       
 
       
    expect(resultTwo).toHaveBeenCalledWith({

     

       
899
       
 
       
      data: 2,

     

       
900
       
 
       
      operation,

     

       
901
       
+
       
      hasNext: false,

     

       
902
       
+
       
      stale: false,

     

       
903
       
 
       
    });

     

       
904
       
 
       


     

       
905
       
 
       
    expect(resultOne).toHaveBeenCalledWith({

     

       
906
       
 
       
      data: 2,

     

       
907
       
 
       
      operation,

     

       
908
       
+
       
      hasNext: false,

     

       
909
       
+
       
      stale: false,

     

       
910
       
 
       
    });

     

       
911
       
 
       
  });

     

       
912
       
 
       


     
···

       
914
       
 
       
    const exchange: Exchange = () => ops$ => {

     

       
915
       
 
       
      return pipe(

     

       
916
       
 
       
        ops$,

     

       
917
       
+
       
        map(op => ({ hasNext: false, stale: true, data: 1, operation: op })),

     

       
918
       
 
       
        take(1)

     

       
919
       
 
       
      );

     

       
920
       
 
       
    };

     
···

       
933
       
 
       
      data: 1,

     

       
934
       
 
       
      operation: queryOperation,

     

       
935
       
 
       
      stale: true,

     

       
936
       
+
       
      hasNext: false,

     

       
937
       
 
       
    });

     

       
938
       
 
       


     

       
939
       
 
       
    pipe(client.executeRequestOperation(queryOperation), subscribe(resultTwo));

     
···

       
942
       
 
       
      data: 1,

     

       
943
       
 
       
      operation: queryOperation,

     

       
944
       
 
       
      stale: true,

     

       
945
       
+
       
      hasNext: false,

     

       
946
       
 
       
    });

     

       
947
       
 
       
  });

     

       
948
       
 
       


     
···

       
983
       
 
       
    const exchange: Exchange = () => ops$ => {

     

       
984
       
 
       
      return pipe(

     

       
985
       
 
       
        ops$,

     

       
986
       
+
       
        map(op => ({ hasNext: false, stale: true, data: 1, operation: op }))

     

       
987
       
 
       
      );

     

       
988
       
 
       
    };

     

       
989
       
 
       


     
···

       
1002
       
 
       
      data: 1,

     

       
1003
       
 
       
      operation: queryOperation,

     

       
1004
       
 
       
      stale: true,

     

       
1005
       
+
       
      hasNext: false,

     

       
1006
       
 
       
    });

     

       
1007
       
 
       
  });

     

       
1008
       
 
       
});

     

···

       
5
       
 
       
  "data": undefined,

     

       
6
       
 
       
  "error": [CombinedError: [Network] No Content],

     

       
7
       
 
       
  "extensions": undefined,

     

       
0
       
 
       

     

       
8
       
 
       
  "operation": {

     

       
9
       
 
       
    "context": {

     

       
10
       
 
       
      "fetchOptions": {

     
···

       
141
       
 
       
      "name": "Clara",

     

       
142
       
 
       
    },

     

       
143
       
 
       
  },

     

       
0
       
 
       

     

       
144
       
 
       
}

     

       
145
       
 
       
`;

     

       
146
       
 
       


     
···

       
149
       
 
       
  "data": undefined,

     

       
150
       
 
       
  "error": [CombinedError: [Network] No Content],

     

       
151
       
 
       
  "extensions": undefined,

     

       
0
       
 
       

     

       
152
       
 
       
  "operation": {

     

       
153
       
 
       
    "context": {

     

       
154
       
 
       
      "fetchOptions": [MockFunction spy] {

     
···

       
295
       
 
       
      "name": "Clara",

     

       
296
       
 
       
    },

     

       
297
       
 
       
  },

     

       
0
       
 
       

     

       
298
       
 
       
}

     

       
299
       
 
       
`;

     

       
300
       
 
       


     
···

       
452
       
 
       
      "name": "Clara",

     

       
453
       
 
       
    },

     

       
454
       
 
       
  },

     

       
0
       
 
       

     

       
455
       
 
       
}

     

       
456
       
 
       
`;

     

       
457