commit 183e5f0c891bad7244d4fa4e00cc6eaef36a0a9b · kitten.sh/graphqlsp

.changeset/new-chairs-wonder.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       fix case where the hover-information would target the wrong TypeScript node by one character

+2 -2

packages/graphqlsp/src/ast/token.ts

···

       22
       22
        
       

     

       23
       23
        
         let foundToken: Token | undefined = undefined;

     

       24
       24
        
         for (let line = 0; line < input.length; line++) {

     

       25
       25
       -
           const lPos = cPos;

     

       25
       25
       +
           const lPos = cPos - 1;

     

       26
       26
        
           const stream = new CharacterStream(input[line] + '\n');

     

       27
       27
        
           while (!stream.eol()) {

     

       28
       28
        
             const token = parser.token(stream, state);

     

       29
       29
        
             const string = stream.current();

     

       30
       30
        
       

     

       31
       31
        
             if (

     

       32
       32
       -
               lPos + stream.getStartOfToken() <= cursorPosition &&

     

       32
       32
       +
               lPos + stream.getStartOfToken() + 1 <= cursorPosition &&

     

       33
       33
        
               lPos + stream.getCurrentPosition() >= cursorPosition

     

       34
       34
        
             ) {

     

       35
       35
        
               foundToken = {

+10

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

···

       10
       10
        
         }

     

       11
       11
        
       `);

     

       12
       12
        
       

     

       13
       13
       +
       // prettier-ignore

     

       14
       14
       +
       export const Regression190 = graphql(`

     

       15
       15
       +
       fragment pokemonFields on Pokemon {

     

       16
       16
       +
         id

     

       17
       17
       +
         name

     

       18
       18
       +
         fleeRate

     

       19
       19
       +
         

     

       20
       20
       +
       }

     

       21
       21
       +
       `);

     

       22
       22
       +
       

     

       13
       23
        
       export const Pokemon = () => {};

test/e2e/fixture-project/fixtures/simple.ts

···

       9
       9
        
         }

     

       10
       10
        
       `;

     

       11
       11
        
       

     

       12
       12
       +
       const Regression190 = gql`

     

       13
       13
       +
       query AllPosts {

     

       14
       14
       +
         

     

       15
       15
       +
       }

     

       16
       16
       +
       `;

     

       17
       17
       +
       

     

       12
       18
        
       const sql = (x: string | TemplateStringsArray) => x;

     

       13
       19
        
       const x = sql`'{}'`;

+74 -2

test/e2e/graphqlsp.test.ts

···

       109
       109
        
           ]);

     

       110
       110
        
         }, 7500);

     

       111
       111
        
       

     

       112
       112
       -
         it('Gives quick-info when hovering', async () => {

     

       112
       112
       +
         it('Gives quick-info when hovering start (#15)', async () => {

     

       113
       113
        
           server.send({

     

       114
       114
        
             seq: 9,

     

       115
       115
        
             type: 'request',

     
···

       117
       117
        
             arguments: {

     

       118
       118
        
               file: testFile,

     

       119
       119
        
               line: 5,

     

       120
       120
       -
               offset: 7,

     

       120
       120
       +
               offset: 5,

     

       121
       121
        
             },

     

       122
       122
        
           });

     

       123
       123
        
       

     
···

       134
       134
        
           expect(res?.body.documentation).toEqual(

     

       135
       135
        
             `Query.posts: [Post]\n\nList out all posts`

     

       136
       136
        
           );

     

       137
       137
       +
         }, 7500);

     

       138
       138
       +
       

     

       139
       139
       +
         it('Handles empty line (#190)', async () => {

     

       140
       140
       +
           server.send({

     

       141
       141
       +
             seq: 10,

     

       142
       142
       +
             type: 'request',

     

       143
       143
       +
             command: 'completionInfo',

     

       144
       144
       +
             arguments: {

     

       145
       145
       +
               file: testFile,

     

       146
       146
       +
               line: 14,

     

       147
       147
       +
               offset: 3,

     

       148
       148
       +
               includeExternalModuleExports: true,

     

       149
       149
       +
               includeInsertTextCompletions: true,

     

       150
       150
       +
               triggerKind: 1,

     

       151
       151
       +
             },

     

       152
       152
       +
           });

     

       153
       153
       +
       

     

       154
       154
       +
           await server.waitForResponse(

     

       155
       155
       +
             response =>

     

       156
       156
       +
               response.type === 'response' && response.command === 'completionInfo'

     

       157
       157
       +
           );

     

       158
       158
       +
       

     

       159
       159
       +
           const res = server.responses

     

       160
       160
       +
             .reverse()

     

       161
       161
       +
             .find(

     

       162
       162
       +
               resp => resp.type === 'response' && resp.command === 'completionInfo'

     

       163
       163
       +
             );

     

       164
       164
       +
       

     

       165
       165
       +
           expect(res).toBeDefined();

     

       166
       166
       +
           expect(typeof res?.body.entries).toEqual('object');

     

       167
       167
       +
           const defaultAttrs = { kind: 'var', kindModifiers: 'declare' };

     

       168
       168
       +
           expect(res?.body.entries).toEqual([

     

       169
       169
       +
             {

     

       170
       170
       +
               ...defaultAttrs,

     

       171
       171
       +
               name: 'post',

     

       172
       172
       +
               sortText: '0post',

     

       173
       173
       +
               labelDetails: { detail: ' Post' },

     

       174
       174
       +
             },

     

       175
       175
       +
             {

     

       176
       176
       +
               ...defaultAttrs,

     

       177
       177
       +
               name: 'posts',

     

       178
       178
       +
               sortText: '1posts',

     

       179
       179
       +
               labelDetails: { detail: ' [Post]', description: 'List out all posts' },

     

       180
       180
       +
             },

     

       181
       181
       +
             {

     

       182
       182
       +
               ...defaultAttrs,

     

       183
       183
       +
               name: '__typename',

     

       184
       184
       +
               sortText: '2__typename',

     

       185
       185
       +
               labelDetails: {

     

       186
       186
       +
                 detail: ' String!',

     

       187
       187
       +
                 description: 'The name of the current Object type at runtime.',

     

       188
       188
       +
               },

     

       189
       189
       +
             },

     

       190
       190
       +
             {

     

       191
       191
       +
               ...defaultAttrs,

     

       192
       192
       +
               name: '__schema',

     

       193
       193
       +
               sortText: '3__schema',

     

       194
       194
       +
               labelDetails: {

     

       195
       195
       +
                 detail: ' __Schema!',

     

       196
       196
       +
                 description: 'Access the current type schema of this server.',

     

       197
       197
       +
               },

     

       198
       198
       +
             },

     

       199
       199
       +
             {

     

       200
       200
       +
               ...defaultAttrs,

     

       201
       201
       +
               name: '__type',

     

       202
       202
       +
               sortText: '4__type',

     

       203
       203
       +
               labelDetails: {

     

       204
       204
       +
                 detail: ' __Type',

     

       205
       205
       +
                 description: 'Request the type information of a single type.',

     

       206
       206
       +
               },

     

       207
       207
       +
             },

     

       208
       208
       +
           ]);

     

       137
       209
        
         }, 7500);

     

       138
       210
        
       });

