···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

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

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Ensure we track usage across all references

     

···

       
8
       
 
       
 * @example

     

       
9
       
 
       
 * ```

     

       
10
       
 
       
 * import { initGraphQLTada } from 'gql.tada';

     

       
11
       
-
       
 * import { introspection } from './introspection';

     

       
12
       
 
       
 *

     

       
13
       
 
       
 * export const graphql = initGraphQLTada<{

     

       
14
       
 
       
 *   introspection: typeof introspection;

     

···

       
8
       
 
       
 * @example

     

       
9
       
 
       
 * ```

     

       
10
       
 
       
 * import { initGraphQLTada } from 'gql.tada';

     

       
11
       
+
       
 * import type { introspection } from './introspection';

     

       
12
       
 
       
 *

     

       
13
       
 
       
 * export const graphql = initGraphQLTada<{

     

       
14
       
 
       
 *   introspection: typeof introspection;

     

···

       
195
       
 
       
    );

     

       
196
       
 
       
    if (!references) return;

     

       
197
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
198
       
 
       
    references.forEach(ref => {

     

       
199
       
 
       
      if (ref.fileName !== source.fileName) return;

     

       
200
       
 
       


     
···

       
209
       
 
       


     

       
210
       
 
       
      if (output.name.getText() === variableDeclaration.name.getText()) return;

     

       
211
       
 
       


     

       
212
       
-
       
      const inProgress: string[] = [];

     

       
213
       
-
       
      const allPaths: string[] = [];

     

       
214
       
-
       
      const allFields: string[] = [];

     

       
215
       
-
       
      const reserved = ['id', '__typename'];

     

       
216
       
-
       
      const fieldToLoc = new Map<string, { start: number; length: number }>();

     

       
217
       
-
       
      // This visitor gets all the leaf-paths in the document

     

       
218
       
-
       
      // as well as all fields that are part of the document

     

       
219
       
-
       
      // We need the leaf-paths to check usage and we need the

     

       
220
       
-
       
      // fields to validate whether an access on a given reference

     

       
221
       
-
       
      // is valid given the current document...

     

       
222
       
-
       
      visit(parse(node.getText().slice(1, -1)), {

     

       
223
       
-
       
        Field: {

     

       
224
       
-
       
          enter: node => {

     

       
225
       
-
       
            if (!reserved.includes(node.name.value)) {

     

       
226
       
-
       
              allFields.push(node.name.value);

     

       
227
       
-
       
            }

     

       
228
       
-
       


     

       
229
       
-
       
            if (!node.selectionSet && !reserved.includes(node.name.value)) {

     

       
230
       
-
       
              let p;

     

       
231
       
-
       
              if (inProgress.length) {

     

       
232
       
-
       
                p = inProgress.join('.') + '.' + node.name.value;

     

       
233
       
-
       
              } else {

     

       
234
       
-
       
                p = node.name.value;

     

       
235
       
-
       
              }

     

       
236
       
-
       
              allPaths.push(p);

     

       
237
       
-
       


     

       
238
       
-
       
              fieldToLoc.set(p, {

     

       
239
       
-
       
                start: node.name.loc!.start,

     

       
240
       
-
       
                length: node.name.loc!.end - node.name.loc!.start,

     

       
241
       
-
       
              });

     

       
242
       
-
       
            } else if (node.selectionSet) {

     

       
243
       
-
       
              inProgress.push(node.name.value);

     

       
244
       
-
       
            }

     

       
245
       
-
       
          },

     

       
246
       
-
       
          leave: node => {

     

       
247
       
-
       
            if (node.selectionSet) {

     

       
248
       
-
       
              inProgress.pop();

     

       
249
       
-
       
            }

     

       
250
       
-
       
          },

     

       
251
       
-
       
        },

     

       
252
       
-
       
      });

     

       
253
       
-
       


     

       
254
       
 
       
      let temp = output.name;

     

       
255
       
 
       
      // Supported cases:

     

       
256
       
 
       
      // - const result = await client.query() || useFragment()

     
···

       
266
       
 
       
        temp = temp.elements[0].name;

     

       
267
       
 
       
      }

     

       
268
       
 
       


     

       
269
       
-
       
      let allAccess: string[] = [];

     

       
270
       
 
       
      if (ts.isObjectBindingPattern(temp)) {

     

       
271
       
-
       
        allAccess = traverseDestructuring(temp, [], allFields, source, info);

     

       
0
       
 
       

     

       
272
       
 
       
      } else {

     

       
273
       
-
       
        allAccess = crawlScope(temp, [], allFields, source, info);

     

       
0
       
 
       

     

       
274
       
 
       
      }

     

       
0
       
 
       

     

       
275
       
 
       


     

       
276
       
-
       
      const unused = allPaths.filter(x => !allAccess.includes(x));

     

       
277
       
-
       
      unused.forEach(unusedField => {

     

       
278
       
-
       
        const loc = fieldToLoc.get(unusedField);

     

       
279
       
-
       
        if (!loc) return;

     

       
0
       
 
       

     

       
280
       
 
       


     

       
281
       
-
       
        diagnostics.push({

     

       
282
       
-
       
          file: source,

     

       
283
       
-
       
          length: loc.length,

     

       
284
       
-
       
          start: node.getStart() + loc.start + 1,

     

       
285
       
-
       
          category: ts.DiagnosticCategory.Warning,

     

       
286
       
-
       
          code: UNUSED_FIELD_CODE,

     

       
287
       
-
       
          messageText: `Field '${unusedField}' is not used.`,

     

       
288
       
-
       
        });

     

       
289
       
 
       
      });

     

       
290
       
 
       
    });

     

       
