vscode-apollo 1.19.3 → 2.0.0

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

@@ -0,0 +1,176 @@
+// FileSchemaProvider (FileProvider (SDL || IntrospectionResult) => schema)
+import {
+  GraphQLSchema,
+  buildClientSchema,
+  Source,
+  printSchema,
+  parse,
+  buildASTSchema,
+} from "graphql";
+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/node";
+import { Debug } from "../../utilities";
+import { buildSubgraphSchema } from "@apollo/subgraph";
+import { URI } from "vscode-uri";
+// import federationDirectives from "@apollo/federation/src/directives";
+
+export interface FileSchemaProviderConfig {
+  path?: string;
+  paths?: string[];
+}
+// XXX file subscription
+export class FileSchemaProvider implements GraphQLSchemaProvider {
+  private schema?: GraphQLSchema;
+  private federatedServiceSDL?: string;
+
+  constructor(
+    private config: FileSchemaProviderConfig,
+    private configDir: URI | undefined,
+  ) {}
+
+  async resolveSchema() {
+    if (this.schema) return this.schema;
+    const { path, paths } = this.config;
+
+    // load each path and get sdl string from each, if a list, concatenate them all
+    const documents = path
+      ? [this.loadFileAndGetDocument(path)]
+      : paths
+      ? paths.map(this.loadFileAndGetDocument, this)
+      : undefined;
+
+    if (!documents)
+      throw new Error(
+        `Schema could not be loaded for [${
+          path ? path : paths ? paths.join(", ") : "undefined"
+        }]`,
+      );
+
+    this.schema = buildASTSchema(mergeTypeDefs(documents));
+
+    if (!this.schema) throw new Error(`Schema could not be loaded for ${path}`);
+    return this.schema;
+  }
+
+  // load a graphql file or introspection result and return the GraphQL DocumentNode
+  // this is the mechanism for loading a single file's DocumentNode
+  loadFileAndGetDocument(path: string) {
+    let result;
+    try {
+      result = this.readFileSync(path);
+    } catch (err: any) {
+      throw new Error(`Unable to read file ${path}. ${err.message}`);
+    }
+
+    const ext = extname(path);
+
+    // an actual introspection query result, convert to DocumentNode
+    if (ext === ".json") {
+      const parsed = JSON.parse(result);
+      const __schema = parsed.data
+        ? parsed.data.__schema
+        : parsed.__schema
+        ? parsed.__schema
+        : parsed;
+
+      const schema = buildClientSchema({ __schema });
+      return parse(printSchema(schema));
+    } else if (ext === ".graphql" || ext === ".graphqls" || ext === ".gql") {
+      const uri = URI.file(resolve(path)).toString();
+      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",
+    );
+  }
+
+  onSchemaChange(
+    _handler: NotificationHandler<GraphQLSchema>,
+  ): SchemaChangeUnsubscribeHandler {
+    throw new Error("File watching not implemented yet");
+    return () => {};
+  }
+
+  // Load SDL from files. This is only used with federated services,
+  // since they need full SDL and not the printout of GraphQLSchema
+  async resolveFederatedServiceSDL() {
+    if (this.federatedServiceSDL) return this.federatedServiceSDL;
+
+    const { path, paths } = this.config;
+
+    // load each path and get sdl string from each, if a list, concatenate them all
+    const SDLs = path
+      ? [this.loadFileAndGetSDL(path)]
+      : paths
+      ? paths.map(this.loadFileAndGetSDL, this)
+      : undefined;
+
+    if (!SDLs || SDLs.filter((s) => !Boolean(s)).length > 0)
+      return Debug.error(
+        `SDL could not be loaded for one of more files: [${
+          path ? path : paths ? paths.join(", ") : "undefined"
+        }]`,
+      );
+
+    const federatedSchema = buildSubgraphSchema(
+      SDLs.map((sdl) => ({ typeDefs: parse(sdl as string) })),
+    );
+
+    // call the `Query._service` resolver to get the actual printed sdl
+    const queryType = federatedSchema.getQueryType();
+    if (!queryType)
+      return Debug.error("No query type found for federated schema");
+    const serviceField = queryType.getFields()["_service"];
+    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",
+      );
+
+    this.federatedServiceSDL = serviceResults.sdl;
+    return this.federatedServiceSDL;
+  }
+
+  // this is the mechanism for loading a single file's SDL
+  loadFileAndGetSDL(path: string) {
+    let result;
+    try {
+      result = this.readFileSync(path);
+    } catch (err: any) {
+      return Debug.error(`Unable to read file ${path}. ${err.message}`);
+    }
+
+    const ext = extname(path);
+
+    // this file should already be in sdl format
+    if (ext === ".graphql" || ext === ".graphqls" || ext === ".gql") {
+      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",
+      );
+    }
+  }
+
+  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

