vscode-apollo 2.0.0 → 2.1.0

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

@@ -0,0 +1,349 @@
+import path, { extname } from "path";
+import { lstatSync, readFileSync } from "fs";
+import { URI } from "vscode-uri";
+
+import {
+  TypeSystemDefinitionNode,
+  isTypeSystemDefinitionNode,
+  TypeSystemExtensionNode,
+  isTypeSystemExtensionNode,
+  DefinitionNode,
+  GraphQLSchema,
+  Kind,
+} from "graphql";
+
+import {
+  FileChangeType,
+  NotificationHandler,
+  Position,
+} from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+
+import { GraphQLDocument, extractGraphQLDocuments } from "../document";
+
+import { ClientConfig, isClientConfig, isLocalServiceConfig } from "../config";
+import {
+  schemaProviderFromConfig,
+  GraphQLSchemaProvider,
+  SchemaResolveConfig,
+} from "../providers/schema";
+import { ApolloEngineClient, ClientIdentity } from "../engine";
+import { GraphQLProject, DocumentUri, GraphQLProjectConfig } from "./base";
+import throttle from "lodash.throttle";
+
+const fileAssociations: { [extension: string]: string } = {
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  ".js": "javascript",
+  ".ts": "typescript",
+  ".jsx": "javascriptreact",
+  ".tsx": "typescriptreact",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".py": "python",
+  ".rb": "ruby",
+  ".dart": "dart",
+  ".re": "reason",
+  ".ex": "elixir",
+  ".exs": "elixir",
+};
+
+export interface GraphQLInternalProjectConfig extends GraphQLProjectConfig {
+  config: ClientConfig;
+  clientIdentity: ClientIdentity;
+}
+export abstract class GraphQLInternalProject
+  extends GraphQLProject
+  implements GraphQLSchemaProvider
+{
+  public schemaProvider: GraphQLSchemaProvider;
+  protected engineClient?: ApolloEngineClient;
+
+  private needsValidation = false;
+
+  protected documentsByFile: Map<DocumentUri, GraphQLDocument[]>;
+
+  constructor({
+    config,
+    configFolderURI,
+    loadingHandler,
+    clientIdentity,
+  }: GraphQLInternalProjectConfig) {
+    super({ config, configFolderURI, loadingHandler });
+    const { includes = [], 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.schemaProvider = schemaProviderFromConfig(config, clientIdentity);
+    const { engine } = config;
+    if (engine.apiKey) {
+      this.engineClient = new ApolloEngineClient(
+        engine.apiKey!,
+        engine.endpoint,
+        clientIdentity,
+      );
+    }
+  }
+
+  public resolveSchema(config: SchemaResolveConfig): Promise<GraphQLSchema> {
+    this.lastLoadDate = +new Date();
+    return this.schemaProvider.resolveSchema(config);
+  }
+
+  public resolveFederatedServiceSDL() {
+    return this.schemaProvider.resolveFederatedServiceSDL();
+  }
+
+  public onSchemaChange(handler: NotificationHandler<GraphQLSchema>) {
+    this.lastLoadDate = +new Date();
+    return this.schemaProvider.onSchemaChange(handler);
+  }
+
+  includesFile(uri: DocumentUri) {
+    return this.fileSet.includesFile(uri);
+  }
+
+  allIncludedFiles() {
+    return this.fileSet.allFiles();
+  }
+
+  async scanAllIncludedFiles() {
+    await this.loadingHandler.handle(
+      `Loading queries for ${this.displayName}`,
+      (async () => {
+        for (const filePath of this.allIncludedFiles()) {
+          const uri = URI.file(filePath).toString();
+
+          // If we already have query documents for this file, that means it was either
+          // opened or changed before we got a chance to read it.
+          if (this.documentsByFile.has(uri)) continue;
+
+          this.fileDidChange(uri);
+        }
+      })(),
+    );
+  }
+
+  fileDidChange(uri: DocumentUri) {
+    const filePath = URI.parse(uri).fsPath;
+    const extension = extname(filePath);
+    const languageId = fileAssociations[extension];
+
+    // Don't process files of an unsupported filetype
+    if (!languageId) return;
+
+    // Don't process directories. Directories might be named like files so
+    // we have to explicitly check.
+    if (!lstatSync(filePath).isFile()) return;
+
+    const contents = readFileSync(filePath, "utf8");
+    const document = TextDocument.create(uri, languageId, -1, contents);
+    this.documentDidChange(document);
+  }
+
+  fileWasDeleted(uri: DocumentUri) {
+    this.removeGraphQLDocumentsFor(uri);
+    this.checkForDuplicateOperations();
+  }
+
+  documentDidChange = (document: TextDocument) => {
+    const documents = extractGraphQLDocuments(
+      document,
+      this.config.client && this.config.client.tagName,
+    );
+    if (documents) {
+      this.documentsByFile.set(document.uri, documents);
+      this.invalidate();
+    } else {
+      this.removeGraphQLDocumentsFor(document.uri);
+    }
+    this.checkForDuplicateOperations();
+  };
+
+  checkForDuplicateOperations = throttle(
+    () => {
+      const filePathForOperationName: Record<string, string> = {};
+      for (const [
+        fileUri,
+        documentsForFile,
+      ] of this.documentsByFile.entries()) {
+        const filePath = URI.parse(fileUri).fsPath;
+        for (const document of documentsForFile) {
+          if (!document.ast) continue;
+          for (const definition of document.ast.definitions) {
+            if (
+              definition.kind === Kind.OPERATION_DEFINITION &&
+              definition.name
+            ) {
+              const operationName = definition.name.value;
+              if (operationName in filePathForOperationName) {
+                const conflictingFilePath =
+                  filePathForOperationName[operationName];
+                throw new Error(
+                  `️️There are multiple definitions for the \`${definition.name.value}\` operation. Please fix all naming conflicts before continuing.\nConflicting definitions found at ${filePath} and ${conflictingFilePath}.`,
+                );
+              }
+              filePathForOperationName[operationName] = filePath;
+            }
+          }
+        }
+      }
+    },
+    250,
+    { leading: true, trailing: true },
+  );
+
+  private removeGraphQLDocumentsFor(uri: DocumentUri) {
+    if (this.documentsByFile.has(uri)) {
+      this.documentsByFile.delete(uri);
+
+      if (this._onDiagnostics) {
+        this._onDiagnostics({ uri: uri, diagnostics: [] });
+      }
+
+      this.invalidate();
+    }
+  }
+
+  protected invalidate() {
+    if (!this.needsValidation && this.isReady) {
+      setTimeout(() => {
+        this.validateIfNeeded();
+      }, 0);
+      this.needsValidation = true;
+    }
+  }
+
+  private validateIfNeeded() {
+    if (!this.needsValidation || !this.isReady) return;
+
+    this.validate();
+
+    this.needsValidation = false;
+  }
+
+  private getRelativeLocalSchemaFilePaths(): string[] {
+    const serviceConfig =
+      isClientConfig(this.config) &&
+      typeof this.config.client.service === "object" &&
+      isLocalServiceConfig(this.config.client.service)
+        ? this.config.client.service
+        : undefined;
+    const localSchemaFile = serviceConfig?.localSchemaFile;
+    return (
+      localSchemaFile === undefined
+        ? []
+        : Array.isArray(localSchemaFile)
+        ? localSchemaFile
+        : [localSchemaFile]
+    ).map((filePath) =>
+      path.relative(this.rootURI.fsPath, path.join(process.cwd(), filePath)),
+    );
+  }
+
+  abstract validate(): void;
+
+  clearAllDiagnostics() {
+    if (!this._onDiagnostics) return;
+
+    for (const uri of this.documentsByFile.keys()) {
+      this._onDiagnostics({ uri, diagnostics: [] });
+    }
+  }
+
+  documentsAt(uri: DocumentUri): GraphQLDocument[] | undefined {
+    return this.documentsByFile.get(uri);
+  }
+
+  documentAt(
+    uri: DocumentUri,
+    position: Position,
+  ): GraphQLDocument | undefined {
+    const queryDocuments = this.documentsByFile.get(uri);
+    if (!queryDocuments) return undefined;
+
+    return queryDocuments.find((document) =>
+      document.containsPosition(position),
+    );
+  }
+
+  get documents(): GraphQLDocument[] {
+    const documents: GraphQLDocument[] = [];
+    for (const documentsForFile of this.documentsByFile.values()) {
+      documents.push(...documentsForFile);
+    }
+    return documents;
+  }
+
+  get definitions(): DefinitionNode[] {
+    const definitions = [];
+
+    for (const document of this.documents) {
+      if (!document.ast) continue;
+
+      definitions.push(...document.ast.definitions);
+    }
+
+    return definitions;
+  }
+
+  definitionsAt(uri: DocumentUri): DefinitionNode[] {
+    const documents = this.documentsAt(uri);
+    if (!documents) return [];
+
+    const definitions = [];
+
+    for (const document of documents) {
+      if (!document.ast) continue;
+
+      definitions.push(...document.ast.definitions);
+    }
+
+    return definitions;
+  }
+
+  get typeSystemDefinitionsAndExtensions(): (
+    | TypeSystemDefinitionNode
+    | TypeSystemExtensionNode
+  )[] {
+    const definitionsAndExtensions = [];
+    for (const document of this.documents) {
+      if (!document.ast) continue;
+      for (const definition of document.ast.definitions) {
+        if (
+          isTypeSystemDefinitionNode(definition) ||
+          isTypeSystemExtensionNode(definition)
+        ) {
+          definitionsAndExtensions.push(definition);
+        }
+      }
+    }
+    return definitionsAndExtensions;
+  }
+  onDidOpen: undefined;
+  onDidClose: undefined;
+  onDidChangeWatchedFiles: GraphQLProject["onDidChangeWatchedFiles"] = (
+    params,
+  ) => {
+    for (const { uri, type } of params.changes) {
+      switch (type) {
+        case FileChangeType.Created:
+          this.fileDidChange(uri);
+          break;
+        case FileChangeType.Deleted:
+          this.fileWasDeleted(uri);
+          break;
+      }
+    }
+  };
+  onUnhandledRequest: undefined;
+  onUnhandledNotification: undefined;
+  dispose: undefined;
+}

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

@@ -0,0 +1,308 @@
+import { extractGraphQLSources } from "../../document";
+import {
+  ProtocolNotificationType,
+  DidChangeTextDocumentNotification,
+  DidOpenTextDocumentNotification,
+  DidCloseTextDocumentNotification,
+  TextDocumentPositionParams,
+  Diagnostic,
+  NotificationHandler,
+  PublishDiagnosticsParams,
+} from "vscode-languageserver-protocol";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { DocumentUri, GraphQLProject } from "../base";
+import { generateKeyBetween } from "fractional-indexing";
+import { Source } from "graphql";
+import {
+  findContainedSourceAndPosition,
+  rangeInContainingDocument,
+} from "../../utilities/source";
+import { URI } from "vscode-uri";
+import { DEBUG } from "./project";
+
+export interface FilePart {
+  fractionalIndex: string;
+  source: Source;
+  diagnostics: Diagnostic[];
+}
+
+export function handleFilePartUpdates(
+  parsed: ReadonlyArray<Source>,
+  previousParts: ReadonlyArray<FilePart>,
+): ReadonlyArray<FilePart> {
+  const newParts: FilePart[] = [];
+  let newIdx = 0;
+  let oldIdx = 0;
+  let offsetCorrection = 0;
+  while (newIdx < parsed.length || oldIdx < previousParts.length) {
+    const source = parsed[newIdx] as Source | undefined;
+    const oldPart = previousParts[oldIdx] as FilePart | undefined;
+    if (!source) return newParts;
+    const newOffset = source.locationOffset.line;
+
+    if (
+      oldPart &&
+      (source.body === oldPart.source.body ||
+        newOffset === oldPart.source.locationOffset.line + offsetCorrection)
+    ) {
+      // replacement of chunk
+      newParts.push({ ...oldPart, source });
+      offsetCorrection =
+        source.locationOffset.line - oldPart.source.locationOffset.line;
+      newIdx++;
+      oldIdx++;
+    } else if (
+      !oldPart ||
+      newOffset < oldPart.source.locationOffset.line + offsetCorrection
+    ) {
+      // inserted chunk
+      const fractionalIndex = generateKeyBetween(
+        newParts.length == 0
+          ? null
+          : newParts[newParts.length - 1].fractionalIndex,
+        oldPart ? oldPart.fractionalIndex : null,
+      );
+      newParts.push({ source, fractionalIndex, diagnostics: [] });
+      newIdx++;
+      offsetCorrection += source.body.split("\n").length - 1;
+    } else {
+      // deleted chunk
+      oldIdx++;
+    }
+  }
+  return newParts;
+}
+
+function getUri(document: TextDocument, part: FilePart) {
+  let uri = URI.parse(part.source.name);
+  if (document.languageId !== "graphql") {
+    uri = uri.with({ fragment: part.fractionalIndex });
+  }
+
+  return uri.toString();
+}
+
+function splitUri(fullUri: DocumentUri) {
+  const uri = URI.parse(fullUri);
+  return {
+    uri: uri.with({ fragment: null }).toString(),
+    fractionalIndex: uri.fragment || "a0",
+  };
+}
+
+export class DocumentSynchronization {
+  private pendingDocumentChanges = new Map<DocumentUri, TextDocument>();
+  private knownFiles = new Map<
+    DocumentUri,
+    {
+      full: TextDocument;
+      parts: ReadonlyArray<FilePart>;
+    }
+  >();
+
+  constructor(
+    private sendNotification: <P, RO>(
+      type: ProtocolNotificationType<P, RO>,
+      params?: P,
+    ) => Promise<void>,
+    private sendDiagnostics: NotificationHandler<PublishDiagnosticsParams>,
+  ) {}
+
+  private documentSynchronizationScheduled = false;
+  /**
+   * Ensures that only one `syncNextDocumentChange` is queued with the connection at a time.
+   * As a result, other, more important, changes can be processed with higher priority.
+   */
+  private scheduleDocumentSync = async () => {
+    if (
+      this.pendingDocumentChanges.size === 0 ||
+      this.documentSynchronizationScheduled
+    ) {
+      return;
+    }
+
+    this.documentSynchronizationScheduled = true;
+    try {
+      const next = this.pendingDocumentChanges.values().next();
+      if (next.done) return;
+      await this.sendDocumentChanges(next.value);
+    } finally {
+      this.documentSynchronizationScheduled = false;
+      setImmediate(this.scheduleDocumentSync);
+    }
+  };
+
+  private async sendDocumentChanges(
+    document: TextDocument,
+    previousParts = this.knownFiles.get(document.uri)?.parts || [],
+  ) {
+    this.pendingDocumentChanges.delete(document.uri);
+
+    const previousObj = Object.fromEntries(
+      previousParts.map((p) => [p.fractionalIndex, p]),
+    );
+    const newParts = handleFilePartUpdates(
+      extractGraphQLSources(document) || [],
+      previousParts,
+    );
+    const newObj = Object.fromEntries(
+      newParts.map((p) => [p.fractionalIndex, p]),
+    );
+    this.knownFiles.set(document.uri, { full: document, parts: newParts });
+
+    for (const newPart of newParts) {
+      const previousPart = previousObj[newPart.fractionalIndex];
+      if (!previousPart) {
+        await this.sendNotification(DidOpenTextDocumentNotification.type, {
+          textDocument: {
+            uri: getUri(document, newPart),
+            languageId: "graphql",
+            version: document.version,
+            text: newPart.source.body,
+          },
+        });
+      } else if (newPart.source.body !== previousPart.source.body) {
+        await this.sendNotification(DidChangeTextDocumentNotification.type, {
+          textDocument: {
+            uri: getUri(document, newPart),
+            version: document.version,
+          },
+          contentChanges: [
+            {
+              text: newPart.source.body,
+            },
+          ],
+        });
+      }
+    }
+    for (const previousPart of previousParts) {
+      if (!newObj[previousPart.fractionalIndex]) {
+        await this.sendNotification(DidCloseTextDocumentNotification.type, {
+          textDocument: {
+            uri: getUri(document, previousPart),
+          },
+        });
+      }
+    }
+  }
+
+  async resendAllDocuments() {
+    for (const file of this.knownFiles.values()) {
+      await this.sendDocumentChanges(file.full, []);
+    }
+  }
+
+  onDidOpenTextDocument: NonNullable<GraphQLProject["onDidOpen"]> = async (
+    params,
+  ) => {
+    this.documentDidChange(params.document);
+  };
+
+  onDidCloseTextDocument: NonNullable<GraphQLProject["onDidClose"]> = (
+    params,
+  ) => {
+    const known = this.knownFiles.get(params.document.uri);
+    if (!known) {
+      return;
+    }
+    this.knownFiles.delete(params.document.uri);
+    return Promise.all(
+      known.parts.map((part) =>
+        this.sendNotification(DidCloseTextDocumentNotification.type, {
+          textDocument: {
+            uri: getUri(known.full, part),
+          },
+        }),
+      ),
+    );
+  };
+
+  async documentDidChange(document: TextDocument) {
+    if (this.pendingDocumentChanges.has(document.uri)) {
+      // this will put the document at the end of the queue again
+      // in hopes that we can skip a bit of unnecessary work sometimes
+      // when many files change around a lot
+      // we will always ensure that a document is synchronized via `synchronizedWithDocument`
+      // before we do other operations on the document, so this is safe
+      this.pendingDocumentChanges.delete(document.uri);
+    }
+
+    this.pendingDocumentChanges.set(document.uri, document);
+    this.scheduleDocumentSync();
+  }
+
+  async synchronizedWithDocument(documentUri: DocumentUri): Promise<void> {
+    const document = this.pendingDocumentChanges.get(documentUri);
+    if (document) {
+      await this.sendDocumentChanges(document);
+    }
+  }
+
+  async insideVirtualDocument<T>(
+    positionParams: TextDocumentPositionParams,
+    cb: (virtualPositionParams: TextDocumentPositionParams) => Promise<T>,
+  ): Promise<T | undefined> {
+    await this.synchronizedWithDocument(positionParams.textDocument.uri);
+    const found = this.knownFiles.get(positionParams.textDocument.uri);
+    if (!found) {
+      return;
+    }
+    const match = findContainedSourceAndPosition(
+      found.parts,
+      positionParams.position,
+    );
+
+    if (!match) return;
+    return cb({
+      textDocument: {
+        uri: getUri(found.full, match),
+      },
+      position: match.position,
+    });
+  }
+
+  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) {
+      return;
+    }
+    const part = found.parts.find(
+      (p) => p.fractionalIndex === uriDetails.fractionalIndex,
+    );
+    if (!part) {
+      return;
+    }
+    part.diagnostics = params.diagnostics;
+
+    const fullDocumentParams: PublishDiagnosticsParams = {
+      uri: found.full.uri,
+      version: found.full.version,
+      diagnostics: found.parts.flatMap((p) =>
+        p.diagnostics.map((diagnostic) => ({
+          ...diagnostic,
+          range: rangeInContainingDocument(p.source, diagnostic.range),
+        })),
+      ),
+    };
+
+    this.sendDiagnostics(fullDocumentParams);
+  }
+
+  get openDocuments() {
+    return [...this.knownFiles.values()].map((f) => f.full);
+  }
+
+  clearAllDiagnostics() {
+    for (const file of this.knownFiles.values()) {
+      for (const part of file.parts) {
+        part.diagnostics = [];
+      }
+      this.sendDiagnostics({ uri: file.full.uri, diagnostics: [] });
+    }
+  }
+}