vscode-apollo 1.19.2 → 1.20.0

package/src/language-server/diagnostics.ts

@@ -0,0 +1,109 @@
+import {
+  GraphQLSchema,
+  GraphQLError,
+  FragmentDefinitionNode,
+  findDeprecatedUsages,
+  isExecutableDefinitionNode,
+} from "graphql";
+
+import { Diagnostic, DiagnosticSeverity } from "vscode-languageserver";
+
+import { GraphQLDocument } from "./document";
+import { highlightNodeForNode } from "./utilities/graphql";
+import { rangeForASTNode } from "./utilities/source";
+
+import { getValidationErrors } from "./errors/validation";
+import { DocumentUri } from "./project/base";
+import { ValidationRule } from "graphql/validation/ValidationContext";
+
+/**
+ * Build an array of code diagnostics for all executable definitions in a document.
+ */
+export function collectExecutableDefinitionDiagnositics(
+  schema: GraphQLSchema,
+  queryDocument: GraphQLDocument,
+  fragments: { [fragmentName: string]: FragmentDefinitionNode } = {},
+  rules?: ValidationRule[]
+): Diagnostic[] {
+  const ast = queryDocument.ast;
+  if (!ast) return queryDocument.syntaxErrors;
+
+  const astWithExecutableDefinitions = {
+    ...ast,
+    definitions: ast.definitions.filter(isExecutableDefinitionNode),
+  };
+
+  const diagnostics = [];
+
+  for (const error of getValidationErrors(
+    schema,
+    astWithExecutableDefinitions,
+    fragments,
+    rules
+  )) {
+    diagnostics.push(
+      ...diagnosticsFromError(error, DiagnosticSeverity.Error, "Validation")
+    );
+  }
+
+  for (const error of findDeprecatedUsages(
+    schema,
+    astWithExecutableDefinitions
+  )) {
+    diagnostics.push(
+      ...diagnosticsFromError(error, DiagnosticSeverity.Warning, "Deprecation")
+    );
+  }
+
+  return diagnostics;
+}
+
+export function diagnosticsFromError(
+  error: GraphQLError,
+  severity: DiagnosticSeverity,
+  type: string
+): GraphQLDiagnostic[] {
+  if (!error.nodes) {
+    return [];
+  }
+
+  return error.nodes.map((node) => {
+    return {
+      source: `GraphQL: ${type}`,
+      message: error.message,
+      severity,
+      range: rangeForASTNode(highlightNodeForNode(node) || node),
+      error,
+    };
+  });
+}
+
+export interface GraphQLDiagnostic extends Diagnostic {
+  /**
+   * The GraphQLError that produced this Diagnostic
+   */
+  error: GraphQLError;
+}
+
+export namespace GraphQLDiagnostic {
+  export function is(diagnostic: Diagnostic): diagnostic is GraphQLDiagnostic {
+    return "error" in diagnostic;
+  }
+}
+
+export class DiagnosticSet {
+  private diagnosticsByFile = new Map<DocumentUri, Diagnostic[]>();
+
+  entries() {
+    return this.diagnosticsByFile.entries();
+  }
+
+  addDiagnostics(uri: DocumentUri, diagnostics: Diagnostic[]) {
+    const existingDiagnostics = this.diagnosticsByFile.get(uri);
+    if (!existingDiagnostics) {
+      this.diagnosticsByFile.set(uri, diagnostics);
+    } else {
+      existingDiagnostics.push(...diagnostics);
+    }
+  }
+}

package/src/language-server/document.ts

