vscode-apollo 1.19.3 → 2.0.0

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

@@ -0,0 +1,284 @@
+import { dirname } from "path";
+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";
+
+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>();
+
+const studioServiceConfig = z.string();
+
+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>;
+
+const localServiceConfig = z.object({
+  name: z.string().optional(),
+  localSchemaFile: z.union([z.string(), z.array(z.string())]),
+});
+export type LocalServiceConfig = z.infer<typeof localServiceConfig>;
+
+const clientServiceConfig = z.preprocess(
+  (value) => value || context.getValue()?.serviceName,
+  z.union([studioServiceConfig, remoteServiceConfig, localServiceConfig]),
+);
+export type ClientServiceConfig = z.infer<typeof clientServiceConfig>;
+
+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>;
+
+const roverConfig = z.object({
+  bin: z.string().optional(),
+  profile: z.string().optional(),
+});
+type RoverConfigFormat = z.infer<typeof roverConfig>;
+
+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>;
+
+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 FullClientConfigFormat = Extract<
+  ParsedApolloConfigFormat,
+  { client: {} }
+>;
+
+export type FullRoverConfigFormat = Extract<
+  ParsedApolloConfigFormat,
+  { rover: {} }
+>;
+
+/** 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 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 abstract class ApolloConfig {
+  public engine: EngineConfig;
+  public client?: ClientConfigFormat;
+  public rover?: RoverConfigFormat;
+  private _variant?: string;
+  private _graphId?: string;
+
+  protected constructor(
+    public rawConfig: ParsedApolloConfigFormat,
+    public configURI?: URI,
+  ) {
+    this.engine = rawConfig.engine!;
+    this._graphId = getGraphIdFromConfig(rawConfig);
+  }
+
+  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|mjs|json)$/i)
+      ? URI.parse(dirname(this.configURI.fsPath))
+      : this.configURI;
+  }
+
+  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;
+    }
+    return tag;
+  }
+
+  set graph(graphId: string | undefined) {
+    this._graphId = graphId;
+  }
+
+  get graph(): string | undefined {
+    if (this._graphId) return this._graphId;
+    return getGraphIdFromConfig(this.rawConfig);
+  }
+}
+
+export class ClientConfig extends ApolloConfig {
+  public client!: ClientConfigFormat;
+
+  constructor(
+    public rawConfig: FullClientConfigFormat,
+    public configURI?: URI,
+  ) {
+    super(rawConfig, configURI);
+    this.client = rawConfig.client;
+  }
+}
+
+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/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,101 @@
+import { cosmiconfig } from "cosmiconfig";
+import { resolve } from "path";
+import { readFileSync, existsSync, lstatSync } from "fs";
+import {
+  ApolloConfig,
+  RawApolloConfigFormat,
+  parseApolloConfig,
+} 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.mjs`,
+  `${MODULE_NAME}.config.cjs`,
+];
+const envFileNames = [".env", ".env.local"];
+
+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: string;
+}
+
+export type ConfigResult<T> = {
+  config: T;
+  filepath: string;
+  isEmpty?: boolean;
+} | null;
+
+// XXX load .env files automatically
+export async function loadConfig({
+  configPath,
+}: LoadConfigSettings): Promise<ApolloConfig | null> {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    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: ConfigResult<RawApolloConfigFormat>;
+  try {
+    loadedConfig = (await explorer.search(
+      configPath,
+    )) as ConfigResult<RawApolloConfigFormat>;
+  } catch (error) {
+    throw new Error(`A config file failed to load with options: ${JSON.stringify(
+      arguments[0],
+    )}.
+    The error was: ${error}`);
+  }
+
+  if (!loadedConfig || loadedConfig.isEmpty) {
+    Debug.error(
+      `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.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',
+    );
+  }
+
+  // add API key from the env
+  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 = resolve(configPath, envFile);
+
+    if (existsSync(dotEnvPath) && lstatSync(dotEnvPath).isFile()) {
+      const env: { [key: string]: string } = require("dotenv").parse(
+        readFileSync(dotEnvPath),
+      );
+      apiKey = env[keyEnvVar];
+    }
+  });
+
+  if (apiKey) {
+    nameFromKey = getServiceFromKey(apiKey);
+  }
+
+  let { config, filepath } = loadedConfig;
+
+  return parseApolloConfig(config, URI.file(resolve(filepath)), {
+    apiKey,
+    serviceName: nameFromKey,
+  });
+}

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

@@ -0,0 +1,45 @@
+import {
+  ApolloConfig,
+  ClientConfig,
+  ClientServiceConfig,
+  LocalServiceConfig,
+  ParsedApolloConfigFormat,
+} from "./config";
+import { ServiceSpecifier, ServiceIDAndTag } from "../engine";
+
+export function isClientConfig(config: ApolloConfig): config is ClientConfig {
+  return config instanceof ClientConfig;
+}
+
+// checks the `config.client.service` object for a localSchemaFile
+export function isLocalServiceConfig(
+  config: ClientServiceConfig,
+): config is LocalServiceConfig {
+  return !!(config as LocalServiceConfig).localSchemaFile;
+}
+
+export function getServiceFromKey(key?: string) {
+  if (key) {
+    const [type, service] = key.split(":");
+    if (type === "service") return service;
+  }
+  return;
+}
+
+export function getGraphIdFromConfig(config: ParsedApolloConfigFormat) {
+  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;
+}

package/src/language-server/diagnostics.ts

@@ -0,0 +1,118 @@
+import {
+  GraphQLSchema,
+  GraphQLError,
+  FragmentDefinitionNode,
+  isExecutableDefinitionNode,
+  DocumentNode,
+  validate,
+  NoDeprecatedCustomRule,
+} from "graphql";
+
+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";
+import { rangeForASTNode } from "./utilities/source";
+
+import { getValidationErrors } from "./errors/validation";
+import { DocumentUri } from "./project/base";
+import { ValidationRule } from "graphql/validation/ValidationContext";
+
+/**
+ * Build an array of code diagnostics for all executable definitions in a document.
+ */
+export function collectExecutableDefinitionDiagnositics(
+  schema: GraphQLSchema,
+  queryDocument: GraphQLDocument,
+  fragments: { [fragmentName: string]: FragmentDefinitionNode } = {},
+  rules?: ValidationRule[],
+): Diagnostic[] {
+  const ast = queryDocument.ast;
+  if (!ast) return queryDocument.syntaxErrors;
+
+  const astWithExecutableDefinitions = {
+    ...ast,
+    definitions: ast.definitions.filter(isExecutableDefinitionNode),
+  };
+
+  const diagnostics = [];
+
+  for (const error of getValidationErrors(
+    schema,
+    astWithExecutableDefinitions,
+    fragments,
+    rules,
+  )) {
+    diagnostics.push(
+      ...diagnosticsFromError(error, DiagnosticSeverity.Error, "Validation"),
+    );
+  }
+
+  for (const error of findDeprecatedUsages(
+    schema,
+    astWithExecutableDefinitions,
+  )) {
+    diagnostics.push(
+      ...diagnosticsFromError(error, DiagnosticSeverity.Warning, "Deprecation"),
+    );
+  }
+
+  return diagnostics;
+}
+
+export function diagnosticsFromError(
+  error: GraphQLError,
+  severity: DiagnosticSeverity,
+  type: string,
+): GraphQLDiagnostic[] {
+  if (!error.nodes) {
+    return [];
+  }
+
+  return error.nodes.map((node) => {
+    return {
+      source: `GraphQL: ${type}`,
+      message: error.message,
+      severity,
+      range: rangeForASTNode(highlightNodeForNode(node) || node),
+      error,
+    };
+  });
+}
+
+export interface GraphQLDiagnostic extends Diagnostic {
+  /**
+   * The GraphQLError that produced this Diagnostic
+   */
+  error: GraphQLError;
+}
+
+export namespace GraphQLDiagnostic {
+  export function is(diagnostic: Diagnostic): diagnostic is GraphQLDiagnostic {
+    return "error" in diagnostic;
+  }
+}
+
+export class DiagnosticSet {
+  private diagnosticsByFile = new Map<DocumentUri, Diagnostic[]>();
+
+  entries() {
+    return this.diagnosticsByFile.entries();
+  }
+
+  addDiagnostics(uri: DocumentUri, diagnostics: Diagnostic[]) {
+    const existingDiagnostics = this.diagnosticsByFile.get(uri);
+    if (!existingDiagnostics) {
+      this.diagnosticsByFile.set(uri, diagnostics);
+    } else {
+      existingDiagnostics.push(...diagnostics);
+    }
+  }
+}