@@ -0,0 +1,59 @@
+import {
+  GraphQLSchemaProvider,
+  SchemaChangeUnsubscribeHandler,
+  SchemaResolveConfig,
+} from "./base";
+import {
+  ApolloConfig,
+  isClientConfig,
+  isLocalServiceConfig,
+  ClientConfig,
+} from "../../config";
+
+import { EndpointSchemaProvider } from "./endpoint";
+import { EngineSchemaProvider } from "./engine";
+import { FileSchemaProvider } from "./file";
+import { ClientIdentity } from "../../engine";
+
+export {
+  GraphQLSchemaProvider,
+  SchemaChangeUnsubscribeHandler,
+  SchemaResolveConfig,
+};
+
+export function schemaProviderFromConfig(
+  config: ApolloConfig,
+  clientIdentity: ClientIdentity, // engine provider needs this
+): GraphQLSchemaProvider {
+  if (isClientConfig(config)) {
+    if (typeof config.client.service === "string") {
+      return new EngineSchemaProvider(config, clientIdentity);
+    }
+
+    if (config.client.service) {
+      if (isLocalServiceConfig(config.client.service)) {
+        const isListOfSchemaFiles = Array.isArray(
+          config.client.service.localSchemaFile,
+        );
+        return new FileSchemaProvider(
+          isListOfSchemaFiles
+            ? { paths: config.client.service.localSchemaFile as string[] }
+            : {
+                path: config.client.service.localSchemaFile as string,
+              },
+          config.configDirURI,
+        );
+      }
+
+      return new EndpointSchemaProvider(config.client.service);
+    }
+  }
+
+  if (config.graph && config.engine) {
+    return new EngineSchemaProvider(config as ClientConfig, clientIdentity);
+  }
+
+  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",
+  );
+}

package/src/language-server/server.ts