@@ -0,0 +1,277 @@
+import { parse, Source, DocumentNode } from "graphql";
+import { SourceLocation, getLocation } from "graphql/language/location";
+
+import {
+  TextDocument,
+  Position,
+  Diagnostic,
+  DiagnosticSeverity,
+} from "vscode-languageserver";
+
+import { getRange as rangeOfTokenAtLocation } from "graphql-language-service-interface/dist/getDiagnostics";
+
+import {
+  positionFromSourceLocation,
+  rangeInContainingDocument,
+} from "./utilities/source";
+
+export class GraphQLDocument {
+  ast?: DocumentNode;
+  syntaxErrors: Diagnostic[] = [];
+
+  constructor(public source: Source) {
+    try {
+      this.ast = parse(source);
+    } catch (error: any) {
+      // Don't add syntax errors when GraphQL has been commented out
+      if (maybeCommentedOut(source.body)) return;
+
+      // A GraphQL syntax error only has a location and no node, because we don't have an AST
+      // So we use the online parser to get the range of the token at that location
+      const range = rangeInContainingDocument(
+        source,
+        rangeOfTokenAtLocation(error.locations[0], source.body)
+      );
+      this.syntaxErrors.push({
+        severity: DiagnosticSeverity.Error,
+        message: error.message,
+        source: "GraphQL: Syntax",
+        range,
+      });
+    }
+  }
+
+  containsPosition(position: Position): boolean {
+    if (position.line < this.source.locationOffset.line - 1) return false;
+    const end = positionFromSourceLocation(
+      this.source,
+      getLocation(this.source, this.source.body.length)
+    );
+    return position.line <= end.line;
+  }
+}
+
+export function extractGraphQLDocuments(
+  document: TextDocument,
+  tagName: string = "gql"
+): GraphQLDocument[] | null {
+  switch (document.languageId) {
+    case "graphql":
+      return [
+        new GraphQLDocument(new Source(document.getText(), document.uri)),
+      ];
+    case "javascript":
+    case "javascriptreact":
+    case "typescript":
+    case "typescriptreact":
+    case "vue":
+    case "svelte":
+      return extractGraphQLDocumentsFromJSTemplateLiterals(document, tagName);
+    case "python":
+      return extractGraphQLDocumentsFromPythonStrings(document, tagName);
+    case "ruby":
+      return extractGraphQLDocumentsFromRubyStrings(document, tagName);
+    case "dart":
+      return extractGraphQLDocumentsFromDartStrings(document, tagName);
+    case "reason":
+      return extractGraphQLDocumentsFromReasonStrings(document, tagName);
+    case "elixir":
+      return extractGraphQLDocumentsFromElixirStrings(document, tagName);
+    default:
+      return null;
+  }
+}
+
+function extractGraphQLDocumentsFromJSTemplateLiterals(
+  document: TextDocument,
+  tagName: string
+): GraphQLDocument[] | null {
+  const text = document.getText();
+
+  const documents: GraphQLDocument[] = [];
+
+  const regExp = new RegExp(
+    `(?:${tagName}(?:\\s|\\()*\`|\`#graphql)([\\s\\S]+?)\`\\)?`,
+    "gm"
+  );
+
+  let result;
+  while ((result = regExp.exec(text)) !== null) {
+    const contents = replacePlaceholdersWithWhiteSpace(result[1]);
+    const position = document.positionAt(result.index + (tagName.length + 1));
+    const locationOffset: SourceLocation = {
+      line: position.line + 1,
+      column: position.character + 1,
+    };
+    const source = new Source(contents, document.uri, locationOffset);
+    documents.push(new GraphQLDocument(source));
+  }
+
+  if (documents.length < 1) return null;
+
+  return documents;
+}
+
+function extractGraphQLDocumentsFromPythonStrings(
+  document: TextDocument,
+  tagName: string
+): GraphQLDocument[] | null {
+  const text = document.getText();
+
+  const documents: GraphQLDocument[] = [];
+
+  const regExp = new RegExp(
+    `\\b(${tagName}\\s*\\(\\s*[bfru]*("(?:"")?|'(?:'')?))([\\s\\S]+?)\\2\\s*\\)`,
+    "gm"
+  );
+
+  let result;
+  while ((result = regExp.exec(text)) !== null) {
+    const contents = replacePlaceholdersWithWhiteSpace(result[3]);
+    const position = document.positionAt(result.index + result[1].length);
+    const locationOffset: SourceLocation = {
+      line: position.line + 1,
+      column: position.character + 1,
+    };
+    const source = new Source(contents, document.uri, locationOffset);
+    documents.push(new GraphQLDocument(source));
+  }
+
+  if (documents.length < 1) return null;
+
+  return documents;
+}
+
+function extractGraphQLDocumentsFromRubyStrings(
+  document: TextDocument,
+  tagName: string
+): GraphQLDocument[] | null {
+  const text = document.getText();
+
+  const documents: GraphQLDocument[] = [];
+
+  const regExp = new RegExp(`(<<-${tagName})([\\s\\S]+?)${tagName}`, "gm");
+
+  let result;
+  while ((result = regExp.exec(text)) !== null) {
+    const contents = replacePlaceholdersWithWhiteSpace(result[2]);
+    const position = document.positionAt(result.index + result[1].length);
+    const locationOffset: SourceLocation = {
+      line: position.line + 1,
+      column: position.character + 1,
+    };
+    const source = new Source(contents, document.uri, locationOffset);
+    documents.push(new GraphQLDocument(source));
+  }
+
+  if (documents.length < 1) return null;
+
+  return documents;
+}
+
+function extractGraphQLDocumentsFromDartStrings(
+  document: TextDocument,
+  tagName: string
+): GraphQLDocument[] | null {
+  const text = document.getText();
+
+  const documents: GraphQLDocument[] = [];
+
+  const regExp = new RegExp(
+    `\\b(${tagName}\\(\\s*r?("""|'''))([\\s\\S]+?)\\2\\s*\\)`,
+    "gm"
+  );
+
+  let result;
+  while ((result = regExp.exec(text)) !== null) {
+    const contents = replacePlaceholdersWithWhiteSpace(result[3]);
+    const position = document.positionAt(result.index + result[1].length);
+    const locationOffset: SourceLocation = {
+      line: position.line + 1,
+      column: position.character + 1,
+    };
+    const source = new Source(contents, document.uri, locationOffset);
+    documents.push(new GraphQLDocument(source));
+  }
+
+  if (documents.length < 1) return null;
+
+  return documents;
+}
+
+function extractGraphQLDocumentsFromReasonStrings(
+  document: TextDocument,
+  tagName: string
+): GraphQLDocument[] | null {
+  const text = document.getText();
+
+  const documents: GraphQLDocument[] = [];
+
+  const reasonFileFilter = new RegExp(/(\[%(graphql|relay\.))/g);
+
+  if (!reasonFileFilter.test(text)) {
+    return documents;
+  }
+
+  const reasonRegexp = new RegExp(
+    /(?<=\[%(graphql|relay\.\w*)[\s\S]*{\|)[.\s\S]+?(?=\|})/gm
+  );
+
+  let result;
+  while ((result = reasonRegexp.exec(text)) !== null) {
+    const contents = result[0];
+    const position = document.positionAt(result.index);
+    const locationOffset: SourceLocation = {
+      line: position.line + 1,
+      column: position.character + 1,
+    };
+    const source = new Source(contents, document.uri, locationOffset);
+    documents.push(new GraphQLDocument(source));
+  }
+
+  if (documents.length < 1) return null;
+
+  return documents;
+}
+
+function extractGraphQLDocumentsFromElixirStrings(
+  document: TextDocument,
+  tagName: string
+): GraphQLDocument[] | null {
+  const text = document.getText();
+  const documents: GraphQLDocument[] = [];
+
+  const regExp = new RegExp(
+    `\\b(${tagName}\\(\\s*r?("""))([\\s\\S]+?)\\2\\s*\\)`,
+    "gm"
+  );
+
+  let result;
+  while ((result = regExp.exec(text)) !== null) {
+    const contents = replacePlaceholdersWithWhiteSpace(result[3]);
+    const position = document.positionAt(result.index + result[1].length);
+    const locationOffset: SourceLocation = {
+      line: position.line + 1,
+      column: position.character + 1,
+    };
+    const source = new Source(contents, document.uri, locationOffset);
+    documents.push(new GraphQLDocument(source));
+  }
+
+  if (documents.length < 1) return null;
+
+  return documents;
+}
+
+function replacePlaceholdersWithWhiteSpace(content: string) {
+  return content.replace(/\$\{([\s\S]+?)\}/gm, (match) => {
+    return Array(match.length).join(" ");
+  });
+}
+
+function maybeCommentedOut(content: string) {
+  return (
+    (content.indexOf("/*") > -1 && content.indexOf("*/") > -1) ||
+    content.split("//").length > 1
+  );
+}

package/src/language-server/engine/GraphQLDataSource.ts

@@ -0,0 +1,124 @@
+import { DataSourceConfig } from "apollo-datasource";
+import { ApolloLink, execute, GraphQLRequest, makePromise } from "apollo-link";
+import { setContext } from "apollo-link-context";
+import { onError } from "apollo-link-error";
+import { createHttpLink } from "apollo-link-http";
+import {
+  ApolloError,
+  AuthenticationError,
+  ForbiddenError,
+} from "apollo-server-errors";
+import to from "await-to-js";
+import { GraphQLError } from "graphql";
+import { fetch } from "../../env";
+
+export interface GraphQLResponse<T> {
+  data?: T;
+  errors?: GraphQLError[];
+}
+export class GraphQLDataSource<TContext = any> {
+  public baseURL!: string;
+  public context!: TContext;
+
+  public initialize(config: DataSourceConfig<TContext>): void {
+    this.context = config.context;
+  }
+
+  // XXX can we kill the casting here?
+  public async execute<T>(
+    operation: GraphQLRequest
+  ): Promise<GraphQLResponse<T>> {
+    return this.executeSingleOperation(operation) as Promise<
+      GraphQLResponse<T>
+    >;
+  }
+
+  protected willSendRequest?(request: any): any;
+
+  private composeLinks(): ApolloLink {
+    const uri = this.resolveUri();
+
+    return ApolloLink.from([
+      this.onErrorLink(),
+      this.onRequestLink(),
+      createHttpLink({ fetch, uri }),
+    ]);
+  }
+
+  private didEncounterError(error: any) {
+    const status = error.statusCode ? error.statusCode : null;
+    const message = error.bodyText
+      ? error.bodyText
+      : error.message
+      ? error.message
+      : null;
+
+    let apolloError: ApolloError;
+
+    switch (status) {
+      case 401:
+        apolloError = new AuthenticationError(message);
+        break;
+      case 403:
+        apolloError = new ForbiddenError(message);
+        break;
+      default:
+        apolloError = new ApolloError(message);
+    }
+
+    throw apolloError;
+  }
+
+  private async executeSingleOperation(operation: GraphQLRequest) {
+    const link = this.composeLinks();
+
+    const [error, response] = await to(makePromise(execute(link, operation)));
+
+    if (error) {
+      this.didEncounterError(error);
+    }
+
+    return response;
+  }
+
+  private resolveUri(): string {
+    const baseURL = this.baseURL;
+
+    if (!baseURL) {
+      throw new ApolloError(
+        "Cannot make request to GraphQL API, missing baseURL"
+      );
+    }
+
+    return baseURL;
+  }
+
+  private onRequestLink() {
+    return setContext((_, request) => {
+      if (this.willSendRequest) {
+        this.willSendRequest(request);
+      }
+
+      return request;
+    });
+  }
+
+  private onErrorLink() {
+    return onError(({ graphQLErrors, networkError, operation }) => {
+      const { result, response } = operation.getContext();
+      if (graphQLErrors) {
+        graphQLErrors.map((graphqlError) =>
+          console.error(`[GraphQL error]: ${graphqlError.message}`)
+        );
+      }
+
+      if (networkError) {
+        console.log(`[Network Error]: ${networkError}`);
+      }
+
+      if (response && response.status >= 400) {
+        console.log(`[Network Error] ${response.bodyText}`);
+      }
+    });
+  }
+}

package/src/language-server/engine/index.ts

@@ -0,0 +1,105 @@
+import { GraphQLDataSource } from "./GraphQLDataSource";
+import { DefaultEngineConfig } from "../config";
+import { SCHEMA_TAGS_AND_FIELD_STATS } from "./operations/schemaTagsAndFieldStats";
+import {
+  FrontendUrlRootQuery,
+  SchemaTagsAndFieldStatsQuery,
+} from "../graphqlTypes";
+import { FRONTEND_URL_ROOT } from "./operations/frontendUrlRoot";
+
+export interface ClientIdentity {
+  name?: string;
+  version?: string;
+  referenceID?: string;
+}
+
+export type ServiceID = string;
+export type ClientID = string;
+export type SchemaTag = string;
+export type ServiceIDAndTag = [ServiceID, SchemaTag?];
+export type ServiceSpecifier = string;
+// Map from parent type name to field name to latency in ms.
+export type FieldLatenciesMS = Map<string, Map<string, number | null>>;
+
+export function noServiceError(service: string | undefined, endpoint?: string) {
+  return `Could not find graph ${
+    service ? service : ""
+  } from Apollo at ${endpoint}. Please check your API key and graph ID`;
+}
+
+export class ApolloEngineClient extends GraphQLDataSource {
+  constructor(
+    private engineKey: string,
+    engineEndpoint: string = DefaultEngineConfig.endpoint,
+    private clientIdentity?: ClientIdentity
+  ) {
+    super();
+    this.baseURL = engineEndpoint;
+  }
+
+  // XXX fix typings on base package
+  willSendRequest(request: any) {
+    if (!request.headers) request.headers = {};
+    request.headers["x-api-key"] = this.engineKey;
+    if (this.clientIdentity && this.clientIdentity.name) {
+      request.headers["apollo-client-name"] = this.clientIdentity.name;
+      request.headers["apollo-client-reference-id"] =
+        this.clientIdentity.referenceID;
+      request.headers["apollo-client-version"] = this.clientIdentity.version;
+      return;
+    }
+
+    // default values
+    request.headers["apollo-client-name"] = "Apollo Language Server";
+    request.headers["apollo-client-reference-id"] =
+      "146d29c0-912c-46d3-b686-920e52586be6";
+    request.headers["apollo-client-version"] =
+      require("../../package.json").version;
+  }
+
+  async loadSchemaTagsAndFieldLatencies(serviceID: string) {
+    const { data, errors } = await this.execute<SchemaTagsAndFieldStatsQuery>({
+      query: SCHEMA_TAGS_AND_FIELD_STATS,
+      variables: {
+        id: serviceID,
+      },
+    });
+
+    if (!(data && data.service && data.service.schemaTags) || errors) {
+      throw new Error(
+        errors
+          ? errors.map((error) => error.message).join("\n")
+          : "No service returned. Make sure your service name and API key match"
+      );
+    }
+
+    const schemaTags: string[] = data.service.schemaTags.map(
+      ({ tag }: { tag: string }) => tag
+    );
+
+    const fieldLatenciesMS: FieldLatenciesMS = new Map();
+
+    data.service.stats.fieldLatencies.forEach((fieldLatency) => {
+      const { parentType, fieldName } = fieldLatency.groupBy;
+
+      if (!parentType || !fieldName) {
+        return;
+      }
+      const fieldsMap =
+        fieldLatenciesMS.get(parentType) ||
+        fieldLatenciesMS.set(parentType, new Map()).get(parentType)!;
+
+      fieldsMap.set(fieldName, fieldLatency.metrics.fieldHistogram.durationMs);
+    });
+
+    return { schemaTags, fieldLatenciesMS };
+  }
+
+  async loadFrontendUrlRoot() {
+    const { data } = await this.execute<FrontendUrlRootQuery>({
+      query: FRONTEND_URL_ROOT,
+    });
+
+    return data?.frontendUrlRoot;
+  }
+}

package/src/language-server/engine/operations/frontendUrlRoot.ts

@@ -0,0 +1,7 @@
+import gql from "graphql-tag";
+
+export const FRONTEND_URL_ROOT = gql`
+  query FrontendUrlRoot {
+    frontendUrlRoot
+  }
+`;

package/src/language-server/engine/operations/schemaTagsAndFieldStats.ts

@@ -0,0 +1,24 @@
+import gql from "graphql-tag";
+
+export const SCHEMA_TAGS_AND_FIELD_STATS = gql`
+  query SchemaTagsAndFieldStats($id: ID!) {
+    service(id: $id) {
+      schemaTags {
+        tag
+      }
+      stats(from: "-86400", to: "-0") {
+        fieldLatencies {
+          groupBy {
+            parentType
+            fieldName
+          }
+          metrics {
+            fieldHistogram {
+              durationMs(percentile: 0.95)
+            }
+          }
+        }
+      }
+    }
+  }
+`;