vscode-apollo 2.1.0 → 2.2.0

package/.vscode/launch.json

@@ -17,6 +17,7 @@
       "env": {
         "APOLLO_ENGINE_ENDPOINT": "http://localhost:7096/apollo",
         "APOLLO_FEATURE_FLAGS": "rover"
+        //"APOLLO_ROVER_LANGUAGE_IDS": "graphql,javascript"
       },
       "outFiles": ["${workspaceRoot}/lib/**/*.js"]
     },

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+## 2.2.0
+
+### Minor Changes
+
+- [#184](https://github.com/apollographql/vscode-graphql/pull/184) [`9c53a11e`](https://github.com/apollographql/vscode-graphql/commit/9c53a11e3006dd69675af976ef3857212d8f9f43) Thanks [@phryneas](https://github.com/phryneas)! - Derive extensions for supported languages and monitored files from other installed extensions.
+  Adjust default `includes` for client projects.
+
+  This changes the default `includes` similar to (depending on additional extensions you might have installed):
+
+  ```diff
+  -'src/**/*.{ts,tsx,js,jsx,graphql,gql}',
+  +'src/**/*{.gql,.graphql,.graphqls,.js,.mjs,.cjs,.es6,.pac,.ts,.mts,.cts,.jsx,.tsx,.vue,.svelte,.py,.rpy,.pyw,.cpy,.gyp,.gypi,.pyi,.ipy,.pyt,.rb,.rbx,.rjs,.gemspec,.rake,.ru,.erb,.podspec,.rbi,.dart,.re,.ex,.exs}'
+  ```
+
 ## 2.1.0
 
 ### Minor Changes

package/package.json

@@ -2,7 +2,7 @@
   "name": "vscode-apollo",
   "displayName": "Apollo GraphQL",
   "description": "Rich editor support for GraphQL client and server development that seamlessly integrates with the Apollo platform",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "referenceID": "87197759-7617-40d0-b32e-46d378e907c7",
   "author": "Apollo GraphQL <opensource@apollographql.com>",
   "license": "MIT",
@@ -40,7 +40,6 @@
     "@apollo/client": "3.11.4",
     "@apollo/subgraph": "2.8.4",
     "@graphql-tools/schema": "10.0.5",
-    "@wry/context": "0.7.4",
     "@wry/equality": "0.5.7",
     "cosmiconfig": "9.0.0",
     "dotenv": "16.4.5",

package/src/language-server/config/__tests__/loadConfig.ts

@@ -99,9 +99,6 @@ Object {
       "**/node_modules",
       "**/__tests__",
     ],
-    "includes": Array [
-      "src/**/*.{ts,tsx,js,jsx,graphql,gql}",
-    ],
     "service": "hello",
     "tagName": "gql",
   },
