vscode-apollo 1.19.3 → 1.20.0

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

@@ -0,0 +1,75 @@
+import {
+  GraphQLSchemaProvider,
+  SchemaChangeUnsubscribeHandler,
+  SchemaResolveConfig,
+} from "./base";
+import {
+  ApolloConfig,
+  isClientConfig,
+  isServiceConfig,
+  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 {
+  // 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);
+    }
+
+    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,
+              }
+        );
+      }
+
+      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,252 @@
+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";
+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";
+
+const connection: Connection = createConnection(ProposedFeatures.all);
+Debug.SetConnection(connection);
+
+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"],
+      version: process.env["APOLLO_CLIENT_VERSION"],
+      referenceID: process.env["APOLLO_CLIENT_REFERENCE_ID"],
+    },
+  }
+);
+
+workspace.onDiagnostics((params) => {
+  connection.sendDiagnostics(params);
+});
+
+workspace.onDecorations((params) => {
+  connection.sendNotification("apollographql/engineDecorations", {
+    decorations: params,
+  });
+});
+
+workspace.onSchemaTags((params) => {
+  connection.sendNotification(
+    "apollographql/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)
+  );
+});
+
+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: documents.syncKind,
+    } 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: TextDocuments = new TextDocuments();
+
+// 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(".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("apollographql/reloadService", () =>
+  workspace.reloadService()
+);
+
+connection.onNotification(
+  "apollographql/tagSelected",
+  (selection: QuickPickItem) => workspace.updateSchemaTag(selection)
+);
+
+connection.onNotification("apollographql/getStats", async ({ uri }) => {
+  const status = await languageProvider.provideStats(uri);
+  connection.sendNotification("apollographql/statsLoaded", status);
+});
+
+// Listen on the connection
+connection.listen();

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

@@ -0,0 +1,4 @@
+// `codemirror` types have some issues, and this isn't really being used anyways
+declare module "codemirror" {
+  type Token = any;
+}

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 };
+  }
+}