fix a few more things related to type cacheing

Author: acao

packages/graphql-language-service-server/src/GraphQLCache.ts

@@ -433,11 +433,11 @@ export class GraphQLCache implements GraphQLCacheInterface {
   };
 
   async updateFragmentDefinition(
-    rootDir: Uri,
+    projectCacheKey: Uri,
     filePath: Uri,
     contents: Array<CachedContent>,
   ): Promise<void> {
-    const cache = this._fragmentDefinitionsCache.get(rootDir);
+    const cache = this._fragmentDefinitionsCache.get(projectCacheKey);
     const asts = contents.map(({ query }) => {
       try {
         return {
@@ -455,29 +455,44 @@ export class GraphQLCache implements GraphQLCacheInterface {
           cache.delete(key);
         }
       }
-      for (const { ast, query } of asts) {
-        if (!ast) {
-          continue;
-        }
-        for (const definition of ast.definitions) {
-          if (definition.kind === Kind.FRAGMENT_DEFINITION) {
-            cache.set(definition.name.value, {
-              filePath,
-              content: query,
-              definition,
-            });
-          }
+      this._setFragmentCache(asts, cache, filePath);
+    } else {
+      const newFragmentCache = this._setFragmentCache(
+        asts,
+        new Map(),
+        filePath,
+      );
+      this._fragmentDefinitionsCache.set(projectCacheKey, newFragmentCache);
+    }
+  }
+  _setFragmentCache(
+    asts: { ast: DocumentNode | null; query: string }[],
+    fragmentCache: Map<string, FragmentInfo>,
+    filePath: string | undefined,
+  ) {
+    for (const { ast, query } of asts) {
+      if (!ast) {
+        continue;
+      }
+      for (const definition of ast.definitions) {
+        if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+          fragmentCache.set(definition.name.value, {
+            filePath,
+            content: query,
+            definition,
+          });
         }
       }
     }
+    return fragmentCache;
   }
 
   async updateObjectTypeDefinition(
-    rootDir: Uri,
+    projectCacheKey: Uri,
     filePath: Uri,
     contents: Array<CachedContent>,
   ): Promise<void> {
-    const cache = this._typeDefinitionsCache.get(rootDir);
+    const cache = this._typeDefinitionsCache.get(projectCacheKey);
     const asts = contents.map(({ query }) => {
       try {
         return {
@@ -495,21 +510,32 @@ export class GraphQLCache implements GraphQLCacheInterface {
           cache.delete(key);
         }
       }
-      for (const { ast, query } of asts) {
-        if (!ast) {
-          continue;
-        }
-        for (const definition of ast.definitions) {
-          if (isTypeDefinitionNode(definition)) {
-            cache.set(definition.name.value, {
-              filePath,
-              content: query,
-              definition,
-            });
-          }
+      this._setDefinitionCache(asts, cache, filePath);
+    } else {
+      const newTypeCache = this._setDefinitionCache(asts, new Map(), filePath);
+      this._typeDefinitionsCache.set(projectCacheKey, newTypeCache);
+    }
+  }
+  _setDefinitionCache(
+    asts: { ast: DocumentNode | null; query: string }[],
+    typeCache: Map<string, ObjectTypeInfo>,
+    filePath: string | undefined,
+  ) {
+    for (const { ast, query } of asts) {
+      if (!ast) {
+        continue;
+      }
+      for (const definition of ast.definitions) {
+        if (isTypeDefinitionNode(definition)) {
+          typeCache.set(definition.name.value, {
+            filePath,
+            content: query,
+            definition,
+          });
         }
       }
     }
+    return typeCache;
   }
 
   _extendSchema(

packages/graphql-language-service-server/src/MessageProcessor.ts

@@ -926,12 +926,18 @@ export class MessageProcessor {
     return Array.from(this._textDocumentCache);
   }
 
-  private async _cacheSchemaText(uri: string, text: string, version: number) {
+  private async _cacheSchemaText(
+    uri: string,
+    text: string,
+    version: number,
+    project?: GraphQLProjectConfig,
+  ) {
     try {
       const contents = this._parser(text, uri);
+      // console.log(uri, contents);
       if (contents.length > 0) {
         await this._invalidateCache({ version, uri }, uri, contents);
-        await this._updateObjectTypeDefinition(uri, contents);
+        await this._updateObjectTypeDefinition(uri, contents, project);
       }
     } catch (err) {
       this._logger.error(String(err));
@@ -1058,10 +1064,10 @@ export class MessageProcessor {
         schemaText = `# This is an automatically generated representation of your schema.\n# Any changes to this file will be overwritten and will not be\n# reflected in the resulting GraphQL schema\n\n${schemaText}`;
 
         const cachedSchemaDoc = this._getCachedDocument(uri);
-
+        this._graphQLCache._schemaMap.set(project.name, schema);
         if (!cachedSchemaDoc) {
           await writeFile(fsPath, schemaText, 'utf8');
-          await this._cacheSchemaText(uri, schemaText, 1);
+          await this._cacheSchemaText(uri, schemaText, 0, project);
         }
         // do we have a change in the getSchema result? if so, update schema cache
         if (cachedSchemaDoc) {
@@ -1070,6 +1076,7 @@ export class MessageProcessor {
             uri,
             schemaText,
             cachedSchemaDoc.version++,
+            project,
           );
         }
       }
@@ -1206,11 +1213,12 @@ export class MessageProcessor {
   private async _updateObjectTypeDefinition(
     uri: Uri,
     contents: CachedContent[],
+    project?: GraphQLProjectConfig,
   ): Promise<void> {
-    const project = await this._graphQLCache.getProjectForFile(uri);
-    if (project) {
-      const cacheKey = this._graphQLCache._cacheKeyForProject(project);
-
+    const resolvedProject =
+      project ?? (await this._graphQLCache.getProjectForFile(uri));
+    if (resolvedProject) {
+      const cacheKey = this._graphQLCache._cacheKeyForProject(resolvedProject);
       await this._graphQLCache.updateObjectTypeDefinition(
         cacheKey,
         uri,

packages/graphql-language-service-server/src/__tests__/MessageProcessor.spec.ts

@@ -6,6 +6,7 @@ import { FileChangeType } from 'vscode-languageserver';
 import { serializeRange } from './__utils__/utils';
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { URI } from 'vscode-uri';
 
 const defaultFiles = [
   ['query.graphql', 'query { bar ...B }'],
@@ -133,8 +134,8 @@ describe('project with simple config and graphql files', () => {
         character: 0,
       },
       end: {
-        line: 0,
-        character: 25,
+        line: 2,
+        character: 1,
       },
     });
     // change the file to make the fragment invalid
@@ -268,5 +269,45 @@ describe('project with simple config and graphql files', () => {
         character: 1,
       },
     });
+
+    // TODO: super weird, the type definition cache isn't built until _after_ the first definitions request (for that file?)...
+    // this may be a bug just on init, or perhaps every definitions request is outdated???
+    // local schema file should be used for definitions
+
+    const typeDefinitions = await project.lsp.handleDefinitionRequest({
+      textDocument: { uri: project.uri('fragments.graphql') },
+      position: { character: 15, line: 0 },
+    });
+
+    // TODO: these should return a type definition from the schema
+    //
+    expect(typeDefinitions[0].uri).toEqual(URI.parse(genSchemaPath).toString());
+
+    expect(serializeRange(typeDefinitions[0].range)).toEqual({
+      start: {
+        line: 10,
+        character: 0,
+      },
+      end: {
+        line: 98,
+        character: 1,
+      },
+    });
+
+    const schemaDefs = await project.lsp.handleDefinitionRequest({
+      textDocument: { uri: URI.parse(genSchemaPath).toString() },
+      position: { character: 20, line: 17 },
+    });
+    expect(schemaDefs[0].uri).toEqual(URI.parse(genSchemaPath).toString());
+    expect(serializeRange(schemaDefs[0].range)).toEqual({
+      start: {
+        line: 100,
+        character: 0,
+      },
+      end: {
+        line: 108,
+        character: 1,
+      },
+    });
   });
 });