commit 3b78093b8801553ad04b92472446250abf4ba58e · kitten.sh/graphqlsp

.changeset/stupid-cobras-boil.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Fix quick-info getting offset by preceding fragments

+27 -3

packages/example/src/Pokemon.generated.ts

···

       1
       1
        
       import * as Types from '../__generated__/baseGraphQLSP';

     

       2
       2
        
       import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';

     

       3
       3
        
       export type PokemonFieldsFragment = {

     

       4
       4
       -
         __typename?: 'Pokemon';

     

       4
       4
       +
         __typename: 'Pokemon';

     

       5
       5
        
         id: string;

     

       6
       6
        
         name: string;

     

       7
       7
        
         attacks?: {

     

       8
       8
       -
           __typename?: 'AttacksConnection';

     

       8
       8
       +
           __typename: 'AttacksConnection';

     

       9
       9
        
           fast?: Array<{

     

       10
       10
       -
             __typename?: 'Attack';

     

       10
       10
       +
             __typename: 'Attack';

     

       11
       11
        
             damage?: number | null;

     

       12
       12
        
             name?: string | null;

     

       13
       13
        
           } | null> | null;

     

       14
       14
        
         } | null;

     

       15
       15
       +
       };

     

       16
       16
       +
       

     

       17
       17
       +
       export type WeaknessFieldsFragment = {

     

       18
       18
       +
         __typename: 'Pokemon';

     

       19
       19
       +
         weaknesses?: Array<Types.PokemonType | null> | null;

     

       15
       20
        
       };

     

       16
       21
        
       

     

       17
       22
        
       export const PokemonFieldsFragmentDoc = {

     
···

       57
       62
        
           },

     

       58
       63
        
         ],

     

       59
       64
        
       } as unknown as DocumentNode<PokemonFieldsFragment, unknown>;

     

       65
       65
       +
       export const WeaknessFieldsFragmentDoc = {

     

       66
       66
       +
         kind: 'Document',

     

       67
       67
       +
         definitions: [

     

       68
       68
       +
           {

     

       69
       69
       +
             kind: 'FragmentDefinition',

     

       70
       70
       +
             name: { kind: 'Name', value: 'weaknessFields' },

     

       71
       71
       +
             typeCondition: {

     

       72
       72
       +
               kind: 'NamedType',

     

       73
       73
       +
               name: { kind: 'Name', value: 'Pokemon' },

     

       74
       74
       +
             },

     

       75
       75
       +
             selectionSet: {

     

       76
       76
       +
               kind: 'SelectionSet',

     

       77
       77
       +
               selections: [

     

       78
       78
       +
                 { kind: 'Field', name: { kind: 'Name', value: 'weaknesses' } },

     

       79
       79
       +
               ],

     

       80
       80
       +
             },

     

       81
       81
       +
           },

     

       82
       82
       +
         ],

     

       83
       83
       +
       } as unknown as DocumentNode<WeaknessFieldsFragment, unknown>;

packages/example/src/Pokemon.ts

