commit cc4e1a0d63ba4ff455d75a5a0a5a3fb1a316cd99 · kitten.sh/urql

.changeset/tiny-candles-dress.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       '@urql/introspection': patch

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Fix `Any` type being included, even when it isn’t needed.

+38 -22

packages/introspection/src/minifyIntrospectionQuery.ts

···

       3
       3
        
         IntrospectionType,

     

       4
       4
        
         IntrospectionTypeRef,

     

       5
       5
        
         IntrospectionInputValue,

     

       6
       6
       +
         IntrospectionDirective,

     

       6
       7
        
       } from 'graphql';

     

       7
       8
        
       

     

       8
       9
        
       let _includeScalars = false;

     
···

       25
       26
        
             };

     

       26
       27
        
       

     

       27
       28
        
           case 'SCALAR':

     

       28
       28
       -
             _hasAnyType = _hasAnyType || _includeScalars;

     

       29
       29
       -
             return _includeScalars ? fromType : anyType;

     

       29
       29
       +
             if (_includeScalars) {

     

       30
       30
       +
               return fromType;

     

       31
       31
       +
             } else {

     

       32
       32
       +
               _hasAnyType = true;

     

       33
       33
       +
               return anyType;

     

       34
       34
       +
             }

     

       30
       35
        
       

     

       31
       36
        
           case 'INPUT_OBJECT':

     

       32
       32
       -
             _hasAnyType = _hasAnyType || _includeInputs;

     

       33
       33
       -
             return _includeInputs ? fromType : anyType;

     

       37
       37
       +
             if (_includeInputs) {

     

       38
       38
       +
               return fromType;

     

       39
       39
       +
             } else {

     

       40
       40
       +
               _hasAnyType = true;

     

       41
       41
       +
               return anyType;

     

       42
       42
       +
             }

     

       34
       43
        
       

     

       35
       44
        
           case 'ENUM':

     

       36
       36
       -
             _hasAnyType = _hasAnyType || _includeEnums;

     

       37
       37
       -
             return _includeEnums ? fromType : anyType;

     

       45
       45
       +
             if (_includeEnums) {

     

       46
       46
       +
               return fromType;

     

       47
       47
       +
             } else {

     

       48
       48
       +
               _hasAnyType = true;

     

       49
       49
       +
               return anyType;

     

       50
       50
       +
             }

     

       38
       51
        
       

     

       39
       52
        
           case 'OBJECT':

     

       40
       53
        
           case 'INTERFACE':

     
···

       244
       257
        
           })

     

       245
       258
        
           .map(minifyIntrospectionType);

     

       246
       259
        
       

     

       247
       247
       -
         const minifiedDirectives = (directives || []).map(directive => ({

     

       248
       248
       -
           name: directive.name,

     

       249
       249
       -
           isRepeatable: directive.isRepeatable ? true : undefined,

     

       250
       250
       -
           locations: directive.locations,

     

       251
       251
       -
           args: directive.args.map(

     

       252
       252
       -
             arg =>

     

       253
       253
       -
               ({

     

       254
       254
       -
                 name: arg.name,

     

       255
       255
       -
                 type: mapType(arg.type),

     

       256
       256
       -
                 defaultValue: arg.defaultValue || undefined,

     

       257
       257
       -
               }) as IntrospectionInputValue

     

       258
       258
       -
           ),

     

       259
       259
       -
         }));

     

       260
       260
       +
         if (_hasAnyType) {

     

       261
       261
       +
           minifiedTypes.push({ kind: 'SCALAR', name: anyType.name });

     

       262
       262
       +
         }

     

       260
       263
        
       

     

       261
       261
       -
         if (!_includeScalars || !_includeEnums || !_includeInputs || _hasAnyType) {

     

       262
       262
       -
           minifiedTypes.push({ kind: 'SCALAR', name: anyType.name });

     

       264
       264
       +
         let minifiedDirectives: IntrospectionDirective[] = [];

     

       265
       265
       +
         if (opts.includeDirectives) {

     

       266
       266
       +
           minifiedDirectives = (directives || []).map(directive => ({

     

       267
       267
       +
             name: directive.name,

     

       268
       268
       +
             isRepeatable: directive.isRepeatable ? true : undefined,

     

       269
       269
       +
             locations: directive.locations,

     

       270
       270
       +
             args: directive.args.map(

     

       271
       271
       +
               arg =>

     

       272
       272
       +
                 ({

     

       273
       273
       +
                   name: arg.name,

     

       274
       274
       +
                   type: mapType(arg.type),

     

       275
       275
       +
                   defaultValue: arg.defaultValue || undefined,

     

       276
       276
       +
                 }) as IntrospectionInputValue

     

       277
       277
       +
             ),

     

       278
       278
       +
           }));

     

       263
       279
        
         }

     

       264
       280
        
       

     

       265
       281
        
         return {

     
···

       268
       284
        
             mutationType,

     

       269
       285
        
             subscriptionType,

     

       270
       286
        
             types: minifiedTypes,

     

       271
       271
       -
             directives: opts.includeDirectives ? minifiedDirectives : [],

     

       287
       287
       +
             directives: minifiedDirectives,

     

       272
       288
        
           },

     

       273
       289
        
         };

     

       274
       290
        
       };