···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

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

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
add caching for gql-diagnostics

     

···

       
38
       
 
       
  .then(result => {

     

       
39
       
 
       
    result.data?.pokemon;

     

       
40
       
 
       
  });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
38
       
 
       
  .then(result => {

     

       
39
       
 
       
    result.data?.pokemon;

     

       
40
       
 
       
  });

     

       
41
       
+
       


     

       
42
       
+
       
const myQuery = gql`

     

       
43
       
+
       
  query PokemonsAreAwesome {

     

       
44
       
+
       
    pokemons {

     

       
45
       
+
       
      id

     

       
46
       
+
       
    }

     

       
47
       
+
       
  }

     

       
48
       
+
       
`;

     

···

       
46
       
 
       
    "@graphql-codegen/typescript": "^4.0.1",

     

       
47
       
 
       
    "@graphql-codegen/typescript-operations": "^4.0.1",

     

       
48
       
 
       
    "@graphql-typed-document-node/core": "^3.2.0",

     

       
0
       
 
       

     

       
49
       
 
       
    "graphql-language-service": "^5.1.7",

     

       
0
       
 
       

     

       
50
       
 
       
    "node-fetch": "^2.0.0"

     

       
51
       
 
       
  },

     

       
52
       
 
       
  "publishConfig": {

     

···

       
46
       
 
       
    "@graphql-codegen/typescript": "^4.0.1",

     

       
47
       
 
       
    "@graphql-codegen/typescript-operations": "^4.0.1",

     

       
48
       
 
       
    "@graphql-typed-document-node/core": "^3.2.0",

     

       
49
       
+
       
    "@sindresorhus/fnv1a": "^2.0.0",

     

       
50
       
 
       
    "graphql-language-service": "^5.1.7",

     

       
51
       
+
       
    "lru-cache": "^10.0.1",

     

       
52
       
 
       
    "node-fetch": "^2.0.0"

     

       
53
       
 
       
  },

     

       
54
       
 
       
  "publishConfig": {

     

···

       
18
       
 
       
  OperationDefinitionNode,

     

       
19
       
 
       
  parse,

     

       
20
       
 
       
} from 'graphql';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
21
       
 
       


     

       
22
       
 
       
import {

     

       
23
       
 
       
  findAllImports,

     
···

       
35
       
 
       


     

       
36
       
 
       
let isGeneratingTypes = false;

     

       
37
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
38
       
 
       
export function getGraphQLDiagnostics(

     

       
39
       
 
       
  // This is so that we don't change offsets when there are

     

       
40
       
 
       
  // TypeScript errors

     

       
41
       
 
       
  hasTSErrors: Boolean,

     

       
42
       
 
       
  filename: string,

     

       
43
       
 
       
  baseTypesPath: string,

     

       
44
       
-
       
  schema: { current: GraphQLSchema | null },

     

       
45
       
 
       
  info: ts.server.PluginCreateInfo

     

       
46
       
 
       
): ts.Diagnostic[] | undefined {

     

       
47
       
 
       
  const logger = (msg: string) =>

     
···

       
69
       
 
       
    return resolveTemplate(node, filename, info).combinedText;

     

       
70
       
 
       
  });

     

       
71
       
 
       


     

       
72
       
-
       
  const diagnostics = nodes

     

       
73
       
