commit 5865e2a1256aac36ae8ca57318f42b08d25702b6 · kitten.sh/graphqlsp

.changeset/many-nails-wait.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Add validation step to check that the persisted-operations hash has been updated when the document changes

+25

packages/graphqlsp/src/diagnostics.ts

···

       25
       25
        
         getColocatedFragmentNames,

     

       26
       26
        
       } from './checkImports';

     

       27
       27
        
       import {

     

       28
       28
       +
         generateHashForDocument,

     

       28
       29
        
         getDocumentReferenceFromDocumentNode,

     

       29
       30
        
         getDocumentReferenceFromTypeQuery,

     

       30
       31
        
       } from './persisted';

     
···

       54
       55
        
       export const MISSING_PERSISTED_TYPE_ARG = 520100;

     

       55
       56
        
       export const MISSING_PERSISTED_CODE_ARG = 520101;

     

       56
       57
        
       export const MISSING_PERSISTED_DOCUMENT = 520102;

     

       58
       58
       +
       export const MISSMATCH_HASH_TO_DOCUMENT = 520103;

     

       57
       59
        
       export const ALL_DIAGNOSTICS = [

     

       58
       60
        
         SEMANTIC_DIAGNOSTIC_CODE,

     

       59
       61
        
         MISSING_OPERATION_NAME_CODE,

     
···

       63
       65
        
         MISSING_PERSISTED_TYPE_ARG,

     

       64
       66
        
         MISSING_PERSISTED_CODE_ARG,

     

       65
       67
        
         MISSING_PERSISTED_DOCUMENT,

     

       68
       68
       +
         MISSMATCH_HASH_TO_DOCUMENT,

     

       66
       69
        
       ];

     

       67
       70
        
       

     

       68
       71
        
       const cache = new LRUCache<number, ts.Diagnostic[]>({

     
···

       245
       248
        
                   start: callExpression.arguments.pos,

     

       246
       249
        
                   length: callExpression.arguments.end - callExpression.arguments.pos,

     

       247
       250
        
                 };

     

       251
       251
       +
               }

     

       252
       252
       +
       

     

       253
       253
       +
               const hash = callExpression.arguments[0].getText().slice(1, -1);

     

       254
       254
       +
               if (hash.startsWith('sha256:')) {

     

       255
       255
       +
                 const hash = generateHashForDocument(

     

       256
       256
       +
                   info,

     

       257
       257
       +
                   initializer.arguments[0],

     

       258
       258
       +
                   foundFilename

     

       259
       259
       +
                 );

     

       260
       260
       +
                 if (!hash) return null;

     

       261
       261
       +
                 const upToDateHash = `sha256:${hash}`;

     

       262
       262
       +
                 if (upToDateHash !== hash) {

     

       263
       263
       +
                   return {

     

       264
       264
       +
                     category: ts.DiagnosticCategory.Warning,

     

       265
       265
       +
                     code: MISSMATCH_HASH_TO_DOCUMENT,

     

       266
       266
       +
                     file: source,

     

       267
       267
       +
                     messageText: `The persisted document's hash is outdated`,

     

       268
       268
       +
                     start: callExpression.arguments.pos,

     

       269
       269
       +
                     length:

     

       270
       270
       +
                       callExpression.arguments.end - callExpression.arguments.pos,

     

       271
       271
       +
                   };

     

       272
       272
       +
                 }

     

       248
       273
        
               }

     

       249
       274
        
       

     

       250
       275
        
               return null;

+43 -30

packages/graphqlsp/src/persisted.ts

