vscode-apollo 1.20.0 → 2.0.1

package/src/language-server/providers/schema/engine.ts

@@ -1,18 +1,21 @@
 // EngineSchemaProvider (engine schema reg => schema)
-import { NotificationHandler } from "vscode-languageserver";
+import { NotificationHandler } from "vscode-languageserver/node";
 import gql from "graphql-tag";
-import { GraphQLSchema, buildClientSchema } from "graphql";
+import { GraphQLSchema, IntrospectionQuery, buildClientSchema } from "graphql";
 import { ApolloEngineClient, ClientIdentity } from "../../engine";
-import { ClientConfig, keyEnvVar, parseServiceSpecifier } from "../../config";
-import { getServiceFromKey, isServiceKey } from "../../config";
+import { ClientConfig, keyEnvVar } from "../../config";
 import {
   GraphQLSchemaProvider,
   SchemaChangeUnsubscribeHandler,
   SchemaResolveConfig,
 } from "./base";
 
-import { GetSchemaByTagQuery } from "../../graphqlTypes";
+import {
+  GetSchemaByTagQuery,
+  GetSchemaByTagQueryVariables,
+} from "../../graphqlTypes";
 import { Debug } from "../../utilities";
+import { TypedDocumentNode } from "@apollo/client/core";
 
 export class EngineSchemaProvider implements GraphQLSchemaProvider {
   private schema?: GraphQLSchema;
@@ -20,7 +23,7 @@ export class EngineSchemaProvider implements GraphQLSchemaProvider {
 
   constructor(
     private config: ClientConfig,
-    private clientIdentity?: ClientIdentity
+    private clientIdentity: ClientIdentity,
   ) {}
 
   async resolveSchema(override: SchemaResolveConfig) {
@@ -29,7 +32,7 @@ export class EngineSchemaProvider implements GraphQLSchemaProvider {
 
     if (!this.config.graph) {
       throw new Error(
-        `No graph ID found for client. Please specify a graph ID via the config or the --graph flag`
+        `No graph ID found for client. Please specify a graph ID via the config or the --graph flag`,
       );
     }
 
@@ -37,42 +40,43 @@ export class EngineSchemaProvider implements GraphQLSchemaProvider {
     if (!this.client) {
       if (!engine.apiKey) {
         throw new Error(
-          `No API key found. Please set ${keyEnvVar} or use --key`
+          `No API key found. Please set ${keyEnvVar} or use --key`,
         );
       }
       this.client = new ApolloEngineClient(
         engine.apiKey,
         engine.endpoint,
-        this.clientIdentity
+        this.clientIdentity,
       );
     }
 
-    const { data, errors } = await this.client.execute<GetSchemaByTagQuery>({
+    const { data, errors } = await this.client.query({
       query: SCHEMA_QUERY,
       variables: {
         id: this.config.graph,
         tag: override && override.tag ? override.tag : this.config.variant,
       },
+      fetchPolicy: "no-cache",
     });
     if (errors) {
       // XXX better error handling of GraphQL errors
-      throw new Error(errors.map(({ message }: Error) => message).join("\n"));
+      throw new Error(errors.map(({ message }) => message).join("\n"));
     }
 
     if (!(data && data.service && data.service.__typename === "Service")) {
       throw new Error(
-        `Unable to get schema from the Apollo registry for graph ${this.config.graph}`
+        `Unable to get schema from the Apollo registry for graph ${this.config.graph}`,
       );
     }
 
-    // @ts-ignore
-    // XXX Types of `data.service.schema` won't match closely enough with `IntrospectionQuery`
-    this.schema = buildClientSchema(data.service.schema);
+    this.schema = buildClientSchema(
+      data.service.schema as unknown as IntrospectionQuery,
+    );
     return this.schema;
   }
 
   onSchemaChange(
-    _handler: NotificationHandler<GraphQLSchema>
+    _handler: NotificationHandler<GraphQLSchema>,
   ): SchemaChangeUnsubscribeHandler {
     throw new Error("Polling of Apollo not implemented yet");
     return () => {};
@@ -80,13 +84,16 @@ export class EngineSchemaProvider implements GraphQLSchemaProvider {
 
   async resolveFederatedServiceSDL() {
     Debug.error(
-      "Cannot resolve a federated service's SDL from Apollo. Use an endpoint or a file instead"
+      "Cannot resolve a federated service's SDL from Apollo. Use an endpoint or a file instead",
     );
     return;
   }
 }
 
-export const SCHEMA_QUERY = gql`
+export const SCHEMA_QUERY: TypedDocumentNode<
+  GetSchemaByTagQuery,
+  GetSchemaByTagQueryVariables
+> = gql`
   query GetSchemaByTag($tag: String!, $id: ID!) {
     service(id: $id) {
       ... on Service {

package/src/language-server/providers/schema/file.ts

@@ -3,23 +3,18 @@ import {
   GraphQLSchema,
   buildClientSchema,
   Source,
-  buildSchema,
   printSchema,
   parse,
-  visit,
+  buildASTSchema,
 } from "graphql";
-import { readFileSync } from "fs";
-import { extname, resolve } from "path";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { existsSync, readFileSync } from "fs";
+import { extname, resolve, isAbsolute } from "path";
 import { GraphQLSchemaProvider, SchemaChangeUnsubscribeHandler } from "./base";
-import { NotificationHandler } from "vscode-languageserver";
+import { NotificationHandler } from "vscode-languageserver/node";
 import { Debug } from "../../utilities";
-import { buildSchemaFromSDL } from "apollo-graphql";
-import {
-  buildFederatedSchema,
-  composeServices,
-  printSchema as printFederatedSchema,
-} from "@apollo/federation";
-import URI from "vscode-uri";
+import { buildSubgraphSchema } from "@apollo/subgraph";
+import { URI } from "vscode-uri";
 // import federationDirectives from "@apollo/federation/src/directives";
 
 export interface FileSchemaProviderConfig {
@@ -31,7 +26,10 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
   private schema?: GraphQLSchema;
   private federatedServiceSDL?: string;
 
-  constructor(private config: FileSchemaProviderConfig) {}
+  constructor(
+    private config: FileSchemaProviderConfig,
+    private configDir: URI | undefined,
+  ) {}
 
   async resolveSchema() {
     if (this.schema) return this.schema;
@@ -48,10 +46,10 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
       throw new Error(
         `Schema could not be loaded for [${
           path ? path : paths ? paths.join(", ") : "undefined"
-        }]`
+        }]`,
       );
 
-    this.schema = buildSchemaFromSDL(documents);
+    this.schema = buildASTSchema(mergeTypeDefs(documents));
 
     if (!this.schema) throw new Error(`Schema could not be loaded for ${path}`);
     return this.schema;
@@ -62,9 +60,7 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
   loadFileAndGetDocument(path: string) {
     let result;
     try {
-      result = readFileSync(path, {
-        encoding: "utf-8",
-      });
+      result = this.readFileSync(path);
     } catch (err: any) {
       throw new Error(`Unable to read file ${path}. ${err.message}`);
     }
@@ -87,12 +83,12 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
       return parse(new Source(result, uri));
     }
     throw new Error(
-      "File Type not supported for schema loading. Must be a .json, .graphql, .gql, or .graphqls file"
+      "File Type not supported for schema loading. Must be a .json, .graphql, .gql, or .graphqls file",
     );
   }
 
   onSchemaChange(
-    _handler: NotificationHandler<GraphQLSchema>
+    _handler: NotificationHandler<GraphQLSchema>,
   ): SchemaChangeUnsubscribeHandler {
     throw new Error("File watching not implemented yet");
     return () => {};
@@ -116,11 +112,11 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
       return Debug.error(
         `SDL could not be loaded for one of more files: [${
           path ? path : paths ? paths.join(", ") : "undefined"
-        }]`
+        }]`,
       );
 
-    const federatedSchema = buildFederatedSchema(
-      SDLs.map((sdl) => ({ typeDefs: parse(sdl as string) }))
+    const federatedSchema = buildSubgraphSchema(
+      SDLs.map((sdl) => ({ typeDefs: parse(sdl as string) })),
     );
 
     // call the `Query._service` resolver to get the actual printed sdl
@@ -128,14 +124,16 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
     if (!queryType)
       return Debug.error("No query type found for federated schema");
     const serviceField = queryType.getFields()["_service"];
-    const serviceResults =
-      serviceField &&
-      serviceField.resolve &&
-      serviceField.resolve(null, {}, null, {} as any);
+    const serviceResults = serviceField?.resolve?.(
+      null,
+      {},
+      null,
+      {} as any,
+    ) as { sdl?: string };
 
     if (!serviceResults || !serviceResults.sdl)
       return Debug.error(
-        "No SDL resolver or result from federated schema after building"
+        "No SDL resolver or result from federated schema after building",
       );
 
     this.federatedServiceSDL = serviceResults.sdl;
@@ -146,9 +144,7 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
   loadFileAndGetSDL(path: string) {
     let result;
     try {
-      result = readFileSync(path, {
-        encoding: "utf-8",
-      });
+      result = this.readFileSync(path);
     } catch (err: any) {
       return Debug.error(`Unable to read file ${path}. ${err.message}`);
     }
@@ -160,8 +156,21 @@ export class FileSchemaProvider implements GraphQLSchemaProvider {
       return result as string;
     } else {
       return Debug.error(
-        "When using localSchemaFile to check or push a federated service, you can only use .graphql, .gql, and .graphqls files"
+        "When using localSchemaFile to check or push a federated service, you can only use .graphql, .gql, and .graphqls files",
       );
     }
   }
+
+  private readFileSync(path: string) {
+    let finalPath = path;
+    if (!isAbsolute(finalPath) && this.configDir) {
+      const resolvedPath = resolve(this.configDir?.fsPath, path);
+      if (existsSync(resolvedPath)) {
+        finalPath = resolvedPath;
+      }
+    }
+    return readFileSync(finalPath, {
+      encoding: "utf-8",
+    });
+  }
 }

package/src/language-server/providers/schema/index.ts

@@ -6,7 +6,6 @@ import {
 import {
   ApolloConfig,
   isClientConfig,
-  isServiceConfig,
   isLocalServiceConfig,
   ClientConfig,
 } from "../../config";
@@ -24,24 +23,8 @@ export {
 
 export function schemaProviderFromConfig(
   config: ApolloConfig,
-  clientIdentity?: ClientIdentity // engine provider needs this
+  clientIdentity: ClientIdentity, // engine provider needs this
 ): GraphQLSchemaProvider {
-  // we need this to be first because there will pretty much always be a
-  // url (since it's a default). If there is a localSchemaFile, we need to
-  // use that instead of the url.
-  if (config.service && config.service.localSchemaFile) {
-    const isListOfSchemaFiles = Array.isArray(config.service.localSchemaFile);
-    return new FileSchemaProvider(
-      isListOfSchemaFiles
-        ? { paths: config.service.localSchemaFile as string[] }
-        : { path: config.service.localSchemaFile as string }
-    );
-  }
-
-  if (config.service && config.service.endpoint) {
-    return new EndpointSchemaProvider(config.service.endpoint);
-  }
-
   if (isClientConfig(config)) {
     if (typeof config.client.service === "string") {
       return new EngineSchemaProvider(config, clientIdentity);
@@ -50,14 +33,15 @@ export function schemaProviderFromConfig(
     if (config.client.service) {
       if (isLocalServiceConfig(config.client.service)) {
         const isListOfSchemaFiles = Array.isArray(
-          config.client.service.localSchemaFile
+          config.client.service.localSchemaFile,
         );
         return new FileSchemaProvider(
           isListOfSchemaFiles
             ? { paths: config.client.service.localSchemaFile as string[] }
             : {
                 path: config.client.service.localSchemaFile as string,
-              }
+              },
+          config.configDirURI,
         );
       }
 
@@ -70,6 +54,6 @@ export function schemaProviderFromConfig(
   }
 
   throw new Error(
-    "No schema provider was created, because the project type was unable to be resolved from your config. Please add either a client or service config. For more information, please refer to https://go.apollo.dev/t/config"
+    "No schema provider was created, because the project type was unable to be resolved from your config. Please add either a client or service config. For more information, please refer to https://go.apollo.dev/t/config",
   );
 }

package/src/language-server/server.ts

@@ -1,41 +1,57 @@
 import "../env";
-// FIXME: The global fetch dependency comes from `apollo-link-http` and should be removed there.
-import "../env/fetch/global";
 import {
   createConnection,
   ProposedFeatures,
   TextDocuments,
   FileChangeType,
   ServerCapabilities,
-} from "vscode-languageserver";
+  TextDocumentSyncKind,
+} from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
 import type { QuickPickItem } from "vscode";
 import { GraphQLWorkspace } from "./workspace";
 import { GraphQLLanguageProvider } from "./languageProvider";
 import { LanguageServerLoadingHandler } from "./loadingHandler";
 import { debounceHandler, Debug } from "./utilities";
-import type { Connection } from "src/messages";
-import URI from "vscode-uri";
+import { URI } from "vscode-uri";
+import {
+  LanguageServerNotifications as Notifications,
+  LanguageServerCommands as Commands,
+  LanguageServerRequests as Requests,
+} from "../messages";
+import { isValidationError } from "zod-validation-error";
+
+const connection = createConnection(ProposedFeatures.all);
 
-const connection: Connection = createConnection(ProposedFeatures.all);
 Debug.SetConnection(connection);
+const { sendNotification: originalSendNotification } = connection;
+connection.sendNotification = async (...args: [any, ...any[]]) => {
+  await whenConnectionInitialized;
+  connection.sendNotification = originalSendNotification;
+  connection.sendNotification(...args);
+};
 
 let hasWorkspaceFolderCapability = false;
 
 // Awaitable promise for sending messages before the connection is initialized
 let initializeConnection: () => void;
 const whenConnectionInitialized: Promise<void> = new Promise(
-  (resolve) => (initializeConnection = resolve)
+  (resolve) => (initializeConnection = resolve),
 );
 
 const workspace = new GraphQLWorkspace(
   new LanguageServerLoadingHandler(connection),
   {
     clientIdentity: {
-      name: process.env["APOLLO_CLIENT_NAME"],
-      version: process.env["APOLLO_CLIENT_VERSION"],
-      referenceID: process.env["APOLLO_CLIENT_REFERENCE_ID"],
+      name: process.env["APOLLO_CLIENT_NAME"] || "Apollo Language Server",
+      version:
+        process.env["APOLLO_CLIENT_VERSION"] ||
+        "146d29c0-912c-46d3-b686-920e52586be6",
+      referenceID:
+        process.env["APOLLO_CLIENT_REFERENCE_ID"] ||
+        require("../../package.json").version,
     },
-  }
+  },
 );
 
 workspace.onDiagnostics((params) => {
@@ -43,27 +59,25 @@ workspace.onDiagnostics((params) => {
 });
 
 workspace.onDecorations((params) => {
-  connection.sendNotification("apollographql/engineDecorations", {
+  connection.sendNotification(Notifications.EngineDecorations, {
     decorations: params,
   });
 });
 
 workspace.onSchemaTags((params) => {
-  connection.sendNotification(
-    "apollographql/tagsLoaded",
-    JSON.stringify(params)
-  );
+  connection.sendNotification(Notifications.TagsLoaded, JSON.stringify(params));
 });
 
 workspace.onConfigFilesFound(async (params) => {
-  await whenConnectionInitialized;
-
   connection.sendNotification(
-    "apollographql/configFilesFound",
-    params instanceof Error
-      ? // Can't stringify Errors, just results in "{}"
-        JSON.stringify({ message: params.message, stack: params.stack })
-      : JSON.stringify(params)
+    Notifications.ConfigFilesFound,
+    JSON.stringify(params, (_key, value) =>
+      !value
+        ? value
+        : value instanceof Error || isValidationError(value)
+        ? { message: value.message, stack: value.stack }
+        : value,
+    ),
   );
 });
 
@@ -77,7 +91,7 @@ connection.onInitialize(async ({ capabilities, workspaceFolders }) => {
     // 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))
+      workspaceFolders.map((folder) => workspace.addProjectsInFolder(folder)),
     );
   }
 
@@ -99,7 +113,7 @@ connection.onInitialize(async ({ capabilities, workspaceFolders }) => {
       executeCommandProvider: {
         commands: [],
       },
-      textDocumentSync: documents.syncKind,
+      textDocumentSync: TextDocumentSyncKind.Full,
     } as ServerCapabilities,
   };
 });
@@ -110,7 +124,7 @@ connection.onInitialized(async () => {
     connection.workspace.onDidChangeWorkspaceFolders(async (event) => {
       await Promise.all([
         ...event.removed.map((folder) =>
-          workspace.removeProjectsInFolder(folder)
+          workspace.removeProjectsInFolder(folder),
         ),
         ...event.added.map((folder) => workspace.addProjectsInFolder(folder)),
       ]);
@@ -118,7 +132,7 @@ connection.onInitialized(async () => {
   }
 });
 
-const documents: TextDocuments = new TextDocuments();
+const documents = new TextDocuments(TextDocument);
 
 // Make the text document manager listen on the connection
 // for open, change and close text document events
@@ -139,7 +153,7 @@ documents.onDidChangeContent(
     }
 
     project.documentDidChange(params.document);
-  })
+  }),
 );
 
 connection.onDidChangeWatchedFiles((params) => {
@@ -147,6 +161,8 @@ connection.onDidChangeWatchedFiles((params) => {
     if (
       uri.endsWith("apollo.config.js") ||
       uri.endsWith("apollo.config.cjs") ||
+      uri.endsWith("apollo.config.mjs") ||
+      uri.endsWith("apollo.config.ts") ||
       uri.endsWith(".env")
     ) {
       workspace.reloadProjectForConfig(uri);
@@ -180,15 +196,19 @@ connection.onDidChangeWatchedFiles((params) => {
 const languageProvider = new GraphQLLanguageProvider(workspace);
 
 connection.onHover((params, token) =>
-  languageProvider.provideHover(params.textDocument.uri, params.position, token)
+  languageProvider.provideHover(
+    params.textDocument.uri,
+    params.position,
+    token,
+  ),
 );
 
 connection.onDefinition((params, token) =>
   languageProvider.provideDefinition(
     params.textDocument.uri,
     params.position,
-    token
-  )
+    token,
+  ),
 );
 
 connection.onReferences((params, token) =>
@@ -196,16 +216,16 @@ connection.onReferences((params, token) =>
     params.textDocument.uri,
     params.position,
     params.context,
-    token
-  )
+    token,
+  ),
 );
 
 connection.onDocumentSymbol((params, token) =>
-  languageProvider.provideDocumentSymbol(params.textDocument.uri, token)
+  languageProvider.provideDocumentSymbol(params.textDocument.uri, token),
 );
 
 connection.onWorkspaceSymbol((params, token) =>
-  languageProvider.provideWorkspaceSymbol(params.query, token)
+  languageProvider.provideWorkspaceSymbol(params.query, token),
 );
 
 connection.onCompletion(
@@ -213,15 +233,15 @@ connection.onCompletion(
     languageProvider.provideCompletionItems(
       params.textDocument.uri,
       params.position,
-      token
-    )
-  )
+      token,
+    ),
+  ),
 );
 
 connection.onCodeLens(
   debounceHandler((params, token) =>
-    languageProvider.provideCodeLenses(params.textDocument.uri, token)
-  )
+    languageProvider.provideCodeLenses(params.textDocument.uri, token),
+  ),
 );
 
 connection.onCodeAction(
@@ -229,23 +249,25 @@ connection.onCodeAction(
     languageProvider.provideCodeAction(
       params.textDocument.uri,
       params.range,
-      token
-    )
-  )
+      token,
+    ),
+  ),
 );
 
-connection.onNotification("apollographql/reloadService", () =>
-  workspace.reloadService()
+connection.onNotification(Commands.ReloadService, () =>
+  workspace.reloadService(),
 );
 
-connection.onNotification(
-  "apollographql/tagSelected",
-  (selection: QuickPickItem) => workspace.updateSchemaTag(selection)
+connection.onNotification(Commands.TagSelected, (selection: QuickPickItem) =>
+  workspace.updateSchemaTag(selection),
 );
 
-connection.onNotification("apollographql/getStats", async ({ uri }) => {
+connection.onNotification(Commands.GetStats, async ({ uri }) => {
   const status = await languageProvider.provideStats(uri);
-  connection.sendNotification("apollographql/statsLoaded", status);
+  connection.sendNotification(Notifications.StatsLoaded, status);
+});
+connection.onRequest(Requests.FileStats, async ({ uri }) => {
+  return languageProvider.provideStats(uri);
 });
 
 // Listen on the connection

package/src/language-server/typings/graphql.d.ts

@@ -10,13 +10,13 @@ import {
 // to `@types/graphql`.
 declare module "graphql/language/predicates" {
   function isExecutableDefinitionNode(
-    node: ASTNode
+    node: ASTNode,
   ): node is OperationDefinitionNode | FragmentDefinitionNode;
   function isTypeSystemDefinitionNode(
-    node: ASTNode
+    node: ASTNode,
   ): node is TypeSystemDefinitionNode;
   function isTypeSystemExtensionNode(
-    node: ASTNode
+    node: ASTNode,
   ): node is TypeSystemExtensionNode;
 }