-
       
    .map(originalNode => {

     

       
74
       
-
       
      let node = originalNode;

     

       
75
       
-
       
      if (isNoSubstitutionTemplateLiteral(node) || isTemplateExpression(node)) {

     

       
76
       
-
       
        if (isTaggedTemplateExpression(node.parent)) {

     

       
77
       
-
       
          node = node.parent;

     

       
78
       
-
       
        } else {

     

       
79
       
-
       
          return undefined;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
80
       
 
       
        }

     

       
81
       
-
       
      }

     

       
82
       
 
       


     

       
83
       
-
       
      const { combinedText: text, resolvedSpans } = resolveTemplate(

     

       
84
       
-
       
        node,

     

       
85
       
-
       
        filename,

     

       
86
       
-
       
        info

     

       
87
       
-
       
      );

     

       
88
       
-
       
      const lines = text.split('\n');

     

       
89
       
 
       


     

       
90
       
-
       
      let isExpression = false;

     

       
91
       
-
       
      if (isAsExpression(node.parent)) {

     

       
92
       
-
       
        if (isExpressionStatement(node.parent.parent)) {

     

       
93
       
-
       
          isExpression = true;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
94
       
 
       
        }

     

       
95
       
-
       
      } else {

     

       
96
       
-
       
        if (isExpressionStatement(node.parent)) {

     

       
97
       
-
       
          isExpression = true;

     

       
98
       
-
       
        }

     

       
99
       
-
       
      }

     

       
100
       
-
       
      // When we are dealing with a plain gql statement we have to add two these can be recognised

     

       
101
       
-
       
      // by the fact that the parent is an expressionStatement

     

       
102
       
-
       
      let startingPosition =

     

       
103
       
-
       
        node.pos + (tagTemplate.length + (isExpression ? 2 : 1));

     

       
104
       
-
       
      const endPosition = startingPosition + node.getText().length;

     

       
105
       
-
       
      const graphQLDiagnostics = getDiagnostics(text, schema.current)

     

       
106
       
-
       
        .map(x => {

     

       
107
       
-
       
          const { start, end } = x.range;

     

       
108
       
 
       


     

       
109
       
-
       
          // We add the start.line to account for newline characters which are

     

       
110
       
-
       
          // split out

     

       
111
       
-
       
          let startChar = startingPosition + start.line;

     

       
112
       
-
       
          for (let i = 0; i <= start.line; i++) {

     

       
113
       
-
       
            if (i === start.line) startChar += start.character;

     

       
114
       
-
       
            else startChar += lines[i].length;

     

       
115
       
-
       
          }

     

       
116
       
 
       


     

       
117
       
-
       
          let endChar = startingPosition + end.line;

     

       
118
       
-
       
          for (let i = 0; i <= end.line; i++) {

     

       
119
       
-
       
            if (i === end.line) endChar += end.character;

     

       
120
       
-
       
            else endChar += lines[i].length;

     

       
121
       
-
       
          }

     

       
122
       
 
       


     

       
123
       
-
       
          const locatedInFragment = resolvedSpans.find(x => {

     

       
124
       
-
       
            const newEnd = x.new.start + x.new.length;

     

       
125
       
-
       
            return startChar >= x.new.start && endChar <= newEnd;

     

       
126
       
-
       
          });

     

       
127
       
 
       


     

       
128
       
-
       
          if (!!locatedInFragment) {

     

       
129
       
-
       
            return {

     

       
130
       
-
       
              ...x,

     

       
131
       
-
       
              start: locatedInFragment.original.start,

     

       
132
       
-
       
              length: locatedInFragment.original.length,

     

       
133
       
-
       
            };

     

       
134
       
-
       
          } else {

     

       
135
       
-
       
            if (startChar > endPosition) {

     

       
136
       
-
       
              // we have to calculate the added length and fix this

     

       
137
       
-
       
              const addedCharacters = resolvedSpans

     

       
138
       
-
       
                .filter(x => x.new.start + x.new.length < startChar)

     

       
139
       
-
       
                .reduce(

     

       
140
       
-
       
                  (acc, span) => acc + (span.new.length - span.original.length),

     

       
141
       
-
       
                  0

     

       
142
       
-
       
                );

     

       
143
       
-
       
              startChar = startChar - addedCharacters;

     

       
144
       
-
       
              endChar = endChar - addedCharacters;

     

       
145
       
 
       
              return {

     

       
146
       
 
       
                ...x,

     

       
147
       
-
       
                start: startChar + 1,

     

       
148
       
-
       
                length: endChar - startChar,

     

       
149
       
 
       
              };

     

       
150
       
 
       
            } else {

     

       
151
       
-
       
              return {

     

       
152
       
-
       
                ...x,

     

       
153
       
-
       
                start: startChar + 1,

     

       
154
       
-
       
                length: endChar - startChar,

     

       
155
       
-
       
              };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
156
       
 
       
            }

     

       
157
       
-
       
          }

     

       
158
       
-
       
        })

     

       
159
       
-
       
        .filter(x => x.start + x.length <= endPosition);

     

       
160
       
 
       


     

       
161
       
-
       
      try {

     

       
162
       
-
       
        const parsed = parse(text, { noLocation: true });

     

       
163
       
 
       


     

       
164
       
-
       
        if (

     

       
165
       
-
       
          parsed.definitions.some(x => x.kind === Kind.OPERATION_DEFINITION)

     

       
166
       
-
       
        ) {

     

       
167
       
-
       
          const op = parsed.definitions.find(

     

       
168
       
-
       
            x => x.kind === Kind.OPERATION_DEFINITION

     

       
169
       
-
       
          ) as OperationDefinitionNode;

     

       
170
       
-
       
          if (!op.name) {

     

       
171
       
-
       
            graphQLDiagnostics.push({

     

       
172
       
-
       
              message: 'Operation needs a name for types to be generated.',

     

       
173
       
-
       
              start: node.pos,

     

       
174
       
-
       
              code: MISSING_OPERATION_NAME_CODE,

     

       
175
       
-
       
              length: originalNode.getText().length,

     

       
176
       
-
       
              range: {} as any,

     

       
177
       
-
       
              severity: 2,

     

       
178
       
-
       
            } as any);

     

       
0
       
 
       

     

       
179
       
 
       
          }

     

       
180
       
-
       
        }

     

       
181
       
-
       
      } catch (e) {}

     

       
182
       
-
       


     

       
183
       
-
       
      return graphQLDiagnostics;

     

       
184
       
-
       
    })

     

       
185
       
-
       
    .flat()

     

       
186
       
-
       
    .filter(Boolean) as Array<Diagnostic & { length: number; start: number }>;

     

       
187
       
 
       


     

       
188
       
-
       
  const tsDiagnostics: ts.Diagnostic[] = diagnostics.map(diag => ({

     

       
189
       
-
       
    file: source,

     

       
190
       
-
       
    length: diag.length,

     

       
191
       
-
       
    start: diag.start,

     

       
192
       
-
       
    category:

     

       
193
       
-
       
      diag.severity === 2

     

       
194
       
-
       
        ? ts.DiagnosticCategory.Warning

     

       
195
       
-
       
        : ts.DiagnosticCategory.Error,

     

       
196
       
-
       
    code:

     

       
197
       
-
       
      typeof diag.code === 'number'

     

       
198
       
-
       
        ? diag.code

     

       
199
       
-
       
        : diag.severity === 2

     

       
200
       
-
       
        ? USING_DEPRECATED_FIELD_CODE

     

       
201
       
-
       
        : SEMANTIC_DIAGNOSTIC_CODE,

     

       
202
       
-
       
    messageText: diag.message.split('\n')[0],

     

       
203
       
-
       
  }));

     

       