···

       119
       119
        
         )

     

       120
       120
        
           return undefined;

     

       121
       121
        
       

     

       122
       122
       -
         const externalSource = getSource(info, foundFilename)!;

     

       123
       123
       -
         const { fragments } = findAllCallExpressions(externalSource, info);

     

       124
       124
       -
       

     

       125
       125
       -
         const text = resolveTemplate(

     

       122
       122
       +
         const hash = generateHashForDocument(

     

       123
       123
       +
           info,

     

       126
       124
        
           initializer.arguments[0],

     

       127
       127
       -
           foundFilename,

     

       128
       128
       -
           info

     

       129
       129
       -
         ).combinedText;

     

       130
       130
       -
         const parsed = parse(text);

     

       131
       131
       -
         const spreads = new Set();

     

       132
       132
       -
         visit(parsed, {

     

       133
       133
       -
           FragmentSpread: node => {

     

       134
       134
       -
             spreads.add(node.name.value);

     

       135
       135
       -
           },

     

       136
       136
       -
         });

     

       137
       137
       -
       

     

       138
       138
       -
         let resolvedText = text;

     

       139
       139
       -
         [...spreads].forEach(spreadName => {

     

       140
       140
       -
           const fragmentDefinition = fragments.find(x => x.name.value === spreadName);

     

       141
       141
       -
           if (!fragmentDefinition) {

     

       142
       142
       -
             console.warn(

     

       143
       143
       -
               `[GraphQLSP] could not find fragment for spread ${spreadName}!`

     

       144
       144
       -
             );

     

       145
       145
       -
             return;

     

       146
       146
       -
           }

     

       147
       147
       -
       

     

       148
       148
       -
           resolvedText = `${resolvedText}\n\n${print(fragmentDefinition)}`;

     

       149
       149
       -
         });

     

       150
       150
       -
       

     

       151
       151
       -
         const hash = createHash('sha256').update(text).digest('hex');

     

       152
       152
       -
       

     

       125
       125
       +
           foundFilename

     

       126
       126
       +
         );

     

       153
       127
        
         const existingHash = callExpression.arguments[0];

     

       154
       128
        
         // We assume for now that this is either undefined or an existing string literal

     

       155
       129
        
         if (!existingHash) {

     
···

       187
       161
        
           return undefined;

     

       188
       162
        
         }

     

       189
       163
        
       }

     

       164
       164
       +
       

     

       165
       165
       +
       export const generateHashForDocument = (

     

       166
       166
       +
         info: ts.server.PluginCreateInfo,

     

       167
       167
       +
         templateLiteral:

     

       168
       168
       +
           | ts.NoSubstitutionTemplateLiteral

     

       169
       169
       +
           | ts.TaggedTemplateExpression,

     

       170
       170
       +
         foundFilename: string

     

       171
       171
       +
       ): string | undefined => {

     

       172
       172
       +
         const externalSource = getSource(info, foundFilename)!;

     

       173
       173
       +
         const { fragments } = findAllCallExpressions(externalSource, info);

     

       174
       174
       +
       

     

       175
       175
       +
         const text = resolveTemplate(

     

       176
       176
       +
           templateLiteral,

     

       177
       177
       +
           foundFilename,

     

       178
       178
       +
           info

     

       179
       179
       +
         ).combinedText;

     

       180
       180
       +
         const parsed = parse(text);

     

       181
       181
       +
         const spreads = new Set();

     

       182
       182
       +
         visit(parsed, {

     

       183
       183
       +
           FragmentSpread: node => {

     

       184
       184
       +
             spreads.add(node.name.value);

     

       185
       185
       +
           },

     

       186
       186
       +
         });

     

       187
       187
       +
       

     

       188
       188
       +
         let resolvedText = text;

     

       189
       189
       +
         [...spreads].forEach(spreadName => {

     

       190
       190
       +
           const fragmentDefinition = fragments.find(x => x.name.value === spreadName);

     

       191
       191
       +
           if (!fragmentDefinition) {

     

       192
       192
       +
             console.warn(

     

       193
       193
       +
               `[GraphQLSP] could not find fragment for spread ${spreadName}!`

     

       194
       194
       +
             );

     

       195
       195
       +
             return;

     

       196
       196
       +
           }

     

       197
       197
       +
       

     

       198
       198
       +
           resolvedText = `${resolvedText}\n\n${print(fragmentDefinition)}`;

     

       199
       199
       +
         });

     

       200
       200
       +
       

     

       201
       201
       +
         return createHash('sha256').update(text).digest('hex');

     

       202
       202
       +
       };

     

       190
       203
        
       

     

       191
       204
        
       export const getDocumentReferenceFromTypeQuery = (

     

       192
       205
        
         typeQuery: ts.TypeQueryNode,