commit 06d190d72b98ce05fa5587e6cece4225fb10e57e · kitten.sh/graphqlsp

+2 -1

packages/example-tada/src/index.tsx

···

       7
       7
        
           pokemon(id: $id) {

     

       8
       8
        
             id

     

       9
       9
        
             fleeRate

     

       10
       10
       -
             ...pokemonFields

     

       11
       10
        
             ...Pok

     

       11
       11
       +
             ...pokemonFields

     

       12
       12
        
             attacks {

     

       13
       13
        
               special {

     

       14
       14
        
                 name

     
···

       66
       66
        
         const { pokemon } = result.data || {};

     

       67
       67
        
         console.log(pokemon?.weight?.maximum)

     

       68
       68
        
       

     

       69
       69
       +
         // @ts-ignore

     

       69
       70
        
         return <Pokemon data={result.data!.pokemon} />;

     

       70
       71
        
       }

+44 -3

packages/graphqlsp/src/checkImports.ts

···

       3
       3
        
       

     

       4
       4
        
       import { findAllCallExpressions, findAllImports, getSource } from './ast';

     

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

     

       6
       6
       +
       import {

     

       7
       7
       +
         VariableDeclaration,

     

       8
       8
       +
         VariableStatement,

     

       9
       9
       +
         isSourceFile,

     

       10
       10
       +
       } from 'typescript';

     

       6
       11
        
       

     

       7
       12
        
       export const MISSING_FRAGMENT_CODE = 52003;

     

       8
       13
        
       

     
···

       14
       19
        
         { start: number; length: number; fragments: Array<string> }

     

       15
       20
        
       > => {

     

       16
       21
        
         const imports = findAllImports(source);

     

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

     

       23
       23
       +
       

     

       17
       24
        
         const importSpecifierToFragments: Record<

     

       18
       25
        
           string,

     

       19
       26
        
           { start: number; length: number; fragments: Array<string> }

     

       20
       27
        
         > = {};

     

       28
       28
       +
       

     

       29
       29
       +
         if (!typeChecker) return importSpecifierToFragments;

     

       21
       30
        
       

     

       22
       31
        
         if (imports.length) {

     

       23
       32
        
           imports.forEach(imp => {

     
···

       35
       44
        
                 const externalSource = getSource(info, def.fileName);

     

       36
       45
        
                 if (!externalSource) return;

     

       37
       46
        
       

     

       38
       38
       -
                 const fragmentsForImport = getFragmentsInSource(externalSource, info);

     

       47
       47
       +
                 const fragmentsForImport = getFragmentsInSource(

     

       48
       48
       +
                   externalSource,

     

       49
       49
       +
                   typeChecker,

     

       50
       50
       +
                   info

     

       51
       51
       +
                 );

     

       39
       52
        
       

     

       40
       53
        
                 const names = fragmentsForImport.map(fragment => fragment.name.value);

     

       41
       54
        
                 if (

     
···

       73
       86
        
                 const externalSource = getSource(info, def.fileName);

     

       74
       87
        
                 if (!externalSource) return;

     

       75
       88
        
       

     

       76
       76
       -
                 const fragmentsForImport = getFragmentsInSource(externalSource, info);

     

       89
       89
       +
                 const fragmentsForImport = getFragmentsInSource(

     

       90
       90
       +
                   externalSource,

     

       91
       91
       +
                   typeChecker,

     

       92
       92
       +
                   info

     

       93
       93
       +
                 );

     

       77
       94
        
                 const names = fragmentsForImport.map(fragment => fragment.name.value);

     

       78
       95
        
                 if (

     

       79
       96
        
                   names.length &&

     
···

       111
       128
        
       

     

       112
       129
        
                   const fragmentsForImport = getFragmentsInSource(

     

       113
       130
        
                     externalSource,

     

       131
       131
       +
                     typeChecker,

     

       114
       132
        
                     info

     

       115
       133
        
                   );

     

       116
       134
        
                   const names = fragmentsForImport.map(

     
···

       144
       162
        
       

     

       145
       163
        
       function getFragmentsInSource(

     

       146
       164
        
         src: ts.SourceFile,

     

       165
       165
       +
         typeChecker: ts.TypeChecker,

     

       147
       166
        
         info: ts.server.PluginCreateInfo

     

       148
       167
        
       ): Array<FragmentDefinitionNode> {

     

       149
       168
        
         let fragments: Array<FragmentDefinitionNode> = [];

     

       150
       169
        
         const callExpressions = findAllCallExpressions(src, info, false);

     

       151
       170
        
       

     

       152
       152
       -
         callExpressions.nodes.forEach(node => {

     

       171
       171
       +
         const symbol = typeChecker.getSymbolAtLocation(src);

     

       172
       172
       +
         if (!symbol) return [];

     

       173
       173
       +
       

     

       174
       174
       +
         const exports = typeChecker.getExportsOfModule(symbol);

     

       175
       175
       +
         const exportedNames = exports.map(symb => symb.name);

     

       176
       176
       +
         const nodes = callExpressions.nodes.filter(x => {

     

       177
       177
       +
           let parent = x.parent;

     

       178
       178
       +
           while (

     

       179
       179
       +
             parent &&

     

       180
       180
       +
             !ts.isSourceFile(parent) &&

     

       181
       181
       +
             !ts.isVariableDeclaration(parent)

     

       182
       182
       +
           ) {

     

       183
       183
       +
             parent = parent.parent;

     

       184
       184
       +
           }

     

       185
       185
       +
       

     

       186
       186
       +
           if (ts.isVariableDeclaration(parent)) {

     

       187
       187
       +
             return exportedNames.includes(parent.name.getText());

     

       188
       188
       +
           } else {

     

       189
       189
       +
             return false;

     

       190
       190
       +
           }

     

       191
       191
       +
         });

     

       192
       192
       +
       

     

       193
       193
       +
         nodes.forEach(node => {

     

       153
       194
        
           const text = resolveTemplate(node, src.fileName, info).combinedText;

     

       154
       195
        
           try {

     

       155
       196
        
             const parsed = parse(text, { noLocation: true });