204
       
 
       


     

       
205
       
-
       
  const imports = findAllImports(source);

     

       
206
       
-
       
  if (imports.length && shouldCheckForColocatedFragments) {

     

       
207
       
-
       
    const typeChecker = info.languageService.getProgram()?.getTypeChecker();

     

       
208
       
-
       
    imports.forEach(imp => {

     

       
209
       
-
       
      if (!imp.importClause) return;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
210
       
 
       


     

       
211
       
-
       
      const importedNames: string[] = [];

     

       
212
       
-
       
      if (imp.importClause.name) {

     

       
213
       
-
       
        importedNames.push(imp.importClause?.name.text);

     

       
214
       
-
       
      }

     

       
0
       
 
       

     

       
215
       
 
       


     

       
216
       
-
       
      if (

     

       
217
       
-
       
        imp.importClause.namedBindings &&

     

       
218
       
-
       
        isNamespaceImport(imp.importClause.namedBindings)

     

       
219
       
-
       
      ) {

     

       
220
       
-
       
        // TODO: we might need to warn here when the fragment is unused as a namespace import

     

       
221
       
-
       
        return;

     

       
222
       
-
       
      } else if (

     

       
223
       
-
       
        imp.importClause.namedBindings &&

     

       
224
       
-
       
        isNamedImportBindings(imp.importClause.namedBindings)

     

       
225
       
-
       
      ) {

     

       
226
       
-
       
        imp.importClause.namedBindings.elements.forEach(el => {

     

       
227
       
-
       
          importedNames.push(el.name.text);

     

       
228
       
-
       
        });

     

       
229
       
-
       
      }

     

       
230
       
 
       


     

       
231
       
-
       
      const symbol = typeChecker?.getSymbolAtLocation(imp.moduleSpecifier);

     

       
232
       
-
       
      if (!symbol) return;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
233
       
 
       


     

       
234
       
-
       
      const moduleExports = typeChecker?.getExportsOfModule(symbol);

     

       
235
       
-
       
      if (!moduleExports) return;

     

       
236
       
 
       


     

       
237
       
-
       
      const missingImports = moduleExports

     

       
238
       
-
       
        .map(exp => {

     

       
239
       
-
       
          if (importedNames.includes(exp.name)) {

     

       
240
       
-
       
            return;

     

       
241
       
-
       
          }

     

       
242
       
 
       


     

       
243
       
-
       
          const declarations = exp.getDeclarations();

     

       
244
       
-
       
          const declaration = declarations?.find(x => {

     

       
245
       
-
       
            // TODO: check whether the sourceFile.fileName resembles the module

     

       
246
       
-
       
            // specifier

     

       
247
       
-
       
            return true;

     

       
248
       
-
       
          });

     

       
249
       
 
       


     

       
250
       
-
       
          if (!declaration) return;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
251
       
 
       


     

       
252
       
-
       
          const [template] = findAllTaggedTemplateNodes(declaration);

     

       
253
       
-
       
          if (template) {

     

       
254
       
-
       
            let node = template;

     

       
255
       
-
       
            if (

     

       
256
       
-
       
              isNoSubstitutionTemplateLiteral(node) ||

     

       
257
       
-
       
              isTemplateExpression(node)

     

       
258
       
-
       
            ) {

     

       
259
       
-
       
              if (isTaggedTemplateExpression(node.parent)) {

     

       
260
       
-
       
                node = node.parent;

     

       
261
       
-
       
              } else {

     

       
262
       
-
       
                return;

     

       
263
       
-
       
              }

     

       
264
       
-
       
            }

     

       
265
       
 
       


     

       
266
       
-
       
            const text = resolveTemplate(

     

       
267
       
-
       
              node,

     

       
268
       
-
       
              node.getSourceFile().fileName,

     

       
269
       
-
       
              info

     

       
270
       
-
       
            ).combinedText;

     

       
271
       
-
       
            try {

     

       
272
       
-
       
              const parsed = parse(text, { noLocation: true });

     

       
273
       
 
       
              if (

     

       
274
       
-
       
                parsed.definitions.every(

     

       
275
       
-
       
                  x => x.kind === Kind.FRAGMENT_DEFINITION

     

       
276
       
-
       
                )

     

       
277
       
 
       
              ) {

     

       
278
       
-
       
                return `'${exp.name}'`;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
279
       
 
       
              }

     

       
280
       
-
       
            } catch (e) {

     

       
281
       
-
       
              return;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
282
       
 
       
            }

     

       
283
       
-
       
          }

     

       
284
       
-
       
        })

     

       
285
       
-
       
        .filter(Boolean);

     

       
286
       
 
       


     

       
287
       
-
       
      if (missingImports.length) {

     

       
288
       
-
       
        // TODO: we could use getCodeFixesAtPosition

     

       
289
       
-
       
        // to build on this

     

       
290
       
-
       
        tsDiagnostics.push({

     

       
291
       
-
       
          file: source,

     

       
292
       
-
       
          length: imp.getText().length,

     

       
293
       
-
       
          start: imp.getStart(),

     

       
294
       
-
       
          category: ts.DiagnosticCategory.Message,

     

       
295
       
-
       
          code: MISSING_FRAGMENT_CODE,

     

       
296
       
-
       
          messageText: `Missing Fragment import(s) ${missingImports.join(

     

       
297
       
-
       
            ', '

     

       
298
       
-
       
          )} from ${imp.moduleSpecifier.getText()}.`,

     

       
299
       
-
       
        });

     

       
300
       
-
       
      }

     

       
301
       
-
       
    });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
302
       
 
       
  }

     

       
