commit 557ee4eb85235a814e446ffb2387c8c613cbbe10 · kitten.sh/urql

+5

.changeset/quick-seahorses-cross.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       '@urql/core': patch

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Fix incorrect operation name being picked from queries that contain multiple operations.

+6

.changeset/young-lamps-help.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       '@urql/core': major

     

       3
       3
       +
       '@urql/exchange-execute': minor

     

       4
       4
       +
       ---

     

       5
       5
       +
       

     

       6
       6
       +
       Remove `getOperationName` export from `@urql/core`

+2 -5

exchanges/execute/src/execute.test.ts

···

       33
       33
        
         makeErrorResult,

     

       34
       34
        
         makeOperation,

     

       35
       35
        
         Client,

     

       36
       36
       -
         getOperationName,

     

       37
       36
        
         OperationResult,

     

       38
       37
        
       } from '@urql/core';

     

       39
       38
        
       

     
···

       45
       44
        
         client: {},

     

       46
       45
        
       } as any;

     

       47
       46
        
       

     

       48
       48
       -
       const expectedQueryOperationName = getOperationName(queryOperation.query);

     

       49
       49
       -
       const expectedSubscribeOperationName = getOperationName(

     

       50
       50
       -
         subscriptionOperation.query

     

       51
       51
       -
       );

     

       47
       47
       +
       const expectedQueryOperationName = 'getUser';

     

       48
       48
       +
       const expectedSubscribeOperationName = 'subscribeToUser';

     

       52
       49
        
       

     

       53
       50
        
       const fetchMock = (global as any).fetch as Mock;

     

       54
       51
        
       const mockHttpResponseData = { key: 'value' };

+10 -2

exchanges/execute/src/execute.ts

···

       17
       17
        
         subscribe,

     

       18
       18
        
         ExecutionArgs,

     

       19
       19
        
         SubscriptionArgs,

     

       20
       20
       +
         Kind,

     

       20
       21
        
       } from 'graphql';

     

       21
       22
        
       

     

       22
       23
        
       import {

     
···

       27
       28
        
         mergeResultPatch,

     

       28
       29
        
         Operation,

     

       29
       30
        
         OperationResult,

     

       30
       30
       -
         getOperationName,

     

       31
       31
        
       } from '@urql/core';

     

       32
       32
        
       

     

       33
       33
        
       export interface ExecuteExchangeArgs {

     
···

       150
       150
        
                 }

     

       151
       151
        
               }

     

       152
       152
        
       

     

       153
       153
       +
               let operationName: string | undefined;

     

       154
       154
       +
               for (const node of operation.query.definitions) {

     

       155
       155
       +
                 if (node.kind === Kind.OPERATION_DEFINITION) {

     

       156
       156
       +
                   operationName = node.name ? node.name.value : undefined;

     

       157
       157
       +
                   break;

     

       158
       158
       +
                 }

     

       159
       159
       +
               }

     

       160
       160
       +
       

     

       153
       161
        
               return pipe(

     

       154
       162
        
                 makeExecuteSource(operation, {

     

       155
       163
        
                   schema,

     
···

       157
       165
        
                   rootValue,

     

       158
       166
        
                   contextValue,

     

       159
       167
        
                   variableValues,

     

       160
       160
       -
                   operationName: getOperationName(operation.query),

     

       168
       168
       +
                   operationName,

     

       161
       169
        
                   fieldResolver,

     

       162
       170
        
                   typeResolver,

     

       163
       171
        
                   subscribeFieldResolver,

-1

packages/core/src/index.ts

···

       14
       14
        
         formatDocument,

     

       15
       15
        
         maskTypename,

     

       16
       16
        
         makeOperation,

     

       17
       17
       -
         getOperationName,

     

       18
       17
        
       } from './utils';

+2 -2

packages/core/src/utils/request.ts

···

       169
       169
        
        */

     

       170
       170
        
       export const getOperationName = (query: DocumentNode): string | undefined => {

     

       171
       171
        
         for (const node of query.definitions) {

     

       172
       172
       -
           if (node.kind === Kind.OPERATION_DEFINITION && node.name) {

     

       173
       173
       -
             return node.name.value;

     

       172
       172
       +
           if (node.kind === Kind.OPERATION_DEFINITION) {

     

       173
       173
       +
             return node.name ? node.name.value : undefined;

     

       174
       174
        
           }

     

       175
       175
        
         }

     

       176
       176
        
       };