···

       
1
       
1
       
+
       
---

     

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

     

       
3
       
3
       
+
       
---

     

       
4
       
4
       
+
       


     

       
5
       
5
       
+
       
Fix multiple selection-set updates

     

···

       
3
       
3
       
 
       
on:

     

       
4
       
4
       
 
       
  pull_request:

     

       
5
       
5
       
 
       
  push:

     

       
6
       
6
       
-
       
    branches: main

     

       
6
       
6
       
+
       
    branches:

     

       
7
       
7
       
+
       
      - main

     

       
7
       
8
       
 
       


     

       
8
       
9
       
 
       
jobs:

     

       
9
       
10
       
 
       
  check:

     
···

       
24
       
25
       
 
       
      - name: Setup pnpm

     

       
25
       
26
       
 
       
        uses: pnpm/action-setup@v2.2.4

     

       
26
       
27
       
 
       
        with:

     

       
27
       
27
       
-
       
          version: 7

     

       
28
       
28
       
+
       
          version: 8.6.1

     

       
28
       
29
       
 
       
          run_install: false

     

       
29
       
30
       
 
       


     

       
30
       
31
       
 
       
      - name: Get pnpm store directory

     

···

       
30
       
30
       
 
       
      - name: Setup pnpm

     

       
31
       
31
       
 
       
        uses: pnpm/action-setup@v2.2.4

     

       
32
       
32
       
 
       
        with:

     

       
33
       
33
       
-
       
          version: 8

     

       
33
       
33
       
+
       
          version: 8.6.1

     

       
34
       
34
       
 
       
          run_install: false

     

       
35
       
35
       
 
       


     

       
36
       
36
       
 
       
      - name: Get pnpm store directory

     

···

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

     

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

     

       
3
       
3
       
-
       
export type PokemonsQueryVariables = Types.Exact<{ [key: string]: never }>;

     

       
3
       
3
       
+
       
export type PokQueryVariables = Types.Exact<{ [key: string]: never }>;

     

       
4
       
4
       
 
       


     

       
5
       
5
       
-
       
