commit 09757d11dbe6b25f524e2f1d41815d4228826442 · kitten.sh/graphqlsp

.changeset/wild-lizards-fry.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Stop caching diagnostics for fragment imports and field-usage as these can be controlled externally

+51 -57

packages/graphqlsp/src/diagnostics.ts

···

       43
       43
        
       export const MISSING_OPERATION_NAME_CODE = 52002;

     

       44
       44
        
       export const USING_DEPRECATED_FIELD_CODE = 52004;

     

       45
       45
        
       

     

       46
       46
       -
       let isGeneratingTypes = false;

     

       47
       47
       -
       

     

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

     

       49
       47
        
         // how long to live in ms

     

       50
       48
        
         ttl: 1000 * 60 * 15,

     
···

       95
       93
        
             : texts.join('-') + schema.version

     

       96
       94
        
         );

     

       97
       95
        
       

     

       96
       96
       +
         let tsDiagnostics;

     

       98
       97
        
         if (cache.has(cacheKey)) {

     

       99
       99
       -
           return cache.get(cacheKey)!;

     

       98
       98
       +
           tsDiagnostics = cache.get(cacheKey)!;

     

       100
       99
        
         } else {

     

       101
       101
       -
           const tsDiagnostics = runDiagnostics(

     

       102
       102
       -
             source,

     

       103
       103
       -
             { nodes, fragments },

     

       104
       104
       -
             schema,

     

       105
       105
       -
             info

     

       106
       106
       -
           );

     

       100
       100
       +
           tsDiagnostics = runDiagnostics(source, { nodes, fragments }, schema, info);

     

       107
       101
        
           cache.set(cacheKey, tsDiagnostics);

     

       102
       102
       +
         }

     

       103
       103
       +
       

     

       104
       104
       +
         const shouldCheckForColocatedFragments =

     

       105
       105
       +
           info.config.shouldCheckForColocatedFragments ?? true;

     

       106
       106
       +
         let fragmentDiagnostics: ts.Diagnostic[] = [];

     

       107
       107
       +
         if (isCallExpression && shouldCheckForColocatedFragments) {

     

       108
       108
       +
           const moduleSpecifierToFragments = getColocatedFragmentNames(source, info);

     

       109
       109
       +
       

     

       110
       110
       +
           const usedFragments = new Set();

     

       111
       111
       +
           nodes.forEach(node => {

     

       112
       112
       +
             try {

     

       113
       113
       +
               const parsed = parse(node.getText().slice(1, -1), {

     

       114
       114
       +
                 noLocation: true,

     

       115
       115
       +
               });

     

       116
       116
       +
               visit(parsed, {

     

       117
       117
       +
                 FragmentSpread: node => {

     

       118
       118
       +
                   usedFragments.add(node.name.value);

     

       119
       119
       +
                 },

     

       120
       120
       +
               });

     

       121
       121
       +
             } catch (e) {}

     

       122
       122
       +
           });

     

       123
       123
       +
       

     

       124
       124
       +
           Object.keys(moduleSpecifierToFragments).forEach(moduleSpecifier => {

     

       125
       125
       +
             const {

     

       126
       126
       +
               fragments: fragmentNames,

     

       127
       127
       +
               start,

     

       128
       128
       +
               length,

     

       129
       129
       +
             } = moduleSpecifierToFragments[moduleSpecifier];

     

       130
       130
       +
             const missingFragments = Array.from(

     

       131
       131
       +
               new Set(fragmentNames.filter(x => !usedFragments.has(x)))

     

       132
       132
       +
             );

     

       133
       133
       +
             if (missingFragments.length) {

     

       134
       134
       +
               fragmentDiagnostics.push({

     

       135
       135
       +
                 file: source,

     

       136
       136
       +
                 length,

     

       137
       137
       +
                 start,

     

       138
       138
       +
                 category: ts.DiagnosticCategory.Warning,

     

       139
       139
       +
                 code: MISSING_FRAGMENT_CODE,

     

       140
       140
       +
                 messageText: `Unused co-located fragment definition(s) "${missingFragments.join(

     

       141
       141
       +
                   ', '

     

       142
       142
       +
                 )}" in ${moduleSpecifier}`,

     

       143
       143
       +
               });

     

       144
       144
       +
             }

     

       145
       145
       +
           });

     

       146
       146
       +
       

     

       147
       147
       +
           return [...tsDiagnostics, ...fragmentDiagnostics];

     

       148
       148
       +
         } else {

     

       108
       149
        
           return tsDiagnostics;

     

       109
       150
        
         }

     

       110
       151
        
       }

     
