commit dfcaef7c0c08732fecf7af2656dd3b10b31f779f · kitten.sh/graphqlsp

+5

.changeset/cool-elephants-invent.md

···

       1
       1
       +
       ---

     

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

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Add support for alternative root directories, when your tsconfig does not define GraphQLSP we'll traverse up until we find the `extends` that does and resolve the schema from there

+2

packages/graphqlsp/package.json

···

       44
       44
        
           "graphql": "^16.8.1",

     

       45
       45
        
           "graphql-language-service": "^5.2.0",

     

       46
       46
        
           "lru-cache": "^10.0.1",

     

       47
       47
       +
           "type-fest": "^4.11.1",

     

       47
       48
        
           "typescript": "^5.3.3"

     

       48
       49
        
         },

     

       49
       50
        
         "dependencies": {

     

       51
       51
       +
           "json5": "^2.2.3",

     

       50
       52
        
           "node-fetch": "^2.0.0"

     

       51
       53
        
         },

     

       52
       54
        
         "publishConfig": {

+33 -5

packages/graphqlsp/src/graphql/getSchema.ts

···

       6
       6
        
         IntrospectionQuery,

     

       7
       7
        
         introspectionFromSchema,

     

       8
       8
        
       } from 'graphql';

     

       9
       9
       -
       

     

       9
       9
       +
       import path from 'path';

     

       10
       10
       +
       import JSON5 from 'json5';

     

       10
       11
        
       import { minifyIntrospectionQuery } from '@urql/introspection';

     

       11
       12
        
       import fetch from 'node-fetch';

     

       12
       12
       -
       import path from 'path';

     

       13
       13
        
       import fs from 'fs';

     

       14
       14
       +
       import type { TsConfigJson } from 'type-fest';

     

       14
       15
        
       

     

       16
       16
       +
       import { ts } from '../ts';

     

       15
       17
        
       import { Logger } from '../index';

     

       16
       18
        
       

     

       17
       19
        
       const preambleComments =

     
···

       71
       73
        
       

     

       72
       74
        
         const json = JSON.stringify(minified, null, 2);

     

       73
       75
        
       

     

       74
       74
       -
         let output = path.resolve(path.dirname(root), tadaOutputLocation);

     

       76
       76
       +
         let output = path.resolve(root, tadaOutputLocation);

     

       75
       77
        
         let stat: fs.Stats | undefined;

     

       76
       78
        
         let contents = '';

     

       77
       79
        
       

     
