commit 10b5aba7d166c0502626783f53eb6d650eb9db59 · kitten.sh/graphqlsp

+5

.changeset/lucky-friends-beg.md

···

       1
       +
       ---

     

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

     

       3
       +
       ---

     

       4
       +
       

     

       5
       +
       Detect fragment usage in `maskFragments` calls to prevent false positive unused fragment warnings

+10

packages/graphqlsp/src/ast/checks.ts

···

       123
        
         }

     

       124
        
         return null;

     

       125
        
       };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       123
        
         }

     

       124
        
         return null;

     

       125
        
       };

     

       126
       +
       

     

       127
       +
       /** Checks if node is a maskFragments() call */

     

       128
       +
       export const isMaskFragmentsCall = (

     

       129
       +
         node: ts.Node

     

       130
       +
       ): node is ts.CallExpression => {

     

       131
       +
         if (!ts.isCallExpression(node)) return false;

     

       132
       +
         if (!ts.isIdentifier(node.expression)) return false;

     

       133
       +
         // Only checks function name, not whether it's from gql.tada

     

       134
       +
         return node.expression.escapedText === 'maskFragments';

     

       135
       +
       };

+15

packages/graphqlsp/src/ast/index.ts

···

       327
        
         return sourceFile.statements.filter(ts.isImportDeclaration);

     

       328
        
       }

     

       329
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       330
        
       export function bubbleUpTemplate(node: ts.Node): ts.Node {

     

       331
        
         while (

     

       332
        
           ts.isNoSubstitutionTemplateLiteral(node) ||

···

       327
        
         return sourceFile.statements.filter(ts.isImportDeclaration);

     

       328
        
       }

     

       329
        
       

     

       330
       +
       export function findAllMaskFragmentsCalls(

     

       331
       +
         sourceFile: ts.SourceFile

     

       332
       +
       ): Array<ts.CallExpression> {

     

       333
       +
         const result: Array<ts.CallExpression> = [];

     

       334
       +
       

     

       335
       +
         function find(node: ts.Node): void {

     

       336
       +
           if (checks.isMaskFragmentsCall(node)) {

     

       337
       +
             result.push(node);

     

       338
       +
           }

     

       339
       +
           ts.forEachChild(node, find);

     

       340
       +
         }

     

       341
       +
         find(sourceFile);

     

       342
       +
         return result;

     

       343
       +
       }

     

       344
       +
       

     

       345
        
       export function bubbleUpTemplate(node: ts.Node): ts.Node {

     

       346
        
         while (

     

       347
        
           ts.isNoSubstitutionTemplateLiteral(node) ||

+19

packages/graphqlsp/src/diagnostics.ts

···

       15
        
         findAllCallExpressions,

     

       16
        
         findAllPersistedCallExpressions,

     

       17
        
         findAllTaggedTemplateNodes,

     

       0
        
       
     

       18
        
         getSource,

     

       19
        
         unrollFragment,

     

       20
        
       } from './ast';

     
···

       292
        
       

     

       293
        
         if (isCallExpression && shouldCheckForColocatedFragments) {

     

       294
        
           const moduleSpecifierToFragments = getColocatedFragmentNames(source, info);

     

       0
        
       
     

       295
        
       

     

       296
        
           const usedFragments = new Set();

     

       297
        
           nodes.forEach(({ node }) => {

     
···

       305
        
                 },

     

       306
        
               });

     

       307
        
             } catch (e) {}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       308
        
           });

     

       309
        
       

     

       310
        
           Object.keys(moduleSpecifierToFragments).forEach(moduleSpecifier => {

···

       15
        
         findAllCallExpressions,

     

       16
        
         findAllPersistedCallExpressions,

     

       17
        
         findAllTaggedTemplateNodes,

     

       18
       +
         findAllMaskFragmentsCalls,

     

       19
        
         getSource,

     

       20
        
         unrollFragment,

     

       21
        
       } from './ast';

     
···

       293
        
       

     

       294
        
         if (isCallExpression && shouldCheckForColocatedFragments) {

     

       295
        
           const moduleSpecifierToFragments = getColocatedFragmentNames(source, info);

     

       296
       +
           const typeChecker = info.languageService.getProgram()?.getTypeChecker();

     

       297
        
       

     

       298
        
           const usedFragments = new Set();

     

       299
        
           nodes.forEach(({ node }) => {

     
···

       307
        
                 },

     

       308
        
               });

     

       309
        
             } catch (e) {}

     

       310
       +
           });

     

       311
       +
       

     

       312
       +
           // check for maskFragments() calls

     

       313
       +
           const maskFragmentsCalls = findAllMaskFragmentsCalls(source);

     

       314
       +
           maskFragmentsCalls.forEach(call => {

     

       315
       +
             const firstArg = call.arguments[0];

     

       316
       +
             if (!firstArg) return;

     

       317
       +
       

     

       318
       +
             // Handle array of fragments: maskFragments([Fragment1, Fragment2], data)

     

       319
       +
             if (ts.isArrayLiteralExpression(firstArg)) {

     

       320
       +
               firstArg.elements.forEach(element => {

     

       321
       +
                 if (ts.isIdentifier(element)) {

     

       322
       +
                   const fragmentDefs = unrollFragment(element, info, typeChecker);

     

       323
       +
                   fragmentDefs.forEach(def => usedFragments.add(def.name.value));

     

       324
       +
                 }

     

       325
       +
               });

     

       326
       +
             }

     

       327
        
           });

     

       328
        
       

     

       329
        
           Object.keys(moduleSpecifierToFragments).forEach(moduleSpecifier => {

+1 -1

test/e2e/fixture-project-tada/fixtures/graphql.ts

···

       6
        
       }>();

     

       7
        
       

     

       8
        
       export type { FragmentOf, ResultOf, VariablesOf } from 'gql.tada';

     

       9
       -
       export { readFragment } from 'gql.tada';

···

       6
        
       }>();

     

       7
        
       

     

       8
        
       export type { FragmentOf, ResultOf, VariablesOf } from 'gql.tada';

     

       9
       +
       export { readFragment, maskFragments } from 'gql.tada';