···

       304
       345
        
             info

     

       305
       346
        
           );

     

       306
       347
        
       

     

       307
       307
       -
           const shouldCheckForColocatedFragments =

     

       308
       308
       -
             info.config.shouldCheckForColocatedFragments ?? true;

     

       309
       309
       -
           let fragmentDiagnostics: ts.Diagnostic[] = [];

     

       310
       310
       -
           if (shouldCheckForColocatedFragments) {

     

       311
       311
       -
             const moduleSpecifierToFragments = getColocatedFragmentNames(

     

       312
       312
       -
               source,

     

       313
       313
       -
               info

     

       314
       314
       -
             );

     

       315
       315
       -
       

     

       316
       316
       -
             const usedFragments = new Set();

     

       317
       317
       -
             nodes.forEach(node => {

     

       318
       318
       -
               try {

     

       319
       319
       -
                 const parsed = parse(node.getText().slice(1, -1), {

     

       320
       320
       -
                   noLocation: true,

     

       321
       321
       -
                 });

     

       322
       322
       -
                 visit(parsed, {

     

       323
       323
       -
                   FragmentSpread: node => {

     

       324
       324
       -
                     usedFragments.add(node.name.value);

     

       325
       325
       -
                   },

     

       326
       326
       -
                 });

     

       327
       327
       -
               } catch (e) {}

     

       328
       328
       -
             });

     

       329
       329
       -
       

     

       330
       330
       -
             Object.keys(moduleSpecifierToFragments).forEach(moduleSpecifier => {

     

       331
       331
       -
               const {

     

       332
       332
       -
                 fragments: fragmentNames,

     

       333
       333
       -
                 start,

     

       334
       334
       -
                 length,

     

       335
       335
       -
               } = moduleSpecifierToFragments[moduleSpecifier];

     

       336
       336
       -
               const missingFragments = Array.from(

     

       337
       337
       -
                 new Set(fragmentNames.filter(x => !usedFragments.has(x)))

     

       338
       338
       -
               );

     

       339
       339
       -
               if (missingFragments.length) {

     

       340
       340
       -
                 fragmentDiagnostics.push({

     

       341
       341
       -
                   file: source,

     

       342
       342
       -
                   length,

     

       343
       343
       -
                   start,

     

       344
       344
       -
                   category: ts.DiagnosticCategory.Warning,

     

       345
       345
       -
                   code: MISSING_FRAGMENT_CODE,

     

       346
       346
       -
                   messageText: `Unused co-located fragment definition(s) "${missingFragments.join(

     

       347
       347
       -
                     ', '

     

       348
       348
       -
                   )}" in ${moduleSpecifier}`,

     

       349
       349
       -
                 });

     

       350
       350
       -
               }

     

       351
       351
       -
             });

     

       352
       352
       -
           }

     

       353
       353
       -
       

     

       354
       354
       -
           return [...tsDiagnostics, ...usageDiagnostics, ...fragmentDiagnostics];

     

       348
       348
       +
           return [...tsDiagnostics, ...usageDiagnostics];

     

       355
       349
        
         } else {

     

       356
       350
        
           return tsDiagnostics;

     

       357
       351
        
         }

-2

test/e2e/server.ts

···

       1
       1
        
       import { ChildProcess, fork } from 'node:child_process';

     

       2
       2
       -
       import path from 'node:path';

     

       3
       2
        
       import readline from 'node:readline';

     

       4
       4
       -
       import fs from 'node:fs';

     

       5
       3
        
       import ts from 'typescript/lib/tsserverlibrary';

     

       6
       4
        
       

     

       7
       5
        
       type Command = `${ts.server.protocol.CommandTypes}`;