vscode-apollo 1.19.3 → 1.20.0

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

@@ -0,0 +1,106 @@
+import {
+  ApolloConfig,
+  ApolloConfigFormat,
+  getServiceFromKey,
+  getGraphIdFromConfig,
+  isClientConfig,
+  isLocalServiceConfig,
+  isServiceConfig,
+  parseServiceSpecifier,
+  DefaultConfigBase,
+} from "../";
+
+describe("getServiceFromKey", () => {
+  it("returns undefined with no provided key", () => {
+    expect(getServiceFromKey()).toBeUndefined();
+  });
+
+  it("returns service name from service api key", () => {
+    const key = "service:bob-123:489fhseo4";
+    expect(getServiceFromKey(key)).toEqual("bob-123");
+  });
+
+  it("returns nothing if key is not a service key", () => {
+    const key = "not-a-service:bob-123:489fhseo4";
+    expect(getServiceFromKey(key)).toBeUndefined();
+  });
+
+  it("returns nothing if key is malformed", () => {
+    const key = "service/bob-123:489fhseo4";
+    expect(getServiceFromKey(key)).toBeUndefined();
+  });
+});
+
+describe("getServiceName", () => {
+  describe("client config", () => {
+    it("finds service name when client.service is a string", () => {
+      const rawConfig: ApolloConfigFormat = {
+        client: { service: "my-service", ...DefaultConfigBase },
+      };
+      expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
+
+      const rawConfigWithTag: ApolloConfigFormat = {
+        client: { service: "my-service@master", ...DefaultConfigBase },
+      };
+      expect(getGraphIdFromConfig(rawConfigWithTag)).toEqual("my-service");
+    });
+
+    it("finds service name when client.service is an object", () => {
+      const rawConfig: ApolloConfigFormat = {
+        client: {
+          service: { name: "my-service", localSchemaFile: "./someFile" },
+          ...DefaultConfigBase,
+        },
+      };
+      expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
+    });
+  });
+  describe("service config", () => {
+    it("finds service name from raw service config", () => {
+      const rawConfig: ApolloConfigFormat = {
+        service: {
+          name: "my-service",
+          localSchemaFile: "./someFile",
+          ...DefaultConfigBase,
+        },
+      };
+      expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
+    });
+  });
+});
+
+describe("isClientConfig", () => {
+  it("identifies client config properly", () => {
+    const config = new ApolloConfig({
+      client: { service: "hello", ...DefaultConfigBase },
+    });
+    expect(isClientConfig(config)).toBeTruthy();
+  });
+});
+
+describe("isLocalServiceConfig", () => {
+  it("properly identifies a client config that uses localSchemaFiles", () => {
+    const clientServiceConfig = { name: "my-service", localSchemaFile: "okay" };
+    expect(isLocalServiceConfig(clientServiceConfig)).toBeTruthy();
+  });
+});
+
+describe("isServiceConfig", () => {
+  it("identifies service config properly", () => {
+    const config = new ApolloConfig({ service: { ...DefaultConfigBase } });
+    expect(isServiceConfig(config)).toBeTruthy();
+  });
+});
+
+describe("parseServiceSpecifier", () => {
+  it("parses service identifier for service id and tag properly", () => {
+    const [id, tag] = parseServiceSpecifier("my-service@master");
+    expect(id).toEqual("my-service");
+    expect(tag).toEqual("master");
+
+    const [idFromSimpleName, tagFromSimpleName] =
+      parseServiceSpecifier("my-service");
+    expect(idFromSimpleName).toEqual("my-service");
+    expect(tagFromSimpleName).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,219 @@
+import { dirname } from "path";
+import merge from "lodash.merge";
+import { ClientID, ServiceID, ServiceSpecifier } from "../engine";
+import URI from "vscode-uri";
+import { WithRequired } from "../../env";
+import { getGraphIdFromConfig, parseServiceSpecifier } from "./utils";
+import { ValidationRule } from "graphql/validation/ValidationContext";
+
+export interface EngineStatsWindow {
+  to: number;
+  from: number;
+}
+
+export const DefaultEngineStatsWindow = {
+  to: -0,
+  from: -86400, // one day
+};
+
+export interface HistoricalEngineStatsWindow extends EngineStatsWindow {}
+
+export type EndpointURI = string;
+export interface RemoteServiceConfig {
+  name: ServiceID;
+  url: EndpointURI;
+  headers?: { [key: string]: string };
+  skipSSLValidation?: boolean;
+}
+
+export interface LocalServiceConfig {
+  name: ServiceID;
+  localSchemaFile: string | string[];
+}
+
+export interface EngineConfig {
+  endpoint?: EndpointURI;
+  readonly apiKey?: string;
+}
+
+export const DefaultEngineConfig = {
+  endpoint: "https://graphql.api.apollographql.com/api/graphql",
+};
+
+export const DefaultConfigBase = {
+  includes: ["src/**/*.{ts,tsx,js,jsx,graphql,gql}"],
+  excludes: ["**/node_modules", "**/__tests__"],
+};
+
+export interface ConfigBase {
+  includes: string[];
+  excludes: string[];
+}
+
+export type ClientServiceConfig = RemoteServiceConfig | LocalServiceConfig;
+
+export interface ClientConfigFormat extends ConfigBase {
+  // service linking
+  service?: ServiceSpecifier | ClientServiceConfig;
+  // client identity
+  name?: ClientID;
+  referenceID?: string;
+  version?: string;
+  // client schemas
+  clientOnlyDirectives?: string[];
+  clientSchemaDirectives?: string[];
+  addTypename?: boolean;
+  tagName?: string;
+  // stats window config
+  statsWindow?: EngineStatsWindow;
+
+  /**
+   * Rules that will be applied when validating GraphQL documents.
+   *
+   * If you wish to modify the default list of validation rules, import them from the apollo package and
+   * assign your custom list:
+   *
+   * ```js
+   * const { defaultValidationRules } = require("apollo/lib/defaultValidationRules");
+   *
+   * module.exports = {
+   *   // ...
+   *   validationRules: [...defaultValidationRules, ...customRules]
+   * }
+   * ```
+   *
+   * Or, if you simply wish to filter out some rules from the default list, you can specify a filter function:
+   *
+   * ```js
+   * module.exports = {
+   *   // ...
+   *   validationRules: rule => rule.name !== "NoAnonymousQueries"
+   * }
+   * ```
+   */
+  validationRules?: ValidationRule[] | ((rule: ValidationRule) => boolean);
+}
+
+export const DefaultClientConfig = {
+  ...DefaultConfigBase,
+  tagName: "gql",
+  clientOnlyDirectives: ["connection", "type"],
+  clientSchemaDirectives: ["client", "rest"],
+  addTypename: true,
+  statsWindow: DefaultEngineStatsWindow,
+};
+
+export interface ServiceConfigFormat extends ConfigBase {
+  name?: string;
+  endpoint?: Exclude<RemoteServiceConfig, "name">;
+  localSchemaFile?: string | string[];
+}
+
+export const DefaultServiceConfig = {
+  ...DefaultConfigBase,
+  endpoint: {
+    url: "http://localhost:4000/graphql",
+  },
+};
+
+export interface ConfigBaseFormat {
+  client?: ClientConfigFormat;
+  service?: ServiceConfigFormat;
+  engine?: EngineConfig;
+}
+
+export type ApolloConfigFormat =
+  | WithRequired<ConfigBaseFormat, "client">
+  | WithRequired<ConfigBaseFormat, "service">;
+
+export class ApolloConfig {
+  public isClient: boolean;
+  public isService: boolean;
+  public engine: EngineConfig;
+  public service?: ServiceConfigFormat;
+  public client?: ClientConfigFormat;
+  private _variant?: string;
+  private _graphId?: string;
+
+  constructor(public rawConfig: ApolloConfigFormat, public configURI?: URI) {
+    this.isService = !!rawConfig.service;
+    this.isClient = !!rawConfig.client;
+    this.engine = rawConfig.engine!;
+    this._graphId = getGraphIdFromConfig(rawConfig);
+    this.client = rawConfig.client;
+    this.service = rawConfig.service;
+  }
+
+  get configDirURI() {
+    // if the filepath has a _file_ in it, then we get its dir
+    return this.configURI && this.configURI.fsPath.match(/\.(ts|js|cjs|json)$/i)
+      ? URI.parse(dirname(this.configURI.fsPath))
+      : this.configURI;
+  }
+
+  get projects(): (ClientConfig | ServiceConfig)[] {
+    const configs = [];
+    const { client, service } = this.rawConfig;
+    if (client) configs.push(new ClientConfig(this.rawConfig, this.configURI));
+    if (service)
+      configs.push(new ServiceConfig(this.rawConfig, this.configURI));
+    return configs;
+  }
+
+  set variant(variant: string) {
+    this._variant = variant;
+  }
+
+  get variant(): string {
+    if (this._variant) return this._variant;
+    let tag: string = "current";
+    if (this.client && typeof this.client.service === "string") {
+      const parsedVariant = parseServiceSpecifier(this.client.service)[1];
+      if (parsedVariant) tag = parsedVariant;
+    } else if (this.service && typeof this.service.name === "string") {
+      const parsedVariant = parseServiceSpecifier(this.service.name)[1];
+      if (parsedVariant) tag = parsedVariant;
+    }
+    return tag;
+  }
+
+  set graph(graphId: string | undefined) {
+    this._graphId = graphId;
+  }
+
+  get graph(): string | undefined {
+    if (this._graphId) return this._graphId;
+    return getGraphIdFromConfig(this.rawConfig);
+  }
+
+  // this type needs to be an "EveryKeyIsOptionalApolloConfig"
+  public setDefaults({
+    engine,
+    client,
+    service,
+  }: {
+    engine?: EngineConfig;
+    client?: ClientConfigFormat;
+    service?: ServiceConfigFormat;
+  }): void {
+    const config = merge(this.rawConfig, { client, engine, service });
+    this.rawConfig = config;
+    this.client = config.client;
+    this.service = config.service;
+    if (config.engine) {
+      this.engine = config.engine;
+    }
+  }
+}
+
+export class ClientConfig extends ApolloConfig {
+  public client!: ClientConfigFormat;
+  public isClient!: true;
+  public isService!: false;
+}
+
+export class ServiceConfig extends ApolloConfig {
+  public service!: ServiceConfigFormat;
+  public isClient!: false;
+  public isService!: true;
+}

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

@@ -0,0 +1,3 @@
+export * from "./utils";
+export * from "./config";
+export * from "./loadConfig";

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

@@ -0,0 +1,228 @@
+import cosmiconfig from "cosmiconfig";
+import { LoaderEntry } from "cosmiconfig";
+import TypeScriptLoader from "@endemolshinegroup/cosmiconfig-typescript-loader";
+import { resolve } from "path";
+import { readFileSync, existsSync, lstatSync } from "fs";
+import merge from "lodash.merge";
+import {
+  ApolloConfig,
+  ApolloConfigFormat,
+  DefaultConfigBase,
+  DefaultClientConfig,
+  DefaultServiceConfig,
+  DefaultEngineConfig,
+} from "./config";
+import { getServiceFromKey } from "./utils";
+import URI from "vscode-uri";
+import { Debug } from "../utilities";
+
+// config settings
+const MODULE_NAME = "apollo";
+const defaultFileNames = [
+  "package.json",
+  `${MODULE_NAME}.config.js`,
+  `${MODULE_NAME}.config.ts`,
+  `${MODULE_NAME}.config.cjs`,
+];
+const envFileNames = [".env", ".env.local"];
+
+const loaders = {
+  // XXX improve types for config
+  ".json": (cosmiconfig as any).loadJson as LoaderEntry,
+  ".js": (cosmiconfig as any).loadJs as LoaderEntry,
+  ".cjs": (cosmiconfig as any).loadJs as LoaderEntry,
+  ".ts": {
+    async: TypeScriptLoader,
+  },
+};
+
+export const legacyKeyEnvVar = "ENGINE_API_KEY";
+export const keyEnvVar = "APOLLO_KEY";
+
+export interface LoadConfigSettings {
+  // the current working directory to start looking for the config
+  // config loading only works on node so we default to
+  // process.cwd()
+
+  // configPath and fileName are used in conjunction with one another.
+  // i.e. /User/myProj/my.config.js
+  //    => { configPath: '/User/myProj/', configFileName: 'my.config.js' }
+  configPath?: string;
+
+  // if a configFileName is passed in, loadConfig won't accept any other
+  // configs as a fallback.
+  configFileName?: string;
+
+  // used when run by a `Workspace` where we _know_ a config file should be present.
+  requireConfig?: boolean;
+
+  // for CLI usage, we don't _require_ a config file for everything. This allows us to pass in
+  // options to build one at runtime
+  name?: string;
+  type?: "service" | "client";
+}
+
+export type ConfigResult<T> = {
+  config: T;
+  filepath: string;
+} | null;
+
+// XXX load .env files automatically
+export async function loadConfig({
+  configPath,
+  configFileName,
+  requireConfig = false,
+  name,
+  type,
+}: LoadConfigSettings): Promise<ApolloConfig | null> {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    searchPlaces: configFileName ? [configFileName] : defaultFileNames,
+    loaders,
+  });
+
+  // search can fail if a file can't be parsed (ex: a nonsense js file) so we wrap in a try/catch
+  let loadedConfig;
+  try {
+    loadedConfig = (await explorer.search(
+      configPath
+    )) as ConfigResult<ApolloConfigFormat>;
+  } catch (error) {
+    Debug.error(`A config file failed to load with options: ${JSON.stringify(
+      arguments[0]
+    )}.
+    The error was: ${error}`);
+    return null;
+  }
+
+  if (configPath && !loadedConfig) {
+    Debug.error(
+      `A config file failed to load at '${configPath}'. This is likely because this file is empty or malformed. For more information, please refer to: https://go.apollo.dev/t/config`
+    );
+    return null;
+  }
+
+  if (loadedConfig && loadedConfig.filepath.endsWith("package.json")) {
+    Debug.warning(
+      'The "apollo" package.json configuration key will no longer be supported in Apollo v3. Please use the apollo.config.js file for Apollo project configuration. For more information, see: https://go.apollo.dev/t/config'
+    );
+  }
+
+  if (requireConfig && !loadedConfig) {
+    Debug.error(
+      `No Apollo config found for project. For more information, please refer to: https://go.apollo.dev/t/config`
+    );
+    return null;
+  }
+
+  // add API key from the env
+  let engineConfig = {},
+    apiKey,
+    nameFromKey;
+
+  // loop over the list of possible .env files and try to parse for key
+  // and service name. Files are scanned and found values are preferred
+  // in order of appearance in `envFileNames`.
+  envFileNames.forEach((envFile) => {
+    const dotEnvPath = configPath
+      ? resolve(configPath, envFile)
+      : resolve(process.cwd(), envFile);
+
+    if (existsSync(dotEnvPath) && lstatSync(dotEnvPath).isFile()) {
+      const env: { [key: string]: string } = require("dotenv").parse(
+        readFileSync(dotEnvPath)
+      );
+      const legacyKey = env[legacyKeyEnvVar];
+      const key = env[keyEnvVar];
+      if (legacyKey && key) {
+        Debug.warning(
+          `Both ${legacyKeyEnvVar} and ${keyEnvVar} were found. ${keyEnvVar} will take precedence.`
+        );
+      }
+      if (legacyKey) {
+        Debug.warning(
+          `[Deprecation warning] Setting the key via ${legacyKeyEnvVar} is deprecated and will not be supported in future versions. Please use ${keyEnvVar} instead.`
+        );
+      }
+      apiKey = key || legacyKey;
+    }
+  });
+
+  if (apiKey) {
+    engineConfig = { engine: { apiKey } };
+    nameFromKey = getServiceFromKey(apiKey);
+  }
+
+  // DETERMINE PROJECT TYPE
+  // The CLI passes in a type when loading config. The editor extension
+  // does not. So we determine the type of the config here, and use it if
+  // the type wasn't explicitly passed in.
+  let projectType: "client" | "service";
+  if (type) {
+    projectType = type;
+  } else if (loadedConfig && loadedConfig.config.client) {
+    projectType = "client";
+  } else if (loadedConfig && loadedConfig.config.service) {
+    projectType = "service";
+  } else {
+    Debug.error(
+      "Unable to resolve project type. Please add either a client or service config. For more information, please refer to https://go.apollo.dev/t/config"
+    );
+    return null;
+  }
+
+  // DETERMINE SERVICE NAME
+  // precedence: 1. (highest) config.js (client only) 2. name passed into loadConfig 3. name from api key
+  let serviceName = name || nameFromKey;
+  if (
+    projectType === "client" &&
+    loadedConfig &&
+    loadedConfig.config.client &&
+    typeof loadedConfig.config.client.service === "string"
+  ) {
+    serviceName = loadedConfig.config.client.service;
+  }
+
+  // if there wasn't a config loaded from a file, build one.
+  // if there was a service name found in the env, merge it with the new/existing config object.
+  // if the config loaded doesn't have a client/service key, add one based on projectType
+  if (
+    !loadedConfig ||
+    serviceName ||
+    !(loadedConfig.config.client || loadedConfig.config.service)
+  ) {
+    loadedConfig = {
+      filepath: configPath || process.cwd(),
+      config: {
+        ...(loadedConfig && loadedConfig.config),
+        ...(projectType === "client"
+          ? {
+              client: {
+                ...DefaultConfigBase,
+                ...(loadedConfig && loadedConfig.config.client),
+                service: serviceName,
+              },
+            }
+          : {
+              service: {
+                ...DefaultConfigBase,
+                ...(loadedConfig && loadedConfig.config.service),
+                name: serviceName,
+              },
+            }),
+      },
+    };
+  }
+
+  let { config, filepath } = loadedConfig;
+
+  // selectively apply defaults when loading the config
+  // this is just the includes/excludes defaults.
+  // These need to go on _all_ configs. That's why this is last.
+  if (config.client) config = merge({ client: DefaultClientConfig }, config);
+  if (config.service) config = merge({ service: DefaultServiceConfig }, config);
+  if (engineConfig) config = merge(engineConfig, config);
+
+  config = merge({ engine: DefaultEngineConfig }, config);
+
+  return new ApolloConfig(config, URI.file(resolve(filepath)));
+}

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

@@ -0,0 +1,56 @@
+import {
+  ApolloConfig,
+  ClientConfig,
+  ClientServiceConfig,
+  LocalServiceConfig,
+  ServiceConfig,
+  ApolloConfigFormat,
+} from "./config";
+import { ServiceSpecifier, ServiceIDAndTag } from "../engine";
+
+export function isClientConfig(config: ApolloConfig): config is ClientConfig {
+  return config.isClient;
+}
+
+// checks the `config.client.service` object for a localSchemaFile
+export function isLocalServiceConfig(
+  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(":");
+    if (type === "service") return service;
+  }
+  return;
+}
+
+export function getGraphIdFromConfig(config: ApolloConfigFormat) {
+  if (config.service && config.service.name)
+    return parseServiceSpecifier(config.service.name)[0];
+  if (config.client) {
+    if (typeof config.client.service === "string") {
+      return parseServiceSpecifier(
+        config.client.service as ServiceSpecifier
+      )[0];
+    }
+    return config.client.service && config.client.service.name;
+  } else {
+    return undefined;
+  }
+}
+
+export function parseServiceSpecifier(specifier: ServiceSpecifier) {
+  const [id, tag] = specifier.split("@").map((x) => x.trim());
+  return [id, tag] as ServiceIDAndTag;
+}