+7

test/e2e/fixture-project-tada/fixtures/used-fragment-mask.ts

···

       1
       +
       import { maskFragments } from './graphql';

     

       2
       +
       import { Pokemon, PokemonFields } from './fragment';

     

       3
       +
       

     

       4
       +
       const data = { id: '1', name: 'Pikachu', fleeRate: 0.1 };

     

       5
       +
       const x = maskFragments([PokemonFields], data);

     

       6
       +
       

     

       7
       +
       console.log(Pokemon);

+1 -1

test/e2e/fixture-project-tada/graphql.ts

···

       6
        
       }>();

     

       7
        
       

     

       8
        
       export type { FragmentOf, ResultOf, VariablesOf } from 'gql.tada';

     

       9
       -
       export { readFragment } from 'gql.tada';

···

       6
        
       }>();

     

       7
        
       

     

       8
        
       export type { FragmentOf, ResultOf, VariablesOf } from 'gql.tada';

     

       9
       +
       export { readFragment, maskFragments } from 'gql.tada';

+44

test/e2e/tada.test.ts

···

       12
        
         const outfileCombo = path.join(projectPath, 'simple.ts');

     

       13
        
         const outfileTypeCondition = path.join(projectPath, 'type-condition.ts');

     

       14
        
         const outfileUnusedFragment = path.join(projectPath, 'unused-fragment.ts');

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
         const outfileCombinations = path.join(projectPath, 'fragment.ts');

     

       16
        
       

     

       17
        
         let server: TSServer;

     
···

       35
        
           } satisfies ts.server.protocol.OpenRequestArgs);

     

       36
        
           server.sendCommand('open', {

     

       37
        
             file: outfileUnusedFragment,

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       38
        
             fileContent: '// empty',

     

       39
        
             scriptKindName: 'TS',

     

       40
        
           } satisfies ts.server.protocol.OpenRequestArgs);

     
···

       69
        
                   'utf-8'

     

       70
        
                 ),

     

       71
        
               },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       72
        
             ],

     

       73
        
           } satisfies ts.server.protocol.UpdateOpenRequestArgs);

     

       74
        
       

     
