commit 06ec8710d681461f5013803d27a83cc1493306ad · kitten.sh/graphqlsp

.changeset/hungry-hairs-draw.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Avoid polluting with diagnostics not in current file

+93 -42

packages/graphqlsp/src/ast/resolve.ts

···

       9
       9
        
       import { findNode } from '.';

     

       10
       10
        
       import { getSource } from '../ast';

     

       11
       11
        
       

     

       12
       12
       +
       type TemplateResult = {

     

       13
       13
       +
         combinedText: string;

     

       14
       14
       +
         resolvedSpans: Array<{

     

       15
       15
       +
           identifier: string;

     

       16
       16
       +
           original: { start: number; length: number };

     

       17
       17
       +
           new: { start: number; length: number };

     

       18
       18
       +
         }>;

     

       19
       19
       +
       };

     

       20
       20
       +
       

     

       12
       21
        
       export function resolveTemplate(

     

       13
       22
        
         node: TaggedTemplateExpression,

     

       14
       23
        
         filename: string,

     

       15
       24
        
         info: ts.server.PluginCreateInfo

     

       16
       16
       -
       ): string {

     

       25
       25
       +
       ): TemplateResult {

     

       17
       26
        
         let templateText = node.template.getText().slice(1, -1);

     

       18
       27
        
         if (

     

       19
       28
        
           isNoSubstitutionTemplateLiteral(node.template) ||

     

       20
       29
        
           node.template.templateSpans.length === 0

     

       21
       30
        
         ) {

     

       22
       22
       -
           return templateText;

     

       31
       31
       +
           return { combinedText: templateText, resolvedSpans: [] };

     

       23
       32
        
         }

     

       24
       33
        
       

     

       25
       25
       -
         node.template.templateSpans.forEach(span => {

     

       26
       26
       -
           if (isIdentifier(span.expression)) {

     

       27
       27
       -
             const definitions = info.languageService.getDefinitionAtPosition(

     

       28
       28
       -
               filename,

     

       29
       29
       -
               span.expression.getStart()

     

       30
       30
       -
             );

     

       31
       31
       -
             if (!definitions) return;

     

       32
       32
       -
             const def = definitions[0];

     

       33
       33
       -
             const src = getSource(info, def.fileName);

     

       34
       34
       -
             if (!src) return;

     

       35
       35
       -
             const node = findNode(src, def.textSpan.start);

     

       36
       36
       -
             if (!node || !node.parent) return;

     

       34
       34
       +
         let addedCharacters = 0;

     

       35
       35
       +
         const resolvedSpans = node.template.templateSpans

     

       36
       36
       +
           .map(span => {

     

       37
       37
       +
             if (isIdentifier(span.expression)) {

     

       38
       38
       +
               const definitions = info.languageService.getDefinitionAtPosition(

     

       39
       39
       +
                 filename,

     

       40
       40
       +
                 span.expression.getStart()

     

       41
       41
       +
               );

     

       42
       42
       +
               if (!definitions) return;

     

       43
       43
       +
       

     

       44
       44
       +
               const def = definitions[0];

     

       45
       45
       +
               const src = getSource(info, def.fileName);

     

       46
       46
       +
               if (!src) return;

     

       47
       47
       +
       

     

       48
       48
       +
               const node = findNode(src, def.textSpan.start);

     

       49
       49
       +
               if (!node || !node.parent) return;

     

       50
       50
       +
       

     

       51
       51
       +
               const parent = node.parent;

     

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

     

       53
       53
       +
                 const identifierName = span.expression.escapedText;

     

       54
       54
       +
                 // we reduce by two to account for the "${"

     

       55
       55
       +
                 const originalStart = span.expression.getStart() - 2;

     

       56
       56
       +
                 const originalRange = {

     

       57
       57
       +
                   start: originalStart,

     

       58
       58
       +
                   // we add 1 to account for the "}"

     

       59
       59
       +
                   length: span.expression.end - originalStart + 1,

     

       60
       60
       +
                 };

     

       61
       61
       +
                 if (

     

       62
       62
       +
                   parent.initializer &&

     

       63
       63
       +
                   isTaggedTemplateExpression(parent.initializer)

     

       64
       64
       +
                 ) {

     

       65
       65
       +
                   const text = resolveTemplate(

     

       66
       66
       +
                     parent.initializer,

     

       67
       67
       +
                     def.fileName,

     

       68
       68
       +
                     info

     

       69
       69
       +
                   );

     

       70
       70
       +
                   templateText = templateText.replace(

     

       71
       71
       +
                     '${' + span.expression.escapedText + '}',

     

       72
       72
       +
                     text.combinedText

     

       73
       73
       +
                   );

     

       74
       74
       +
       

     

       75
       75
       +
                   const alteredSpan = {

     

       76
       76
       +
                     identifier: identifierName,

     

       77
       77
       +
                     original: originalRange,

     

       78
       78
       +
                     new: {

     

       79
       79
       +
                       start: originalRange.start + addedCharacters,

     

       80
       80
       +
                       length: text.combinedText.length,

     

       81
       81
       +
                     },

     

       82
       82
       +
                   };

     

       83
       83
       +
                   addedCharacters += text.combinedText.length - originalRange.length;

     

       84
       84
       +
                   return alteredSpan;

     

       85
       85
       +
                 } else if (

     

       86
       86
       +
                   parent.initializer &&

     

       87
       87
       +
                   isAsExpression(parent.initializer) &&

     

       88
       88
       +
                   isTaggedTemplateExpression(parent.initializer.expression)

     

       89
       89
       +
                 ) {

     

       90
       90
       +
                   const text = resolveTemplate(

     

       91
       91
       +
                     parent.initializer.expression,

     

       92
       92
       +
                     def.fileName,

     

       93
       93
       +
                     info

     

       94
       94
       +
                   );

     

       95
       95
       +
                   templateText = templateText.replace(

     

       96
       96
       +
                     '${' + span.expression.escapedText + '}',

     

       97
       97
       +
                     text.combinedText

     

       98
       98
       +
                   );

     

       99
       99
       +
                   const alteredSpan = {

     

       100
       100
       +
                     identifier: identifierName,

     

       101
       101
       +
                     original: originalRange,

     

       102
       102
       +
                     new: {

     

       103
       103
       +
                       start: originalRange.start + addedCharacters,

     

       104
       104
       +
                       length: text.combinedText.length,

     

       105
       105
       +
                     },

     

       106
       106
       +
                   };

     

       107
       107
       +
                   addedCharacters += text.combinedText.length - originalRange.length;

     

       108
       108
       +
                   return alteredSpan;

     

       109
       109
       +
                 }

     

       37
       110
        
       

     

       38
       38
       -
             const parent = node.parent;

     

       39
       39
       -
             if (ts.isVariableDeclaration(parent)) {

     

       40
       40
       -
               if (

     

       41
       41
       -
                 parent.initializer &&

     

       42
       42
       -
                 isTaggedTemplateExpression(parent.initializer)

     

       43
       43
       -
               ) {

     

       44
       44
       -
                 const text = resolveTemplate(parent.initializer, def.fileName, info);

     

       45
       45
       -
                 templateText = templateText.replace(

     

       46
       46
       -
                   '${' + span.expression.escapedText + '}',

     

       47
       47
       -
                   text

     

       48
       48
       -
                 );

     

       49
       49
       -
               } else if (

     

       50
       50
       -
                 parent.initializer &&

     

       51
       51
       -
                 isAsExpression(parent.initializer) &&

     

       52
       52
       -
                 isTaggedTemplateExpression(parent.initializer.expression)

     

       53
       53
       -
               ) {

     

       54
       54
       -
                 const text = resolveTemplate(

     

       55
       55
       -
                   parent.initializer.expression,

     

       56
       56
       -
                   def.fileName,

     

       57
       57
       -
                   info

     

       58
       58
       -
                 );

     

       59
       59
       -
                 templateText = templateText.replace(

     

       60
       60
       -
                   '${' + span.expression.escapedText + '}',

     

       61
       61
       -
                   text

     

       62
       62
       -
                 );

     

       111
       111
       +
                 return undefined;

     

       63
       112
        
               }

     

       64
       113
        
             }

     

       65
       65
       -
           }

     

       66
       66
       -
         });

     

       67
       114
        
       

     

       68
       68
       -
         return templateText;

     

       115
       115
       +
             return undefined;

     

       116
       116
       +
           })

     

       117
       117
       +
           .filter(Boolean) as TemplateResult['resolvedSpans'];

     

       118
       118
       +
       

     

       119
       119
       +
         return { combinedText: templateText, resolvedSpans };

     

       69
       120
        
       }

+1 -1

packages/graphqlsp/src/autoComplete.ts

···

       48
       48
        
           const foundToken = getToken(template, cursorPosition);

     

       49
       49
        
           if (!foundToken || !schema.current) return undefined;

     

       50
       50
        
       

     

       51
       51
       -
           const text = resolveTemplate(node, filename, info);

     

       51
       51
       +
           const text = resolveTemplate(node, filename, info).combinedText;

     

       52
       52
        
       

     

       53
       53
        
           const cursor = new Cursor(foundToken.line, foundToken.start);

     

       54
       54

+62 -20

packages/graphqlsp/src/diagnostics.ts

···

       40
       40
        
         schema: { current: GraphQLSchema | null },

     

       41
       41
        
         info: ts.server.PluginCreateInfo

     

       42
       42
        
       ): ts.Diagnostic[] | undefined {

     

       43
       43
       +
         const logger = (msg: string) =>

     

       44
       44
       +
           info.project.projectService.logger.info(`[GraphQLSP] ${msg}`);

     

       43
       45
        
         const disableTypegen = info.config.disableTypegen;

     

       44
       46
        
         const tagTemplate = info.config.template || 'gql';

     

       45
       47
        
         const scalars = info.config.scalars || {};

     
···

       60
       62
        
             }

     

       61
       63
        
           }

     

       62
       64
        
       

     

       63
       63
       -
           return resolveTemplate(node, filename, info);

     

       65
       65
       +
           return resolveTemplate(node, filename, info).combinedText;

     

       64
       66
        
         });

     

       65
       67
        
       

     

       66
       68
        
         const diagnostics = nodes

     