export type PokemonsQuery = {

     

       
6
       
6
       
-
       
  __typename?: 'Query';

     

       
5
       
5
       
+
       
export type PokQuery = {

     

       
6
       
6
       
+
       
  __typename: 'Query';

     

       
7
       
7
       
 
       
  pokemons?: Array<{

     

       
8
       
8
       
 
       
    __typename: 'Pokemon';

     

       
9
       
9
       
 
       
    id: string;

     
···

       
12
       
12
       
 
       
  } | null> | null;

     

       
13
       
13
       
 
       
};

     

       
14
       
14
       
 
       


     

       
15
       
15
       
-
       
export type PokemonQueryVariables = Types.Exact<{

     

       
15
       
15
       
+
       
export type PoQueryVariables = Types.Exact<{

     

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

     

       
17
       
17
       
 
       
}>;

     

       
18
       
18
       
 
       


     

       
19
       
19
       
-
       
export type PokemonQuery = {

     

       
20
       
20
       
-
       
  __typename?: 'Query';

     

       
19
       
19
       
+
       
export type PoQuery = {

     

       
20
       
20
       
+
       
  __typename: 'Query';

     

       
21
       
21
       
 
       
  pokemon?: {

     

       
22
       
22
       
 
       
    __typename: 'Pokemon';

     

       
23
       
23
       
 
       
    id: string;

     
···

       
25
       
25
       
 
       
  } | null;

     

       
26
       
26
       
 
       
};

     

       
27
       
27
       
 
       


     

       
28
       
28
       
-
       
export const PokemonsDocument = {

     

       
28
       
28
       
+
       
export const PokDocument = {

     

       
29
       
29
       
 
       
  kind: 'Document',

     

       
30
       
30
       
 
       
  definitions: [

     

       
31
       
31
       
 
       
    {

     

       
32
       
32
       
 
       
      kind: 'OperationDefinition',

     

       
33
       
33
       
 
       
      operation: 'query',

     

       
34
       
34
       
-
       
      name: { kind: 'Name', value: 'Pokemons' },

     

       
34
       
34
       
+
       
      name: { kind: 'Name', value: 'Pok' },

     

       
35
       
35
       
 
       
      selectionSet: {

     

       
36
       
36
       
 
       
        kind: 'SelectionSet',

     

       
37
       
37
       
 
       
        selections: [

     
···

       
52
       
52
       
 
       
      },

     

       
53
       
53
       
 
       
    },

     

       
54
       
54
       
 
       
  ],

     

       
55
       
55
       
-
       
} as unknown as DocumentNode<PokemonsQuery, PokemonsQueryVariables>;

     

       
56
       
56
       
-
       
export const PokemonDocument = {

     

       
55
       
55
       
+
       
} as unknown as DocumentNode<PokQuery, PokQueryVariables>;

     

       
56
       
56
       
+
       
export const PoDocument = {

     

       
57
       
57
       
 
       
  kind: 'Document',

     

       
58
       
58
       
 
       
  definitions: [

     

       
59
       
59
       
 
       
    {

     

       
60
       
60
       
 
       
      kind: 'OperationDefinition',

     

       
61
       
61
       
 
       
      operation: 'query',

     

       
62
       
62
       
-
       
      name: { kind: 'Name', value: 'Pokemon' },

     

       
62
       
62
       
+
       
      name: { kind: 'Name', value: 'Po' },

     

       
63
       
63
       
 
       
      variableDefinitions: [

     

       
64
       
64
       
 
       
        {

     

       
65
       
65
       
 
       
          kind: 'VariableDefinition',

     
···

       
99
       
99
       
 
       
      },

     

       
100
       
100
       
 
       
    },

     

       
101
       
101
       
 
       
  ],

     

       
102
       
102
       
-
       
} as unknown as DocumentNode<PokemonQuery, PokemonQueryVariables>;

     

       
102
       
102
       
+
       
} as unknown as DocumentNode<PoQuery, PoQueryVariables>;

     

···

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

     

       
3
       
3
       
 
       


     

       
4
       
4
       
 
       
const PokemonsQuery = gql`

     

       
5
       
5
       
-
       
  query Pokemons {

     

       
5
       
5
       
+
       
  query Pok {

     

       
6
       
6
       
 
       
    pokemons {

     

       
7
       
7
       
 
       
      id

     

       
8
       
8
       
 
       
      name

     
···

       
10
       
10
       
 
       
      fleeRate

     

       
11
       
11
       
 
       
    }

     

       
12
       
12
       
 
       
  }

     

       
13
       
13
       
-
       
` as typeof import('./index.generated').PokemonsDocument;

     

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

     

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
const client = createClient({

     

       
16
       
16
       
 
       
  url: '',

     
···

       
24
       
24
       
 
       
  });

     

       
25
       
25
       
 
       


     

       
26
       
26
       
 
       
const PokemonQuery = gql`

     

       
27
       
27
       
-
       
  query Pokemon($id: ID!) {

     

       
27
       
27
       
+
       
  query Po($id: ID!) {

     

       
28
       
28
       
 
       
    pokemon(id: $id) {

     

       
29
       
29
       
 
       
      id

     

       
30
       
30
       
 
       
      fleeRate

     

       
31
       
31
       
 
       
      __typename

     

       
32
       
32
       
 
       
    }

     

       
33
       
33
       
 
       
  }

     

       
34
       
34
       
-
       
` as typeof import('./index.generated').PokemonDocument;

     

       
34
       
34
       
+
       
` as typeof import('./index.generated').PoDocument;

     

       
35
       
35
       
 
       


     

       
36
       
36
       
 
       
client

     

       
37
       
37
       
 
       
  .query(PokemonQuery, { id: '' })

     

···

       
46
       
46
       
 
       
  const shouldCheckForColocatedFragments =

     

       
47
       
47
       
 
       
    info.config.shouldCheckForColocatedFragments || true;

     

       
48
       
48
       
 
       


     

       
49
       
49
       
-
       
  const source = getSource(info, filename);

     

       
49
       
49
       
+
       
  let source = getSource(info, filename);

     

       
50
       
50
       
 
       
  if (!source) return undefined;

     

       
51
       
51
       
 
       


     

       
52
       
52
       
 
       
  const nodes = findAllTaggedTemplateNodes(source);

     
···

       
268
       
268
       
 
       
        scalars,

     

       
269
       
269
       
 
       
        baseTypesPath

     

       
270
       
270
       
 
       
      ).then(() => {

     

       
271
       
271
       
+
       
        source = getSource(info, filename);

     

       
272
       
272
       
+
       
        if (!source) return undefined;

     

       
273
       
273
       
+
       


     

       
271
       
274
       
 
       
        if (isFileDirty(filename, source) && !hasTSErrors) {

     

       
272
       
275
       
 
       
          return;

     

       
273
       
276
       
 
       
        }

     

       
274
       
277
       
 
       


     

       
275
       
275
       
-
       
        nodes.forEach((node, i) => {

     

       
278
       
278
       
+
       
        let addedLength = 0;

     

       
279
       
279
       
+
       
        const finalSourceText = nodes.reduce((sourceText, node, i) => {

     

       
280
       
280
       
+
       
          source = getSource(info, filename);

     

       
281
       
281
       
+
       
          if (!source) return sourceText;

     

       
282
       
282
       
+
       


     

       
276
       
283
       
 
       
          const queryText = texts[i] || '';

     

       
277
       
284
       
 
       
          const parsed = parse(queryText, { noLocation: true });

     

       
278
       
285
       
 
       
          const isFragment = parsed.definitions.every(

     
···

       
290
       
297
       
 
       
            name = operationNode.name?.value || '';

     

       
291
       
298
       
 
       
          }

     

       
292
       
299
       
 
       


     

       
293
       
293
       
-
       
          if (!name) return;

     

       
300
       
300
       
+
       
          if (!name) return sourceText;

     

       
294
       
301
       
 
       


     

       
295
       
302
       
 
       
          name = name.charAt(0).toUpperCase() + name.slice(1);

     

       
296
       
303
       
 
       
          const parentChildren = node.parent.getChildren();

     
···

       
300
       
307
       
 
       
            : `${name}Document`;

     

       
301
       
308
       
 
       
          let imp = ` as typeof import('./${nameParts

     

       
302
       
309
       
 
       
            .join('.')

     

       
303
       
303
       
-
       
            .replace('.ts', '')}').${exportName}`;

     

       
310
       
310
       
+
       
            .replace('.ts', '')}').${exportName}\n`;

     

       
304
       
311
       
 
       


     

       
305
       
312
       
 
       
          // This checks whether one of the children is an import-type

     

       
306
       
313
       
 
       
          // which is a short-circuit if there is no as

     
···

       
308
       
315
       
 
       
            isImportTypeNode(x)

     

       
309
       
316
       
 
       
          ) as ImportTypeNode;

     

       
310
       
317
       
 
       


     

       
311
       
311
       
-
       
          if (typeImport && typeImport.getText().includes(exportName)) return;

     

       
318
       
318
       
+
       
          if (typeImport && typeImport.getText().includes(exportName))

     

       
319
       
319
       
+
       
            return sourceText;

     

       
312
       
320
       
 
       


     

       
313
       
321
       
 
       
          const span = { length: 1, start: node.end };

     

       
314
       
322
       
 
       


     
···

       
323
       
331
       
 
       
            // but ` as ` meaning we need to keep that part

     

       
324
       
332
       
 
       
            // around.

     

       
325
       
333
       
 
       
            imp = imp.slice(4);

     

       
326
       
326
       
-
       
            text = source.text.replace(typeImport.getText(), imp);

     

       
334
       
334
       
+
       
            // We remove the \n

     

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

     

       
336
       
336
       
+
       
            text = sourceText.replace(typeImport.getText(), imp);

     

       
327
       
337
       
 
       
            span.length =

     

       
328
       
338
       
 
       
              imp.length + ((oldExportName || '').length - exportName.length);

     

       
329
       
339
       
 
       
          } else {

     

       
330
       
340
       
 
       
            text =

     

       
331
       
331
       
-
       
              source.text.substring(0, span.start) +

     

       
341
       
341
       
+
       
              sourceText.substring(0, span.start) +

     

       
332
       
342
       
 
       
              imp +

     

       
333
       
333
       
-
       
              source.text.substring(

     

       
334
       
334
       
-
       
                span.start + span.length,

     

       
335
       
335
       
-
       
                source.text.length

     

       
336
       
336
       
-
       
              );

     

       
343
       
343
       
+
       
              sourceText.substring(span.start + span.length, sourceText.length);

     

       
337
       
344
       
 
       
          }

     

       
338
       
345
       
 
       


     

       
339
       
339
       
-
       
          const scriptInfo =

     

       
340
       
340
       
-
       
            info.project.projectService.getScriptInfo(filename);

     

       
341
       
341
       
-
       
          const snapshot = scriptInfo!.getSnapshot();

     

       
346
       
346
       
+
       
          sourceText = text;

     

       
347
       
347
       
+
       
          addedLength = addedLength + imp.length;

     

       
348
       
348
       
+
       
          // @ts-ignore

     

       
349
       
349
       
+
       
          source.hasBeenIncrementallyParsed = false;

     

       
350
       
350
       
+
       
          source.update(text, { span, newLength: imp.length });

     

       
351
       
351
       
+
       
          source.text = text;

     

       
352
       
352
       
+
       


     

       
353
       
353
       
+
       
          return sourceText;

     

       
354
       
354
       
+
       
        }, source.text);

     

       