···

       88
        
             file: outfileUnusedFragment,

     

       89
        
             tmpfile: outfileUnusedFragment,

     

       90
        
           } satisfies ts.server.protocol.SavetoRequestArgs);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       91
        
         });

     

       92
        
       

     

       93
        
         afterAll(() => {

     

       94
        
           try {

     

       95
        
             fs.unlinkSync(outfileUnusedFragment);

     

       0
        
       
     

       96
        
             fs.unlinkSync(outfileCombinations);

     

       97
        
             fs.unlinkSync(outfileCombo);

     

       98
        
             fs.unlinkSync(outfileTypeCondition);

     
···

       384
        
               },

     

       385
        
             ]

     

       386
        
           `);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       387
        
         }, 30000);

     

       388
        
       

     

       389
        
         it('gives quick-info at start of word (#15)', async () => {

···

       12
        
         const outfileCombo = path.join(projectPath, 'simple.ts');

     

       13
        
         const outfileTypeCondition = path.join(projectPath, 'type-condition.ts');

     

       14
        
         const outfileUnusedFragment = path.join(projectPath, 'unused-fragment.ts');

     

       15
       +
         const outfileUsedFragmentMask = path.join(

     

       16
       +
           projectPath,

     

       17
       +
           'used-fragment-mask.ts'

     

       18
       +
         );

     

       19
        
         const outfileCombinations = path.join(projectPath, 'fragment.ts');

     

       20
        
       

     

       21
        
         let server: TSServer;

     
···

       39
        
           } satisfies ts.server.protocol.OpenRequestArgs);

     

       40
        
           server.sendCommand('open', {

     

       41
        
             file: outfileUnusedFragment,

     

       42
       +
             fileContent: '// empty',

     

       43
       +
             scriptKindName: 'TS',

     

       44
       +
           } satisfies ts.server.protocol.OpenRequestArgs);

     

       45
       +
           server.sendCommand('open', {

     

       46
       +
             file: outfileUsedFragmentMask,

     

       47
        
             fileContent: '// empty',

     

       48
        
             scriptKindName: 'TS',

     

       49
        
           } satisfies ts.server.protocol.OpenRequestArgs);

     
···

       78
        
                   'utf-8'

     

       79
        
                 ),

     

       80
        
               },

     

       81
       +
               {

     

       82
       +
                 file: outfileUsedFragmentMask,

     

       83
       +
                 fileContent: fs.readFileSync(

     

       84
       +
                   path.join(projectPath, 'fixtures/used-fragment-mask.ts'),

     

       85
       +
                   'utf-8'

     

       86
       +
                 ),

     

       87
       +
               },

     

       88
        
             ],

     

       89
        
           } satisfies ts.server.protocol.UpdateOpenRequestArgs);

     

       90
        
       

     
···

       104
        
             file: outfileUnusedFragment,

     

       105
        
             tmpfile: outfileUnusedFragment,

     

       106
        
           } satisfies ts.server.protocol.SavetoRequestArgs);

     

       107
       +
           server.sendCommand('saveto', {

     

       108
       +
             file: outfileUsedFragmentMask,

     

       109
       +
             tmpfile: outfileUsedFragmentMask,

     

       110
       +
           } satisfies ts.server.protocol.SavetoRequestArgs);

     

       111
        
         });

     

       112
        
       

     

       113
        
         afterAll(() => {

     

       114
        
           try {

     

       115
        
             fs.unlinkSync(outfileUnusedFragment);

     

       116
       +
             fs.unlinkSync(outfileUsedFragmentMask);

     

       117
        
             fs.unlinkSync(outfileCombinations);

     

       118
        
             fs.unlinkSync(outfileCombo);

     

       119
        
             fs.unlinkSync(outfileTypeCondition);

     
···

       405
        
               },

     

       406
        
             ]

     

       407
        
           `);

     

       408
       +
         }, 30000);

     

       409
       +
       

     

       410
       +
         it('should not warn about unused fragments when using maskFragments', async () => {

     

       411
       +
           server.sendCommand('saveto', {

     

       412
       +
             file: outfileUsedFragmentMask,

     

       413
       +
             tmpfile: outfileUsedFragmentMask,

     

       414
       +
           } satisfies ts.server.protocol.SavetoRequestArgs);

     

       415
       +
       

     

       416
       +
           await server.waitForResponse(

     

       417
       +
             e =>

     

       418
       +
               e.type === 'event' &&

     

       419
       +
               e.event === 'semanticDiag' &&

     

       420
       +
               e.body?.file === outfileUsedFragmentMask

     

       421
       +
           );

     

       422
       +
       

     

       423
       +
           const res = server.responses.filter(

     

       424
       +
             resp =>

     

       425
       +
               resp.type === 'event' &&

     

       426
       +
               resp.event === 'semanticDiag' &&

     

       427
       +
               resp.body?.file === outfileUsedFragmentMask

     

       428
       +
           );

     

       429
       +
           // Should have no diagnostics about unused fragments since maskFragments uses them

     

       430
       +
           expect(res[0].body.diagnostics).toMatchInlineSnapshot(`[]`);

     

       431
        
         }, 30000);

     

       432
        
       

     

       433
        
         it('gives quick-info at start of word (#15)', async () => {