303
       
 
       


     

       
304
       
 
       
  if (

     

···

       
18
       
 
       
  OperationDefinitionNode,

     

       
19
       
 
       
  parse,

     

       
20
       
 
       
} from 'graphql';

     

       
21
       
+
       
import { LRUCache } from 'lru-cache';

     

       
22
       
+
       
import fnv1a from '@sindresorhus/fnv1a';

     

       
23
       
 
       


     

       
24
       
 
       
import {

     

       
25
       
 
       
  findAllImports,

     
···

       
37
       
 
       


     

       
38
       
 
       
let isGeneratingTypes = false;

     

       
39
       
 
       


     

       
40
       
+
       
const cache = new LRUCache<number, ts.Diagnostic[]>({

     

       
41
       
+
       
  // how long to live in ms

     

       
42
       
+
       
  ttl: 1000 * 60 * 15,

     

       
43
       
+
       
  max: 5000,

     

       
44
       
+
       
});

     

       
45
       
+
       


     

       
46
       
 
       
export function getGraphQLDiagnostics(

     

       
47
       
 
       
  // This is so that we don't change offsets when there are

     

       
48
       
 
       
  // TypeScript errors

     

       
49
       
 
       
  hasTSErrors: Boolean,

     

       
50
       
 
       
  filename: string,

     

       
51
       
 
       
  baseTypesPath: string,

     

       
52
       
+
       
  schema: { current: GraphQLSchema | null; version: number },

     

       
53
       
 
       
  info: ts.server.PluginCreateInfo

     

       
54
       
 
       
): ts.Diagnostic[] | undefined {

     

       
55
       
 
       
  const logger = (msg: string) =>

     
···

       
77
       
 
       
    return resolveTemplate(node, filename, info).combinedText;

     

       
78
       
 
       
  });

     

       
79
       
 
       


     

       
80
       
+
       
  let tsDiagnostics: ts.Diagnostic[] = [];

     

       
81
       
+
       
  const cacheKey = fnv1a(texts.join('-') + schema.version);

     

       
82
       
