fix object field completion, add tests for the missing cases

acao · acao · commit 9b6304c0628b · 2024-03-08T21:44:58.000+01:00
diff --git a/packages/graphql-language-service-server/src/GraphQLCache.ts b/packages/graphql-language-service-server/src/GraphQLCache.ts
@@ -20,7 +20,6 @@ import {
 } from 'graphql';
 import type {
   CachedContent,
-  GraphQLCache as GraphQLCacheInterface,
   GraphQLFileMetadata,
   GraphQLFileInfo,
   FragmentInfo,
@@ -93,7 +92,7 @@ export async function getGraphQLCache({
   });
 }
 
-export class GraphQLCache implements GraphQLCacheInterface {
+export class GraphQLCache {
   _configDir: Uri;
   _graphQLFileListCache: Map<Uri, Map<string, GraphQLFileInfo>>;
   _graphQLConfig: GraphQLConfig;
@@ -596,8 +595,13 @@ export class GraphQLCache implements GraphQLCacheInterface {
     if (schemaPath && schemaKey) {
       schemaCacheKey = schemaKey as string;
 
-      // Read from disk
-      schema = await projectConfig.getSchema();
+      try {
+        // Read from disk
+        schema = await projectConfig.getSchema();
+      } catch {
+        // // if there is an error reading the schema, just use the last valid schema
+        // schema = this._schemaMap.get(schemaCacheKey);
+      }
 
       if (this._schemaMap.has(schemaCacheKey)) {
         schema = this._schemaMap.get(schemaCacheKey);
diff --git a/packages/graphql-language-service-server/src/GraphQLLanguageService.ts b/packages/graphql-language-service-server/src/GraphQLLanguageService.ts
@@ -29,7 +29,6 @@ import {
   IPosition,
   Outline,
   OutlineTree,
-  GraphQLCache,
   getAutocompleteSuggestions,
   getHoverInformation,
   HoverConfig,
@@ -47,6 +46,8 @@ import {
   getTypeInfo,
 } from 'graphql-language-service';
 
+import type { GraphQLCache } from './GraphQLCache';
+
 import { GraphQLConfig, GraphQLProjectConfig } from 'graphql-config';
 
 import type { Logger } from 'vscode-languageserver';
@@ -223,30 +224,31 @@ export class GraphQLLanguageService {
       return [];
     }
     const schema = await this._graphQLCache.getSchema(projectConfig.name);
-    const fragmentDefinitions = await this._graphQLCache.getFragmentDefinitions(
-      projectConfig,
-    );
+    if (!schema) {
+      return [];
+    }
+    let fragmentInfo = [] as Array<FragmentDefinitionNode>;
+    try {
+      const fragmentDefinitions =
+        await this._graphQLCache.getFragmentDefinitions(projectConfig);
+      fragmentInfo = Array.from(fragmentDefinitions).map(
+        ([, info]) => info.definition,
+      );
+    } catch {}
 
-    const fragmentInfo = Array.from(fragmentDefinitions).map(
-      ([, info]) => info.definition,
+    return getAutocompleteSuggestions(
+      schema,
+      query,
+      position,
+      undefined,
+      fragmentInfo,
+      {
+        uri: filePath,
+        fillLeafsOnComplete:
+          projectConfig?.extensions?.languageService?.fillLeafsOnComplete ??
+          false,
+      },
     );
-
-    if (schema) {
-      return getAutocompleteSuggestions(
-        schema,
-        query,
-        position,
-        undefined,
-        fragmentInfo,
-        {
-          uri: filePath,
-          fillLeafsOnComplete:
-            projectConfig?.extensions?.languageService?.fillLeafsOnComplete ??
-            false,
-        },
-      );
-    }
-    return [];
   }
 
   public async getHoverInformation(
diff --git a/packages/graphql-language-service-server/src/MessageProcessor.ts b/packages/graphql-language-service-server/src/MessageProcessor.ts
@@ -474,20 +474,23 @@ export class MessageProcessor {
 
       if (project?.extensions?.languageService?.enableValidation !== false) {
         // Send the diagnostics onChange as well
-        await Promise.all(
-          contents.map(async ({ query, range }) => {
-            const results = await this._languageService.getDiagnostics(
-              query,
-              uri,
-              this._isRelayCompatMode(query),
-            );
-            if (results && results.length > 0) {
-              diagnostics.push(
-                ...processDiagnosticsMessage(results, query, range),
+        try {
+          await Promise.all(
+            contents.map(async ({ query, range }) => {
+              const results = await this._languageService.getDiagnostics(
+                query,
+                uri,
+                this._isRelayCompatMode(query),
               );
-            }
-          }),
-        );
+              if (results && results.length > 0) {
+                diagnostics.push(
+                  ...processDiagnosticsMessage(results, query, range),
+                );
+              }
+              // skip diagnostic errors, usually related to parsing incomplete fragments
+            }),
+          );
+        } catch {}
       }
 
       this._logger.log(
@@ -600,6 +603,7 @@ export class MessageProcessor {
     if (range) {
       position.line -= range.start.line;
     }
+
     const result = await this._languageService.getAutocompleteSuggestions(
       query,
       toPosition(position),
@@ -729,9 +733,8 @@ export class MessageProcessor {
 
               return { uri, diagnostics };
             }
-          } catch (err) {
-            this._handleConfigError({ err, uri });
-          }
+            // skip diagnostics errors usually from incomplete files
+          } catch {}
           return { uri, diagnostics: [] };
         }
         if (change.type === FileChangeTypeKind.Deleted) {
@@ -1191,7 +1194,13 @@ export class MessageProcessor {
         const schemaFilePath = path.resolve(project.dirpath, schema);
         const uriFilePath = URI.parse(uri).fsPath;
         if (uriFilePath === schemaFilePath) {
-          await this._graphQLCache.invalidateSchemaCacheForProject(project);
+          try {
+            const file = await readFile(schemaFilePath, 'utf-8');
+            // only invalidate the schema cache if we can actually parse the file
+            // otherwise, leave the last valid one in place
+            parse(file, { noLocation: true });
+            this._graphQLCache.invalidateSchemaCacheForProject(project);
+          } catch {}
         }
       }),
     );
diff --git a/packages/graphql-language-service-server/src/__tests__/MessageProcessor.spec.ts b/packages/graphql-language-service-server/src/__tests__/MessageProcessor.spec.ts
@@ -483,38 +483,6 @@ describe('project with simple config and graphql files', () => {
       '__schema',
       '__type',
     ]);
-
-    // project.changeFile(
-    //   'b/schema.graphql',
-    //   schemaFile[1] + '\ntype Example1 { field:   }',
-    // );
-    // TODO: this didn't work at all for multi project,
-    // whereas a schema change works above in a single schema context as per updating the cache
-    //
-    // how to register incomplete changes to model autocomplete, etc?
-    // await project.lsp.handleWatchedFilesChangedNotification({
-    //   changes: [
-    //     { uri: project.uri('b/schema.graphql'), type: FileChangeType.Changed },
-    //   ],
-    // });
-    // better - fails on a graphql parsing error! annoying
-    // await project.lsp.handleDidChangeNotification({
-    //   textDocument: { uri: project.uri('b/schema.graphql'), version: 1 },
-    //   contentChanges: [
-    //     { text: schemaFile[1] + '\ntype Example1 { field:   }' },
-    //   ],
-    // });
-
-    // const schemaCompletion = await project.lsp.handleCompletionRequest({
-    //   textDocument: { uri: project.uri('b/schema.graphql') },
-    //   position: { character: 23, line: 3 },
-    // });
-    // expect(schemaCompletion.items.map(i => i.label)).toEqual([
-    //   'foo',
-    //   '__typename',
-    //   '__schema',
-    //   '__type',
-    // ]);
     // this confirms that autocomplete respects cross-project boundaries for types.
     // it performs a definition request for the foo field in Query
     const schemaCompletion1 = await project.lsp.handleCompletionRequest({
@@ -529,6 +497,39 @@ describe('project with simple config and graphql files', () => {
     });
     expect(serializeRange(schemaDefinition[0].range)).toEqual(fooTypePosition);
 
+    // simulate a watched schema file change (codegen, etc)
+    project.changeFile(
+      'b/schema.graphql',
+      schemaFile[1] + '\ntype Example1 { field:    }',
+    );
+    await project.lsp.handleWatchedFilesChangedNotification({
+      changes: [
+        { uri: project.uri('b/schema.graphql'), type: FileChangeType.Changed },
+      ],
+    });
+    // TODO: repeat this with other changes to the schema file and use a
+    // didChange event to see if the schema updates properly as well
+    // await project.lsp.handleDidChangeNotification({
+    //   textDocument: { uri: project.uri('b/schema.graphql'), version: 1 },
+    //   contentChanges: [
+    //     { text: schemaFile[1] + '\ntype Example1 { field:    }' },
+    //   ],
+    // });
+    // console.log(project.fileCache.get('b/schema.graphql'));
+    const schemaCompletion = await project.lsp.handleCompletionRequest({
+      textDocument: { uri: project.uri('b/schema.graphql') },
+      position: { character: 25, line: 5 },
+    });
+    // TODO: SDL completion still feels incomplete here... where is Int?
+    // where is self-referential Example1?
+    expect(schemaCompletion.items.map(i => i.label)).toEqual([
+      'Query',
+      'Foo',
+      'String',
+      'Test',
+      'Boolean',
+    ]);
+
     expect(project.lsp._logger.error).not.toHaveBeenCalled();
   });
 });
diff --git a/packages/graphql-language-service/src/interface/__tests__/getAutocompleteSuggestions-test.ts b/packages/graphql-language-service/src/interface/__tests__/getAutocompleteSuggestions-test.ts
@@ -607,6 +607,39 @@ describe('getAutocompleteSuggestions', () => {
         { label: 'TestType' },
         { label: 'TestUnion' },
       ]));
+    // TODO: shouldn't TestType and TestUnion be available here?
+    it('provides correct filtered suggestions on object fields in regular SDL files', () =>
+      expect(
+        testSuggestions('type Type {\n  aField: s', new Position(0, 23), [], {
+          uri: 'schema.graphql',
+        }),
+      ).toEqual([
+        { label: 'Episode' },
+        { label: 'String' },
+        { label: 'TestInterface' },
+        { label: 'TestType' },
+        { label: 'TestUnion' },
+      ]));
+    it('provides correct unfiltered suggestions on object fields in regular SDL files', () =>
+      expect(
+        testSuggestions('type Type {\n  aField: ', new Position(0, 22), [], {
+          uri: 'schema.graphql',
+        }),
+      ).toEqual([
+        { label: 'AnotherInterface' },
+        { label: 'Boolean' },
+        { label: 'Character' },
+        { label: 'Droid' },
+        { label: 'Episode' },
+        { label: 'Human' },
+        { label: 'Int' },
+        // TODO: maybe filter out types attached to top level schema?
+        { label: 'Query' },
+        { label: 'String' },
+        { label: 'TestInterface' },
+        { label: 'TestType' },
+        { label: 'TestUnion' },
+      ]));
     it('provides correct suggestions on object fields that are arrays', () =>
       expect(
         testSuggestions('type Type {\n  aField: []', new Position(0, 25), [], {
@@ -626,6 +659,25 @@ describe('getAutocompleteSuggestions', () => {
         { label: 'TestType' },
         { label: 'TestUnion' },
       ]));
+    it('provides correct suggestions on object fields that are arrays in SDL context', () =>
+      expect(
+        testSuggestions('type Type {\n  aField: []', new Position(0, 25), [], {
+          uri: 'schema.graphql',
+        }),
+      ).toEqual([
+        { label: 'AnotherInterface' },
+        { label: 'Boolean' },
+        { label: 'Character' },
+        { label: 'Droid' },
+        { label: 'Episode' },
+        { label: 'Human' },
+        { label: 'Int' },
+        { label: 'Query' },
+        { label: 'String' },
+        { label: 'TestInterface' },
+        { label: 'TestType' },
+        { label: 'TestUnion' },
+      ]));
     it('provides correct suggestions on input object fields', () =>
       expect(
         testSuggestions('input Type {\n  aField: s', new Position(0, 23), [], {
diff --git a/packages/graphql-language-service/src/interface/getAutocompleteSuggestions.ts b/packages/graphql-language-service/src/interface/getAutocompleteSuggestions.ts
@@ -399,34 +399,27 @@ export function getAutocompleteSuggestions(
 
   const unwrappedState = unwrapType(state);
 
-  if (
-    (mode === GraphQLDocumentMode.TYPE_SYSTEM &&
-      !unwrappedState.needsAdvance &&
-      kind === RuleKinds.NAMED_TYPE) ||
-    kind === RuleKinds.LIST_TYPE
-  ) {
-    if (unwrappedState.kind === RuleKinds.FIELD_DEF) {
-      return hintList(
-        token,
-        Object.values(schema.getTypeMap())
-          .filter(type => isOutputType(type) && !type.name.startsWith('__'))
-          .map(type => ({
-            label: type.name,
-            kind: CompletionItemKind.Function,
-          })),
-      );
-    }
-    if (unwrappedState.kind === RuleKinds.INPUT_VALUE_DEF) {
-      return hintList(
-        token,
-        Object.values(schema.getTypeMap())
-          .filter(type => isInputType(type) && !type.name.startsWith('__'))
-          .map(type => ({
-            label: type.name,
-            kind: CompletionItemKind.Function,
-          })),
-      );
-    }
+  if (unwrappedState.kind === RuleKinds.FIELD_DEF) {
+    return hintList(
+      token,
+      Object.values(schema.getTypeMap())
+        .filter(type => isOutputType(type) && !type.name.startsWith('__'))
+        .map(type => ({
+          label: type.name,
+          kind: CompletionItemKind.Function,
+        })),
+    );
+  }
+  if (unwrappedState.kind === RuleKinds.INPUT_VALUE_DEF) {
+    return hintList(
+      token,
+      Object.values(schema.getTypeMap())
+        .filter(type => isInputType(type) && !type.name.startsWith('__'))
+        .map(type => ({
+          label: type.name,
+          kind: CompletionItemKind.Function,
+        })),
+    );
   }
 
   // Variable definition types