@@ -0,0 +1,274 @@
+import "../env";
+import {
+  createConnection,
+  ProposedFeatures,
+  TextDocuments,
+  FileChangeType,
+  ServerCapabilities,
+  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 { 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);
+
+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),
+);
+
+const workspace = new GraphQLWorkspace(
+  new LanguageServerLoadingHandler(connection),
+  {
+    clientIdentity: {
+      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) => {
+  connection.sendDiagnostics(params);
+});
+
+workspace.onDecorations((params) => {
+  connection.sendNotification(Notifications.EngineDecorations, {
+    decorations: params,
+  });
+});
+
+workspace.onSchemaTags((params) => {
+  connection.sendNotification(Notifications.TagsLoaded, JSON.stringify(params));
+});
+
+workspace.onConfigFilesFound(async (params) => {
+  connection.sendNotification(
+    Notifications.ConfigFilesFound,
+    JSON.stringify(params, (_key, value) =>
+      !value
+        ? value
+        : value instanceof Error || isValidationError(value)
+        ? { message: value.message, stack: value.stack }
+        : value,
+    ),
+  );
+});
+
+connection.onInitialize(async ({ capabilities, workspaceFolders }) => {
+  hasWorkspaceFolderCapability = !!(
+    capabilities.workspace && capabilities.workspace.workspaceFolders
+  );
+
+  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,
+      },
+      codeActionProvider: true,
+      executeCommandProvider: {
+        commands: [],
+      },
+      textDocumentSync: TextDocumentSyncKind.Full,
+    } as ServerCapabilities,
+  };
+});
+
+connection.onInitialized(async () => {
+  initializeConnection();
+  if (hasWorkspaceFolderCapability) {
+    connection.workspace.onDidChangeWorkspaceFolders(async (event) => {
+      await Promise.all([
+        ...event.removed.map((folder) =>
+          workspace.removeProjectsInFolder(folder),
+        ),
+        ...event.added.map((folder) => workspace.addProjectsInFolder(folder)),
+      ]);
+    });
+  }
+});
+
+const documents = new TextDocuments(TextDocument);
+
+// Make the text document manager listen on the connection
+// for open, change and close text document events
+documents.listen(connection);
+
+function isFile(uri: string) {
+  return URI.parse(uri).scheme === "file";
+}
+
+documents.onDidChangeContent(
+  debounceHandler((params) => {
+    const project = workspace.projectForFile(params.document.uri);
+    if (!project) return;
+
+    // Only watch changes to files
+    if (!isFile(params.document.uri)) {
+      return;
+    }
+
+    project.documentDidChange(params.document);
+  }),
+);
+
+connection.onDidChangeWatchedFiles((params) => {
+  for (const { uri, type } of params.changes) {
+    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);
+    }
+
+    // Don't respond to changes in files that are currently open,
+    // because we'll get content change notifications instead
+    if (type === FileChangeType.Changed) {
+      continue;
+    }
+
+    // Only watch changes to files
+    if (!isFile(uri)) {
+      continue;
+    }
+
+    const project = workspace.projectForFile(uri);
+    if (!project) continue;
+
+    switch (type) {
+      case FileChangeType.Created:
+        project.fileDidChange(uri);
+        break;
+      case FileChangeType.Deleted:
+        project.fileWasDeleted(uri);
+        break;
+    }
+  }
+});
+
+const languageProvider = new GraphQLLanguageProvider(workspace);
+
+connection.onHover((params, token) =>
+  languageProvider.provideHover(
+    params.textDocument.uri,
+    params.position,
+    token,
+  ),
+);
+
+connection.onDefinition((params, token) =>
+  languageProvider.provideDefinition(
+    params.textDocument.uri,
+    params.position,
+    token,
+  ),
+);
+
+connection.onReferences((params, token) =>
+  languageProvider.provideReferences(
+    params.textDocument.uri,
+    params.position,
+    params.context,
+    token,
+  ),
+);
+
+connection.onDocumentSymbol((params, token) =>
+  languageProvider.provideDocumentSymbol(params.textDocument.uri, token),
+);
+
+connection.onWorkspaceSymbol((params, token) =>
+  languageProvider.provideWorkspaceSymbol(params.query, token),
+);
+
+connection.onCompletion(
+  debounceHandler((params, token) =>
+    languageProvider.provideCompletionItems(
+      params.textDocument.uri,
+      params.position,
+      token,
+    ),
+  ),
+);
+
+connection.onCodeLens(
+  debounceHandler((params, token) =>
+    languageProvider.provideCodeLenses(params.textDocument.uri, token),
+  ),
+);
+
+connection.onCodeAction(
+  debounceHandler((params, token) =>
+    languageProvider.provideCodeAction(
+      params.textDocument.uri,
+      params.range,
+      token,
+    ),
+  ),
+);
+
+connection.onNotification(Commands.ReloadService, () =>
+  workspace.reloadService(),
+);
+
+connection.onNotification(Commands.TagSelected, (selection: QuickPickItem) =>
+  workspace.updateSchemaTag(selection),
+);
+
+connection.onNotification(Commands.GetStats, async ({ uri }) => {
+  const status = await languageProvider.provideStats(uri);
+  connection.sendNotification(Notifications.StatsLoaded, status);
+});
+connection.onRequest(Requests.FileStats, async ({ uri }) => {
+  return languageProvider.provideStats(uri);
+});
+
+// Listen on the connection
+connection.listen();

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

@@ -0,0 +1,27 @@
+import {
+  ASTNode,
+  TypeSystemDefinitionNode,
+  TypeSystemExtensionNode,
+  FragmentDefinitionNode,
+  OperationDefinitionNode,
+} from "graphql";
+
+// FIXME: We should add proper type guards for these predicate functions
+// to `@types/graphql`.
+declare module "graphql/language/predicates" {
+  function isExecutableDefinitionNode(
+    node: ASTNode,
+  ): node is OperationDefinitionNode | FragmentDefinitionNode;
+  function isTypeSystemDefinitionNode(
+    node: ASTNode,
+  ): node is TypeSystemDefinitionNode;
+  function isTypeSystemExtensionNode(
+    node: ASTNode,
+  ): node is TypeSystemExtensionNode;
+}
+
+declare module "graphql/validation/validate" {
+  interface ValidationContext {
+    _fragments: { [fragmentName: string]: FragmentDefinitionNode };
+  }
+}