+
       
  if (cache.has(cacheKey)) {

     

       
83
       
+
       
    tsDiagnostics = cache.get(cacheKey)!;

     

       
84
       
+
       
  } else {

     

       
85
       
+
       
    const diagnostics = nodes

     

       
86
       
+
       
      .map(originalNode => {

     

       
87
       
+
       
        let node = originalNode;

     

       
88
       
+
       
        if (

     

       
89
       
+
       
          isNoSubstitutionTemplateLiteral(node) ||

     

       
90
       
+
       
          isTemplateExpression(node)

     

       
91
       
+
       
        ) {

     

       
92
       
+
       
          if (isTaggedTemplateExpression(node.parent)) {

     

       
93
       
+
       
            node = node.parent;

     

       
94
       
+
       
          } else {

     

       
95
       
+
       
            return undefined;

     

       
96
       
+
       
          }

     

       
97
       
 
       
        }

     

       
0
       
 
       

     

       
98
       
 
       


     

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

     

       
100
       
+
       
          node,

     

       
101
       
+
       
          filename,

     

       
102
       
+
       
          info

     

       
103
       
+
       
        );

     

       
104
       
+
       
        const lines = text.split('\n');

     

       
105
       
 
       


     

       
106
       
+
       
        let isExpression = false;

     

       
107
       
+
       
        if (isAsExpression(node.parent)) {

     

       
108
       
+
       
          if (isExpressionStatement(node.parent.parent)) {

     

       
109
       
+
       
            isExpression = true;

     

       
110
       
+
       
          }

     

       
111
       
+
       
        } else {

     

       
112
       
+
       
          if (isExpressionStatement(node.parent)) {

     

       
113
       
+
       
            isExpression = true;

     

       
114
       
+
       
          }

     

       
115
       
 
       
        }

     

       
116
       
+
       
        // When we are dealing with a plain gql statement we have to add two these can be recognised

     

       
117
       
+
       
        // by the fact that the parent is an expressionStatement

     

       
118
       
+
       
        let startingPosition =

     

       
119
       
+
       
          node.pos + (tagTemplate.length + (isExpression ? 2 : 1));

     

       
120
       
+
       
        const endPosition = startingPosition + node.getText().length;

     

       
121
       
+
       
        const graphQLDiagnostics = getDiagnostics(text, schema.current)

     

       
122
       
+
       
          .map(x => {

     

       
123
       
+
       
            const { start, end } = x.range;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
124
       
 
       


     

       
125
       
+
       
            // We add the start.line to account for newline characters which are

     

       
126
       
+
       
            // split out

     

       
127
       
+
       
            let startChar = startingPosition + start.line;

     

       
128
       
+
       
            for (let i = 0; i <= start.line; i++) {

     

       
129
       
+
       
              if (i === start.line) startChar += start.character;

     

       
130
       
+
       
              else startChar += lines[i].length;

     

       
131
       
+
       
            }

     

       
132
       
 
       


     

       
133
       
+
       
            let endChar = startingPosition + end.line;

     

       
134
       
+
       
            for (let i = 0; i <= end.line; i++) {

     

       
135
       
+
       
              if (i === end.line) endChar += end.character;

     

       
136
       
+
       
              else endChar += lines[i].length;

     

       
137
       
+
       
            }

     

       
138
       
 
       


     

       
139
       
+
       
            const locatedInFragment = resolvedSpans.find(x => {

     

       
140
       
+
       
              const newEnd = x.new.start + x.new.length;

     

       
141
       
+
       
              return startChar >= x.new.start && endChar <= newEnd;

     

       
142
       
+
       
            });

     

       
143
       
 
       


     

       
144
       
+
       
            if (!!locatedInFragment) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
145
       
 
       
              return {

     

       
146
       
 
       
                ...x,

     

       
147
       
+
       
                start: locatedInFragment.original.start,

     

       
148
       
+
       
                length: locatedInFragment.original.length,

     

       
149
       
 
       
              };

     

       
150
       
 
       
            } else {

     

       
151
       
+
       
              if (startChar > endPosition) {

     

       
152
       
+
       
                // we have to calculate the added length and fix this

     

       
153
       
+
       
                const addedCharacters = resolvedSpans

     

       
154
       
+
       
                  .filter(x => x.new.start + x.new.length < startChar)

     

       
155
       
+
       
                  .reduce(

     

       
156
       
+
       
                    (acc, span) =>

     

       
157
       
+
       
                      acc + (span.new.length - span.original.length),

     

       
158
       
+
       
                    0

     

       
159
       
+
       
                  );

     

       
160
       
+
       
                startChar = startChar - addedCharacters;

     

       
161
       
+
       
                endChar = endChar - addedCharacters;

     

       
162
       
+
       
                return {

     

       
163
       
+
       
                  ...x,

     

       
164
       
+
       
                  start: startChar + 1,

     

       
165
       
+
       
                  length: endChar - startChar,

     

       
166
       
+
       
                };

     

       
167
       
+
       
              } else {

     

       
168
       
+
       
                return {

     

       
169
       
+
       
                  ...x,

     

       
170
       
+
       
                  start: startChar + 1,

     

       
171
       
+
       
                  length: endChar - startChar,

     

       
172
       
+
       
                };

     

       
173
       
+
       
              }

     

       
174
       
 
       
            }

     

       
175
       
+
       
          })

     

       
176
       
+
       
          .filter(x => x.start + x.length <= endPosition);

     

       
0
       
 
       

     

       
177
       
 
       


     

       
178
       
+
       
        try {

     

       
179
       
+
       
          const parsed = parse(text, { noLocation: true });

     

       
180
       
 
       


     

       
181
       
+
       
          if (

     

       
182
       
+
       
            parsed.definitions.some(x => x.kind === Kind.OPERATION_DEFINITION)

     

       
183
       
+
       
          ) {

     

       
184
       
+
       
            const op = parsed.definitions.find(

     

       
185
       
+
       
              x => x.kind === Kind.OPERATION_DEFINITION

     

       
186
       
+
       
            ) as OperationDefinitionNode;

     

       
187
       
+
       
            if (!op.name) {

     

       
188
       
+
       
              graphQLDiagnostics.push({

     

       
189
       
+
       
                message: 'Operation needs a name for types to be generated.',

     

       
190
       
+
       
                start: node.pos,

     

       
191
       
+
       
                code: MISSING_OPERATION_NAME_CODE,

     

       
192
       
+
       
                length: originalNode.getText().length,

     

       
193
       
+
       
                range: {} as any,

     

       
194
       
+
       
                severity: 2,

     

       
195
       
+
       
              } as any);

     

       
196
       
+
       
            }

     

       
197
       
 
       
          }

     

       
198
       
+
       
        } catch (e) {}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
199
       
 
       


     

       
200
       
+
       
        return graphQLDiagnostics;

     

       
201
       
+
       
      })

     

       
202
       
+
       
      .flat()

     

       
203
       
+
       
      .filter(Boolean) as Array<Diagnostic & { length: number; start: number }>;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
204
       
 
       


     

       
205
       
+
       
    tsDiagnostics = diagnostics.map(diag => ({

     

       
206
       
+
       
      file: source,

     

       
207
       
+
       
      length: diag.length,

     

       
208
       
+
       
      start: diag.start,

     

       
209
       
+
       
      category:

     

       
210
       
+
       
        diag.severity === 2

     

       
211
       
+
       
          ? ts.DiagnosticCategory.Warning

     

       
212
       
+
       
          : ts.DiagnosticCategory.Error,

     

       
213
       
+
       
      code:

     

       
214
       
+
       
        typeof diag.code === 'number'

     

       
215
       
+
       
          ? diag.code

     

       
216
       
+
       
          : diag.severity === 2

     

       
217
       
+
       
          ? USING_DEPRECATED_FIELD_CODE

     

       
218
       
+
       
          : SEMANTIC_DIAGNOSTIC_CODE,

     

       
219
       
+
       
      messageText: diag.message.split('\n')[0],

     

       
220
       
+
       
    }));

     

       
