commit c149f35eed174c06e7ba647bca2b5689984b62dd · kitten.sh/graphqlsp

.changeset/fluffy-rabbits-shake.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       '@0no-co/graphqlsp': patch

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Strip our internal `@_unmask` directive from fragment-definitions when creating hashes for persisted-operations

+39 -1

packages/graphqlsp/src/persisted.ts

···

       12
       12
        
       import { resolveTemplate } from './ast/resolve';

     

       13
       13
        
       import {

     

       14
       14
        
         FragmentDefinitionNode,

     

       15
       15
       +
         Kind,

     

       15
       16
        
         parse,

     

       16
       17
        
         print,

     

       17
       18
        
         visit,

     
···

       183
       184
        
             foundFilename,

     

       184
       185
        
             info

     

       185
       186
        
           ).combinedText;

     

       187
       187
       +
           const parsed = parse(text);

     

       188
       188
       +
           const seen = new Set<unknown>();

     

       189
       189
       +
           for (const definition of parsed.definitions) {

     

       190
       190
       +
             if (

     

       191
       191
       +
               definition.kind === Kind.FRAGMENT_DEFINITION &&

     

       192
       192
       +
               !seen.has(definition)

     

       193
       193
       +
             ) {

     

       194
       194
       +
               stripUnmaskDirectivesFromDefinition(definition);

     

       195
       195
       +
             }

     

       196
       196
       +
           }

     

       197
       197
       +
       

     

       186
       198
        
           const deduplicatedFragments = fragments

     

       187
       187
       -
             .map(fragment => print(fragment))

     

       199
       199
       +
             .map(fragment => {

     

       200
       200
       +
               stripUnmaskDirectivesFromDefinition(fragment);

     

       201
       201
       +
               return print(fragment)

     

       202
       202
       +
             })

     

       188
       203
        
             .filter((fragment, index, array) => array.indexOf(fragment) === index);

     

       189
       204
        
       

     

       190
       205
        
           deduplicatedFragments.forEach(fragmentDefinition => {

     
···

       203
       218
        
           ).combinedText;

     

       204
       219
        
       

     

       205
       220
        
           const parsed = parse(text);

     

       221
       221
       +
           const seen = new Set<unknown>();

     

       222
       222
       +
           for (const definition of parsed.definitions) {

     

       223
       223
       +
             if (

     

       224
       224
       +
               definition.kind === Kind.FRAGMENT_DEFINITION &&

     

       225
       225
       +
               !seen.has(definition)

     

       226
       226
       +
             ) {

     

       227
       227
       +
               stripUnmaskDirectivesFromDefinition(definition);

     

       228
       228
       +
             }

     

       229
       229
       +
           }

     

       230
       230
       +
       

     

       206
       231
        
           const spreads = new Set<string>();

     

       207
       232
        
           visit(parsed, {

     

       208
       233
        
             FragmentSpread: node => {

     
···

       226
       251
        
               );

     

       227
       252
        
               return;

     

       228
       253
        
             }

     

       254
       254
       +
       

     

       255
       255
       +
             stripUnmaskDirectivesFromDefinition(fragmentDefinition);

     

       229
       256
        
       

     

       230
       257
        
             visit(fragmentDefinition, {

     

       231
       258
        
               FragmentSpread: node => {

     
···

       322
       349
        
           return { node: documentNodeArgument, filename };

     

       323
       350
        
         }

     

       324
       351
        
       };

     

       352
       352
       +
       

     

       353
       353
       +
       type writable<T> = { -readonly [K in keyof T]: T[K] };

     

       354
       354
       +
       

     

       355
       355
       +
       const stripUnmaskDirectivesFromDefinition = (

     

       356
       356
       +
         definition: FragmentDefinitionNode

     

       357
       357
       +
       ) => {

     

       358
       358
       +
         (definition as writable<FragmentDefinitionNode>).directives =

     

       359
       359
       +
           definition.directives?.filter(

     

       360
       360
       +
             directive => directive.name.value !== '_unmask'

     

       361
       361
       +
           );

     

       362
       362
       +
       };