···

       5
       5
        
         fragment pokemonFields on Pokemon {

     

       6
       6
        
           id

     

       7
       7
        
           name

     

       8
       8
       +
           ...someUnknownFragment

     

       8
       9
        
           attacks {

     

       9
       10
        
             fast {

     

       10
       11
        
               damage

     
···

       13
       14
        
           }

     

       14
       15
        
         }

     

       15
       16
        
       ` as typeof import('./Pokemon.generated').PokemonFieldsFragmentDoc;

     

       17
       17
       +
       

     

       18
       18
       +
       export const WeakFields = gql`

     

       19
       19
       +
         fragment weaknessFields on Pokemon {

     

       20
       20
       +
           weaknesses

     

       21
       21
       +
           someUnknownField

     

       22
       22
       +
         }

     

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

     

       24
       24
       +
       

     

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

     

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

     

       18
       27
        
         return `hi ${pokemon.name}`;

+100

packages/example/src/index.generated.ts

···

       12
       12
        
         } | null> | null;

     

       13
       13
        
       };

     

       14
       14
        
       

     

       15
       15
       +
       export type PokemonFieldsFragment = {

     

       16
       16
       +
         __typename: 'Pokemon';

     

       17
       17
       +
         id: string;

     

       18
       18
       +
         name: string;

     

       19
       19
       +
         resistant?: Array<Types.PokemonType | null> | null;

     

       20
       20
       +
         attacks?: {

     

       21
       21
       +
           __typename: 'AttacksConnection';

     

       22
       22
       +
           fast?: Array<{

     

       23
       23
       +
             __typename: 'Attack';

     

       24
       24
       +
             damage?: number | null;

     

       25
       25
       +
             name?: string | null;

     

       26
       26
       +
           } | null> | null;

     

       27
       27
       +
         } | null;

     

       28
       28
       +
       };

     

       29
       29
       +
       

     

       30
       30
       +
       export type MoreFieldsFragment = {

     

       31
       31
       +
         __typename: 'Pokemon';

     

       32
       32
       +
         resistant?: Array<Types.PokemonType | null> | null;

     

       33
       33
       +
       };

     

       34
       34
       +
       

     

       15
       35
        
       export type PoQueryVariables = Types.Exact<{

     

       16
       36
        
         id: Types.Scalars['ID'];

     

       17
       37
        
       }>;

     
