vscode-apollo 1.20.0 → 2.0.0

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

@@ -1,165 +1,240 @@
 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 { URI } from "vscode-uri";
 import { getGraphIdFromConfig, parseServiceSpecifier } from "./utils";
+import { Debug } from "../utilities";
+import z, { ZodError } from "zod";
 import { ValidationRule } from "graphql/validation/ValidationContext";
+import { Slot } from "@wry/context";
+import { fromZodError } from "zod-validation-error";
 
-export interface EngineStatsWindow {
-  to: number;
-  from: number;
+const ROVER_AVAILABLE = (process.env.APOLLO_FEATURE_FLAGS || "")
+  .split(",")
+  .includes("rover");
+
+function ignoredFieldWarning(
+  getMessage = (path: string) =>
+    `The option ${path} is no longer supported, please remove it from your configuration file.`,
+) {
+  return z
+    .custom<unknown>(() => true)
+    .superRefine((val, ctx) => {
+      if (val) {
+        Debug.warning(getMessage(ctx.path.join(".")));
+      }
+    })
+    .optional();
+}
+export interface Context {
+  apiKey?: string;
+  serviceName?: string;
 }
+const context = new Slot<Context>();
 
-export const DefaultEngineStatsWindow = {
-  to: -0,
-  from: -86400, // one day
-};
+const studioServiceConfig = z.string();
 
-export interface HistoricalEngineStatsWindow extends EngineStatsWindow {}
+const remoteServiceConfig = z.object({
+  name: z.string().optional(),
+  url: z.string(),
+  headers: z.record(z.string()).default({}),
+  skipSSLValidation: z.boolean().default(false),
+});
+export type RemoteServiceConfig = z.infer<typeof remoteServiceConfig>;
 
-export type EndpointURI = string;
-export interface RemoteServiceConfig {
-  name: ServiceID;
-  url: EndpointURI;
-  headers?: { [key: string]: string };
-  skipSSLValidation?: boolean;
-}
+const localServiceConfig = z.object({
+  name: z.string().optional(),
+  localSchemaFile: z.union([z.string(), z.array(z.string())]),
+});
+export type LocalServiceConfig = z.infer<typeof localServiceConfig>;
 
-export interface LocalServiceConfig {
-  name: ServiceID;
-  localSchemaFile: string | string[];
-}
+const clientServiceConfig = z.preprocess(
+  (value) => value || context.getValue()?.serviceName,
+  z.union([studioServiceConfig, remoteServiceConfig, localServiceConfig]),
+);
+export type ClientServiceConfig = z.infer<typeof clientServiceConfig>;
 
-export interface EngineConfig {
-  endpoint?: EndpointURI;
-  readonly apiKey?: string;
-}
+const clientConfig = z.object({
+  service: clientServiceConfig,
+  validationRules: z
+    .union([
+      z.array(z.custom<ValidationRule>()),
+      z.function().args(z.custom<ValidationRule>()).returns(z.boolean()),
+    ])
+    .optional(),
+  // maybe shared with rover?
+  includes: z
+    .array(z.string())
+    .default(["src/**/*.{ts,tsx,js,jsx,graphql,gql}"]),
+  // maybe shared with rover?
+  excludes: z.array(z.string()).default(["**/node_modules", "**/__tests__"]),
+  // maybe shared with rover?
+  tagName: z.string().default("gql"),
+  // removed:
+  clientOnlyDirectives: ignoredFieldWarning(),
+  clientSchemaDirectives: ignoredFieldWarning(),
+  statsWindow: ignoredFieldWarning(),
+  name: ignoredFieldWarning(),
+  referenceId: ignoredFieldWarning(),
+  version: ignoredFieldWarning(),
+});
+export type ClientConfigFormat = z.infer<typeof clientConfig>;
 
-export const DefaultEngineConfig = {
-  endpoint: "https://graphql.api.apollographql.com/api/graphql",
-};
+const roverConfig = z.object({
+  bin: z.string().optional(),
+  profile: z.string().optional(),
+});
+type RoverConfigFormat = z.infer<typeof roverConfig>;
 
-export const DefaultConfigBase = {
-  includes: ["src/**/*.{ts,tsx,js,jsx,graphql,gql}"],
-  excludes: ["**/node_modules", "**/__tests__"],
-};
+const engineConfig = z.object({
+  endpoint: z
+    .string()
+    .default(
+      process.env.APOLLO_ENGINE_ENDPOINT ||
+        "https://graphql.api.apollographql.com/api/graphql",
+    ),
+  apiKey: z.preprocess(
+    (val) => val || context.getValue()?.apiKey,
+    z.string().optional(),
+  ),
+});
+export type EngineConfig = z.infer<typeof engineConfig>;
 
-export interface ConfigBase {
-  includes: string[];
-  excludes: string[];
-}
+const baseConfig = z.object({
+  engine: engineConfig.default({}),
+  client: z.unknown().optional(),
+  rover: z.unknown().optional(),
+  service: ignoredFieldWarning(
+    (path) =>
+      `Service-type projects are no longer supported. Please remove the "${path}" field from your configuration file.`,
+  ),
+});
 
-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 type FullClientConfigFormat = Extract<
+  ParsedApolloConfigFormat,
+  { client: {} }
+>;
 
-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 type FullRoverConfigFormat = Extract<
+  ParsedApolloConfigFormat,
+  { rover: {} }
+>;
 
-export const DefaultServiceConfig = {
-  ...DefaultConfigBase,
-  endpoint: {
-    url: "http://localhost:4000/graphql",
-  },
-};
-
-export interface ConfigBaseFormat {
-  client?: ClientConfigFormat;
-  service?: ServiceConfigFormat;
-  engine?: EngineConfig;
+/** Helper function for TypeScript - we just want the first type to make it into the types, not the "no feature flag" fallback */
+function ifRoverAvailable<T>(yes: T, no: any): T {
+  return ROVER_AVAILABLE ? yes : no;
 }
 
-export type ApolloConfigFormat =
-  | WithRequired<ConfigBaseFormat, "client">
-  | WithRequired<ConfigBaseFormat, "service">;
+export const configSchema = baseConfig
+  .superRefine((val, ctx) => {
+    if (ROVER_AVAILABLE) {
+      if ("client" in val && "rover" in val) {
+        ctx.addIssue({
+          code: "custom",
+          message: "Config cannot contain both 'client' and 'rover' fields",
+          fatal: true,
+        });
+      }
+      if (!("client" in val) && !("rover" in val)) {
+        ctx.addIssue({
+          code: "custom",
+          message: "Config needs to contain either 'client' or 'rover' fields",
+          fatal: true,
+        });
+      }
+    } else {
+      if (!("client" in val)) {
+        ctx.addIssue({
+          code: "custom",
+          message: "Config needs to contain a 'client' field.",
+          fatal: true,
+        });
+      }
+    }
+  })
+  .and(
+    ifRoverAvailable(
+      z.union([
+        z
+          .object({
+            client: clientConfig,
+          })
+          .transform((val): typeof val & { rover?: never } => val),
+        z
+          .object({
+            rover: roverConfig,
+          })
+          .transform((val): typeof val & { client?: never } => val),
+      ]),
+      z.object({
+        client: clientConfig,
+      }),
+    ),
+  );
+export type RawApolloConfigFormat = z.input<typeof configSchema>;
+export type ParsedApolloConfigFormat = z.output<typeof configSchema>;
+
+export function parseApolloConfig(
+  rawConfig: RawApolloConfigFormat,
+  configURI?: URI,
+  ctx: Context = {},
+) {
+  const parsed = context.withValue(ctx, () =>
+    configSchema.safeParse(rawConfig),
+  );
+  if (!parsed.success) {
+    // Remove "or Required at rover" errors when a client config is provided
+    // Remove "or Required at client" errors when a rover config is provided
+    for (const [index, error] of parsed.error.errors.entries()) {
+      if (error.code === z.ZodIssueCode.invalid_union) {
+        error.unionErrors = error.unionErrors.filter((e) => {
+          return !(
+            e instanceof ZodError &&
+            e.errors.length === 1 &&
+            e.errors[0].message === "Required" &&
+            e.errors[0].path.length === 1
+          );
+        });
+      }
+    }
+    throw fromZodError(parsed.error, {
+      prefix: `Error parsing config file ${configURI?.fsPath}:`,
+      prefixSeparator: "\n",
+      issueSeparator: ";\n",
+      unionSeparator: "\n  or\n",
+    });
+  }
+  if (parsed.data.client) {
+    return new ClientConfig(parsed.data, configURI);
+  } else if (parsed.data.rover) {
+    return new RoverConfig(parsed.data, configURI);
+  } else {
+    // should never happen
+    throw new Error("Invalid config file format!");
+  }
+}
 
-export class ApolloConfig {
-  public isClient: boolean;
-  public isService: boolean;
+export abstract class ApolloConfig {
   public engine: EngineConfig;
-  public service?: ServiceConfigFormat;
   public client?: ClientConfigFormat;
+  public rover?: RoverConfigFormat;
   private _variant?: string;
   private _graphId?: string;
 
-  constructor(public rawConfig: ApolloConfigFormat, public configURI?: URI) {
-    this.isService = !!rawConfig.service;
-    this.isClient = !!rawConfig.client;
+  protected constructor(
+    public rawConfig: ParsedApolloConfigFormat,
+    public configURI?: URI,
+  ) {
     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)
+    return this.configURI &&
+      this.configURI.fsPath.match(/\.(ts|js|cjs|mjs|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;
   }
@@ -170,9 +245,6 @@ export class ApolloConfig {
     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;
   }
@@ -185,35 +257,28 @@ export class ApolloConfig {
     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;
+
+  constructor(
+    public rawConfig: FullClientConfigFormat,
+    public configURI?: URI,
+  ) {
+    super(rawConfig, configURI);
+    this.client = rawConfig.client;
+  }
 }
 
-export class ServiceConfig extends ApolloConfig {
-  public service!: ServiceConfigFormat;
-  public isClient!: false;
-  public isService!: true;
+export class RoverConfig extends ApolloConfig {
+  public rover!: RoverConfigFormat;
+
+  constructor(
+    public rawConfig: FullRoverConfigFormat,
+    public configURI?: URI,
+  ) {
+    super(rawConfig, configURI);
+    this.rover = rawConfig.rover;
+  }
 }

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

@@ -1,19 +1,13 @@
-import cosmiconfig from "cosmiconfig";
-import { LoaderEntry } from "cosmiconfig";
-import TypeScriptLoader from "@endemolshinegroup/cosmiconfig-typescript-loader";
+import { cosmiconfig } from "cosmiconfig";
 import { resolve } from "path";
 import { readFileSync, existsSync, lstatSync } from "fs";
-import merge from "lodash.merge";
 import {
   ApolloConfig,
-  ApolloConfigFormat,
-  DefaultConfigBase,
-  DefaultClientConfig,
-  DefaultServiceConfig,
-  DefaultEngineConfig,
+  RawApolloConfigFormat,
+  parseApolloConfig,
 } from "./config";
 import { getServiceFromKey } from "./utils";
-import URI from "vscode-uri";
+import { URI } from "vscode-uri";
 import { Debug } from "../utilities";
 
 // config settings
@@ -22,207 +16,86 @@ const defaultFileNames = [
   "package.json",
   `${MODULE_NAME}.config.js`,
   `${MODULE_NAME}.config.ts`,
+  `${MODULE_NAME}.config.mjs`,
   `${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";
+  configPath: string;
 }
 
 export type ConfigResult<T> = {
   config: T;
   filepath: string;
+  isEmpty?: boolean;
 } | 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,
+    searchPlaces: defaultFileNames,
   });
 
   // search can fail if a file can't be parsed (ex: a nonsense js file) so we wrap in a try/catch
-  let loadedConfig;
+  let loadedConfig: ConfigResult<RawApolloConfigFormat>;
   try {
     loadedConfig = (await explorer.search(
-      configPath
-    )) as ConfigResult<ApolloConfigFormat>;
+      configPath,
+    )) as ConfigResult<RawApolloConfigFormat>;
   } catch (error) {
-    Debug.error(`A config file failed to load with options: ${JSON.stringify(
-      arguments[0]
+    throw new Error(`A config file failed to load with options: ${JSON.stringify(
+      arguments[0],
     )}.
     The error was: ${error}`);
-    return null;
   }
 
-  if (configPath && !loadedConfig) {
+  if (!loadedConfig || loadedConfig.isEmpty) {
     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`
+      `No Apollo config found for project or config file failed to load. For more information, please refer to: https://go.apollo.dev/t/config`,
     );
+    // deliberately returning `null` here, but not throwing an error - the user may not have a config file and that's okay, it might just be a project without a graph
     return null;
   }
 
-  if (loadedConfig && loadedConfig.filepath.endsWith("package.json")) {
+  if (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'
+      '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;
+  let 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);
+    const dotEnvPath = resolve(configPath, envFile);
 
     if (existsSync(dotEnvPath) && lstatSync(dotEnvPath).isFile()) {
       const env: { [key: string]: string } = require("dotenv").parse(
-        readFileSync(dotEnvPath)
+        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;
+      apiKey = env[keyEnvVar];
     }
   });
 
   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)));
+  return parseApolloConfig(config, URI.file(resolve(filepath)), {
+    apiKey,
+    serviceName: nameFromKey,
+  });
 }