@@ -137,6 +134,7 @@ Object {
   },
   "rover": Object {
     "bin": "${dir}/bin/rover",
+    "extraArgs": Array [],
   },
 }
 `);
@@ -395,9 +393,14 @@ Object {
         configPath: dirPath,
       });
 
-      expect((config?.rawConfig as any).client.includes).toEqual([
-        "src/**/*.{ts,tsx,js,jsx,graphql,gql}",
-      ]);
+      expect((config?.rawConfig as any).client.includes).toEqual(
+        /**
+         * This will be calculated in the `GraphQLInternalProject` constructor by calling `getSupportedExtensions()`
+         * which will have information about all the extensions added by other VSCode extensions for the language ids
+         * that Apollo supports.
+         */
+        undefined,
+      );
     });
 
     it("merges engine config defaults", async () => {

package/src/language-server/config/config.ts

@@ -1,13 +1,14 @@
-import { dirname } from "path";
+import { dirname, join } from "path";
 import { URI } from "vscode-uri";
 import { getGraphIdFromConfig, parseServiceSpecifier } from "./utils";
 import { Debug } from "../utilities";
 import z, { ZodError } from "zod";
 import { ValidationRule } from "graphql/validation/ValidationContext";
-import { Slot } from "@wry/context";
 import { fromZodError } from "zod-validation-error";
 import which from "which";
 import { accessSync, constants as fsConstants, statSync } from "node:fs";
+import { AsyncLocalStorage } from "async_hooks";
+import { existsSync } from "fs";
 
 const ROVER_AVAILABLE = (process.env.APOLLO_FEATURE_FLAGS || "")
   .split(",")
@@ -29,8 +30,9 @@ function ignoredFieldWarning(
 export interface Context {
   apiKey?: string;
   serviceName?: string;
+  configPath?: string;
 }
-const context = new Slot<Context>();
+const contextStore = new AsyncLocalStorage<Context>();
 
 const studioServiceConfig = z.string();
 
@@ -49,7 +51,7 @@ const localServiceConfig = z.object({
 export type LocalServiceConfig = z.infer<typeof localServiceConfig>;
 
 const clientServiceConfig = z.preprocess(
-  (value) => value || context.getValue()?.serviceName,
+  (value) => value || contextStore.getStore()?.serviceName,
   z.union([studioServiceConfig, remoteServiceConfig, localServiceConfig]),
 );
 export type ClientServiceConfig = z.infer<typeof clientServiceConfig>;
@@ -63,9 +65,7 @@ const clientConfig = z.object({
     ])
     .optional(),
   // maybe shared with rover?
-  includes: z
-    .array(z.string())
-    .default(["src/**/*.{ts,tsx,js,jsx,graphql,gql}"]),
+  includes: z.array(z.string()).optional(),
   // maybe shared with rover?
   excludes: z.array(z.string()).default(["**/node_modules", "**/__tests__"]),
   // maybe shared with rover?
@@ -106,6 +106,21 @@ const roverConfig = z.object({
       },
     ),
   profile: z.string().optional(),
+  supergraphConfig: z
+    .preprocess((value) => {
+      if (value !== undefined) return value;
+      const configPath = contextStore.getStore()?.configPath!;
+      const supergraphConfig = join(configPath, "supergraph.yml");
+      return existsSync(supergraphConfig) ? supergraphConfig : undefined;
+    }, z.string().nullable().optional())
+    .describe(
+      "The path to your `supergraph.yml` file. \n" +
+        "Defaults to a `supergraph.yml` in the folder of your `apollo.config.js`, if there is one.",
+    ),
+  extraArgs: z
+    .array(z.string())
+    .default([])
+    .describe("Extra arguments to pass to the Rover CLI."),
 });
 type RoverConfigFormat = z.infer<typeof roverConfig>;
 
@@ -117,7 +132,7 @@ const engineConfig = z.object({
         "https://graphql.api.apollographql.com/api/graphql",
     ),
   apiKey: z.preprocess(
-    (val) => val || context.getValue()?.apiKey,
+    (val) => val || contextStore.getStore()?.apiKey,
     z.string().optional(),
   ),
 });
@@ -202,9 +217,7 @@ export function parseApolloConfig(
   configURI?: URI,
   ctx: Context = {},
 ) {
-  const parsed = context.withValue(ctx, () =>
-    configSchema.safeParse(rawConfig),
-  );
+  const parsed = contextStore.run(ctx, () => configSchema.safeParse(rawConfig));
   if (!parsed.success) {
     // Remove "or Required at rover" errors when a client config is provided
     // Remove "or Required at client" errors when a rover config is provided

package/src/language-server/config/loadConfig.ts

@@ -1,5 +1,5 @@
 import { cosmiconfig, defaultLoaders } from "cosmiconfig";
-import { resolve } from "path";
+import { dirname, resolve } from "path";
 import { readFileSync, existsSync, lstatSync } from "fs";
 import {
   ApolloConfig,
@@ -103,5 +103,6 @@ export async function loadConfig({
   return parseApolloConfig(config, URI.file(resolve(filepath)), {
     apiKey,
     serviceName: nameFromKey,
+    configPath: dirname(filepath),
   });
 }

package/src/language-server/fileSet.ts

@@ -14,12 +14,10 @@ export class FileSet {
     rootURI,
     includes,
     excludes,
-    configURI,
   }: {
     rootURI: URI;
     includes: string[];
     excludes: string[];
-    configURI?: URI;
   }) {
     invariant(rootURI, `Must provide "rootURI".`);
     invariant(includes, `Must provide "includes".`);
@@ -30,13 +28,6 @@ export class FileSet {
     this.excludes = excludes;
   }
 
-  pushIncludes(files: string[]) {
-    this.includes.push(...files);
-  }
-  pushExcludes(files: string[]) {
-    this.excludes.push(...files);
-  }
-
   includesFile(filePath: string): boolean {
     const normalizedFilePath = normalizeURI(filePath);
 
@@ -57,10 +48,14 @@ export class FileSet {
   }
 
   allFiles(): string[] {
-    // since glob.sync takes a single pattern, but we allow an array of `includes`, we can join all the
-    // `includes` globs into a single pattern and pass to glob.sync. The `ignore` option does, however, allow
-    // an array of globs to ignore, so we can pass it in directly
-    const joinedIncludes = `{${this.includes.join(",")}}`;
+    const joinedIncludes =
+      this.includes.length == 1
+        ? this.includes[0]
+        : // since glob.sync takes a single pattern, but we allow an array of `includes`, we can join all the
+          // `includes` globs into a single pattern and pass to glob.sync. The `ignore` option does, however, allow
+          // an array of globs to ignore, so we can pass it in directly
+          `{${this.includes.join(",")}}`;
+
     return globSync(joinedIncludes, {
       cwd: this.rootURI.fsPath,
       absolute: true,

package/src/language-server/project/base.ts

@@ -12,6 +12,7 @@ import {
   TextDocumentChangeEvent,
   StarRequestHandler,
   StarNotificationHandler,
+  ServerCapabilities,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
 
@@ -46,12 +47,13 @@ export abstract class GraphQLProject {
   private readyPromise: Promise<void>;
   public config: ApolloConfig;
   protected schema?: GraphQLSchema;
-  protected fileSet: FileSet;
   protected rootURI: URI;
   protected loadingHandler: LoadingHandler;
 
   protected lastLoadDate?: number;
 
+  private configFileSet: FileSet;
+
   constructor({
     config,
     configFolderURI,
@@ -63,7 +65,7 @@ export abstract class GraphQLProject {
     // if a config doesn't have a uri associated, we can assume the `rootURI` is the project's root.
     this.rootURI = config.configDirURI || configFolderURI;
 
-    this.fileSet = new FileSet({
+    this.configFileSet = new FileSet({
       rootURI: this.rootURI,
       includes: [
         ".env",
@@ -73,7 +75,6 @@ export abstract class GraphQLProject {
         "apollo.config.ts",
       ],
       excludes: [],
-      configURI: config.configURI,
     });
 
     this._isReady = false;
@@ -117,32 +118,38 @@ export abstract class GraphQLProject {
     this._onDiagnostics = handler;
   }
 
-  abstract includesFile(uri: DocumentUri): boolean;
+  abstract includesFile(uri: DocumentUri, languageId?: string): boolean;
+  isConfiguredBy(uri: DocumentUri): boolean {
+    return this.configFileSet.includesFile(uri);
+  }
 
   abstract onDidChangeWatchedFiles: ConnectionHandler["onDidChangeWatchedFiles"];
-  abstract onDidOpen?: (event: TextDocumentChangeEvent<TextDocument>) => void;
-  abstract onDidClose?: (event: TextDocumentChangeEvent<TextDocument>) => void;
+  onDidOpen?: (event: TextDocumentChangeEvent<TextDocument>) => void;
+  onDidClose?: (event: TextDocumentChangeEvent<TextDocument>) => void;
   abstract documentDidChange(document: TextDocument): void;
   abstract clearAllDiagnostics(): void;
 
-  abstract onCompletion?: ConnectionHandler["onCompletion"];
-  abstract onHover?: ConnectionHandler["onHover"];
-  abstract onDefinition?: ConnectionHandler["onDefinition"];
-  abstract onReferences?: ConnectionHandler["onReferences"];
-  abstract onDocumentSymbol?: ConnectionHandler["onDocumentSymbol"];
-  abstract onCodeLens?: ConnectionHandler["onCodeLens"];
-  abstract onCodeAction?: ConnectionHandler["onCodeAction"];
+  onCompletion?: ConnectionHandler["onCompletion"];
+  onHover?: ConnectionHandler["onHover"];
+  onDefinition?: ConnectionHandler["onDefinition"];
+  onReferences?: ConnectionHandler["onReferences"];
+  onDocumentSymbol?: ConnectionHandler["onDocumentSymbol"];
+  onCodeLens?: ConnectionHandler["onCodeLens"];
+  onCodeAction?: ConnectionHandler["onCodeAction"];
 
-  abstract onUnhandledRequest?: StarRequestHandler;
-  abstract onUnhandledNotification?: (
+  onUnhandledRequest?: StarRequestHandler;
+  onUnhandledNotification?: (
     connection: Connection,
     ...rest: Parameters<StarNotificationHandler>
   ) => ReturnType<StarNotificationHandler>;
 
-  abstract dispose?(): void;
+  dispose?(): void;
 
-  abstract provideSymbol?(
+  provideSymbol?(
     query: string,
     token: CancellationToken,
   ): Promise<SymbolInformation[]>;
+
+  onVSCodeConnectionInitialized?(connection: Connection): void;
+  validate?(): void;
 }

package/src/language-server/project/client.ts

@@ -201,20 +201,7 @@ export class GraphQLClientProject extends GraphQLInternalProject {
     super({ config, configFolderURI, loadingHandler, clientIdentity });
     this.serviceID = config.graph;
 
-    /**
-     * This function is used in the Array.filter function below it to remove any .env files and config files.
-     * If there are 0 files remaining after removing those files, we should warn the user that their config
-     * may be wrong. We shouldn't throw an error here, since they could just be initially setting up a project
-     * and there's no way to know for sure that there _should_ be files.
-     */
-    const filterConfigAndEnvFiles = (path: string) =>
-      !(
-        path.includes("apollo.config") ||
-        path.includes(".env") ||
-        (config.configURI && path === config.configURI.fsPath)
-      );
-
-    if (this.allIncludedFiles().filter(filterConfigAndEnvFiles).length === 0) {
+    if (this.allIncludedFiles().length === 0) {
       console.warn(
         "⚠️  It looks like there are 0 files associated with this Apollo Project. " +
           "This may be because you don't have any files yet, or your includes/excludes " +

package/src/language-server/project/internal.ts

@@ -30,6 +30,8 @@ import {
 import { ApolloEngineClient, ClientIdentity } from "../engine";
 import { GraphQLProject, DocumentUri, GraphQLProjectConfig } from "./base";
 import throttle from "lodash.throttle";
+import { FileSet } from "../fileSet";
+import { getSupportedExtensions } from "../utilities/languageIdForExtension";
 
 const fileAssociations: { [extension: string]: string } = {
   ".graphql": "graphql",
@@ -58,6 +60,7 @@ export abstract class GraphQLInternalProject
 {
   public schemaProvider: GraphQLSchemaProvider;
   protected engineClient?: ApolloEngineClient;
+  private fileSet: FileSet;
 
   private needsValidation = false;
 
@@ -70,16 +73,23 @@ export abstract class GraphQLInternalProject
     clientIdentity,
   }: GraphQLInternalProjectConfig) {
     super({ config, configFolderURI, loadingHandler });
-    const { includes = [], excludes = [] } = config.client;
+    const {
+      // something like
+      // 'src/**/*{.gql,.graphql,.graphqls,.js,.mjs,.cjs,.es6,.pac,.ts,.mts,.cts,.jsx,.tsx,.vue,.svelte,.py,.rpy,.pyw,.cpy,.gyp,.gypi,.pyi,.ipy,.pyt,.rb,.rbx,.rjs,.gemspec,.rake,.ru,.erb,.podspec,.rbi,.dart,.re,.ex,.exs}'
+      includes = [`src/**/*{${getSupportedExtensions().join(",")}}`],
+      excludes = [],
+    } = config.client;
 
     this.documentsByFile = new Map();
-
-    this.fileSet.pushIncludes(includes);
-    // We do not want to include the local schema file in our list of documents
-    this.fileSet.pushExcludes([
-      ...excludes,
-      ...this.getRelativeLocalSchemaFilePaths(),
-    ]);
+    this.fileSet = new FileSet({
+      rootURI: this.rootURI,
+      includes,
+      excludes: [
+        ...excludes,
+        // We do not want to include the local schema file in our list of documents
+        ...this.getRelativeLocalSchemaFilePaths(),
+      ],
+    });
 
     this.schemaProvider = schemaProviderFromConfig(config, clientIdentity);
     const { engine } = config;
@@ -327,8 +337,6 @@ export abstract class GraphQLInternalProject
     }
     return definitionsAndExtensions;
   }
-  onDidOpen: undefined;
-  onDidClose: undefined;
   onDidChangeWatchedFiles: GraphQLProject["onDidChangeWatchedFiles"] = (
     params,
   ) => {
@@ -343,7 +351,4 @@ export abstract class GraphQLInternalProject
       }
     }
   };
-  onUnhandledRequest: undefined;
-  onUnhandledNotification: undefined;
-  dispose: undefined;
 }

package/src/language-server/project/rover/DocumentSynchronization.ts

@@ -8,6 +8,11 @@ import {
   Diagnostic,
   NotificationHandler,
   PublishDiagnosticsParams,
+  SemanticTokensRequest,
+  ProtocolRequestType,
+  SemanticTokensParams,
+  SemanticTokens,
+  CancellationToken,
 } from "vscode-languageserver-protocol";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { DocumentUri, GraphQLProject } from "../base";
@@ -105,6 +110,11 @@ export class DocumentSynchronization {
       type: ProtocolNotificationType<P, RO>,
       params?: P,
     ) => Promise<void>,
+    private sendRequest: <P, R, PR, E, RO>(
+      type: ProtocolRequestType<P, R, PR, E, RO>,
+      params: P,
+      token?: CancellationToken,
+    ) => Promise<R>,
     private sendDiagnostics: NotificationHandler<PublishDiagnosticsParams>,
   ) {}
 
@@ -305,4 +315,71 @@ export class DocumentSynchronization {
       this.sendDiagnostics({ uri: file.full.uri, diagnostics: [] });
     }
   }
+
+  /**
+   * Receives semantic tokens for all sub-documents and glues them together.
+   * See https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_semanticTokens
+   * TLDR: The tokens are a flat array of numbers, where each token is represented by 5 numbers.
+   * The first two numbers represent the token's delta line and delta start character and might need adjusing
+   * relative to the start of a sub-document in relation to the position of the last token of the previous sub-document.
+   *
+   * There is also an "incremental" version of this request, but we don't support it yet.
+   * This is complicated enough as it is.
+   */
+  async getFullSemanticTokens(
+    params: SemanticTokensParams,
+    cancellationToken: CancellationToken,
+  ): Promise<SemanticTokens | null> {
+    await this.synchronizedWithDocument(params.textDocument.uri);
+    const found = this.knownFiles.get(params.textDocument.uri);
+    if (!found) {
+      return null;
+    }
+    const allParts = await Promise.all(
+      found.parts.map(async (part) => {
+        return {
+          part,
+          tokens: await this.sendRequest(
+            SemanticTokensRequest.type,
+            {
+              textDocument: { uri: getUri(found.full, part) },
+            },
+            cancellationToken,
+          ),
+        };
+      }),
+    );
+    let line = 0,
+      char = 0,
+      lastLine = 0,
+      lastChar = 0;
+    const combinedTokens = [];
+    for (const { part, tokens } of allParts) {
+      if (!tokens) {
+        continue;
+      }
+      line = part.source.locationOffset.line - 1;
+      char = part.source.locationOffset.column - 1;
+      for (let i = 0; i < tokens.data.length; i += 5) {
+        const deltaLine = tokens.data[i],
+          deltaStartChar = tokens.data[i + 1];
+
+        // We need to run this loop fully to correctly calculate the `lastLine` and `lastChar`
+        // so for the next incoming tokens, we can adjust the delta correctly.
+        line = line + deltaLine;
+        char = deltaLine === 0 ? char + deltaStartChar : deltaStartChar;
+        // we just need to adjust the deltas only for the first token
+        if (i === 0) {
+          tokens.data[0] = line - lastLine;
+          tokens.data[1] = line === lastLine ? lastChar - char : char;
+        }
+      }
+      combinedTokens.push(...tokens.data);
+      lastLine = line;
+      lastChar = char;
+    }
+    return {
+      data: combinedTokens,
+    };
+  }
 }

package/src/language-server/project/rover/project.ts

@@ -3,7 +3,6 @@ import { DocumentUri, GraphQLProject } from "../base";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import {
   CancellationToken,
-  SymbolInformation,
   InitializeRequest,
   StreamMessageReader,
   StreamMessageWriter,
@@ -19,6 +18,12 @@ import {
   PublishDiagnosticsNotification,
   ConnectionError,
   ConnectionErrors,
+  SemanticTokensRequest,
+  ProtocolRequestType0,
+  ServerCapabilities,
+  SemanticTokensRegistrationType,
+  SemanticTokensOptions,
+  SemanticTokensRegistrationOptions,
 } from "vscode-languageserver/node";
 import cp from "node:child_process";
 import { GraphQLProjectConfig } from "../base";
@@ -26,6 +31,10 @@ import { ApolloConfig, RoverConfig } from "../../config";
 import { DocumentSynchronization } from "./DocumentSynchronization";
 import { AsyncLocalStorage } from "node:async_hooks";
 import internal from "node:stream";
+import { VSCodeConnection } from "../../server";
+import { getLanguageIdForExtension } from "../../utilities/languageIdForExtension";
+import { extname } from "node:path";
+import type { FileExtension } from "../../../tools/utilities/languageInformation";
 
 export const DEBUG = true;
 
@@ -38,6 +47,10 @@ export interface RoverProjectConfig extends GraphQLProjectConfig {
   capabilities: ClientCapabilities;
 }
 
+const supportedLanguageIds = (
+  process.env.APOLLO_ROVER_LANGUAGE_IDS || "graphql"
+).split(",");
+
 export class RoverProject extends GraphQLProject {
   config: RoverConfig;
   /**
@@ -52,11 +65,13 @@ export class RoverProject extends GraphQLProject {
     | undefined;
   private disposed = false;
   readonly capabilities: ClientCapabilities;
+  roverCapabilities?: ServerCapabilities;
   get displayName(): string {
     return "Rover Project";
   }
   private documents = new DocumentSynchronization(
     this.sendNotification.bind(this),
+    this.sendRequest.bind(this),
     (diagnostics) => this._onDiagnostics?.(diagnostics),
   );
 
@@ -143,7 +158,18 @@ export class RoverProject extends GraphQLProject {
         "Connection is closed.",
       );
     }
-    const child = cp.spawn(this.config.rover.bin, ["lsp"], {
+    const args = ["lsp", "--elv2-license", "accept"];
+    if (this.config.rover.profile) {
+      args.push("--profile", this.config.rover.profile);
+    }
+    if (this.config.rover.supergraphConfig) {
+      args.push("--supergraph-config", this.config.rover.supergraphConfig);
+    }
+    args.push(...this.config.rover.extraArgs);
+
+    DEBUG &&
+      console.log(`starting ${this.config.rover.bin} '${args.join("' '")}'`);
+    const child = cp.spawn(this.config.rover.bin, args, {
       env: DEBUG ? { RUST_BACKTRACE: "1" } : {},
       stdio: ["pipe", "pipe", DEBUG ? "inherit" : "ignore"],
     });
@@ -185,6 +211,7 @@ export class RoverProject extends GraphQLProject {
         },
         source.token,
       );
+      this.roverCapabilities = status.capabilities;
       DEBUG && console.log("Connection initialized", status);
 
       await this.connectionStorage.run(
@@ -203,12 +230,16 @@ export class RoverProject extends GraphQLProject {
     return { type: "Rover", loaded: true };
   }
 
-  includesFile(uri: DocumentUri) {
-    return uri.startsWith(this.rootURI.toString());
+  includesFile(
+    uri: DocumentUri,
+    languageId = getLanguageIdForExtension(extname(uri) as FileExtension),
+  ) {
+    return (
+      uri.startsWith(this.rootURI.toString()) &&
+      supportedLanguageIds.includes(languageId)
+    );
   }
 
-  validate?: () => void;
-
   onDidChangeWatchedFiles: GraphQLProject["onDidChangeWatchedFiles"] = (
     params,
   ) => {
@@ -250,8 +281,17 @@ export class RoverProject extends GraphQLProject {
       this.sendRequest(HoverRequest.type, virtualParams, token),
     );
 
-  onUnhandledRequest: GraphQLProject["onUnhandledRequest"] = (type, params) => {
-    DEBUG && console.info("unhandled request from VSCode", { type, params });
+  onUnhandledRequest: GraphQLProject["onUnhandledRequest"] = async (
+    type,
+    params,
+    token,
+  ) => {
+    if (isRequestType(SemanticTokensRequest.type, type, params)) {
+      return this.documents.getFullSemanticTokens(params, token);
+    } else {
+      DEBUG && console.info("unhandled request from VSCode", { type, params });
+      return undefined;
+    }
   };
   onUnhandledNotification: GraphQLProject["onUnhandledNotification"] = (
     _connection,
@@ -262,15 +302,40 @@ export class RoverProject extends GraphQLProject {
       console.info("unhandled notification from VSCode", { type, params });
   };
 
-  // these are not supported yet
-  onDefinition: GraphQLProject["onDefinition"];
-  onReferences: GraphQLProject["onReferences"];
-  onDocumentSymbol: GraphQLProject["onDocumentSymbol"];
-  onCodeLens: GraphQLProject["onCodeLens"];
-  onCodeAction: GraphQLProject["onCodeAction"];
-
-  provideSymbol?(
-    query: string,
-    token: CancellationToken,
-  ): Promise<SymbolInformation[]>;
+  async onVSCodeConnectionInitialized(connection: VSCodeConnection) {
+    // Report the actual capabilities of the upstream LSP to VSCode.
+    // It is important to actually "ask" the LSP for this, because the capabilities
+    // also define the semantic token legend, which is needed to interpret the tokens.
+    await this.getConnection();
+    const capabilities = this.roverCapabilities;
+    if (capabilities?.semanticTokensProvider) {
+      connection.client.register(SemanticTokensRegistrationType.type, {
+        documentSelector: null,
+        ...capabilities.semanticTokensProvider,
+        full: {
+          // the upstream LSP supports "true" here, but we don't yet
+          delta: false,
+        },
+      });
+    }
+  }
+}
+
+function isRequestType<R, PR, E, RO>(
+  type: ProtocolRequestType0<R, PR, E, RO>,
+  method: string,
+  params: any,
+): params is PR;
+function isRequestType<P, R, PR, E, RO>(
+  type: ProtocolRequestType<P, R, PR, E, RO>,
+  method: string,
+  params: any,
+): params is P;
+function isRequestType(
+  type:
+    | ProtocolRequestType0<any, any, any, any>
+    | ProtocolRequestType<any, any, any, any, any>,
+  method: string,
+) {
+  return type.method === method;
 }

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;