221
       
 
       


     

       
222
       
+
       
    const imports = findAllImports(source);

     

       
223
       
+
       
    if (imports.length && shouldCheckForColocatedFragments) {

     

       
224
       
+
       
      const typeChecker = info.languageService.getProgram()?.getTypeChecker();

     

       
225
       
+
       
      imports.forEach(imp => {

     

       
226
       
+
       
        if (!imp.importClause) return;

     

       
227
       
 
       


     

       
228
       
+
       
        const importedNames: string[] = [];

     

       
229
       
+
       
        if (imp.importClause.name) {

     

       
230
       
+
       
          importedNames.push(imp.importClause?.name.text);

     

       
231
       
+
       
        }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
232
       
 
       


     

       
233
       
+
       
        if (

     

       
234
       
+
       
          imp.importClause.namedBindings &&

     

       
235
       
+
       
          isNamespaceImport(imp.importClause.namedBindings)

     

       
236
       
+
       
        ) {

     

       
237
       
+
       
          // TODO: we might need to warn here when the fragment is unused as a namespace import

     

       
238
       
+
       
          return;

     

       
239
       
+
       
        } else if (

     

       
240
       
+
       
          imp.importClause.namedBindings &&

     

       
241
       
+
       
          isNamedImportBindings(imp.importClause.namedBindings)

     

       
242
       
+
       
        ) {

     

       
243
       
+
       
          imp.importClause.namedBindings.elements.forEach(el => {

     

       
244
       
+
       
            importedNames.push(el.name.text);

     

       
245
       
+
       
          });

     

       
246
       
+
       
        }

     

       
247
       
 
       


     

       
248
       
+
       
        const symbol = typeChecker?.getSymbolAtLocation(imp.moduleSpecifier);

     

       
249
       
+
       
        if (!symbol) return;

     

       
250
       
 
       


     

       
251
       
+
       
        const moduleExports = typeChecker?.getExportsOfModule(symbol);

     

       
252
       
+
       
        if (!moduleExports) return;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
253
       
 
       


     

       
254
       
+
       
        const missingImports = moduleExports

     

       
255
       
+
       
          .map(exp => {

     

       
256
       
+
       
            if (importedNames.includes(exp.name)) {

     

       
257
       
+
       
              return;

     

       
258
       
+
       
            }

     

       
0
       
 
       

     

       
259
       
 
       


     

       
260
       
+
       
            const declarations = exp.getDeclarations();

     

       
261
       
+
       
            const declaration = declarations?.find(x => {

     

       
262
       
+
       
              // TODO: check whether the sourceFile.fileName resembles the module

     

       
263
       
+
       
              // specifier

     

       
264
       
+
       
              return true;

     

       
265
       
+
       
            });

     

       
266
       
 
       


     

       
267
       
+
       
            if (!declaration) return;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
268
       
 
       


     

       
269
       
+
       
            const [template] = findAllTaggedTemplateNodes(declaration);

     

       
270
       
+
       
            if (template) {

     

       
271
       
+
       
              let node = template;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
272
       
 
       
              if (

     

       
273
       
+
       
                isNoSubstitutionTemplateLiteral(node) ||

     

       
274
       
+
       
                isTemplateExpression(node)

     

       
0
       
 
       

     

       
275
       
 
       
              ) {

     

       
276
       
+
       
                if (isTaggedTemplateExpression(node.parent)) {

     

       
277
       
+
       
                  node = node.parent;

     

       
278
       
+
       
                } else {

     

       
279
       
+
       
                  return;

     

       
280
       
+
       
                }

     

       
281
       
 
       
              }

     

       
282
       
+
       


     

       
283
       
+
       
              const text = resolveTemplate(

     

       
284
       
+
       
                node,

     

       
285
       
+
       
                node.getSourceFile().fileName,

     

       
286
       
+
       
                info

     

       
287
       
+
       
              ).combinedText;

     

       
288
       
+
       
              try {

     

       
289
       
+
       
                const parsed = parse(text, { noLocation: true });

     

       
290
       
+
       
                if (

     

       
291
       
+
       
                  parsed.definitions.every(

     

       
292
       
+
       
                    x => x.kind === Kind.FRAGMENT_DEFINITION

     

       
293
       
+
       
                  )

     

       
294
       
+
       
                ) {

     

       
295
       
+
       
                  return `'${exp.name}'`;

     

       
296
       
+
       
                }

     

       
297
       
+
       
              } catch (e) {

     

       
298
       
+
       
                return;

     

       
299
       
+
       
              }

     

       
300
       
 
       
            }

     

       
301
       
+
       
          })

     

       
302
       
+
       
          .filter(Boolean);

     

       
0
       
 
       

     

       
303
       
 
       


     

       
304
       
+
       
        if (missingImports.length) {

     

       
305
       
+
       
          // TODO: we could use getCodeFixesAtPosition

     

       
306
       
+
       
          // to build on this

     

       
307
       
+
       
          tsDiagnostics.push({

     

       
308
       
+
       
            file: source,

     

       
309
       
+
       
            length: imp.getText().length,

     

       
310
       
+
       
            start: imp.getStart(),

     

       
311
       
+
       
            category: ts.DiagnosticCategory.Message,

     

       
312
       
+
       
            code: MISSING_FRAGMENT_CODE,

     

       
313
       
+
       
            messageText: `Missing Fragment import(s) ${missingImports.join(

     

       
314
       
+
       
              ', '

     

       
315
       
+
       
            )} from ${imp.moduleSpecifier.getText()}.`,

     

       
316
       
+
       
          });

     

       
317
       
+
       
        }

     

       
318
       
+
       
      });

     

       
319
       
+
       
    }

     

       
