vscode-apollo 2.1.0 → 2.2.1

package/src/language-server/server.ts

@@ -4,7 +4,6 @@ import {
   ProposedFeatures,
   TextDocuments,
   FileChangeType,
-  ServerCapabilities,
   TextDocumentSyncKind,
   SymbolInformation,
   FileEvent,
@@ -21,10 +20,16 @@ import {
   LanguageServerRequests as Requests,
 } from "../messages";
 import { isValidationError } from "zod-validation-error";
-import { Trie } from "@wry/trie";
 import { GraphQLProject } from "./project/base";
+import type { LanguageIdExtensionMap } from "../tools/utilities/languageInformation";
+import { setLanguageIdExtensionMap } from "./utilities/languageIdForExtension";
+
+export type InitializationOptions = {
+  languageIdExtensionMap: LanguageIdExtensionMap;
+};
 
 const connection = createConnection(ProposedFeatures.all);
+export type VSCodeConnection = typeof connection;
 
 Debug.SetConnection(connection);
 const { sendNotification: originalSendNotification } = connection;
@@ -37,8 +42,8 @@ connection.sendNotification = async (...args: [any, ...any[]]) => {
 let hasWorkspaceFolderCapability = false;
 
 // Awaitable promise for sending messages before the connection is initialized
-let initializeConnection: () => void;
-const whenConnectionInitialized: Promise<void> = new Promise(
+let initializeConnection: (c: typeof connection) => void;
+const whenConnectionInitialized: Promise<typeof connection> = new Promise(
   (resolve) => (initializeConnection = resolve),
 );
 
@@ -55,6 +60,7 @@ const workspace = new GraphQLWorkspace(
         require("../../package.json").version,
     },
   },
+  whenConnectionInitialized,
 );
 
 workspace.onDiagnostics((params) => {
@@ -84,46 +90,52 @@ workspace.onConfigFilesFound(async (params) => {
   );
 });
 
-connection.onInitialize(async ({ capabilities, workspaceFolders }) => {
-  hasWorkspaceFolderCapability = !!(
-    capabilities.workspace && capabilities.workspace.workspaceFolders
-  );
-  workspace.capabilities = capabilities;
-
-  if (workspaceFolders) {
-    // We wait until all projects are added, because after `initialize` returns we can get additional requests
-    // like `textDocument/codeLens`, and that way these can await `GraphQLProject#whenReady` to make sure
-    // we provide them eventually.
-    await Promise.all(
-      workspaceFolders.map((folder) => workspace.addProjectsInFolder(folder)),
+connection.onInitialize(
+  async ({ capabilities, workspaceFolders, initializationOptions }) => {
+    const { languageIdExtensionMap } =
+      initializationOptions as InitializationOptions;
+    setLanguageIdExtensionMap(languageIdExtensionMap);
+
+    hasWorkspaceFolderCapability = !!(
+      capabilities.workspace && capabilities.workspace.workspaceFolders
     );
-  }
+    workspace.capabilities = capabilities;
+
+    if (workspaceFolders) {
+      // We wait until all projects are added, because after `initialize` returns we can get additional requests
+      // like `textDocument/codeLens`, and that way these can await `GraphQLProject#whenReady` to make sure
+      // we provide them eventually.
+      await Promise.all(
+        workspaceFolders.map((folder) => workspace.addProjectsInFolder(folder)),
+      );
+    }
 
-  return {
-    capabilities: {
-      hoverProvider: true,
-      completionProvider: {
-        resolveProvider: false,
-        triggerCharacters: ["...", "@"],
-      },
-      definitionProvider: true,
-      referencesProvider: true,
-      documentSymbolProvider: true,
-      workspaceSymbolProvider: true,
-      codeLensProvider: {
-        resolveProvider: false,
+    return {
+      capabilities: {
+        hoverProvider: true,
+        completionProvider: {
+          resolveProvider: false,
+          triggerCharacters: ["...", "@"],
+        },
+        definitionProvider: true,
+        referencesProvider: true,
+        documentSymbolProvider: true,
+        workspaceSymbolProvider: true,
+        codeLensProvider: {
+          resolveProvider: false,
+        },
+        codeActionProvider: true,
+        executeCommandProvider: {
+          commands: [],
+        },
+        textDocumentSync: TextDocumentSyncKind.Full,
       },
-      codeActionProvider: true,
-      executeCommandProvider: {
-        commands: [],
-      },
-      textDocumentSync: TextDocumentSyncKind.Full,
-    } as ServerCapabilities,
-  };
-});
+    };
+  },
+);
 
 connection.onInitialized(async () => {
-  initializeConnection();
+  initializeConnection(connection);
   if (hasWorkspaceFolderCapability) {
     connection.workspace.onDidChangeWorkspaceFolders(async (event) => {
       await Promise.all([
@@ -147,7 +159,10 @@ function isFile(uri: string) {
 }
 
 documents.onDidChangeContent((params) => {
-  const project = workspace.projectForFile(params.document.uri);
+  const project = workspace.projectForFile(
+    params.document.uri,
+    params.document.languageId,
+  );
   if (!project) return;
 
   // Only watch changes to files
@@ -160,12 +175,16 @@ documents.onDidChangeContent((params) => {
 
 documents.onDidOpen(
   (params) =>
-    workspace.projectForFile(params.document.uri)?.onDidOpen?.(params),
+    workspace
+      .projectForFile(params.document.uri, params.document.languageId)
+      ?.onDidOpen?.(params),
 );
 
 documents.onDidClose(
   (params) =>
-    workspace.projectForFile(params.document.uri)?.onDidClose?.(params),
+    workspace
+      .projectForFile(params.document.uri, params.document.languageId)
+      ?.onDidClose?.(params),
 );
 
 connection.onDidChangeWatchedFiles((params) => {
@@ -246,28 +265,31 @@ connection.onWorkspaceSymbol(async (params, token) => {
 
 connection.onCompletion(
   debounceHandler(
-    (params, token, workDoneProgress, resultProgress) =>
+    ((params, token, workDoneProgress, resultProgress) =>
       workspace
         .projectForFile(params.textDocument.uri)
-        ?.onCompletion?.(params, token, workDoneProgress, resultProgress) ?? [],
+        ?.onCompletion?.(params, token, workDoneProgress, resultProgress) ??
+      []) satisfies Parameters<typeof connection.onCompletion>[0],
   ),
 );
 
 connection.onCodeLens(
   debounceHandler(
-    (params, token, workDoneProgress, resultProgress) =>
+    ((params, token, workDoneProgress, resultProgress) =>
       workspace
         .projectForFile(params.textDocument.uri)
-        ?.onCodeLens?.(params, token, workDoneProgress, resultProgress) ?? [],
+        ?.onCodeLens?.(params, token, workDoneProgress, resultProgress) ??
+      []) satisfies Parameters<typeof connection.onCodeLens>[0],
   ),
 );
 
 connection.onCodeAction(
   debounceHandler(
-    (params, token, workDoneProgress, resultProgress) =>
+    ((params, token, workDoneProgress, resultProgress) =>
       workspace
         .projectForFile(params.textDocument.uri)
-        ?.onCodeAction?.(params, token, workDoneProgress, resultProgress) ?? [],
+        ?.onCodeAction?.(params, token, workDoneProgress, resultProgress) ??
+      []) satisfies Parameters<typeof connection.onCodeAction>[0],
   ),
 );
 

package/src/language-server/utilities/languageIdForExtension.ts

@@ -0,0 +1,39 @@
+import {
+  FileExtension,
+  LanguageIdExtensionMap,
+  supportedLanguageIds,
+} from "../../tools/utilities/languageInformation";
+
+let languageIdPerExtension: Record<FileExtension, string> | undefined;
+let supportedExtensions: FileExtension[] | undefined;
+
+export function setLanguageIdExtensionMap(map: LanguageIdExtensionMap) {
+  languageIdPerExtension = Object.fromEntries(
+    Object.entries(map).flatMap(([languageId, extensions]) =>
+      extensions.map((extension) => [extension, languageId]),
+    ),
+  );
+  supportedExtensions = supportedLanguageIds.flatMap(
+    (languageId) => map[languageId],
+  );
+}
+
+/**
+ * @throws if called before the language server has received options via `onInitialize`.
+ */
+export function getLanguageIdForExtension(ext: FileExtension) {
+  if (!languageIdPerExtension) {
+    throw new Error("LanguageIdExtensionMap not set");
+  }
+  return languageIdPerExtension[ext];
+}
+
+/**
+ * @throws if called before the language server has received options via `onInitialize`.
+ */
+export function getSupportedExtensions() {
+  if (!supportedExtensions) {
+    throw new Error("LanguageIdExtensionMap not set");
+  }
+  return supportedExtensions;
+}

package/src/language-server/workspace.ts

@@ -17,6 +17,7 @@ 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;
@@ -35,6 +36,7 @@ export class GraphQLWorkspace {
   constructor(
     private LanguageServerLoadingHandler: LanguageServerLoadingHandler,
     private config: WorkspaceConfig,
+    private whenConnectionInitialized: Promise<VSCodeConnection>,
   ) {}
 
   onDiagnostics(handler: NotificationHandler<PublishDiagnosticsParams>) {
@@ -98,6 +100,11 @@ export class GraphQLWorkspace {
     // base class which is used by codegen and other tools
     project.whenReady.then(() => project.validate?.());
 
+    if (project.onVSCodeConnectionInitialized) {
+      this.whenConnectionInitialized.then(
+        project.onVSCodeConnectionInitialized.bind(project),
+      );
+    }
     return project;
   }
 
@@ -201,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]);
@@ -261,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.json

@@ -601,8 +601,8 @@
     "graphql-object-field": {
       "match": "\\s*(([_A-Za-z][_0-9A-Za-z]*))\\s*(:)",
       "captures": {
-        "1": { "name": "constant.object.key.graphql" },
-        "2": { "name": "string.unquoted.graphql" },
+        "1": { "name": "string.unquoted.graphql" },
+        "2": { "name": "variable.object.key.graphql" },
         "3": { "name": "punctuation.graphql" }
       }
     },