vscode-apollo 1.19.3 → 2.0.0

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

@@ -0,0 +1,191 @@
+import { FileSchemaProvider } from "../file";
+import * as path from "path";
+import * as fs from "fs";
+import { Debug } from "../../../utilities";
+import { URI } from "vscode-uri";
+
+const makeNestedDir = (dir: string) => {
+  if (fs.existsSync(dir)) return;
+
+  try {
+    fs.mkdirSync(dir);
+  } catch (err: any) {
+    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: "./schema.graphql",
+        },
+        URI.from({ scheme: "file", path: dirPath }),
+      );
+      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: ["schema.graphql", "schema2.graphql"],
+        },
+        URI.from({ scheme: "file", path: dirPath }),
+      );
+      const sdl = await provider.resolveFederatedServiceSDL();
+      expect(sdl).toMatchInlineSnapshot(`
+"directive @key(fields: _FieldSet!, resolvable: Boolean = true) repeatable on OBJECT | INTERFACE
+
+directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
+
+directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
+
+directive @external(reason: String) on OBJECT | FIELD_DEFINITION
+
+directive @tag(name: String!) repeatable on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+
+directive @extends on OBJECT | INTERFACE
+
+type Query {
+  _entities(representations: [_Any!]!): [_Entity]!
+  _service: _Service!
+}
+
+extend type Query {
+  myProduct: Product
+}
+
+type Product
+  @key(fields: \\"id\\")
+{
+  id: ID
+  sku: ID
+  name: String
+}
+
+extend type Product {
+  weight: Float
+}
+
+scalar _FieldSet
+
+scalar _Any
+
+type _Service {
+  sdl: String
+}
+
+union _Entity = 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: "./schema.js" },
+        URI.from({ scheme: "file", path: dirPath }),
+      );
+      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/node";
+
+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,138 @@
+// IntrospectionSchemaProvider (http => IntrospectionResult => schema)
+import { NotificationHandler } from "vscode-languageserver/node";
+
+import { execute as linkExecute } from "@apollo/client/link/core";
+import { toPromise } from "@apollo/client/link/utils";
+import { createHttpLink, HttpOptions } from "@apollo/client/link/http";
+import {
+  GraphQLSchema,
+  buildClientSchema,
+  getIntrospectionQuery,
+  ExecutionResult,
+  IntrospectionQuery,
+  parse,
+} from "graphql";
+import { Agent as HTTPSAgent } from "https";
+import { RemoteServiceConfig } 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: HttpOptions = {
+      uri: url,
+    };
+    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 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: HttpOptions = {
+      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,204 @@
+// EngineSchemaProvider (engine schema reg => schema)
+import { NotificationHandler } from "vscode-languageserver/node";
+import gql from "graphql-tag";
+import { GraphQLSchema, IntrospectionQuery, buildClientSchema } from "graphql";
+import { ApolloEngineClient, ClientIdentity } from "../../engine";
+import { ClientConfig, keyEnvVar } from "../../config";
+import {
+  GraphQLSchemaProvider,
+  SchemaChangeUnsubscribeHandler,
+  SchemaResolveConfig,
+} from "./base";
+
+import {
+  GetSchemaByTagQuery,
+  GetSchemaByTagQueryVariables,
+} from "../../graphqlTypes";
+import { Debug } from "../../utilities";
+import { TypedDocumentNode } from "@apollo/client/core";
+
+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.query({
+      query: SCHEMA_QUERY,
+      variables: {
+        id: this.config.graph,
+        tag: override && override.tag ? override.tag : this.config.variant,
+      },
+      fetchPolicy: "no-cache",
+    });
+    if (errors) {
+      // XXX better error handling of GraphQL errors
+      throw new Error(errors.map(({ message }) => 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}`,
+      );
+    }
+
+    this.schema = buildClientSchema(
+      data.service.schema as unknown as IntrospectionQuery,
+    );
+    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: TypedDocumentNode<
+  GetSchemaByTagQuery,
+  GetSchemaByTagQueryVariables
+> = 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
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;