···

       25
       45
        
         } | null;

     

       26
       46
        
       };

     

       27
       47
        
       

     

       48
       48
       +
       export const MoreFieldsFragmentDoc = {

     

       49
       49
       +
         kind: 'Document',

     

       50
       50
       +
         definitions: [

     

       51
       51
       +
           {

     

       52
       52
       +
             kind: 'FragmentDefinition',

     

       53
       53
       +
             name: { kind: 'Name', value: 'moreFields' },

     

       54
       54
       +
             typeCondition: {

     

       55
       55
       +
               kind: 'NamedType',

     

       56
       56
       +
               name: { kind: 'Name', value: 'Pokemon' },

     

       57
       57
       +
             },

     

       58
       58
       +
             selectionSet: {

     

       59
       59
       +
               kind: 'SelectionSet',

     

       60
       60
       +
               selections: [

     

       61
       61
       +
                 { kind: 'Field', name: { kind: 'Name', value: 'resistant' } },

     

       62
       62
       +
               ],

     

       63
       63
       +
             },

     

       64
       64
       +
           },

     

       65
       65
       +
         ],

     

       66
       66
       +
       } as unknown as DocumentNode<MoreFieldsFragment, unknown>;

     

       67
       67
       +
       export const PokemonFieldsFragmentDoc = {

     

       68
       68
       +
         kind: 'Document',

     

       69
       69
       +
         definitions: [

     

       70
       70
       +
           {

     

       71
       71
       +
             kind: 'FragmentDefinition',

     

       72
       72
       +
             name: { kind: 'Name', value: 'pokemonFields' },

     

       73
       73
       +
             typeCondition: {

     

       74
       74
       +
               kind: 'NamedType',

     

       75
       75
       +
               name: { kind: 'Name', value: 'Pokemon' },

     

       76
       76
       +
             },

     

       77
       77
       +
             selectionSet: {

     

       78
       78
       +
               kind: 'SelectionSet',

     

       79
       79
       +
               selections: [

     

       80
       80
       +
                 { kind: 'Field', name: { kind: 'Name', value: 'id' } },

     

       81
       81
       +
                 { kind: 'Field', name: { kind: 'Name', value: 'name' } },

     

       82
       82
       +
                 {

     

       83
       83
       +
                   kind: 'FragmentSpread',

     

       84
       84
       +
                   name: { kind: 'Name', value: 'moreFields' },

     

       85
       85
       +
                 },

     

       86
       86
       +
                 {

     

       87
       87
       +
                   kind: 'Field',

     

       88
       88
       +
                   name: { kind: 'Name', value: 'attacks' },

     

       89
       89
       +
                   selectionSet: {

     

       90
       90
       +
                     kind: 'SelectionSet',

     

       91
       91
       +
                     selections: [

     

       92
       92
       +
                       {

     

       93
       93
       +
                         kind: 'Field',

     

       94
       94
       +
                         name: { kind: 'Name', value: 'fast' },

     

       95
       95
       +
                         selectionSet: {

     

       96
       96
       +
                           kind: 'SelectionSet',

     

       97
       97
       +
                           selections: [

     

       98
       98
       +
                             {

     

       99
       99
       +
                               kind: 'Field',

     

       100
       100
       +
                               name: { kind: 'Name', value: 'damage' },

     

       101
       101
       +
                             },

     

       102
       102
       +
                             { kind: 'Field', name: { kind: 'Name', value: 'name' } },

     

       103
       103
       +
                           ],

     

       104
       104
       +
                         },

     

       105
       105
       +
                       },

     

       106
       106
       +
                     ],

     

       107
       107
       +
                   },

     

       108
       108
       +
                 },

     

       109
       109
       +
               ],

     

       110
       110
       +
             },

     

       111
       111
       +
           },

     

       112
       112
       +
           {

     

       113
       113
       +
             kind: 'FragmentDefinition',

     

       114
       114
       +
             name: { kind: 'Name', value: 'moreFields' },

     

       115
       115
       +
             typeCondition: {

     

       116
       116
       +
               kind: 'NamedType',

     

       117
       117
       +
               name: { kind: 'Name', value: 'Pokemon' },

     

       118
       118
       +
             },

     

       119
       119
       +
             selectionSet: {

     

       120
       120
       +
               kind: 'SelectionSet',

     

       121
       121
       +
               selections: [

     

       122
       122
       +
                 { kind: 'Field', name: { kind: 'Name', value: 'resistant' } },

     

       123
       123
       +
               ],

     

       124
       124
       +
             },

     

       125
       125
       +
           },

     

       126
       126
       +
         ],

     

       127
       127
       +
       } as unknown as DocumentNode<PokemonFieldsFragment, unknown>;

     

       28
       128
        
       export const PokDocument = {

     

       29
       129
        
         kind: 'Document',

     

       30
       130
        
         definitions: [

+5 -2

packages/example/src/index.ts

···

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

     

       2
       2
       -
       import { Pokemon, PokemonFields } from './Pokemon';

     

       2
       2
       +
       import { Pokemon, PokemonFields, WeakFields } from './Pokemon';

     

       3
       3
        
       

     

       4
       4
        
       const PokemonsQuery = gql`

     

       5
       5
        
         query Pok {

     

       6
       6
        
           pokemons {

     

       7
       7
        
             id

     

       8
       8
        
             name

     

       9
       9
       -
             __typename

     

       10
       9
        
             fleeRate

     

       10
       10
       +
             __typenam

     

       11
       11
        
           }

     

       12
       12
        
         }

     

       13
       13
       +
       

     

       14
       14
       +
         ${PokemonFields}

     

       15
       15
       +
         ${WeakFields}

     

       13
       16
        
       ` as typeof import('./index.generated').PokDocument;

     

       14
       17
        
       

     

       15
       18
        
       const client = createClient({

+3 -1

packages/graphqlsp/src/ast/index.ts

···

       4
       4
        
         isNoSubstitutionTemplateLiteral,

     

       5
       5
        
         isTaggedTemplateExpression,

     

       6
       6
        
         isTemplateExpression,

     

       7
       7
       +
         isTemplateSpan,

     

       7
       8
        
         isToken,

     

       8
       9
        
       } from 'typescript';

     

       9
       10
        
       import fs from 'fs';

     
···

       68
       69
        
         while (

     

       69
       70
        
           isNoSubstitutionTemplateLiteral(node) ||

     

       70
       71
        
           isToken(node) ||

     

       71
       71
       -
           isTemplateExpression(node)

     

       72
       72
       +
           isTemplateExpression(node) ||

     

       73
       73
       +
           isTemplateSpan(node)

     

       72
       74
        
         ) {

     

       73
       75
        
           node = node.parent;

     

       74
       76
        
         }

packages/graphqlsp/src/ast/resolve.ts

···

       12
       12
        
       type TemplateResult = {

     

       13
       13
        
         combinedText: string;

     

       14
       14
        
         resolvedSpans: Array<{

     

       15
       15
       +
           lines: number;

     

       15
       16
        
           identifier: string;

     

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

     

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

     
···

       73
       74
        
                   );

     

       74
       75
        
       

     

       75
       76
        
                   const alteredSpan = {

     

       77
       77
       +
                     lines: text.combinedText.split('\n').length,

     

       76
       78
        
                     identifier: identifierName,

     

       77
       79
        
                     original: originalRange,

     

       78
       80
        
                     new: {

     
···

       97
       99
        
                     text.combinedText

     

       98
       100
        
                   );

     

       99
       101
        
                   const alteredSpan = {

     

       102
       102
       +
                     lines: text.combinedText.split('\n').length,

     

       100
       103
        
                     identifier: identifierName,

     

       101
       104
        
                     original: originalRange,

     

       102
       105
        
                     new: {

+5 -2

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).combinedText;

     

       52
       52
       -
       

     

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

     

       52
       52
       +
             node,

     

       53
       53
       +
             filename,

     

       54
       54
       +
             info

     

       55
       55
       +
           );

     

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

     

       54
       57
        
       

     

       55
       58
        
           const [suggestions, spreadSuggestions] = getSuggestionsInternal(

+20 -1

packages/graphqlsp/src/quickInfo.ts

···

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

     

       15
       15
        
         info: ts.server.PluginCreateInfo

     

       16
       16
        
       ): ts.QuickInfo | undefined {

     

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

     

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

     

       19
       19
       +
       

     

       17
       20
        
         const tagTemplate = info.config.template || 'gql';

     

       18
       21
        
       

     

       19
       22
        
         const source = getSource(info, filename);

     
···

       32
       35
        
       

     

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

     

       34
       37
        
       

     

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

     

       39
       39
       +
             node,

     

       40
       40
       +
             filename,

     

       41
       41
       +
             info

     

       42
       42
       +
           );

     

       43
       43
       +
       

     

       44
       44
       +
           const amountOfLines = resolvedSpans

     

       45
       45
       +
             .filter(

     

       46
       46
       +
               x =>

     

       47
       47
       +
                 x.original.start < cursorPosition &&

     

       48
       48
       +
                 x.original.start + x.original.length < cursorPosition

     

       49
       49
       +
             )

     

       50
       50
       +
             .reduce((acc, span) => acc + (span.lines - 1), 0);

     

       51
       51
       +
       

     

       52
       52
       +
           foundToken.line = foundToken.line + amountOfLines;

     

       53
       53
       +
       

     

       35
       54
        
           const hoverInfo = getHoverInformation(

     

       36
       55
        
             schema.current,

     

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

     

       56
       56
       +
             text,

     

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

     

       39
       58
        
           );

     

       40
       59

+2 -2

pnpm-lock.yaml

···

       1
       1
       -
       lockfileVersion: '6.1'

     

       1
       1
       +
       lockfileVersion: '6.0'

     

       2
       2
        
       

     

       3
       3
        
       settings:

     

       4
       4
        
         autoInstallPeers: true

     
···

       4334
       4334
        
           resolution: {directory: packages/graphqlsp, type: directory}

     

       4335
       4335
        
           id: file:packages/graphqlsp

     

       4336
       4336
        
           name: '@0no-co/graphqlsp'

     

       4337
       4337
       -
           version: 0.7.1

     

       4337
       4337
       +
           version: 0.7.2

     

       4338
       4338
        
           dependencies:

     

       4339
       4339
        
             '@graphql-codegen/add': 4.0.1(graphql@16.6.0)

     

       4340
       4340
        
             '@graphql-codegen/core': 3.1.0(graphql@16.6.0)