+190

test/e2e/tada.test.ts

···

       367
       367
        
             ]

     

       368
       368
        
           `);

     

       369
       369
        
         }, 30000);

     

       370
       370
       +
       

     

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

     

       372
       372
       +
           server.send({

     

       373
       373
       +
             seq: 11,

     

       374
       374
       +
             type: 'request',

     

       375
       375
       +
             command: 'quickinfo',

     

       376
       376
       +
             arguments: {

     

       377
       377
       +
               file: outfileCombinations,

     

       378
       378
       +
               line: 7,

     

       379
       379
       +
               offset: 5,

     

       380
       380
       +
             },

     

       381
       381
       +
           });

     

       382
       382
       +
       

     

       383
       383
       +
           await server.waitForResponse(

     

       384
       384
       +
             response =>

     

       385
       385
       +
               response.type === 'response' && response.command === 'quickinfo'

     

       386
       386
       +
           );

     

       387
       387
       +
       

     

       388
       388
       +
           const res = server.responses

     

       389
       389
       +
             .reverse()

     

       390
       390
       +
             .find(resp => resp.type === 'response' && resp.command === 'quickinfo');

     

       391
       391
       +
       

     

       392
       392
       +
           expect(res).toBeDefined();

     

       393
       393
       +
           expect(typeof res?.body).toEqual('object');

     

       394
       394
       +
           expect(res?.body.documentation).toEqual(`Pokemon.name: String!`);

     

       395
       395
       +
         }, 30000);

     

       396
       396
       +
       

     

       397
       397
       +
         it('gives suggestions with empty line (#190)', async () => {

     

       398
       398
       +
           server.send({

     

       399
       399
       +
             seq: 12,

     

       400
       400
       +
             type: 'request',

     

       401
       401
       +
             command: 'completionInfo',

     

       402
       402
       +
             arguments: {

     

       403
       403
       +
               file: outfileCombinations,

     

       404
       404
       +
               line: 19,

     

       405
       405
       +
               offset: 3,

     

       406
       406
       +
               includeExternalModuleExports: true,

     

       407
       407
       +
               includeInsertTextCompletions: true,

     

       408
       408
       +
               triggerKind: 1,

     

       409
       409
       +
             },

     

       410
       410
       +
           });

     

       411
       411
       +
       

     

       412
       412
       +
           await server.waitForResponse(

     

       413
       413
       +
             response =>

     

       414
       414
       +
               response.type === 'response' && response.command === 'completionInfo'

     

       415
       415
       +
           );

     

       416
       416
       +
       

     

       417
       417
       +
           const res = server.responses

     

       418
       418
       +
             .reverse()

     

       419
       419
       +
             .find(

     

       420
       420
       +
               resp => resp.type === 'response' && resp.command === 'completionInfo'

     

       421
       421
       +
             );

     

       422
       422
       +
       

     

       423
       423
       +
           expect(res).toBeDefined();

     

       424
       424
       +
           expect(typeof res?.body.entries).toEqual('object');

     

       425
       425
       +
           expect(res?.body.entries).toMatchInlineSnapshot(`

     

       426
       426
       +
             [

     

       427
       427
       +
               {

     

       428
       428
       +
                 "kind": "var",

     

       429
       429
       +
                 "kindModifiers": "declare",

     

       430
       430
       +
                 "labelDetails": {

     

       431
       431
       +
                   "detail": " AttacksConnection",

     

       432
       432
       +
                 },

     

       433
       433
       +
                 "name": "attacks",

     

       434
       434
       +
                 "sortText": "0attacks",

     

       435
       435
       +
               },

     

       436
       436
       +
               {

     

       437
       437
       +
                 "kind": "var",

     

       438
       438
       +
                 "kindModifiers": "declare",

     

       439
       439
       +
                 "labelDetails": {

     

       440
       440
       +
                   "detail": " [EvolutionRequirement]",

     

       441
       441
       +
                 },

     

       442
       442
       +
                 "name": "evolutionRequirements",

     

       443
       443
       +
                 "sortText": "2evolutionRequirements",

     

       444
       444
       +
               },

     

       445
       445
       +
               {

     

       446
       446
       +
                 "kind": "var",

     

       447
       447
       +
                 "kindModifiers": "declare",

     

       448
       448
       +
                 "labelDetails": {

     

       449
       449
       +
                   "detail": " [Pokemon]",

     

       450
       450
       +
                 },

     

       451
       451
       +
                 "name": "evolutions",

     

       452
       452
       +
                 "sortText": "3evolutions",

     

       453
       453
       +
               },

     

       454
       454
       +
               {

     

       455
       455
       +
                 "kind": "var",

     

       456
       456
       +
                 "kindModifiers": "declare",

     

       457
       457
       +
                 "labelDetails": {

     

       458
       458
       +
                   "description": "Likelihood of an attempt to catch a Pokémon to fail.",

     

       459
       459
       +
                   "detail": " Float",

     

       460
       460
       +
                 },

     

       461
       461
       +
                 "name": "fleeRate",

     

       462
       462
       +
                 "sortText": "4fleeRate",

     

       463
       463
       +
               },

     

       464
       464
       +
               {

     

       465
       465
       +
                 "kind": "var",

     

       466
       466
       +
                 "kindModifiers": "declare",

     

       467
       467
       +
                 "labelDetails": {

     

       468
       468
       +
                   "detail": " PokemonDimension",

     

       469
       469
       +
                 },

     

       470
       470
       +
                 "name": "height",

     

       471
       471
       +
                 "sortText": "5height",

     

       472
       472
       +
               },

     

       473
       473
       +
               {

     

       474
       474
       +
                 "kind": "var",

     

       475
       475
       +
                 "kindModifiers": "declare",

     

       476
       476
       +
                 "labelDetails": {

     

       477
       477
       +
                   "detail": " ID!",

     

       478
       478
       +
                 },

     

       479
       479
       +
                 "name": "id",

     

       480
       480
       +
                 "sortText": "6id",

     

       481
       481
       +
               },

     

       482
       482
       +
               {

     

       483
       483
       +
                 "kind": "var",

     

       484
       484
       +
                 "kindModifiers": "declare",

     

       485
       485
       +
                 "labelDetails": {

     

       486
       486
       +
                   "description": "Maximum combat power a Pokémon may achieve at max level.",

     

       487
       487
       +
                   "detail": " Int",

     

       488
       488
       +
                 },

     

       489
       489
       +
                 "name": "maxCP",

     

       490
       490
       +
                 "sortText": "7maxCP",

     

       491
       491
       +
               },

     

       492
       492
       +
               {

     

       493
       493
       +
                 "kind": "var",

     

       494
       494
       +
                 "kindModifiers": "declare",

     

       495
       495
       +
                 "labelDetails": {

     

       496
       496
       +
                   "description": "Maximum health points a Pokémon may achieve at max level.",

     

       497
       497
       +
                   "detail": " Int",

     

       498
       498
       +
                 },

     

       499
       499
       +
                 "name": "maxHP",

     

       500
       500
       +
                 "sortText": "8maxHP",

     

       501
       501
       +
               },

     

       502
       502
       +
               {

     

       503
       503
       +
                 "kind": "var",

     

       504
       504
       +
                 "kindModifiers": "declare",

     

       505
       505
       +
                 "labelDetails": {

     

       506
       506
       +
                   "detail": " String!",

     

       507
       507
       +
                 },

     

       508
       508
       +
                 "name": "name",

     

       509
       509
       +
                 "sortText": "9name",

     

       510
       510
       +
               },

     

       511
       511
       +
               {

     

       512
       512
       +
                 "kind": "var",

     

       513
       513
       +
                 "kindModifiers": "declare",

     

       514
       514
       +
                 "labelDetails": {

     

       515
       515
       +
                   "detail": " [PokemonType]",

     

       516
       516
       +
                 },

     

       517
       517
       +
                 "name": "resistant",

     

       518
       518
       +
                 "sortText": "10resistant",

     

       519
       519
       +
               },

     

       520
       520
       +
               {

     

       521
       521
       +
                 "kind": "var",

     

       522
       522
       +
                 "kindModifiers": "declare",

     

       523
       523
       +
                 "labelDetails": {

     

       524
       524
       +
                   "detail": " [PokemonType]",

     

       525
       525
       +
                 },

     

       526
       526
       +
                 "name": "types",

     

       527
       527
       +
                 "sortText": "11types",

     

       528
       528
       +
               },

     

       529
       529
       +
               {

     

       530
       530
       +
                 "kind": "var",

     

       531
       531
       +
                 "kindModifiers": "declare",

     

       532
       532
       +
                 "labelDetails": {

     

       533
       533
       +
                   "detail": " [PokemonType]",

     

       534
       534
       +
                 },

     

       535
       535
       +
                 "name": "weaknesses",

     

       536
       536
       +
                 "sortText": "12weaknesses",

     

       537
       537
       +
               },

     

       538
       538
       +
               {

     

       539
       539
       +
                 "kind": "var",

     

       540
       540
       +
                 "kindModifiers": "declare",

     

       541
       541
       +
                 "labelDetails": {

     

       542
       542
       +
                   "detail": " PokemonDimension",

     

       543
       543
       +
                 },

     

       544
       544
       +
                 "name": "weight",

     

       545
       545
       +
                 "sortText": "13weight",

     

       546
       546
       +
               },

     

       547
       547
       +
               {

     

       548
       548
       +
                 "kind": "var",

     

       549
       549
       +
                 "kindModifiers": "declare",

     

       550
       550
       +
                 "labelDetails": {

     

       551
       551
       +
                   "description": "The name of the current Object type at runtime.",

     

       552
       552
       +
                   "detail": " String!",

     

       553
       553
       +
                 },

     

       554
       554
       +
                 "name": "__typename",

     

       555
       555
       +
                 "sortText": "14__typename",

     

       556
       556
       +
               },

     

       557
       557
       +
             ]

     

       558
       558
       +
           `);

     

       559
       559
       +
         }, 30000);

     

       370
       560
        
       });