···

       74
       76
        
               }

     

       75
       77
        
             }

     

       76
       78
        
       

     

       77
       77
       -
             const text = resolveTemplate(node, filename, info);

     

       79
       79
       +
             const { combinedText: text, resolvedSpans } = resolveTemplate(

     

       80
       80
       +
               node,

     

       81
       81
       +
               filename,

     

       82
       82
       +
               info

     

       83
       83
       +
             );

     

       78
       84
        
             const lines = text.split('\n');

     

       79
       85
        
       

     

       80
       86
        
             let startingPosition = node.pos + (tagTemplate.length + 1);

     

       81
       81
       -
             const graphQLDiagnostics = getDiagnostics(text, schema.current).map(x => {

     

       82
       82
       -
               const { start, end } = x.range;

     

       87
       87
       +
             const endPosition = startingPosition + node.getText().length;

     

       88
       88
       +
             const graphQLDiagnostics = getDiagnostics(text, schema.current)

     

       89
       89
       +
               .map(x => {

     

       90
       90
       +
                 const { start, end } = x.range;

     

       83
       91
        
       

     

       84
       84
       -
               // We add the start.line to account for newline characters which are

     

       85
       85
       -
               // split out

     

       86
       86
       -
               let startChar = startingPosition + start.line;

     

       87
       87
       -
               for (let i = 0; i <= start.line; i++) {

     

       88
       88
       -
                 if (i === start.line) startChar += start.character;

     

       89
       89
       -
                 else startChar += lines[i].length;

     

       90
       90
       -
               }

     

       92
       92
       +
                 // We add the start.line to account for newline characters which are

     

       93
       93
       +
                 // split out

     

       94
       94
       +
                 let startChar = startingPosition + start.line;

     

       95
       95
       +
                 for (let i = 0; i <= start.line; i++) {

     

       96
       96
       +
                   if (i === start.line) startChar += start.character;

     

       97
       97
       +
                   else startChar += lines[i].length;

     

       98
       98
       +
                 }

     

       91
       99
        
       

     

       92
       92
       -
               let endChar = startingPosition + end.line;

     

       93
       93
       -
               for (let i = 0; i <= end.line; i++) {

     

       94
       94
       -
                 if (i === end.line) endChar += end.character;

     

       95
       95
       -
                 else endChar += lines[i].length;

     

       96
       96
       -
               }

     

       100
       100
       +
                 let endChar = startingPosition + end.line;

     

       101
       101
       +
                 for (let i = 0; i <= end.line; i++) {

     

       102
       102
       +
                   if (i === end.line) endChar += end.character;

     

       103
       103
       +
                   else endChar += lines[i].length;

     

       104
       104
       +
                 }

     

       97
       105
        
       

     

       98
       98
       -
               // We add 1 to the start because the range is exclusive of start.character

     

       99
       99
       -
               return { ...x, start: startChar + 1, length: endChar - startChar };

     

       100
       100
       -
             });

     

       106
       106
       +
                 const locatedInFragment = resolvedSpans.find(x => {

     

       107
       107
       +
                   const newEnd = x.new.start + x.new.length;

     

       108
       108
       +
                   return startChar >= x.new.start && endChar <= newEnd;

     

       109
       109
       +
                 });

     

       110
       110
       +
       

     

       111
       111
       +
                 if (!!locatedInFragment) {

     

       112
       112
       +
                   return {

     

       113
       113
       +
                     ...x,

     

       114
       114
       +
                     start: locatedInFragment.original.start,

     

       115
       115
       +
                     length: locatedInFragment.original.length,

     

       116
       116
       +
                   };

     

       117
       117
       +
                 } else {

     

       118
       118
       +
                   if (startChar > endPosition) {

     

       119
       119
       +
                     // we have to calculate the added length and fix this

     

       120
       120
       +
                     const addedCharacters = resolvedSpans

     

       121
       121
       +
                       .filter(x => x.new.start + x.new.length < startChar)

     

       122
       122
       +
                       .reduce(

     

       123
       123
       +
                         (acc, span) => acc + (span.new.length - span.original.length),

     

       124
       124
       +
                         0

     

       125
       125
       +
                       );

     

       126
       126
       +
                     startChar = startChar - addedCharacters;

     

       127
       127
       +
                     endChar = endChar - addedCharacters;

     

       128
       128
       +
                     return {

     

       129
       129
       +
                       ...x,

     

       130
       130
       +
                       start: startChar + 1,

     

       131
       131
       +
                       length: endChar - startChar,

     

       132
       132
       +
                     };

     

       133
       133
       +
                   } else {

     

       134
       134
       +
                     return {

     

       135
       135
       +
                       ...x,

     

       136
       136
       +
                       start: startChar + 1,

     

       137
       137
       +
                       length: endChar - startChar,

     

       138
       138
       +
                     };

     

       139
       139
       +
                   }

     

       140
       140
       +
                 }

     

       141
       141
       +
               })

     

       142
       142
       +
               .filter(x => x.start + x.length <= endPosition);

     

       101
       143
        
       

     

       102
       144
        
             try {

     

       103
       145
        
               const parsed = parse(text, { noLocation: true });

     
···

       208
       250
        
                     node,

     

       209
       251
        
                     node.getSourceFile().fileName,

     

       210
       252
        
                     info

     

       211
       211
       -
                   );

     

       253
       253
       +
                   ).combinedText;

     

       212
       254
        
                   try {

     

       213
       255
        
                     const parsed = parse(text, { noLocation: true });

     

       214
       256
        
                     if (

+43 -41

packages/graphqlsp/src/graphql/generateTypes.ts

···

       60
       60
        
         scalars: Record<string, unknown>,

     

       61
       61
        
         baseTypesPath: string

     

       62
       62
        
       ) => {

     

       63
       63
       -
         if (!schema) return;

     

       63
       63
       +
         try {

     

       64
       64
       +
           if (!schema) return;

     

       64
       65
        
       

     

       65
       65
       -
         const parts = outputFile.split('/');

     

       66
       66
       -
         parts.pop();

     

       67
       67
       -
         let basePath = path

     

       68
       68
       -
           .relative(parts.join('/'), baseTypesPath)

     

       69
       69
       -
           .replace('.ts', '');

     

       70
       70
       -
         // case where files are declared globally, we need to prefix with ./

     

       71
       71
       -
         if (basePath === '__generated__/baseGraphQLSP') {

     

       72
       72
       -
           basePath = './' + basePath;

     

       73
       73
       -
         }

     

       66
       66
       +
           const parts = outputFile.split('/');

     

       67
       67
       +
           parts.pop();

     

       68
       68
       +
           let basePath = path

     

       69
       69
       +
             .relative(parts.join('/'), baseTypesPath)

     

       70
       70
       +
             .replace('.ts', '');

     

       71
       71
       +
           // case where files are declared globally, we need to prefix with ./

     

       72
       72
       +
           if (basePath === '__generated__/baseGraphQLSP') {

     

       73
       73
       +
             basePath = './' + basePath;

     

       74
       74
       +
           }

     

       74
       75
        
       

     

       75
       75
       -
         const config = {

     

       76
       76
       -
           documents: [

     

       77
       77
       -
             {

     

       78
       78
       -
               location: 'operation.graphql',

     

       79
       79
       -
               document: parse(doc),

     

       76
       76
       +
           const config = {

     

       77
       77
       +
             documents: [

     

       78
       78
       +
               {

     

       79
       79
       +
                 location: 'operation.graphql',

     

       80
       80
       +
                 document: parse(doc),

     

       81
       81
       +
               },

     

       82
       82
       +
             ],

     

       83
       83
       +
             config: {

     

       84
       84
       +
               scalars,

     

       85
       85
       +
               avoidOptionals: false,

     

       86
       86
       +
               enumsAsTypes: true,

     

       87
       87
       +
               nonOptionalTypename: true,

     

       88
       88
       +
               namespacedImportName: 'Types',

     

       80
       89
        
             },

     

       81
       81
       -
           ],

     

       82
       82
       -
           config: {

     

       83
       83
       -
             scalars,

     

       84
       84
       -
             avoidOptionals: false,

     

       85
       85
       -
             enumsAsTypes: true,

     

       86
       86
       -
             nonOptionalTypename: true,

     

       87
       87
       -
             namespacedImportName: 'Types',

     

       88
       88
       -
           },

     

       89
       89
       -
           filename: outputFile,

     

       90
       90
       -
           schema: parse(printSchema(schema)),

     

       91
       91
       -
           plugins: [

     

       92
       92
       -
             { 'typescript-operations': {} },

     

       93
       93
       -
             { 'typed-document-node': {} },

     

       94
       94
       -
             { add: { content: `import * as Types from "${basePath}"` } },

     

       95
       95
       -
           ],

     

       96
       96
       -
           pluginMap: {

     

       97
       97
       -
             'typescript-operations': typescriptOperationsPlugin,

     

       98
       98
       -
             'typed-document-node': typedDocumentNodePlugin,

     

       99
       99
       -
             add: addPlugin,

     

       100
       100
       -
           },

     

       101
       101
       -
         };

     

       90
       90
       +
             filename: outputFile,

     

       91
       91
       +
             schema: parse(printSchema(schema)),

     

       92
       92
       +
             plugins: [

     

       93
       93
       +
               { 'typescript-operations': {} },

     

       94
       94
       +
               { 'typed-document-node': {} },

     

       95
       95
       +
               { add: { content: `import * as Types from "${basePath}"` } },

     

       96
       96
       +
             ],

     

       97
       97
       +
             pluginMap: {

     

       98
       98
       +
               'typescript-operations': typescriptOperationsPlugin,

     

       99
       99
       +
               'typed-document-node': typedDocumentNodePlugin,

     

       100
       100
       +
               add: addPlugin,

     

       101
       101
       +
             },

     

       102
       102
       +
           };

     

       102
       103
        
       

     

       103
       103
       -
         // @ts-ignore

     

       104
       104
       -
         const output = await codegen(config);

     

       105
       105
       -
         fs.writeFile(path.join(outputFile), output, 'utf8', err => {

     

       106
       106
       -
           console.error(err);

     

       107
       107
       -
         });

     

       104
       104
       +
           // @ts-ignore

     

       105
       105
       +
           const output = await codegen(config);

     

       106
       106
       +
           fs.writeFile(path.join(outputFile), output, 'utf8', err => {

     

       107
       107
       +
             console.error(err);

     

       108
       108
       +
           });

     

       109
       109
       +
         } catch (e) {}

     

       108
       110
        
       };

+1 -1

packages/graphqlsp/src/quickInfo.ts

···

       34
       34
        
       

     

       35
       35
        
           const hoverInfo = getHoverInformation(

     

       36
       36
        
             schema.current,

     

       37
       37
       -
             resolveTemplate(node, filename, info),

     

       37
       37
       +
             resolveTemplate(node, filename, info).combinedText,

     

       38
       38
        
             new Cursor(foundToken.line, foundToken.start)

     

       39
       39
        
           );

     

       40
       40