vscode-apollo 1.19.2 → 1.20.0

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

@@ -0,0 +1,150 @@
+import { FileSchemaProvider } from "../file";
+import * as path from "path";
+import * as fs from "fs";
+import { Debug } from "../../../utilities";
+
+const makeNestedDir = (dir: string) => {
+  if (fs.existsSync(dir)) return;
+
+  try {
+    fs.mkdirSync(dir);
+  } catch (err) {
+    if (err.code == "ENOENT") {
+      makeNestedDir(path.dirname(dir)); //create parent dir
+      makeNestedDir(dir); //create dir
+    }
+  }
+};
+
+const deleteFolderRecursive = (path: string) => {
+  // don't delete files on windows -- will get a resource locked error
+  if (require("os").type().includes("Windows")) {
+    return;
+  }
+
+  if (fs.existsSync(path)) {
+    fs.readdirSync(path).forEach(function (file, index) {
+      var curPath = path + "/" + file;
+      if (fs.lstatSync(curPath).isDirectory()) {
+        // recurse
+        deleteFolderRecursive(curPath);
+      } else {
+        // delete file
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(path);
+  }
+};
+
+const writeFilesToDir = (dir: string, files: Record<string, string>) => {
+  Object.keys(files).forEach((key) => {
+    if (key.includes("/")) makeNestedDir(path.dirname(key));
+    fs.writeFileSync(`${dir}/${key}`, files[key]);
+  });
+};
+
+describe("FileSchemaProvider", () => {
+  let dir: string;
+  let dirPath: string;
+
+  // set up a temp dir
+  beforeEach(() => {
+    dir = fs.mkdtempSync("__tmp__");
+    dirPath = `${process.cwd()}/${dir}`;
+  });
+
+  // clean up our temp dir
+  afterEach(() => {
+    if (dir) {
+      deleteFolderRecursive(dir);
+    }
+  });
+
+  describe("resolveFederatedServiceSDL", () => {
+    it("finds and loads sdl from graphql file for a federated service", async () => {
+      writeFilesToDir(dir, {
+        "schema.graphql": `
+          extend type Query {
+            myProduct: Product
+          }
+
+          type Product @key(fields: "id") {
+            id: ID
+            sku: ID
+            name: String
+          }
+        `,
+      });
+
+      const provider = new FileSchemaProvider({
+        path: dir + "/schema.graphql",
+      });
+      const sdl = await provider.resolveFederatedServiceSDL();
+      expect(sdl).toMatchInlineSnapshot;
+    });
+
+    it("finds and loads sdl from multiple graphql files for a federated service", async () => {
+      writeFilesToDir(dir, {
+        "schema.graphql": `
+          extend type Query {
+            myProduct: Product
+          }
+
+          type Product @key(fields: "id") {
+            id: ID
+            sku: ID
+            name: String
+          }`,
+        "schema2.graphql": `
+          extend type Product {
+            weight: Float
+          }`,
+      });
+
+      const provider = new FileSchemaProvider({
+        paths: [dir + "/schema.graphql", dir + "/schema2.graphql"],
+      });
+      const sdl = await provider.resolveFederatedServiceSDL();
+      expect(sdl).toMatchInlineSnapshot(`
+        "type Product @key(fields: \\"id\\") {
+          id: ID
+          sku: ID
+          name: String
+          weight: Float
+        }
+
+        extend type Query {
+          myProduct: Product
+        }
+        "
+      `);
+    });
+
+    it("errors when sdl file is not a graphql file", async () => {
+      const toWrite = `
+        module.exports = \`
+        extend type Query {
+          myProduct: Product
+        }
+
+        type Product @key(fields: "id") {
+          id: ID
+          sku: ID
+          name: string
+        }\`
+      `;
+      writeFilesToDir(dir, {
+        "schema.js": toWrite,
+      });
+
+      // noop -- just spy on and silence the error
+      const errorSpy = jest.spyOn(Debug, "error");
+      errorSpy.mockImplementation(() => {});
+
+      const provider = new FileSchemaProvider({ path: dir + "/schema.js" });
+      const sdl = await provider.resolveFederatedServiceSDL();
+      expect(errorSpy).toBeCalledTimes(2);
+    });
+  });
+});

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

@@ -0,0 +1,15 @@
+import { GraphQLSchema } from "graphql";
+import { NotificationHandler } from "vscode-languageserver";
+
+export interface SchemaResolveConfig {
+  tag?: string;
+  force?: boolean;
+}
+export type SchemaChangeUnsubscribeHandler = () => void;
+export interface GraphQLSchemaProvider {
+  resolveSchema(config?: SchemaResolveConfig): Promise<GraphQLSchema>;
+  onSchemaChange(
+    handler: NotificationHandler<GraphQLSchema>
+  ): SchemaChangeUnsubscribeHandler;
+  resolveFederatedServiceSDL(): Promise<string | void>;
+}

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

@@ -0,0 +1,157 @@
+// IntrospectionSchemaProvider (http => IntrospectionResult => schema)
+import { NotificationHandler } from "vscode-languageserver";
+import { execute as linkExecute, toPromise } from "apollo-link";
+import { createHttpLink, HttpLink } from "apollo-link-http";
+import {
+  GraphQLSchema,
+  buildClientSchema,
+  getIntrospectionQuery,
+  ExecutionResult,
+  IntrospectionQuery,
+  parse,
+} from "graphql";
+import { Agent as HTTPSAgent } from "https";
+import { fetch } from "../../../env";
+import { RemoteServiceConfig, DefaultServiceConfig } from "../../config";
+import { GraphQLSchemaProvider, SchemaChangeUnsubscribeHandler } from "./base";
+import { Debug } from "../../utilities";
+import { isString } from "util";
+
+export class EndpointSchemaProvider implements GraphQLSchemaProvider {
+  private schema?: GraphQLSchema;
+  private federatedServiceSDL?: string;
+
+  constructor(private config: Exclude<RemoteServiceConfig, "name">) {}
+  async resolveSchema() {
+    if (this.schema) return this.schema;
+    const { skipSSLValidation, url, headers } = this.config;
+    const options: HttpLink.Options = {
+      uri: url,
+      fetch,
+    };
+    if (url.startsWith("https:") && skipSSLValidation) {
+      options.fetchOptions = {
+        agent: new HTTPSAgent({ rejectUnauthorized: false }),
+      };
+    }
+
+    const { data, errors } = (await toPromise(
+      linkExecute(createHttpLink(options), {
+        query: parse(getIntrospectionQuery()),
+        context: { headers },
+      })
+    ).catch((e) => {
+      // html response from introspection
+      if (isString(e.message) && e.message.includes("token <")) {
+        throw new Error(
+          "Apollo tried to introspect a running GraphQL service at " +
+            url +
+            "\nIt expected a JSON schema introspection result, but got an HTML response instead." +
+            "\nYou may need to add headers to your request or adjust your endpoint url.\n" +
+            "-----------------------------\n" +
+            "For more information, please refer to: https://go.apollo.dev/t/config \n\n" +
+            "The following error occurred:\n-----------------------------\n" +
+            e.message
+        );
+      }
+
+      // 404 encountered with the default url
+      if (
+        url === DefaultServiceConfig.endpoint.url &&
+        isString(e.message) &&
+        e.message.includes("ECONNREFUSED")
+      ) {
+        throw new Error(
+          "Failed to connect to a running GraphQL endpoint at " +
+            url +
+            "\nThis may be because you didn't start your service.\n" +
+            "By default, when an endpoint, Apollo API key, or localSchemaFile isn't provided, Apollo tries to fetch a schema from " +
+            DefaultServiceConfig.endpoint.url +
+            "\n-----------------------------\n" +
+            "\nFor more information, please refer to: https://go.apollo.dev/t/config \n\n" +
+            "The following error occurred: \n" +
+            "-----------------------------\n" +
+            e.message
+        );
+      }
+      // 404 with a non-default url
+      if (isString(e.message) && e.message.includes("ECONNREFUSED")) {
+        throw new Error(
+          "Failed to connect to a running GraphQL endpoint at " +
+            url +
+            "\nThis may be because you didn't start your service or the endpoint URL is incorrect."
+        );
+      }
+      throw new Error(e);
+    })) as ExecutionResult<IntrospectionQuery>;
+
+    if (errors && errors.length) {
+      // XXX better error handling of GraphQL errors
+      throw new Error(errors.map(({ message }: Error) => message).join("\n"));
+    }
+
+    if (!data) {
+      throw new Error("No data received from server introspection.");
+    }
+
+    this.schema = buildClientSchema(data);
+    return this.schema;
+  }
+
+  onSchemaChange(
+    _handler: NotificationHandler<GraphQLSchema>
+  ): SchemaChangeUnsubscribeHandler {
+    throw new Error("Polling of endpoint not implemented yet");
+    return () => {};
+  }
+
+  async resolveFederatedServiceSDL() {
+    if (this.federatedServiceSDL) return this.federatedServiceSDL;
+
+    const { skipSSLValidation, url, headers } = this.config;
+    const options: HttpLink.Options = {
+      uri: url,
+      fetch,
+    };
+    if (url.startsWith("https:") && skipSSLValidation) {
+      options.fetchOptions = {
+        agent: new HTTPSAgent({ rejectUnauthorized: false }),
+      };
+    }
+
+    const getFederationInfoQuery = `
+      query getFederationInfo {
+        _service {
+          sdl
+        }
+      }
+    `;
+
+    const { data, errors } = (await toPromise(
+      linkExecute(createHttpLink(options), {
+        query: parse(getFederationInfoQuery),
+        context: { headers },
+      })
+    )) as ExecutionResult<{ _service: { sdl: string } }>;
+
+    if (errors && errors.length) {
+      return Debug.error(
+        errors.map(({ message }: Error) => message).join("\n")
+      );
+    }
+
+    if (!data || !data._service) {
+      return Debug.error(
+        "No data received from server when querying for _service."
+      );
+    }
+
+    this.federatedServiceSDL = data._service.sdl;
+    return data._service.sdl;
+  }
+
+  // public async isFederatedSchema() {
+  //   const schema = this.schema || (await this.resolveSchema());
+  //   return false;
+  // }
+}

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

@@ -0,0 +1,197 @@
+// EngineSchemaProvider (engine schema reg => schema)
+import { NotificationHandler } from "vscode-languageserver";
+import gql from "graphql-tag";
+import { GraphQLSchema, buildClientSchema } from "graphql";
+import { ApolloEngineClient, ClientIdentity } from "../../engine";
+import { ClientConfig, keyEnvVar, parseServiceSpecifier } from "../../config";
+import { getServiceFromKey, isServiceKey } from "../../config";
+import {
+  GraphQLSchemaProvider,
+  SchemaChangeUnsubscribeHandler,
+  SchemaResolveConfig,
+} from "./base";
+
+import { GetSchemaByTagQuery } from "../../graphqlTypes";
+import { Debug } from "../../utilities";
+
+export class EngineSchemaProvider implements GraphQLSchemaProvider {
+  private schema?: GraphQLSchema;
+  private client?: ApolloEngineClient;
+
+  constructor(
+    private config: ClientConfig,
+    private clientIdentity?: ClientIdentity
+  ) {}
+
+  async resolveSchema(override: SchemaResolveConfig) {
+    if (this.schema && (!override || !override.force)) return this.schema;
+    const { engine, client } = this.config;
+
+    if (!this.config.graph) {
+      throw new Error(
+        `No graph ID found for client. Please specify a graph ID via the config or the --graph flag`
+      );
+    }
+
+    // create engine client
+    if (!this.client) {
+      if (!engine.apiKey) {
+        throw new Error(
+          `No API key found. Please set ${keyEnvVar} or use --key`
+        );
+      }
+      this.client = new ApolloEngineClient(
+        engine.apiKey,
+        engine.endpoint,
+        this.clientIdentity
+      );
+    }
+
+    const { data, errors } = await this.client.execute<GetSchemaByTagQuery>({
+      query: SCHEMA_QUERY,
+      variables: {
+        id: this.config.graph,
+        tag: override && override.tag ? override.tag : this.config.variant,
+      },
+    });
+    if (errors) {
+      // XXX better error handling of GraphQL errors
+      throw new Error(errors.map(({ message }: Error) => message).join("\n"));
+    }
+
+    if (!(data && data.service && data.service.__typename === "Service")) {
+      throw new Error(
+        `Unable to get schema from the Apollo registry for graph ${this.config.graph}`
+      );
+    }
+
+    // @ts-ignore
+    // XXX Types of `data.service.schema` won't match closely enough with `IntrospectionQuery`
+    this.schema = buildClientSchema(data.service.schema);
+    return this.schema;
+  }
+
+  onSchemaChange(
+    _handler: NotificationHandler<GraphQLSchema>
+  ): SchemaChangeUnsubscribeHandler {
+    throw new Error("Polling of Apollo not implemented yet");
+    return () => {};
+  }
+
+  async resolveFederatedServiceSDL() {
+    Debug.error(
+      "Cannot resolve a federated service's SDL from Apollo. Use an endpoint or a file instead"
+    );
+    return;
+  }
+}
+
+export const SCHEMA_QUERY = gql`
+  query GetSchemaByTag($tag: String!, $id: ID!) {
+    service(id: $id) {
+      ... on Service {
+        __typename
+        schema(tag: $tag) {
+          hash
+          __schema: introspection {
+            queryType {
+              name
+            }
+            mutationType {
+              name
+            }
+            subscriptionType {
+              name
+            }
+            types(filter: { includeBuiltInTypes: true }) {
+              ...IntrospectionFullType
+            }
+            directives {
+              name
+              description
+              locations
+              args {
+                ...IntrospectionInputValue
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  fragment IntrospectionFullType on IntrospectionType {
+    kind
+    name
+    description
+    fields {
+      name
+      description
+      args {
+        ...IntrospectionInputValue
+      }
+      type {
+        ...IntrospectionTypeRef
+      }
+      isDeprecated
+      deprecationReason
+    }
+    inputFields {
+      ...IntrospectionInputValue
+    }
+    interfaces {
+      ...IntrospectionTypeRef
+    }
+    enumValues(includeDeprecated: true) {
+      name
+      description
+      isDeprecated
+      deprecationReason
+    }
+    possibleTypes {
+      ...IntrospectionTypeRef
+    }
+  }
+
+  fragment IntrospectionInputValue on IntrospectionInputValue {
+    name
+    description
+    type {
+      ...IntrospectionTypeRef
+    }
+    defaultValue
+  }
+
+  fragment IntrospectionTypeRef on IntrospectionType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;

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

@@ -0,0 +1,167 @@
+// FileSchemaProvider (FileProvider (SDL || IntrospectionResult) => schema)
+import {
+  GraphQLSchema,
+  buildClientSchema,
+  Source,
+  buildSchema,
+  printSchema,
+  parse,
+  visit,
+} from "graphql";
+import { readFileSync } from "fs";
+import { extname, resolve } from "path";
+import { GraphQLSchemaProvider, SchemaChangeUnsubscribeHandler } from "./base";
+import { NotificationHandler } from "vscode-languageserver";
+import { Debug } from "../../utilities";
+import { buildSchemaFromSDL } from "apollo-graphql";
+import {
+  buildFederatedSchema,
+  composeServices,
+  printSchema as printFederatedSchema,
+} from "@apollo/federation";
+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) {}
+
+  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 = buildSchemaFromSDL(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 = readFileSync(path, {
+        encoding: "utf-8",
+      });
+    } 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 = buildFederatedSchema(
+      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 &&
+      serviceField.resolve &&
+      serviceField.resolve(null, {}, null, {} as any);
+
+    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 = readFileSync(path, {
+        encoding: "utf-8",
+      });
+    } 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"
+      );
+    }
+  }
+}