342
       
355
       
 
       


     

       
343
       
343
       
-
       
          source.update(text, { span, newLength: imp.length });

     

       
344
       
344
       
-
       
          scriptInfo!.editContent(0, snapshot.getLength(), text);

     

       
345
       
345
       
-
       
          info.languageServiceHost.writeFile!(source.fileName, text);

     

       
346
       
346
       
-
       
          if (!!typeImport) {

     

       
347
       
347
       
-
       
            // To update the types, otherwise data is stale

     

       
348
       
348
       
-
       
            scriptInfo!.reloadFromFile();

     

       
349
       
349
       
-
       
          }

     

       
350
       
350
       
-
       
          scriptInfo!.registerFileUpdate();

     

       
351
       
351
       
-
       
        });

     

       
356
       
356
       
+
       
        const scriptInfo = info.project.projectService.getScriptInfo(filename);

     

       
357
       
357
       
+
       
        const snapshot = scriptInfo!.getSnapshot();

     

       
358
       
358
       
+
       
        scriptInfo!.editContent(0, snapshot.getLength(), finalSourceText);

     

       
359
       
359
       
+
       
        info.languageServiceHost.writeFile!(source.fileName, finalSourceText);

     

       
360
       
360
       
+
       
        scriptInfo!.reloadFromFile();

     

       
