vscode-apollo 2.1.0 → 2.2.1

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";
@@ -94,10 +99,17 @@ export class DocumentSynchronization {
   private pendingDocumentChanges = new Map<DocumentUri, TextDocument>();
   private knownFiles = new Map<
     DocumentUri,
-    {
-      full: TextDocument;
-      parts: ReadonlyArray<FilePart>;
-    }
+    | {
+        source: "editor";
+        full: TextDocument;
+        parts: ReadonlyArray<FilePart>;
+      }
+    | {
+        source: "lsp";
+        full: Pick<TextDocument, "uri">;
+        parts?: undefined;
+        diagnostics?: Diagnostic[];
+      }
   >();
 
   constructor(
@@ -105,6 +117,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>,
   ) {}
 
@@ -148,7 +165,11 @@ export class DocumentSynchronization {
     const newObj = Object.fromEntries(
       newParts.map((p) => [p.fractionalIndex, p]),
     );
-    this.knownFiles.set(document.uri, { full: document, parts: newParts });
+    this.knownFiles.set(document.uri, {
+      source: "editor",
+      full: document,
+      parts: newParts,
+    });
 
     for (const newPart of newParts) {
       const previousPart = previousObj[newPart.fractionalIndex];
@@ -188,7 +209,9 @@ export class DocumentSynchronization {
 
   async resendAllDocuments() {
     for (const file of this.knownFiles.values()) {
-      await this.sendDocumentChanges(file.full, []);
+      if (file.source === "editor") {
+        await this.sendDocumentChanges(file.full, []);
+      }
     }
   }
 
@@ -198,7 +221,7 @@ export class DocumentSynchronization {
     this.documentDidChange(params.document);
   };
 
-  onDidCloseTextDocument: NonNullable<GraphQLProject["onDidClose"]> = (
+  onDidCloseTextDocument: NonNullable<GraphQLProject["onDidClose"]> = async (
     params,
   ) => {
     const known = this.knownFiles.get(params.document.uri);
@@ -206,15 +229,15 @@ export class DocumentSynchronization {
       return;
     }
     this.knownFiles.delete(params.document.uri);
-    return Promise.all(
-      known.parts.map((part) =>
-        this.sendNotification(DidCloseTextDocumentNotification.type, {
+    if (known.source === "editor") {
+      for (const part of known.parts) {
+        await this.sendNotification(DidCloseTextDocumentNotification.type, {
           textDocument: {
             uri: getUri(known.full, part),
           },
-        }),
-      ),
-    );
+        });
+      }
+    }
   };
 
   async documentDidChange(document: TextDocument) {
@@ -244,7 +267,7 @@ export class DocumentSynchronization {
   ): Promise<T | undefined> {
     await this.synchronizedWithDocument(positionParams.textDocument.uri);
     const found = this.knownFiles.get(positionParams.textDocument.uri);
-    if (!found) {
+    if (!found || found.source !== "editor") {
       return;
     }
     const match = findContainedSourceAndPosition(
@@ -264,11 +287,14 @@ export class DocumentSynchronization {
   handlePartDiagnostics(params: PublishDiagnosticsParams) {
     DEBUG && console.log("Received diagnostics", params);
     const uriDetails = splitUri(params.uri);
-    if (!uriDetails) {
-      return;
-    }
     const found = this.knownFiles.get(uriDetails.uri);
-    if (!found) {
+    if (!found || found.source === "lsp") {
+      this.knownFiles.set(uriDetails.uri, {
+        source: "lsp",
+        full: { uri: uriDetails.uri },
+        diagnostics: params.diagnostics,
+      });
+      this.sendDiagnostics(params);
       return;
     }
     const part = found.parts.find(
@@ -294,15 +320,88 @@ export class DocumentSynchronization {
   }
 
   get openDocuments() {
-    return [...this.knownFiles.values()].map((f) => f.full);
+    return [...this.knownFiles.values()]
+      .filter((f) => f.source === "editor")
+      .map((f) => f.full);
   }
 
   clearAllDiagnostics() {
     for (const file of this.knownFiles.values()) {
-      for (const part of file.parts) {
-        part.diagnostics = [];
+      if (file.source === "editor") {
+        for (const part of file.parts) {
+          part.diagnostics = [];
+        }
+      } else {
+        file.diagnostics = [];
       }
       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 || found.source !== "editor") {
+      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/providers/schema/endpoint.ts

@@ -17,7 +17,16 @@ import { RemoteServiceConfig } from "../../config";
 import { GraphQLSchemaProvider, SchemaChangeUnsubscribeHandler } from "./base";
 import { Debug } from "../../utilities";
 import { isString } from "util";
-
+import { fetch as undiciFetch, Agent } from "undici";
+
+const skipSSLValidationFetchOptions = {
+  // see https://github.com/nodejs/undici/issues/1489#issuecomment-1543856261
+  dispatcher: new Agent({
+    connect: {
+      rejectUnauthorized: false,
+    },
+  }),
+} satisfies import("undici").RequestInit;
 export class EndpointSchemaProvider implements GraphQLSchemaProvider {
   private schema?: GraphQLSchema;
   private federatedServiceSDL?: string;
@@ -28,11 +37,11 @@ export class EndpointSchemaProvider implements GraphQLSchemaProvider {
     const { skipSSLValidation, url, headers } = this.config;
     const options: HttpOptions = {
       uri: url,
+      fetch: undiciFetch as typeof fetch,
     };
+
     if (url.startsWith("https:") && skipSSLValidation) {
-      options.fetchOptions = {
-        agent: new HTTPSAgent({ rejectUnauthorized: false }),
-      };
+      options.fetchOptions = skipSSLValidationFetchOptions;
     }
 
     const { data, errors } = (await toPromise(
@@ -92,12 +101,10 @@ export class EndpointSchemaProvider implements GraphQLSchemaProvider {
     const { skipSSLValidation, url, headers } = this.config;
     const options: HttpOptions = {
       uri: url,
-      fetch,
+      fetch: undiciFetch as typeof fetch,
     };
     if (url.startsWith("https:") && skipSSLValidation) {
-      options.fetchOptions = {
-        agent: new HTTPSAgent({ rejectUnauthorized: false }),
-      };
+      options.fetchOptions = skipSSLValidationFetchOptions;
     }
 
     const getFederationInfoQuery = `