commit efeed9bfab886959517f9f2d995f65f20cabe397 · kitten.sh/graphqlsp

.changeset/olive-jokes-drum.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Check the `dirty` state of the file an additional time to prevent writing to the file when the user types directly after saving

+15 -4

src/index.ts

···

       26
       26
        
       import { Cursor } from './cursor';

     

       27
       27
        
       import { loadSchema } from './getSchema';

     

       28
       28
        
       import { getToken } from './token';

     

       29
       29
       -
       import { findAllTaggedTemplateNodes, findNode, getSource } from './utils';

     

       29
       29
       +
       import {

     

       30
       30
       +
         findAllTaggedTemplateNodes,

     

       31
       31
       +
         findNode,

     

       32
       32
       +
         getSource,

     

       33
       33
       +
         isFileDirty,

     

       34
       34
       +
       } from './utils';

     

       30
       35
        
       import { resolveTemplate } from './resolve';

     

       31
       36
        
       import { generateTypedDocumentNodes } from './types/generate';

     

       32
       37
        
       

     
···

       174
       179
        
               const nameParts = name.split('.');

     

       175
       180
        
               nameParts[nameParts.length - 1] = 'generated.ts';

     

       176
       181
        
               parts[parts.length - 1] = nameParts.join('.');

     

       177
       177
       -
               const contents = fs.readFileSync(filename, 'utf-8');

     

       178
       178
       -
               const currentText = source.getFullText();

     

       179
       182
        
       

     

       180
       180
       -
               if (contents !== currentText) {

     

       183
       183
       +
               if (isFileDirty(filename, source)) {

     

       181
       184
        
                 return [...newDiagnostics, ...originalDiagnostics];

     

       182
       185
        
               }

     

       183
       186
        
       

     
···

       187
       190
        
                 texts.join('\n'),

     

       188
       191
        
                 scalars

     

       189
       192
        
               ).then(() => {

     

       193
       193
       +
                 if (isFileDirty(filename, source)) {

     

       194
       194
       +
                   return;

     

       195
       195
       +
                 }

     

       196
       196
       +
       

     

       190
       197
        
                 nodes.forEach((node, i) => {

     

       191
       198
        
                   const queryText = texts[i] || '';

     

       192
       199
        
                   const parsed = parse(queryText);

     
···

       222
       229
        
                   const typeImport = parentChildren.find(x =>

     

       223
       230
        
                     isImportTypeNode(x)

     

       224
       231
        
                   ) as ImportTypeNode;

     

       232
       232
       +
       

     

       225
       233
        
                   if (typeImport && typeImport.getText().includes(exportName)) return;

     

       226
       234
        
       

     

       227
       235
        
                   const span = { length: 1, start: node.end };

     

       236
       236
       +
       

     

       237
       237
       +
                   // TODO: if we have a typeImport but the name has been updated/is wrong

     

       238
       238
       +
                   // we need to leave the "as x" typecast

     

       228
       239
        
                   const text =

     

       229
       240
        
                     source.text.substring(0, span.start) +

     

       230
       241
        
                     imp +

src/utils.ts

···

       3
       3
        
         isNoSubstitutionTemplateLiteral,

     

       4
       4
        
         isTaggedTemplateExpression,

     

       5
       5
        
       } from 'typescript';

     

       6
       6
       +
       import fs from 'fs';

     

       7
       7
       +
       

     

       8
       8
       +
       export function isFileDirty(fileName: string, source: ts.SourceFile) {

     

       9
       9
       +
         const contents = fs.readFileSync(fileName, 'utf-8');

     

       10
       10
       +
         const currentText = source.getFullText();

     

       11
       11
       +
       

     

       12
       12
       +
         return currentText !== contents;

     

       13
       13
       +
       }

     

       6
       14
        
       

     

       7
       15
        
       export function findNode(

     

       8
       16
        
         sourceFile: ts.SourceFile,