320
       
+
       


     

       
321
       
+
       
    cache.set(cacheKey, tsDiagnostics);

     

       
322
       
 
       
  }

     

       
323
       
 
       


     

       
324
       
 
       
  if (

     

···

       
25
       
 
       
  shouldTypegen: boolean,

     

       
26
       
 
       
  scalars: Record<string, unknown>,

     

       
27
       
 
       
  extraTypes?: string

     

       
28
       
-
       
): { current: GraphQLSchema | null } => {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
30
       
 
       
  let url: URL | undefined;

     

       
31
       
 
       


     

       
32
       
 
       
  let isJSON = false;

     
···

       
77
       
 
       
            ref.current = buildClientSchema(

     

       
78
       
 
       
              (result as { data: IntrospectionQuery }).data

     

       
79
       
 
       
            );

     

       
0
       
 
       

     

       
80
       
 
       
            logger(`Got schema for ${url!.toString()}`);

     

       
81
       
 
       
            if (shouldTypegen)

     

       
82
       
 
       
              generateBaseTypes(

     
···

       
103
       
 
       
      ref.current = isJson

     

       
104
       
 
       
        ? buildClientSchema(JSON.parse(contents))

     

       
105
       
 
       
        : buildSchema(contents);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
106
       
 
       
      if (shouldTypegen) generateBaseTypes(ref.current, baseTypesPath, scalars);

     

       
107
       
 
       
    });

     

       
108
       
 
       


     

       
109
       
 
       
    ref.current = isJson

     

       
110
       
 
       
      ? buildClientSchema(JSON.parse(contents))

     

       
111
       
 
       
      : buildSchema(contents);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
112
       
 
       
    if (shouldTypegen)

     

       
113
       
 
       
      generateBaseTypes(ref.current, baseTypesPath, scalars, extraTypes);

     

       
114
       
 
       
    logger(`Got schema and initialized watcher for ${schema}`);

     

···

       
25
       
 
       
  shouldTypegen: boolean,

     

       
26
       
 
       
  scalars: Record<string, unknown>,

     

       
27
       
 
       
  extraTypes?: string

     

       
28
       
+
       
): { current: GraphQLSchema | null; version: number } => {

     

       
29
       
+
       
  const ref: { current: GraphQLSchema | null; version: number } = {

     

       
30
       
+
       
    current: null,

     

       
31
       
+
       
    version: 0,

     

       
32
       
+
       
  };

     

       
33
       
 
       
  let url: URL | undefined;

     

       
34
       
 
       


     

       
35
       
 
       
  let isJSON = false;

     
···

       
80
       
 
       
            ref.current = buildClientSchema(

     

       
81
       
 
       
              (result as { data: IntrospectionQuery }).data

     

       
82
       
 
       
            );

     

       
83
       
+
       
            ref.version = ref.version + 1;

     

       
84
       
 
       
            logger(`Got schema for ${url!.toString()}`);

     

       
85
       
 
       
            if (shouldTypegen)

     

       
86
       
 
       
              generateBaseTypes(

     
···

       
107
       
 
       
      ref.current = isJson

     

       
108
       
 
       
        ? buildClientSchema(JSON.parse(contents))

     

       
109
       
 
       
        : buildSchema(contents);

     

       
110
       
+
       
      ref.version = ref.version + 1;

     

       
111
       
+
       


     

       
112
       
 
       
      if (shouldTypegen) generateBaseTypes(ref.current, baseTypesPath, scalars);

     

       
113
       
 
       
    });

     

       
114
       
 
       


     

       
115
       
 
       
    ref.current = isJson

     

       
116
       
 
       
      ? buildClientSchema(JSON.parse(contents))

     

       
117
       
 
       
      : buildSchema(contents);

     

       
118
       
+
       
    ref.version = ref.version + 1;

     

       
119
       
+
       


     

       
120
       
 
       
    if (shouldTypegen)

     

       
121
       
 
       
      generateBaseTypes(ref.current, baseTypesPath, scalars, extraTypes);

     

       
122
       
 
       
    logger(`Got schema and initialized watcher for ${schema}`);

     

···

       
84
       
 
       
      '@graphql-typed-document-node/core':

     

       
85
       
 
       
        specifier: ^3.2.0

     

       
86
       
 
       
        version: 3.2.0(graphql@16.6.0)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
87
       
 
       
      graphql-language-service:

     

       
88
       
 
       
        specifier: ^5.1.7

     

       
89
       
 
       
        version: 5.1.7(graphql@16.6.0)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
90
       
 
       
      node-fetch:

     

       
91
       
 
       
        specifier: ^2.0.0

     

       
92
       
 
       
        version: 2.6.7

     
···

       
1354
       
 
       
      rollup: 3.20.2

     

       
1355
       
 
       
    dev: true

     

       
1356
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1357
       
 
       
  /@types/chai-subset@1.3.3:

     

       
