commit 313cb3bc5f666eec1b6eac390eb33d7fce36922a · kitten.sh/graphqlsp

+5

.changeset/cuddly-lobsters-return.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Allow specifying headers for fetching the introspection

+1 -3

packages/example/src/Pokemon.ts

···

       5
       5
        
         fragment pokemonFields on Pokemon {

     

       6
       6
        
           id

     

       7
       7
        
           name

     

       8
       8
       -
           ...someUnknownFragment

     

       9
       8
        
           attacks {

     

       10
       9
        
             fast {

     

       11
       10
        
               damage

     
···

       18
       17
        
       export const WeakFields = gql`

     

       19
       18
        
         fragment weaknessFields on Pokemon {

     

       20
       19
        
           weaknesses

     

       21
       21
       -
           someUnknownField

     

       22
       20
        
         }

     

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

     

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

     

       24
       22
        
       

     

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

     

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

+11 -30

packages/example/src/index.generated.ts

···

       16
       16
        
         __typename: 'Pokemon';

     

       17
       17
        
         id: string;

     

       18
       18
        
         name: string;

     

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

     

       20
       19
        
         attacks?: {

     

       21
       20
        
           __typename: 'AttacksConnection';

     

       22
       21
        
           fast?: Array<{

     
···

       27
       26
        
         } | null;

     

       28
       27
        
       };

     

       29
       28
        
       

     

       30
       30
       -
       export type MoreFieldsFragment = {

     

       29
       29
       +
       export type WeaknessFieldsFragment = {

     

       31
       30
        
         __typename: 'Pokemon';

     

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

     

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

     

       33
       32
        
       };

     

       34
       33
        
       

     

       35
       34
        
       export type PoQueryVariables = Types.Exact<{

     
···

       45
       44
        
         } | null;

     

       46
       45
        
       };

     

       47
       46
        
       

     

       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
       47
        
       export const PokemonFieldsFragmentDoc = {

     

       68
       48
        
         kind: 'Document',

     

       69
       49
        
         definitions: [

     
···

       79
       59
        
               selections: [

     

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

     

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

     

       82
       82
       -
                 {

     

       83
       83
       -
                   kind: 'FragmentSpread',

     

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

     

       85
       85
       -
                 },

     

       86
       62
        
                 {

     

       87
       63
        
                   kind: 'Field',

     

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

     
···

       109
       85
        
               ],

     

       110
       86
        
             },

     

       111
       87
        
           },

     

       88
       88
       +
         ],

     

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

     

       90
       90
       +
       export const WeaknessFieldsFragmentDoc = {

     

       91
       91
       +
         kind: 'Document',

     

       92
       92
       +
         definitions: [

     

       112
       93
        
           {

     

       113
       94
        
             kind: 'FragmentDefinition',

     

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

     

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

     

       115
       96
        
             typeCondition: {

     

       116
       97
        
               kind: 'NamedType',

     

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

     
···

       119
       100
        
             selectionSet: {

     

       120
       101
        
               kind: 'SelectionSet',

     

       121
       102
        
               selections: [

     

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

     

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

     

       123
       104
        
               ],

     

       124
       105
        
             },

     

       125
       106
        
           },

     

       126
       107
        
         ],

     

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

     

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

     

       128
       109
        
       export const PokDocument = {

     

       129
       110
        
         kind: 'Document',

     

       130
       111
        
         definitions: [

     
···

       143
       124
        
                     selections: [

     

       144
       125
        
                       { kind: 'Field', name: { kind: 'Name', value: 'id' } },

     

       145
       126
        
                       { kind: 'Field', name: { kind: 'Name', value: 'name' } },

     

       146
       146
       -
                       { kind: 'Field', name: { kind: 'Name', value: '__typename' } },

     

       147
       127
        
                       { kind: 'Field', name: { kind: 'Name', value: 'fleeRate' } },

     

       128
       128
       +
                       { kind: 'Field', name: { kind: 'Name', value: '__typename' } },

     

       148
       129
        
                     ],

     

       149
       130
        
                   },

     

       150
       131
        
                 },

+1 -2

packages/example/src/index.ts

+2 -1

packages/graphqlsp/README.md

···

       43
       43
        
       

     

       44
       44
        
       ### Configuration

     

       45
       45
        
       

     

       46
       46
       -
       - `schema` allows you to specify a url, `.json` or `.graphql` file as your schema

     

       46
       46
       +
       - `schema` allows you to specify a url, `.json` or `.graphql` file as your schema. If you need to specify headers for your introspection

     

       47
       47
       +
         you can opt into the object notation i.e. `{ "schema": { "url": "x", "headers": { "Authorization": "y" } }}`

     

       47
       48
        
       - `disableTypegen` disables type-generation in general

     

       48
       49
        
       - `scalars` allows you to pass an object of scalars that we'll feed into `graphql-code-generator`

     

       49
       50
        
       - `extraTypes` allows you to specify imports or declare types to help with `scalar` definitions

+26 -7

packages/graphqlsp/src/graphql/getSchema.ts

···

       12
       12
        
       import { Logger } from '../index';

     

       13
       13
        
       import { generateBaseTypes } from './generateTypes';

     

       14
       14
        
       

     

       15
       15
       +
       export type SchemaOrigin = {

     

       16
       16
       +
         url: string;

     

       17
       17
       +
         headers: Record<string, unknown>;

     

       18
       18
       +
       };

     

       19
       19
       +
       

     

       15
       20
        
       export const loadSchema = (

     

       16
       21
        
         root: string,

     

       17
       17
       -
         schema: string,

     

       22
       22
       +
         schema: SchemaOrigin | string,

     

       18
       23
        
         logger: Logger,

     

       19
       24
        
         baseTypesPath: string,

     

       20
       25
        
         shouldTypegen: boolean,

     
···

       24
       29
        
         const ref: { current: GraphQLSchema | null } = { current: null };

     

       25
       30
        
         let url: URL | undefined;

     

       26
       31
        
       

     

       32
       32
       +
         let isJSON = false;

     

       33
       33
       +
         let config: undefined | SchemaOrigin;

     

       34
       34
       +
       

     

       27
       35
        
         try {

     

       28
       28
       -
           url = new URL(schema);

     

       36
       36
       +
           if (typeof schema === 'object') {

     

       37
       37
       +
             url = new URL(schema.url);

     

       38
       38
       +
           } else {

     

       39
       39
       +
             url = new URL(schema);

     

       40
       40
       +
           }

     

       29
       41
        
         } catch (e) {}

     

       30
       42
        
       

     

       31
       43
        
         if (url) {

     

       32
       44
        
           logger(`Fetching introspection from ${url.toString()}`);

     

       33
       45
        
           fetch(url.toString(), {

     

       34
       46
        
             method: 'POST',

     

       35
       35
       -
             headers: {

     

       36
       36
       -
               'Content-Type': 'application/json',

     

       37
       37
       -
             },

     

       47
       47
       +
             headers:

     

       48
       48
       +
               isJSON && config

     

       49
       49
       +
                 ? {

     

       50
       50
       +
                     ...(config.headers || {}),

     

       51
       51
       +
                     'Content-Type': 'application/json',

     

       52
       52
       +
                   }

     

       53
       53
       +
                 : {

     

       54
       54
       +
                     'Content-Type': 'application/json',

     

       55
       55
       +
                   },

     

       38
       56
        
             body: JSON.stringify({

     

       39
       57
        
               query: getIntrospectionQuery({

     

       40
       58
        
                 descriptions: true,

     

       41
       41
       -
                 schemaDescription: true,

     

       59
       59
       +
                 schemaDescription: false,

     

       42
       60
        
                 inputValueDeprecation: false,

     

       43
       61
        
                 directiveIsRepeatable: false,

     

       44
       62
        
                 specifiedByUrl: false,

     
···

       51
       69
        
               else return response.text();

     

       52
       70
        
             })

     

       53
       71
        
             .then(result => {

     

       72
       72
       +
               logger(`Got result ${JSON.stringify(result)}`);

     

       54
       73
        
               if (typeof result === 'string') {

     

       55
       74
        
                 logger(`Got error while fetching introspection ${result}`);

     

       56
       75
        
               } else if (result.data) {

     
···

       73
       92
        
                 logger(`Got invalid response ${JSON.stringify(result)}`);

     

       74
       93
        
               }

     

       75
       94
        
             });

     

       76
       76
       -
         } else {

     

       95
       95
       +
         } else if (typeof schema === 'string') {

     

       77
       96
        
           const isJson = schema.endsWith('json');

     

       78
       97
        
           const resolvedPath = path.resolve(path.dirname(root), schema);

     

       79
       98
        
           logger(`Getting schema from ${resolvedPath}`);

+18 -7

packages/graphqlsp/src/index.ts

···

       1
       1
        
       import ts from 'typescript/lib/tsserverlibrary';

     

       2
       2
        
       

     

       3
       3
       -
       import { loadSchema } from './graphql/getSchema';

     

       3
       3
       +
       import { SchemaOrigin, loadSchema } from './graphql/getSchema';

     

       4
       4
        
       import { getGraphQLCompletions } from './autoComplete';

     

       5
       5
        
       import { getGraphQLQuickInfo } from './quickInfo';

     

       6
       6
        
       import { getGraphQLDiagnostics } from './diagnostics';

     
···

       20
       20
        
       

     

       21
       21
        
       export type Logger = (msg: string) => void;

     

       22
       22
        
       

     

       23
       23
       +
       type Config = {

     

       24
       24
       +
         schema: SchemaOrigin | string;

     

       25
       25
       +
         template?: string;

     

       26
       26
       +
         disableTypegen?: boolean;

     

       27
       27
       +
         extraTypes?: string;

     

       28
       28
       +
         scalars?: Record<string, unknown>;

     

       29
       29
       +
         shouldCheckForColocatedFragments?: boolean;

     

       30
       30
       +
       };

     

       31
       31
       +
       

     

       23
       32
        
       function create(info: ts.server.PluginCreateInfo) {

     

       24
       33
        
         const logger: Logger = (msg: string) =>

     

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

     

       26
       26
       -
         logger('config: ' + JSON.stringify(info.config));

     

       27
       27
       -
         if (!info.config.schema) {

     

       35
       35
       +
         const config: Config = info.config;

     

       36
       36
       +
       

     

       37
       37
       +
         logger('config: ' + JSON.stringify(config));

     

       38
       38
       +
         if (!config.schema) {

     

       28
       39
        
           logger('Missing "schema" option in configuration.');

     

       29
       40
        
           throw new Error('Please provide a GraphQL Schema!');

     

       30
       41
        
         }

     

       31
       42
        
       

     

       32
       43
        
         logger('Setting up the GraphQL Plugin');

     

       33
       44
        
       

     

       34
       34
       -
         const scalars = info.config.scalars || {};

     

       35
       35
       -
         const extraTypes = info.config.extraTypes;

     

       36
       36
       -
         const disableTypegen = info.config.disableTypegen;

     

       45
       45
       +
         const scalars = config.scalars || {};

     

       46
       46
       +
         const extraTypes = config.extraTypes || '';

     

       47
       47
       +
         const disableTypegen = config.disableTypegen || false;

     

       37
       48
        
       

     

       38
       49
        
         const proxy = createBasicDecorator(info);

     

       39
       50
        
       

     
···

       42
       53
        
       

     

       43
       54
        
         const schema = loadSchema(

     

       44
       55
        
           info.project.getProjectName(),

     

       45
       45
       -
           info.config.schema,

     

       56
       56
       +
           config.schema,

     

       46
       57
        
           logger,

     

       47
       58
        
           baseTypesPath,

     

       48
       59
        
           !disableTypegen,

-1

pnpm-lock.yaml

···

       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.2

     

       4338
       4337
        
           dependencies:

     

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

     

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