361
       
361
       
+
       
        scriptInfo!.registerFileUpdate();

     

       
352
       
362
       
 
       
      });

     

       
353
       
353
       
-
       
    } catch (e) {}

     

       
363
       
363
       
+
       
    } catch (e) {

     

       
364
       
364
       
+
       
      const scriptInfo = info.project.projectService.getScriptInfo(filename);

     

       
365
       
365
       
+
       
      scriptInfo!.reloadFromFile();

     

       
366
       
366
       
+
       
    }

     

       
354
       
367
       
 
       
  }

     

       
355
       
368
       
 
       


     

       
356
       
369
       
 
       
  return tsDiagnostics;

     

···

       
1
       
1
       
-
       
lockfileVersion: '6.0'

     

       
1
       
1
       
+
       
lockfileVersion: '6.1'

     

       
2
       
2
       
+
       


     

       
3
       
3
       
+
       
settings:

     

       
4
       
4
       
+
       
  autoInstallPeers: true

     

       
5
       
5
       
+
       
  excludeLinksFromLockfile: false

     

       
2
       
6
       
 
       


     

       
3
       
7
       
 
       
importers:

     

       
4
       
8
       
 
       


     
···

       
1054
       
1058
       
 
       
      '@graphql-codegen/plugin-helpers': 4.2.0(graphql@16.6.0)

     

       
1055
       
1059
       
 
       
      graphql: 16.6.0

     

       
1056
       
1060
       
 
       
      tslib: 2.5.0

     

       
1057
       
1057
       
-
       
    dev: false

     

       
1058
       
1061
       
 
       


     

       
1059
       
1062
       
 
       
  /@graphql-codegen/core@3.1.0(graphql@16.6.0):

     

       
1060
       
1063
       
 
       
    resolution: {integrity: sha512-DH1/yaR7oJE6/B+c6ZF2Tbdh7LixF1K8L+8BoSubjNyQ8pNwR4a70mvc1sv6H7qgp6y1bPQ9tKE+aazRRshysw==}

     
···

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

     

       
4332
       
4335
       
 
       
    id: file:packages/graphqlsp

     

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

     

       
4334
       
4334
       
-
       
    version: 0.1.0

     

       
4337
       
4337
       
+
       
    version: 0.7.1

     

       
4335
       
4338
       
 
       
    dependencies:

     

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

     

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

     

       
4337
       
4341
       
 
       
      '@graphql-codegen/typed-document-node': 3.0.2(graphql@16.6.0)

     

       
4338
       
4342
       
 
       
      '@graphql-codegen/typescript': 3.0.3(graphql@16.6.0)