vscode-apollo 2.0.1 → 2.2.0

package/src/language-server/workspace.ts

@@ -2,6 +2,7 @@ import {
   WorkspaceFolder,
   NotificationHandler,
   PublishDiagnosticsParams,
+  ClientCapabilities,
 } from "vscode-languageserver/node";
 import { QuickPickItem } from "vscode";
 import { GraphQLProject, DocumentUri } from "./project/base";
@@ -15,6 +16,8 @@ import { URI } from "vscode-uri";
 import { Debug } from "./utilities";
 import type { EngineDecoration } from "../messages";
 import { equal } from "@wry/equality";
+import { isRoverConfig, RoverProject } from "./project/rover/project";
+import { VSCodeConnection } from "./server";
 
 export interface WorkspaceConfig {
   clientIdentity: ClientIdentity;
@@ -26,12 +29,14 @@ export class GraphQLWorkspace {
   private _onSchemaTags?: NotificationHandler<[ServiceID, SchemaTag[]]>;
   private _onConfigFilesFound?: NotificationHandler<(ApolloConfig | Error)[]>;
   private _projectForFileCache: Map<string, GraphQLProject> = new Map();
+  public capabilities?: ClientCapabilities;
 
   private projectsByFolderUri: Map<string, GraphQLProject[]> = new Map();
 
   constructor(
     private LanguageServerLoadingHandler: LanguageServerLoadingHandler,
     private config: WorkspaceConfig,
+    private whenConnectionInitialized: Promise<VSCodeConnection>,
   ) {}
 
   onDiagnostics(handler: NotificationHandler<PublishDiagnosticsParams>) {
@@ -65,8 +70,15 @@ export class GraphQLWorkspace {
           configFolderURI: URI.parse(folder.uri),
           clientIdentity,
         })
+      : isRoverConfig(config)
+      ? new RoverProject({
+          config,
+          loadingHandler: this.LanguageServerLoadingHandler,
+          configFolderURI: URI.parse(folder.uri),
+          capabilities: this.capabilities!, // TODO?
+        })
       : (() => {
-          throw new Error("TODO rover project");
+          throw new Error("Impossible config!");
         })();
 
     project.onDiagnostics((params) => {
@@ -86,8 +98,13 @@ export class GraphQLWorkspace {
     // after a project has loaded, we do an initial validation to surface errors
     // on the start of the language server. Instead of doing this in the
     // base class which is used by codegen and other tools
-    project.whenReady.then(() => project.validate());
+    project.whenReady.then(() => project.validate?.());
 
+    if (project.onVSCodeConnectionInitialized) {
+      this.whenConnectionInitialized.then(
+        project.onVSCodeConnectionInitialized.bind(project),
+      );
+    }
     return project;
   }
 
@@ -157,12 +174,24 @@ export class GraphQLWorkspace {
     this.projectsByFolderUri.forEach((projects, uri) => {
       this.projectsByFolderUri.set(
         uri,
-        projects.map((project) => {
-          project.clearAllDiagnostics();
-          return this.createProject({
-            config: project.config,
-            folder: { uri } as WorkspaceFolder,
-          });
+        projects.map((oldProject) => {
+          oldProject.clearAllDiagnostics();
+
+          try {
+            const newProject = this.createProject({
+              config: oldProject.config,
+              folder: { uri } as WorkspaceFolder,
+            });
+            if (
+              oldProject instanceof RoverProject &&
+              newProject instanceof RoverProject
+            ) {
+              newProject.restoreFromPreviousProject(oldProject);
+            }
+            return newProject;
+          } finally {
+            oldProject.dispose?.();
+          }
         }),
       );
     });
@@ -179,7 +208,7 @@ export class GraphQLWorkspace {
       error = e;
     }
 
-    const project = this.projectForFile(configUri);
+    const project = this.projectForConfigFile(configUri);
 
     if (this._onConfigFilesFound) {
       this._onConfigFilesFound([config || error]);
@@ -227,7 +256,10 @@ export class GraphQLWorkspace {
   removeProjectsInFolder(folder: WorkspaceFolder) {
     const projects = this.projectsByFolderUri.get(folder.uri);
     if (projects) {
-      projects.forEach((project) => project.clearAllDiagnostics());
+      projects.forEach((project) => {
+        project.clearAllDiagnostics();
+        project.dispose?.();
+      });
       this.projectsByFolderUri.delete(folder.uri);
     }
   }
@@ -236,14 +268,31 @@ export class GraphQLWorkspace {
     return Array.from(this.projectsByFolderUri.values()).flat();
   }
 
-  projectForFile(uri: DocumentUri): GraphQLProject | undefined {
+  projectForConfigFile(configUri: DocumentUri): GraphQLProject | undefined {
+    for (const projects of this.projectsByFolderUri.values()) {
+      const project = projects.find((project) =>
+        project.isConfiguredBy(configUri),
+      );
+      if (project) {
+        return project;
+      }
+    }
+    return undefined;
+  }
+
+  projectForFile(
+    uri: DocumentUri,
+    languageId?: string,
+  ): GraphQLProject | undefined {
     const cachedResult = this._projectForFileCache.get(uri);
     if (cachedResult) {
       return cachedResult;
     }
 
     for (const projects of this.projectsByFolderUri.values()) {
-      const project = projects.find((project) => project.includesFile(uri));
+      const project = projects.find((project) =>
+        project.includesFile(uri, languageId),
+      );
       if (project) {
         this._projectForFileCache.set(uri, project);
         return project;

package/src/languageServerClient.ts

@@ -6,9 +6,17 @@ import {
   RevealOutputChannelOn,
 } from "vscode-languageclient/node";
 import { workspace, OutputChannel } from "vscode";
+import { supportedLanguageIds } from "./tools/utilities/languageInformation";
+import type { InitializationOptions } from "./language-server/server";
+import { getLangugageInformation } from "./tools/utilities/getLanguageInformation";
 
 const { version, referenceID } = require("../package.json");
 
+const languageIdExtensionMap = getLangugageInformation();
+const supportedExtensions = supportedLanguageIds.flatMap(
+  (id) => languageIdExtensionMap[id],
+);
+
 export function getLanguageServerClient(
   serverModule: string,
   outputChannel: OutputChannel,
@@ -41,25 +49,12 @@ export function getLanguageServerClient(
   };
 
   const clientOptions: LanguageClientOptions = {
-    documentSelector: [
-      "graphql",
-      "javascript",
-      "typescript",
-      "javascriptreact",
-      "typescriptreact",
-      "vue",
-      "svelte",
-      "python",
-      "ruby",
-      "dart",
-      "reason",
-      "elixir",
-    ],
+    documentSelector: supportedLanguageIds,
     synchronize: {
       fileEvents: [
         workspace.createFileSystemWatcher("**/.env?(.local)"),
         workspace.createFileSystemWatcher(
-          "**/*.{graphql,js,ts,cjs,mjs,jsx,tsx,vue,svelte,py,rb,dart,re,ex,exs}",
+          "**/*{" + supportedExtensions.join(",") + "}",
         ),
       ],
     },
@@ -69,6 +64,9 @@ export function getLanguageServerClient(
       .get("debug.revealOutputOnLanguageServerError")
       ? RevealOutputChannelOn.Error
       : RevealOutputChannelOn.Never,
+    initializationOptions: {
+      languageIdExtensionMap,
+    } satisfies InitializationOptions,
   };
 
   return new LanguageClient(

package/src/tools/utilities/getLanguageInformation.ts

@@ -0,0 +1,41 @@
+import * as vscode from "vscode";
+import {
+  LanguageIdExtensionMap,
+  minimumKnownExtensions,
+} from "./languageInformation";
+
+/**
+ * @returns An object with language identifiers as keys and file extensions as values.
+ * see https://github.com/microsoft/vscode/issues/109919
+ */
+export function getLangugageInformation(): LanguageIdExtensionMap {
+  const allKnownExtensions = vscode.extensions.all
+    .map(
+      (i) =>
+        i.packageJSON?.contributes?.languages as (
+          | undefined
+          | {
+              id?: string;
+              extensions?: string[];
+            }
+        )[],
+    )
+    .flat()
+    .filter(
+      (i): i is { id: string; extensions: `.${string}`[] } =>
+        !!(i && i.id && i.extensions?.length),
+    )
+    .reduce<Record<string, Set<`.${string}`>>>(
+      (acc, i) => {
+        if (!acc[i.id]) acc[i.id] = new Set();
+        for (const ext of i.extensions) acc[i.id].add(ext);
+        return acc;
+      },
+      Object.fromEntries(
+        Object.entries(minimumKnownExtensions).map(([k, v]) => [k, new Set(v)]),
+      ),
+    );
+  return Object.fromEntries(
+    Object.entries(allKnownExtensions).map(([k, v]) => [k, [...v]] as const),
+  ) as LanguageIdExtensionMap;
+}

package/src/tools/utilities/languageInformation.ts

@@ -0,0 +1,41 @@
+const _supportedDocumentTypes = [
+  "graphql",
+  "javascript",
+  "typescript",
+  "javascriptreact",
+  "typescriptreact",
+  "vue",
+  "svelte",
+  "python",
+  "ruby",
+  "dart",
+  "reason",
+  "elixir",
+] as const;
+export type SupportedLanguageIds = (typeof _supportedDocumentTypes)[number];
+export const supportedLanguageIds =
+  // remove the `readonly` we get from using `as const`
+  _supportedDocumentTypes as any as SupportedLanguageIds[];
+
+export type FileExtension = `.${string}`;
+
+export const minimumKnownExtensions: Record<
+  SupportedLanguageIds,
+  FileExtension[]
+> = {
+  graphql: [".gql", ".graphql", ".graphqls"],
+  javascript: [".js", ".mjs", ".cjs"],
+  typescript: [".ts", ".mts", ".cts"],
+  javascriptreact: [".jsx"],
+  typescriptreact: [".tsx"],
+  vue: [".vue"],
+  svelte: [".svelte"],
+  python: [".py"],
+  ruby: [".rb"],
+  dart: [".dart"],
+  reason: [".re"],
+  elixir: [".ex", ".exs"],
+};
+
+export type LanguageIdExtensionMap = Record<string, `.${string}`[]> &
+  typeof minimumKnownExtensions;

package/syntaxes/graphql.js.json

@@ -3,43 +3,40 @@
   "injectionSelector": "L:source -string -comment",
   "patterns": [
     {
-      "name": "taggedTemplates",
       "contentName": "meta.embedded.block.graphql",
-      "begin": "(Relay\\.QL|gql|graphql(\\.experimental)?)\\(?(`)",
+      "begin": "(?:Relay\\.QL|gql|graphql(\\.experimental)?)\\s*(?:<.*?>\\s*)?`",
+      "end": "`",
+      "patterns": [{ "include": "source.graphql" }]
+    },
+    {
+      "contentName": "meta.embedded.block.graphql",
+      "begin": "`(\\s*#[ ]*(gql|graphql|GraphQL))",
       "beginCaptures": {
         "1": {
-          "name": "entity.name.function.tagged-template.js"
+          "name": "meta.embedded.block.graphql comment.line.graphql.js"
         },
         "2": {
-          "name": "punctuation.definition.string.template.begin.js"
-        }
-      },
-      "end": "`\\)?",
-      "endCaptures": {
-        "0": {
-          "name": "punctuation.definition.string.template.end.js"
+          "name": "markup.italic"
         }
       },
+      "end": "`",
       "patterns": [{ "include": "source.graphql" }]
     },
     {
-      "name": "taggedTemplates",
       "contentName": "meta.embedded.block.graphql",
-      "begin": "(`)(#graphql)",
+      "begin": "(?:gql|graphql)\\s*(?:<.*?>\\s*)?\\(\\s*`",
+      "end": "`\\s*\\)",
+      "patterns": [{ "include": "source.graphql" }]
+    },
+    {
+      "contentName": "meta.embedded.block.graphql",
+      "begin": "(?:\\/\\*[\\s\\*]*(gql|graphql|GraphQL)\\s*\\*\\/)\\s*(`)",
       "beginCaptures": {
         "1": {
-          "name": "punctuation.definition.string.template.begin.js"
-        },
-        "2": {
-          "name": "comment.line.graphql.js"
+          "name": "markup.italic"
         }
       },
       "end": "`",
-      "endCaptures": {
-        "0": {
-          "name": "punctuation.definition.string.template.end.js"
-        }
-      },
       "patterns": [{ "include": "source.graphql" }]
     }
   ],