commit 5c9169ebf4772565580d2609d6608a6c7769be08 · kitten.sh/graphqlsp

.changeset/lovely-months-type.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Correctly replace with identical replacement strings

+1 -1

packages/example/src/Pokemon.ts

···

       20
       20
        
           weaknesses

     

       21
       21
        
           someUnknownField

     

       22
       22
        
         }

     

       23
       23
       -
       ` as typeof import('./Pokemon.generated').WeaknessFieldsFragmentDoc;

     

       23
       23
       +
       ` as typeof import('./Pokemon.generated').PokemonFieldsFragmentDoc;

     

       24
       24
        
       

     

       25
       25
        
       export const Pokemon = (data: any) => {

     

       26
       26
        
         const pokemon = useFragment(PokemonFields, data);

+4 -1

packages/graphqlsp/src/diagnostics.ts

···

       375
       375
        
                   imp = imp.slice(4);

     

       376
       376
        
                   // We remove the \n

     

       377
       377
        
                   imp = imp.substring(0, imp.length - 1);

     

       378
       378
       -
                   text = sourceText.replace(typeImport.getText(), imp);

     

       378
       378
       +
                   const from = node.getStart();

     

       379
       379
       +
                   text =

     

       380
       380
       +
                     sourceText.slice(0, from) +

     

       381
       381
       +
                     sourceText.slice(from).replace(typeImport.getText(), imp);

     

       379
       382
        
                   span.length =

     

       380
       383
        
                     imp.length + ((oldExportName || '').length - exportName.length);

     

       381
       384
        
                 } else {

+13

test/e2e/fixture-project/fixtures/rename-complex.ts

···

       1
       1
       +
       import { gql } from '@urql/core';

     

       2
       2
       +
       

     

       3
       3
       +
       export const PostFields = gql`

     

       4
       4
       +
         fragment PostFields on Post {

     

       5
       5
       +
           id

     

       6
       6
       +
         }

     

       7
       7
       +
       ` as typeof import('./rename-complex.generated').PostFieldsFragmentDoc;

     

       8
       8
       +
       

     

       9
       9
       +
       export const Post2Fields = gql`

     

       10
       10
       +
         fragment Post2Fields on Post {

     

       11
       11
       +
           title

     

       12
       12
       +
         }

     

       13
       13
       +
       ` as typeof import('./rename-complex.generated').PostFieldsFragmentDoc;

+39

test/e2e/generate-types.test.ts

···

       11
       11
        
       const projectPath = path.resolve(__dirname, 'fixture-project');

     

       12
       12
        
       describe('Type-generation', () => {

     

       13
       13
        
         const outFile = path.join(projectPath, 'rename.ts');

     

       14
       14
       +
         const outFileComplex = path.join(projectPath, 'rename-complex.ts');

     

       14
       15
        
         const genFile = path.join(projectPath, 'rename.generated.ts');

     

       16
       16
       +
         const genFileComplex = path.join(projectPath, 'rename-complex.generated.ts');

     

       15
       17
        
         const baseGenFile = path.join(projectPath, '__generated__/baseGraphQLSP.ts');

     

       16
       18
        
       

     

       17
       19
        
         let server: TSServer;

     
···

       22
       24
        
         afterAll(() => {

     

       23
       25
        
           try {

     

       24
       26
        
             fs.unlinkSync(outFile);

     

       27
       27
       +
             fs.unlinkSync(outFileComplex);

     

       25
       28
        
             fs.unlinkSync(genFile);

     

       29
       29
       +
             fs.unlinkSync(genFileComplex);

     

       26
       30
        
             fs.unlinkSync(baseGenFile);

     

       27
       31
        
           } catch {}

     

       28
       32
        
         });

     
···

       91
       95
        
             expect(fs.readFileSync(genFile, 'utf-8')).toContain(

     

       92
       96
        
               'export const PostListDocument ='

     

       93
       97
        
             );

     

       98
       98
       +
           });

     

       99
       99
       +
         }, 20000);

     

       100
       100
       +
       

     

       101
       101
       +
         it('gets renamed correctly (complex)', async () => {

     

       102
       102
       +
           server.sendCommand('open', {

     

       103
       103
       +
             file: outFileComplex,

     

       104
       104
       +
             fileContent: '// empty',

     

       105
       105
       +
             scriptKindName: 'TS',

     

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

     

       107
       107
       +
       

     

       108
       108
       +
           server.sendCommand('updateOpen', {

     

       109
       109
       +
             openFiles: [

     

       110
       110
       +
               {

     

       111
       111
       +
                 file: outFileComplex,

     

       112
       112
       +
                 fileContent: fs.readFileSync(

     

       113
       113
       +
                   path.join(projectPath, 'fixtures/rename-complex.ts'),

     

       114
       114
       +
                   'utf-8'

     

       115
       115
       +
                 ),

     

       116
       116
       +
               },

     

       117
       117
       +
             ],

     

       118
       118
       +
           } satisfies ts.server.protocol.UpdateOpenRequestArgs);

     

       119
       119
       +
       

     

       120
       120
       +
           server.sendCommand('saveto', {

     

       121
       121
       +
             file: outFileComplex,

     

       122
       122
       +
             tmpfile: outFileComplex,

     

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

     

       124
       124
       +
       

     

       125
       125
       +
           await waitForExpect(() => {

     

       126
       126
       +
             const contents = fs.readFileSync(outFileComplex, 'utf-8');

     

       127
       127
       +
             expect(contents).toContain(`    id

     

       128
       128
       +
         }

     

       129
       129
       +
       \` as typeof import('./rename-complex.generated').PostFieldsFragmentDoc`);

     

       130
       130
       +
             expect(contents).toContain(`    title

     

       131
       131
       +
         }

     

       132
       132
       +
       \` as typeof import('./rename-complex.generated').Post2FieldsFragmentDoc`);

     

       94
       133
        
           });

     

       95
       134
        
         }, 20000);

     

       96
       135
        
       });