1358
       
 
       
    resolution: {integrity: sha512-frBecisrNGz+F4T6bcc+NLeolfiojh5FxW2klu669+8BARtyQv2C/GkNW6FUodVe4BroGMP/wER/YDGc7rEllw==}

     

       
1359
       
 
       
    dependencies:

     
···

       
2927
       
 
       
    dependencies:

     

       
2928
       
 
       
      tslib: 2.5.0

     

       
2929
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2930
       
 
       
  /lru-cache@4.1.5:

     

       
2931
       
 
       
    resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==}

     

       
2932
       
 
       
    dependencies:

     
···

       
4327
       
 
       
      '@graphql-codegen/typescript': 4.0.1(graphql@16.6.0)

     

       
4328
       
 
       
      '@graphql-codegen/typescript-operations': 4.0.1(graphql@16.6.0)

     

       
4329
       
 
       
      '@graphql-typed-document-node/core': 3.2.0(graphql@16.6.0)

     

       
0
       
 
       

     

       
4330
       
 
       
      graphql-language-service: 5.1.7(graphql@16.6.0)

     

       
0
       
 
       

     

       
4331
       
 
       
      node-fetch: 2.6.7

     

       
4332
       
 
       
    transitivePeerDependencies:

     

       
4333
       
 
       
      - encoding

     

···

       
84
       
 
       
      '@graphql-typed-document-node/core':

     

       
85
       
 
       
        specifier: ^3.2.0

     

       
86
       
 
       
        version: 3.2.0(graphql@16.6.0)

     

       
87
       
+
       
      '@sindresorhus/fnv1a':

     

       
88
       
+
       
        specifier: ^2.0.0

     

       
89
       
+
       
        version: 2.0.0

     

       
90
       
 
       
      graphql-language-service:

     

       
91
       
 
       
        specifier: ^5.1.7

     

       
92
       
 
       
        version: 5.1.7(graphql@16.6.0)

     

       
93
       
+
       
      lru-cache:

     

       
94
       
+
       
        specifier: ^10.0.1

     

       
95
       
+
       
        version: 10.0.1

     

       
96
       
 
       
      node-fetch:

     

       
97
       
 
       
        specifier: ^2.0.0

     

       
98
       
 
       
        version: 2.6.7

     
···

       
1360
       
 
       
      rollup: 3.20.2

     

       
1361
       
 
       
    dev: true

     

       
1362
       
 
       


     

       
1363
       
+
       
  /@sindresorhus/fnv1a@2.0.0:

     

       
1364
       
+
       
    resolution: {integrity: sha512-HAK3TQvR1AbJ4uMFBp9K0V+jlujsHkCokWJRebQK1mlXBG+i7Q5/Y7AKRmqVPt4T78Uqp2U5fFHgK3gxi4OUqw==}

     

       
1365
       
+
       
    engines: {node: '>=10'}

     

       
1366
       
+
       
    dev: false

     

       
1367
       
+
       


     

       
1368
       
+
       
  /@sindresorhus/fnv1a@2.0.1:

     

       
1369
       
+
       
    resolution: {integrity: sha512-suq9tRQ6bkpMukTG5K5z0sPWB7t0zExMzZCdmYm6xTSSIm/yCKNm7VCL36wVeyTsFr597/UhU1OAYdHGMDiHrw==}

     

       
1370
       
+
       
    engines: {node: '>=10'}

     

       
1371
       
+
       
    dev: true

     

       
1372
       
+
       


     

       
1373
       
 
       
  /@types/chai-subset@1.3.3:

     

       
1374
       
 
       
    resolution: {integrity: sha512-frBecisrNGz+F4T6bcc+NLeolfiojh5FxW2klu669+8BARtyQv2C/GkNW6FUodVe4BroGMP/wER/YDGc7rEllw==}

     

       
1375
       
 
       
    dependencies:

     
···

       
2943
       
 
       
    dependencies:

     

       
2944
       
 
       
      tslib: 2.5.0

     

       
2945
       
 
       


     

       
2946
       
+
       
  /lru-cache@10.0.1:

     

       
2947
       
+
       
    resolution: {integrity: sha512-IJ4uwUTi2qCccrioU6g9g/5rvvVl13bsdczUUcqbciD9iLr095yj8DQKdObriEvuNSx325N1rV1O0sJFszx75g==}

     

       
2948
       
+
       
    engines: {node: 14 || >=16.14}

     

       
2949
       
+
       


     

       
2950
       
 
       
  /lru-cache@4.1.5:

     

       
2951
       
 
       
    resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==}

     

       
2952
       
 
       
    dependencies:

     
···

       
4347
       
 
       
      '@graphql-codegen/typescript': 4.0.1(graphql@16.6.0)

     

       
4348
       
 
       
      '@graphql-codegen/typescript-operations': 4.0.1(graphql@16.6.0)

     

       
4349
       
 
       
      '@graphql-typed-document-node/core': 3.2.0(graphql@16.6.0)

     

       
4350
       
+
       
      '@sindresorhus/fnv1a': 2.0.1

     

       
4351
       
 
       
      graphql-language-service: 5.1.7(graphql@16.6.0)

     

       
4352
       
+
       
      lru-cache: 10.0.1

     

       
4353
       
 
       
      node-fetch: 2.6.7

     

       
4354
       
 
       
    transitivePeerDependencies:

     

       
4355
       
 
       
      - encoding