291
       
 
       
  });

     

···

       
195
       
 
       
    );

     

       
196
       
 
       
    if (!references) return;

     

       
197
       
 
       


     

       
198
       
+
       
    const allAccess: string[] = [];

     

       
199
       
+
       
    const inProgress: string[] = [];

     

       
200
       
+
       
    const allPaths: string[] = [];

     

       
201
       
+
       
    const allFields: string[] = [];

     

       
202
       
+
       
    const reserved = ['id', '__typename'];

     

       
203
       
+
       
    const fieldToLoc = new Map<string, { start: number; length: number }>();

     

       
204
       
+
       
    // This visitor gets all the leaf-paths in the document

     

       
205
       
+
       
    // as well as all fields that are part of the document

     

       
206
       
+
       
    // We need the leaf-paths to check usage and we need the

     

       
207
       
+
       
    // fields to validate whether an access on a given reference

     

       
208
       
+
       
    // is valid given the current document...

     

       
209
       
+
       
    visit(parse(node.getText().slice(1, -1)), {

     

       
210
       
+
       
      Field: {

     

       
211
       
+
       
        enter: node => {

     

       
212
       
+
       
          if (!reserved.includes(node.name.value)) {

     

       
213
       
+
       
            allFields.push(node.name.value);

     

       
214
       
+
       
          }

     

       
215
       
+
       


     

       
216
       
+
       
          if (!node.selectionSet && !reserved.includes(node.name.value)) {

     

       
217
       
+
       
            let p;

     

       
218
       
+
       
            if (inProgress.length) {

     

       
219
       
+
       
              p = inProgress.join('.') + '.' + node.name.value;

     

       
220
       
+
       
            } else {

     

       
221
       
+
       
              p = node.name.value;

     

       
222
       
+
       
            }

     

       
223
       
+
       
            allPaths.push(p);

     

       
224
       
+
       


     

       
225
       
+
       
            fieldToLoc.set(p, {

     

       
226
       
+
       
              start: node.name.loc!.start,

     

       
227
       
+
       
              length: node.name.loc!.end - node.name.loc!.start,

     

       
228
       
+
       
            });

     

       
229
       
+
       
          } else if (node.selectionSet) {

     

       
230
       
+
       
            inProgress.push(node.name.value);

     

       
231
       
+
       
          }

     

       
232
       
+
       
        },

     

       
233
       
+
       
        leave: node => {

     

       
234
       
+
       
          if (node.selectionSet) {

     

       
235
       
+
       
            inProgress.pop();

     

       
236
       
+
       
          }

     

       
237
       
+
       
        },

     

       
238
       
+
       
      },

     

       
239
       
+
       
    });

     

       
240
       
+
       


     

       
241
       
 
       
    references.forEach(ref => {

     

       
242
       
 
       
      if (ref.fileName !== source.fileName) return;

     

       
243
       
 
       


     
···

       
252
       
 
       


     

       
253
       
 
       
      if (output.name.getText() === variableDeclaration.name.getText()) return;

     

       
254
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
255
       
 
       
      let temp = output.name;

     

       
256
       
 
       
      // Supported cases:

     

       
257
       
 
       
      // - const result = await client.query() || useFragment()

     
···

       
267
       
 
       
        temp = temp.elements[0].name;

     

       
268
       
 
       
      }

     

       
269
       
 
       


     

       
0
       
 
       

     

       
270
       
 
       
      if (ts.isObjectBindingPattern(temp)) {

     

       
271
       
+
       
        const result = traverseDestructuring(temp, [], allFields, source, info);

     

       
272
       
+
       
        allAccess.push(...result);

     

       
273
       
 
       
      } else {

     

       
274
       
+
       
        const result = crawlScope(temp, [], allFields, source, info);

     

       
275
       
+
       
        allAccess.push(...result);

     

       
276
       
 
       
      }

     

       
277
       
+
       
    });

     

       
278
       
 
       


     

       
279
       
+
       
    const unused = allPaths.filter(x => !allAccess.includes(x));

     

       
280
       
+
       


     

       
281
       
+
       
    unused.forEach(unusedField => {

     

       
282
       
+
       
      const loc = fieldToLoc.get(unusedField);

     

       
283
       
+
       
      if (!loc) return;

     

       
284
       
 
       


     

       
285
       
+
       
      diagnostics.push({

     

       
286
       
+
       
        file: source,

     

       
287
       
+
       
        length: loc.length,

     

       
288
       
+
       
        start: node.getStart() + loc.start + 1,

     

       
289
       
+
       
        category: ts.DiagnosticCategory.Warning,

     

       
290
       
+
       
        code: UNUSED_FIELD_CODE,

     

       
291
       
+
       
        messageText: `Field '${unusedField}' is not used.`,

     

       
0
       
 
       

     

       
292
       
 
       
      });

     

       
293
       
 
       
    });

     

       
294
       
 
       
  });

     

···

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

     

       
6
       
 
       
        "schema": "./schema.graphql",

     

       
7
       
 
       
        "disableTypegen": true,

     

       
8
       
-
       
        "shouldCheckForColocatedFragments": true

     

       
9
       
 
       
      }

     

       
10
       
 
       
    ],

     

       
11
       
 
       
    "target": "es2016",

     

···

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

     

       
6
       
 
       
        "schema": "./schema.graphql",

     

       
7
       
 
       
        "disableTypegen": true,

     

       
8
       
+
       
        "trackFieldUsage": false

     

       
9
       
 
       
      }

     

       
10
       
 
       
    ],

     

       
11
       
 
       
    "target": "es2016",