···

       132
       134
        
         headers: Record<string, unknown>;

     

       133
       135
        
       };

     

       134
       136
        
       

     

       137
       137
       +
       const getRootDir = (

     

       138
       138
       +
         info: ts.server.PluginCreateInfo,

     

       139
       139
       +
         tsconfigPath: string

     

       140
       140
       +
       ): string | undefined => {

     

       141
       141
       +
         const tsconfigContents = info.project.readFile(tsconfigPath);

     

       142
       142
       +
         const parsed = JSON5.parse<TsConfigJson>(tsconfigContents!);

     

       143
       143
       +
       

     

       144
       144
       +
         if (

     

       145
       145
       +
           parsed.compilerOptions?.plugins?.find(x => x.name === '@0no-co/graphqlsp')

     

       146
       146
       +
         ) {

     

       147
       147
       +
           return path.dirname(tsconfigPath);

     

       148
       148
       +
         } else if (Array.isArray(parsed.extends)) {

     

       149
       149
       +
           return parsed.extends.find(p => {

     

       150
       150
       +
             const resolved = path.resolve(path.dirname(tsconfigPath), p);

     

       151
       151
       +
             return getRootDir(info, resolved);

     

       152
       152
       +
           });

     

       153
       153
       +
         } else if (parsed.extends) {

     

       154
       154
       +
           const resolved = path.resolve(path.dirname(tsconfigPath), parsed.extends);

     

       155
       155
       +
           return getRootDir(info, resolved);

     

       156
       156
       +
         }

     

       157
       157
       +
       };

     

       158
       158
       +
       

     

       135
       159
        
       export const loadSchema = (

     

       136
       136
       -
         root: string,

     

       160
       160
       +
         info: ts.server.PluginCreateInfo,

     

       137
       161
        
         schema: SchemaOrigin | string,

     

       138
       162
        
         tadaOutputLocation: string | undefined,

     

       139
       163
        
         logger: Logger

     

       140
       164
        
       ): { current: GraphQLSchema | null; version: number } => {

     

       165
       165
       +
         const root =

     

       166
       166
       +
           getRootDir(info, info.project.getProjectName()) ||

     

       167
       167
       +
           path.dirname(info.project.getProjectName());

     

       168
       168
       +
         logger('Got root-directory to resolve schema from: ' + root);

     

       141
       169
        
         const ref: {

     

       142
       170
        
           current: GraphQLSchema | null;

     

       143
       171
        
           version: number;

     
···

       227
       255
        
           pollSchema();

     

       228
       256
        
         } else if (typeof schema === 'string') {

     

       229
       257
        
           const isJson = path.extname(schema) === '.json';

     

       230
       230
       -
           const resolvedPath = path.resolve(path.dirname(root), schema);

     

       258
       258
       +
           const resolvedPath = path.resolve(root, schema);

     

       231
       259
        
           logger(`Getting schema from ${resolvedPath}`);

     

       232
       260
        
       

     

       233
       261
        
           async function readSchema() {

+1 -1

packages/graphqlsp/src/index.ts

···

       49
       49
        
         const proxy = createBasicDecorator(info);

     

       50
       50
        
       

     

       51
       51
        
         const schema = loadSchema(

     

       52
       52
       -
           info.project.getProjectName(),

     

       52
       52
       +
           info,

     

       53
       53
        
           config.schema,

     

       54
       54
        
           // TODO: either we check here for the client having a package.json

     

       55
       55
        
           // with gql.tada and use a default file loc or we use a config

+12 -1

pnpm-lock.yaml

···

       167
       167
        
       

     

       168
       168
        
         packages/graphqlsp:

     

       169
       169
        
           dependencies:

     

       170
       170
       +
             json5:

     

       171
       171
       +
               specifier: ^2.2.3

     

       172
       172
       +
               version: 2.2.3

     

       170
       173
        
             node-fetch:

     

       171
       174
        
               specifier: ^2.0.0

     

       172
       175
        
               version: 2.6.7

     
···

       195
       198
        
             lru-cache:

     

       196
       199
        
               specifier: ^10.0.1

     

       197
       200
        
               version: 10.0.1

     

       201
       201
       +
             type-fest:

     

       202
       202
       +
               specifier: ^4.11.1

     

       203
       203
       +
               version: 4.11.1

     

       198
       204
        
             typescript:

     

       199
       205
        
               specifier: ^5.3.3

     

       200
       206
        
               version: 5.3.3

     
···

       4227
       4233
        
           resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}

     

       4228
       4234
        
           engines: {node: '>=6'}

     

       4229
       4235
        
           hasBin: true

     

       4230
       4230
       -
           dev: true

     

       4231
       4236
        
       

     

       4232
       4237
        
         /jsonc-parser@3.2.0:

     

       4233
       4238
        
           resolution: {integrity: sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==}

     
···

       5710
       5715
        
           engines: {node: '>=10'}

     

       5711
       5716
        
           dev: true

     

       5712
       5717
        
       

     

       5718
       5718
       +
         /type-fest@4.11.1:

     

       5719
       5719
       +
           resolution: {integrity: sha512-MFMf6VkEVZAETidGGSYW2B1MjXbGX+sWIywn2QPEaJ3j08V+MwVRHMXtf2noB8ENJaD0LIun9wh5Z6OPNf1QzQ==}

     

       5720
       5720
       +
           engines: {node: '>=16'}

     

       5721
       5721
       +
           dev: true

     

       5722
       5722
       +
       

     

       5713
       5723
        
         /typed-array-length@1.0.4:

     

       5714
       5724
        
           resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==}

     

       5715
       5725
        
           dependencies:

     
···

       6176
       6186
        
           resolution: {directory: packages/graphqlsp, type: directory}

     

       6177
       6187
        
           name: '@0no-co/graphqlsp'

     

       6178
       6188
        
           dependencies:

     

       6189
       6189
       +
             json5: 2.2.3

     

       6179
       6190
        
             node-fetch: 2.6.7

     

       6180
       6191
        
           transitivePeerDependencies:

     

       6181
       6192
        
             - encoding

+21

tsconfig.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "compilerOptions": {

     

       3
       3
       +
           "plugins": [

     

       4
       4
       +
             {

     

       5
       5
       +
               "name": "@0no-co/graphqlsp",

     

       6
       6
       +
               "schema": "./packages/example-tada/schema.graphql",

     

       7
       7
       +
               "tadaOutputLocation": "./packages/example-tada/introspection.ts"

     

       8
       8
       +
             }

     

       9
       9
       +
           ],

     

       10
       10
       +
           "jsx": "react-jsx",

     

       11
       11
       +
           /* Language and Environment */

     

       12
       12
       +
           "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,

     

       13
       13
       +
           /* Modules */

     

       14
       14
       +
           "module": "commonjs" /* Specify what module code is generated. */,

     

       15
       15
       +
           "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,

     

       16
       16
       +
           "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,

     

       17
       17
       +
           /* Type Checking */

     

       18
       18
       +
           "strict": true /* Enable all strict type-checking options. */,

     

       19
       19
       +
           "skipLibCheck": true /* Skip type checking all .d.ts files. */

     

       20
       20
       +
         }

     

       21
       21
       +
       }