vscode-apollo 1.20.0 → 2.0.1

package/src/language-server/config/loadTsConfig.ts

@@ -0,0 +1,70 @@
+import { Loader, defaultLoaders } from "cosmiconfig";
+import { dirname } from "node:path";
+import { rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+
+// implementation based on https://github.com/cosmiconfig/cosmiconfig/blob/a5a842547c13392ebb89a485b9e56d9f37e3cbd3/src/loaders.ts
+// Copyright (c) 2015 David Clark licensed MIT. Full license can be found here:
+// https://github.com/cosmiconfig/cosmiconfig/blob/a5a842547c13392ebb89a485b9e56d9f37e3cbd3/LICENSE
+
+let typescript: typeof import("typescript");
+export const loadTs: Loader = async function loadTs(filepath, content) {
+  try {
+    return await defaultLoaders[".ts"](filepath, content);
+  } catch (error) {
+    if (
+      !(error instanceof Error) ||
+      !error.message.includes("module is not defined")
+    )
+      throw error;
+  }
+
+  if (typescript === undefined) {
+    typescript = await import("typescript");
+  }
+  const compiledFilepath = `${filepath.slice(0, -2)}cjs`;
+  let transpiledContent;
+  try {
+    try {
+      const config = resolveTsConfig(dirname(filepath)) ?? {};
+      config.compilerOptions = {
+        ...config.compilerOptions,
+        module: typescript.ModuleKind.CommonJS,
+        moduleResolution: typescript.ModuleResolutionKind.Bundler,
+        target: typescript.ScriptTarget.ES2022,
+        noEmit: false,
+      };
+      transpiledContent = typescript.transpileModule(
+        content,
+        config,
+      ).outputText;
+      await writeFile(compiledFilepath, transpiledContent);
+    } catch (error: any) {
+      error.message = `TypeScript Error in ${filepath}:\n${error.message}`;
+      throw error;
+    }
+    // eslint-disable-next-line @typescript-eslint/return-await
+    return await defaultLoaders[".js"](compiledFilepath, transpiledContent);
+  } finally {
+    if (existsSync(compiledFilepath)) {
+      await rm(compiledFilepath);
+    }
+  }
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function resolveTsConfig(directory: string): any {
+  const filePath = typescript.findConfigFile(directory, (fileName) => {
+    return typescript.sys.fileExists(fileName);
+  });
+  if (filePath !== undefined) {
+    const { config, error } = typescript.readConfigFile(filePath, (path) =>
+      typescript.sys.readFile(path),
+    );
+    if (error) {
+      throw new Error(`Error in ${filePath}: ${error.messageText.toString()}`);
+    }
+    return config;
+  }
+  return;
+}

package/src/language-server/config/utils.ts

@@ -3,30 +3,21 @@ import {
   ClientConfig,
   ClientServiceConfig,
   LocalServiceConfig,
-  ServiceConfig,
-  ApolloConfigFormat,
+  ParsedApolloConfigFormat,
 } from "./config";
 import { ServiceSpecifier, ServiceIDAndTag } from "../engine";
 
 export function isClientConfig(config: ApolloConfig): config is ClientConfig {
-  return config.isClient;
+  return config instanceof ClientConfig;
 }
 
 // checks the `config.client.service` object for a localSchemaFile
 export function isLocalServiceConfig(
-  config: ClientServiceConfig
+  config: ClientServiceConfig,
 ): config is LocalServiceConfig {
   return !!(config as LocalServiceConfig).localSchemaFile;
 }
 
-export function isServiceConfig(config: ApolloConfig): config is ServiceConfig {
-  return config.isService;
-}
-
-export function isServiceKey(key?: string) {
-  return key && /service:.*:.*/.test(key);
-}
-
 export function getServiceFromKey(key?: string) {
   if (key) {
     const [type, service] = key.split(":");
@@ -35,13 +26,11 @@ export function getServiceFromKey(key?: string) {
   return;
 }
 
-export function getGraphIdFromConfig(config: ApolloConfigFormat) {
-  if (config.service && config.service.name)
-    return parseServiceSpecifier(config.service.name)[0];
+export function getGraphIdFromConfig(config: ParsedApolloConfigFormat) {
   if (config.client) {
     if (typeof config.client.service === "string") {
       return parseServiceSpecifier(
-        config.client.service as ServiceSpecifier
+        config.client.service as ServiceSpecifier,
       )[0];
     }
     return config.client.service && config.client.service.name;

package/src/language-server/diagnostics.ts

@@ -2,11 +2,20 @@ import {
   GraphQLSchema,
   GraphQLError,
   FragmentDefinitionNode,
-  findDeprecatedUsages,
   isExecutableDefinitionNode,
+  DocumentNode,
+  validate,
+  NoDeprecatedCustomRule,
 } from "graphql";
 
-import { Diagnostic, DiagnosticSeverity } from "vscode-languageserver";
+function findDeprecatedUsages(
+  schema: GraphQLSchema,
+  ast: DocumentNode,
+): ReadonlyArray<GraphQLError> {
+  return validate(schema, ast, [NoDeprecatedCustomRule]);
+}
+
+import { Diagnostic, DiagnosticSeverity } from "vscode-languageserver/node";
 
 import { GraphQLDocument } from "./document";
 import { highlightNodeForNode } from "./utilities/graphql";
@@ -23,7 +32,7 @@ export function collectExecutableDefinitionDiagnositics(
   schema: GraphQLSchema,
   queryDocument: GraphQLDocument,
   fragments: { [fragmentName: string]: FragmentDefinitionNode } = {},
-  rules?: ValidationRule[]
+  rules?: ValidationRule[],
 ): Diagnostic[] {
   const ast = queryDocument.ast;
   if (!ast) return queryDocument.syntaxErrors;
@@ -39,19 +48,19 @@ export function collectExecutableDefinitionDiagnositics(
     schema,
     astWithExecutableDefinitions,
     fragments,
-    rules
+    rules,
   )) {
     diagnostics.push(
-      ...diagnosticsFromError(error, DiagnosticSeverity.Error, "Validation")
+      ...diagnosticsFromError(error, DiagnosticSeverity.Error, "Validation"),
     );
   }
 
   for (const error of findDeprecatedUsages(
     schema,
-    astWithExecutableDefinitions
+    astWithExecutableDefinitions,
   )) {
     diagnostics.push(
-      ...diagnosticsFromError(error, DiagnosticSeverity.Warning, "Deprecation")
+      ...diagnosticsFromError(error, DiagnosticSeverity.Warning, "Deprecation"),
     );
   }
 
@@ -61,7 +70,7 @@ export function collectExecutableDefinitionDiagnositics(
 export function diagnosticsFromError(
   error: GraphQLError,
   severity: DiagnosticSeverity,
-  type: string
+  type: string,
 ): GraphQLDiagnostic[] {
   if (!error.nodes) {
     return [];

package/src/language-server/document.ts

@@ -6,9 +6,9 @@ import {
   Position,
   Diagnostic,
   DiagnosticSeverity,
-} from "vscode-languageserver";
+} from "vscode-languageserver/node";
 
-import { getRange as rangeOfTokenAtLocation } from "graphql-language-service-interface/dist/getDiagnostics";
+import { getRange as rangeOfTokenAtLocation } from "graphql-language-service";
 
 import {
   positionFromSourceLocation,
@@ -30,7 +30,7 @@ export class GraphQLDocument {
       // 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)
+        rangeOfTokenAtLocation(error.locations[0], source.body),
       );
       this.syntaxErrors.push({
         severity: DiagnosticSeverity.Error,
@@ -45,7 +45,7 @@ export class GraphQLDocument {
     if (position.line < this.source.locationOffset.line - 1) return false;
     const end = positionFromSourceLocation(
       this.source,
-      getLocation(this.source, this.source.body.length)
+      getLocation(this.source, this.source.body.length),
     );
     return position.line <= end.line;
   }
@@ -53,7 +53,7 @@ export class GraphQLDocument {
 
 export function extractGraphQLDocuments(
   document: TextDocument,
-  tagName: string = "gql"
+  tagName: string = "gql",
 ): GraphQLDocument[] | null {
   switch (document.languageId) {
     case "graphql":
@@ -84,7 +84,7 @@ export function extractGraphQLDocuments(
 
 function extractGraphQLDocumentsFromJSTemplateLiterals(
   document: TextDocument,
-  tagName: string
+  tagName: string,
 ): GraphQLDocument[] | null {
   const text = document.getText();
 
@@ -92,7 +92,7 @@ function extractGraphQLDocumentsFromJSTemplateLiterals(
 
   const regExp = new RegExp(
     `(?:${tagName}(?:\\s|\\()*\`|\`#graphql)([\\s\\S]+?)\`\\)?`,
-    "gm"
+    "gm",
   );
 
   let result;
@@ -114,7 +114,7 @@ function extractGraphQLDocumentsFromJSTemplateLiterals(
 
 function extractGraphQLDocumentsFromPythonStrings(
   document: TextDocument,
-  tagName: string
+  tagName: string,
 ): GraphQLDocument[] | null {
   const text = document.getText();
 
@@ -122,7 +122,7 @@ function extractGraphQLDocumentsFromPythonStrings(
 
   const regExp = new RegExp(
     `\\b(${tagName}\\s*\\(\\s*[bfru]*("(?:"")?|'(?:'')?))([\\s\\S]+?)\\2\\s*\\)`,
-    "gm"
+    "gm",
   );
 
   let result;
@@ -144,7 +144,7 @@ function extractGraphQLDocumentsFromPythonStrings(
 
 function extractGraphQLDocumentsFromRubyStrings(
   document: TextDocument,
-  tagName: string
+  tagName: string,
 ): GraphQLDocument[] | null {
   const text = document.getText();
 
@@ -171,7 +171,7 @@ function extractGraphQLDocumentsFromRubyStrings(
 
 function extractGraphQLDocumentsFromDartStrings(
   document: TextDocument,
-  tagName: string
+  tagName: string,
 ): GraphQLDocument[] | null {
   const text = document.getText();
 
@@ -179,7 +179,7 @@ function extractGraphQLDocumentsFromDartStrings(
 
   const regExp = new RegExp(
     `\\b(${tagName}\\(\\s*r?("""|'''))([\\s\\S]+?)\\2\\s*\\)`,
-    "gm"
+    "gm",
   );
 
   let result;
@@ -201,7 +201,7 @@ function extractGraphQLDocumentsFromDartStrings(
 
 function extractGraphQLDocumentsFromReasonStrings(
   document: TextDocument,
-  tagName: string
+  tagName: string,
 ): GraphQLDocument[] | null {
   const text = document.getText();
 
@@ -214,7 +214,7 @@ function extractGraphQLDocumentsFromReasonStrings(
   }
 
   const reasonRegexp = new RegExp(
-    /(?<=\[%(graphql|relay\.\w*)[\s\S]*{\|)[.\s\S]+?(?=\|})/gm
+    /(?<=\[%(graphql|relay\.\w*)[\s\S]*{\|)[.\s\S]+?(?=\|})/gm,
   );
 
   let result;
@@ -236,14 +236,14 @@ function extractGraphQLDocumentsFromReasonStrings(
 
 function extractGraphQLDocumentsFromElixirStrings(
   document: TextDocument,
-  tagName: string
+  tagName: string,
 ): GraphQLDocument[] | null {
   const text = document.getText();
   const documents: GraphQLDocument[] = [];
 
   const regExp = new RegExp(
     `\\b(${tagName}\\(\\s*r?("""))([\\s\\S]+?)\\2\\s*\\)`,
-    "gm"
+    "gm",
   );
 
   let result;

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

@@ -1,16 +1,18 @@
-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";
+import {
+  ApolloClient,
+  ApolloLink,
+  createHttpLink,
+  InMemoryCache,
+} from "@apollo/client/core";
+import { setContext } from "@apollo/client/link/context";
+import { onError } from "@apollo/client/link/error";
 
 export interface ClientIdentity {
-  name?: string;
-  version?: string;
-  referenceID?: string;
+  name: string;
+  version: string;
+  referenceID: string;
 }
 
 export type ServiceID = string;
@@ -27,54 +29,69 @@ export function noServiceError(service: string | undefined, endpoint?: string) {
   } from Apollo at ${endpoint}. Please check your API key and graph ID`;
 }
 
-export class ApolloEngineClient extends GraphQLDataSource {
+export class ApolloEngineClient {
+  public readonly client: ApolloClient<any>;
+  public readonly query: ApolloClient<any>["query"];
+
   constructor(
-    private engineKey: string,
-    engineEndpoint: string = DefaultEngineConfig.endpoint,
-    private clientIdentity?: ClientIdentity
+    private readonly engineKey: string,
+    baseURL: string,
+    private readonly 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;
+    const link = ApolloLink.from([
+      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}`);
+        }
+      }),
+      createHttpLink({
+        uri: baseURL,
+        headers: {
+          ["x-api-key"]: this.engineKey,
+          ["apollo-client-name"]: this.clientIdentity.name,
+          ["apollo-client-reference-id"]: this.clientIdentity.referenceID,
+          ["apollo-client-version"]: this.clientIdentity.version,
+        },
+      }),
+    ]);
+
+    this.client = new ApolloClient({
+      link,
+      cache: new InMemoryCache(),
+    });
+    this.query = this.client.query.bind(this.client);
   }
 
   async loadSchemaTagsAndFieldLatencies(serviceID: string) {
-    const { data, errors } = await this.execute<SchemaTagsAndFieldStatsQuery>({
+    const { data, errors } = await this.client.query({
       query: SCHEMA_TAGS_AND_FIELD_STATS,
       variables: {
         id: serviceID,
       },
+      fetchPolicy: "no-cache",
     });
 
     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"
+          : "No service returned. Make sure your service name and API key match",
       );
     }
 
     const schemaTags: string[] = data.service.schemaTags.map(
-      ({ tag }: { tag: string }) => tag
+      ({ tag }: { tag: string }) => tag,
     );
 
     const fieldLatenciesMS: FieldLatenciesMS = new Map();
@@ -96,8 +113,9 @@ export class ApolloEngineClient extends GraphQLDataSource {
   }
 
   async loadFrontendUrlRoot() {
-    const { data } = await this.execute<FrontendUrlRootQuery>({
+    const { data } = await this.client.query({
       query: FRONTEND_URL_ROOT,
+      fetchPolicy: "cache-first",
     });
 
     return data?.frontendUrlRoot;

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

@@ -1,6 +1,14 @@
+import { TypedDocumentNode } from "@apollo/client/core";
 import gql from "graphql-tag";
+import type {
+  FrontendUrlRootQuery,
+  FrontendUrlRootQueryVariables,
+} from "src/language-server/graphqlTypes";
 
-export const FRONTEND_URL_ROOT = gql`
+export const FRONTEND_URL_ROOT: TypedDocumentNode<
+  FrontendUrlRootQuery,
+  FrontendUrlRootQueryVariables
+> = gql`
   query FrontendUrlRoot {
     frontendUrlRoot
   }

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

@@ -1,6 +1,14 @@
+import { TypedDocumentNode } from "@apollo/client/core";
 import gql from "graphql-tag";
+import type {
+  SchemaTagsAndFieldStatsQuery,
+  SchemaTagsAndFieldStatsQueryVariables,
+} from "src/language-server/graphqlTypes";
 
-export const SCHEMA_TAGS_AND_FIELD_STATS = gql`
+export const SCHEMA_TAGS_AND_FIELD_STATS: TypedDocumentNode<
+  SchemaTagsAndFieldStatsQuery,
+  SchemaTagsAndFieldStatsQueryVariables
+> = gql`
   query SchemaTagsAndFieldStats($id: ID!) {
     service(id: $id) {
       schemaTags {

package/src/language-server/errors/__tests__/NoMissingClientDirectives.test.ts

@@ -4,8 +4,8 @@ import { basename } from "path";
 
 import { vol } from "memfs";
 import { LoadingHandler } from "../../loadingHandler";
-import { ApolloConfig, ClientConfig } from "../../config";
-import URI from "vscode-uri";
+import { ClientConfig, parseApolloConfig } from "../../config";
+import { URI } from "vscode-uri";
 
 const serviceSchema = /* GraphQL */ `
   type Query {
@@ -130,7 +130,7 @@ const f = /* GraphQL */ `
 
 const rootURI = URI.file(process.cwd());
 
-const config = new ApolloConfig({
+const config = parseApolloConfig({
   client: {
     service: {
       name: "server",
@@ -141,7 +141,7 @@ const config = new ApolloConfig({
     validationRules: [NoMissingClientDirectives],
   },
   engine: {},
-}) as ClientConfig;
+});
 
 class MockLoadingHandler implements LoadingHandler {
   handle<T>(_message: string, value: Promise<T>): Promise<T> {
@@ -179,9 +179,14 @@ describe("client state", () => {
 
   it("should report validation errors for missing @client directives", async () => {
     const project = new GraphQLClientProject({
-      config,
+      config: config as ClientConfig,
       loadingHandler: new MockLoadingHandler(),
       configFolderURI: rootURI,
+      clientIdentity: {
+        name: "",
+        version: "",
+        referenceID: "",
+      },
     });
 
     const errors = Object.create(null);

package/src/language-server/errors/logger.ts

@@ -35,7 +35,7 @@ export function logError(error: Error) {
 export function logErrorMessage(
   message: string,
   fileName?: string,
-  lineNumber?: number
+  lineNumber?: number,
 ) {
   if (isRunningFromXcodeScript) {
     if (fileName && lineNumber) {

package/src/language-server/errors/validation.ts

@@ -18,7 +18,7 @@ import {
   isObjectType,
 } from "graphql";
 
-import { TextEdit } from "vscode-languageserver";
+import { TextEdit } from "vscode-languageserver/node";
 
 import { ToolError, logError } from "./logger";
 import { ValidationRule } from "graphql/validation/ValidationContext";
@@ -35,7 +35,7 @@ export interface CodeActionInfo {
   edits: TextEdit[];
 }
 
-const specifiedRulesToBeRemoved = [NoUnusedFragmentsRule];
+const specifiedRulesToBeRemoved: ValidationRule[] = [NoUnusedFragmentsRule];
 
 export const defaultValidationRules: ValidationRule[] = [
   NoAnonymousQueries,
@@ -48,7 +48,7 @@ export function getValidationErrors(
   schema: GraphQLSchema,
   document: DocumentNode,
   fragments?: { [fragmentName: string]: FragmentDefinitionNode },
-  rules: ValidationRule[] = defaultValidationRules
+  rules: ValidationRule[] = defaultValidationRules,
 ) {
   const typeInfo = new TypeInfo(schema);
 
@@ -83,7 +83,7 @@ export function getValidationErrors(
 
 export function validateQueryDocument(
   schema: GraphQLSchema,
-  document: DocumentNode
+  document: DocumentNode,
 ) {
   try {
     const validationErrors = getValidationErrors(schema, document);
@@ -106,7 +106,7 @@ export function NoAnonymousQueries(context: ValidationContext) {
         context.reportError(
           new GraphQLError("Apollo does not support anonymous operations", [
             node,
-          ])
+          ]),
         );
       }
       return false;
@@ -122,8 +122,8 @@ export function NoTypenameAlias(context: ValidationContext) {
         context.reportError(
           new GraphQLError(
             "Apollo needs to be able to insert __typename when needed, please do not use it as an alias",
-            [node]
-          )
+            [node],
+          ),
         );
       }
     },
@@ -138,7 +138,7 @@ function hasClientSchema(schema: GraphQLSchema): boolean {
   return Boolean(
     (query && query.clientSchema) ||
       (mutation && mutation.clientSchema) ||
-      (subscription && subscription.clientSchema)
+      (subscription && subscription.clientSchema),
   );
 }
 
@@ -152,17 +152,14 @@ export function NoMissingClientDirectives(context: ValidationContext) {
   // together correctly
   // XXX we have a simplified version of this in @apollo/gateway that we could probably use
   // intead of this
-  const executionContext = buildExecutionContext(
+  const executionContext = buildExecutionContext({
     schema,
-    root,
-    Object.create(null),
-    Object.create(null),
-    undefined,
-    undefined,
-    undefined
-  );
+    document: root,
+    rootValue: Object.create(null),
+    contextValue: Object.create(null),
+  });
   function visitor(
-    node: FieldNode | InlineFragmentNode | FragmentDefinitionNode
+    node: FieldNode | InlineFragmentNode | FragmentDefinitionNode,
   ) {
     // In cases where we are looking at a FragmentDefinition, there is no parent type
     // but instead, the FragmentDefinition contains the type that we can read from the
@@ -194,7 +191,7 @@ export function NoMissingClientDirectives(context: ValidationContext) {
         // fields are simple because we can just see if the name exists in the local fields
         // array on the parent type
         selectsClientFieldSet = Boolean(
-          clientFields && clientFields.includes(fieldDef?.name || "")
+          clientFields && clientFields.includes(fieldDef?.name || ""),
         );
         message += `local field "${node.name.value}"`;
         break;
@@ -207,7 +204,7 @@ export function NoMissingClientDirectives(context: ValidationContext) {
           executionContext as ExecutionContext,
           node.selectionSet,
           Object.create(null),
-          Object.create(null)
+          Object.create(null),
         );
 
         // once we have a list of fields on the fragment, we can compare them
@@ -215,7 +212,7 @@ export function NoMissingClientDirectives(context: ValidationContext) {
         // subset of the overall local fields types
         const fieldNames = Object.entries(fields).map(([name]) => name);
         selectsClientFieldSet = fieldNames.every(
-          (field) => clientFields && clientFields.includes(field)
+          (field) => clientFields && clientFields.includes(field),
         );
         message += `fragment ${
           "name" in node ? `"${node.name.value}" ` : ""
@@ -247,9 +244,9 @@ export function NoMissingClientDirectives(context: ValidationContext) {
             TextEdit.insert(
               positionFromSourceLocation(
                 source,
-                getLocation(source, locToInsertDirective)
+                getLocation(source, locToInsertDirective),
               ),
-              " @client"
+              " @client",
             ),
           ],
         };
@@ -257,7 +254,7 @@ export function NoMissingClientDirectives(context: ValidationContext) {
       }
 
       context.reportError(
-        new GraphQLError(message, [node], null, null, null, null, extensions)
+        new GraphQLError(message, [node], null, null, null, null, extensions),
       );
     }