vscode-apollo 2.2.0 → 2.3.0

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

@@ -25,7 +25,10 @@ function ignoredFieldWarning(
         Debug.warning(getMessage(ctx.path.join(".")));
       }
     })
-    .optional();
+    .optional()
+    .describe(
+      `This option is no longer supported, please remove it from your configuration file.`,
+    );
 }
 export interface Context {
   apiKey?: string;
@@ -34,53 +37,113 @@ export interface Context {
 }
 const contextStore = new AsyncLocalStorage<Context>();
 
-const studioServiceConfig = z.string();
+const NAME_DESCRIPTION =
+  "The name your project will be referred to by the Apollo GraphQL extension.";
 
-const remoteServiceConfig = z.object({
-  name: z.string().optional(),
-  url: z.string(),
-  headers: z.record(z.string()).default({}),
-  skipSSLValidation: z.boolean().default(false),
-});
+const studioServiceConfig = z
+  .string()
+  .describe(
+    "The name of the Apollo Studio graph to use. Alternatively pass in an object to configure a local schema.",
+  );
+
+const remoteServiceConfig = z
+  .object({
+    name: z.string().optional().describe(NAME_DESCRIPTION),
+    url: z
+      .string()
+      .describe(
+        "URL of a GraphQL to use for the GraphQL Schema for this project. Needs introspection enabled.",
+      ),
+    headers: z
+      .record(z.string())
+      .default({})
+      .describe("Additional headers to send to the server."),
+    skipSSLValidation: z
+      .boolean()
+      .default(false)
+      .describe(
+        "Skip SSL validation. May be required for self-signed certificates.",
+      ),
+  })
+  .describe("Configuration for using a local schema from a URL.");
 export type RemoteServiceConfig = z.infer<typeof remoteServiceConfig>;
 
-const localServiceConfig = z.object({
-  name: z.string().optional(),
-  localSchemaFile: z.union([z.string(), z.array(z.string())]),
-});
+const LOCAL_SCHEMA_FILE_DESCRIPTION =
+  "Path to a local schema file to use as GraphQL Schema for this project. Can be a string or an array of strings to merge multiple partial schemas into one.";
+const localServiceConfig = z
+  .object({
+    name: z.string().optional().describe(NAME_DESCRIPTION),
+    localSchemaFile: z
+      .union([
+        z.string().describe(LOCAL_SCHEMA_FILE_DESCRIPTION),
+        z.array(z.string()).describe(LOCAL_SCHEMA_FILE_DESCRIPTION),
+      ])
+      .describe(LOCAL_SCHEMA_FILE_DESCRIPTION),
+  })
+  .describe("Configuration for using a local schema from a file.");
 export type LocalServiceConfig = z.infer<typeof localServiceConfig>;
 
-const clientServiceConfig = z.preprocess(
-  (value) => value || contextStore.getStore()?.serviceName,
-  z.union([studioServiceConfig, remoteServiceConfig, localServiceConfig]),
-);
+const clientServiceConfig = z
+  .preprocess(
+    (value) => value || contextStore.getStore()?.serviceName,
+    z.union([studioServiceConfig, remoteServiceConfig, localServiceConfig]),
+  )
+  .describe(
+    "A string to refer to a graph in Apollo Studio, or an object for a local schema.",
+  );
 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()).optional(),
-  // 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(),
-});
+const VALIDATION_RULES_DESCRIPTION =
+  "Additional validation rules to check for. To use this feature, please use a configuration file format that allows passing JavaScript objects.";
+export const clientConfig = z
+  .object({
+    service: clientServiceConfig,
+    validationRules: z
+      .union([
+        z
+          .array(z.custom<ValidationRule>())
+          .describe(VALIDATION_RULES_DESCRIPTION),
+        z
+          .function()
+          .args(z.custom<ValidationRule>())
+          .returns(z.boolean())
+          .describe(VALIDATION_RULES_DESCRIPTION),
+      ])
+      .optional()
+      .describe(VALIDATION_RULES_DESCRIPTION),
+    // maybe shared with rover?
+    includes: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "An array of glob patterns this project should be active on. The Apollo GraphQL extension will only support IntelliSense-like features in files listed here.",
+      ),
+    // maybe shared with rover?
+    excludes: z
+      .array(z.string())
+      .default(["**/node_modules", "**/__tests__"])
+      .describe(
+        "Files to exclude from this project. The Apollo GraphQL extension will not provide IntelliSense-like features in these files.",
+      ),
+    // maybe shared with rover?
+    tagName: z
+      .string()
+      .default("gql")
+      .describe(
+        "The name of the template literal tag or function used in JavaScript files to declare GraphQL Documents.",
+      ),
+    // removed:
+    clientOnlyDirectives: ignoredFieldWarning(),
+    clientSchemaDirectives: ignoredFieldWarning(),
+    statsWindow: ignoredFieldWarning(),
+    name: ignoredFieldWarning(),
+    referenceId: ignoredFieldWarning(),
+    version: ignoredFieldWarning(),
+  })
+  .describe("Configuration for a Client project.");
 export type ClientConfigFormat = z.infer<typeof clientConfig>;
 
-const roverConfig = z.object({
+export const roverConfig = z.object({
   bin: z
     .preprocess(
       (val) => val || which.sync("rover", { nothrow: true }) || undefined,
@@ -104,18 +167,19 @@ const roverConfig = z.object({
         message:
           "Rover binary is not marked as an executable. If you are using OS X or Linux, ensure to set the executable bit.",
       },
-    ),
-  profile: z.string().optional(),
+    )
+    .describe("The path to your Rover binary. If omitted, will look in PATH."),
+  profile: z.string().optional().describe("The name of the profile to use."),
   supergraphConfig: z
     .preprocess((value) => {
       if (value !== undefined) return value;
       const configPath = contextStore.getStore()?.configPath!;
-      const supergraphConfig = join(configPath, "supergraph.yml");
+      const supergraphConfig = join(configPath, "supergraph.yaml");
       return existsSync(supergraphConfig) ? supergraphConfig : undefined;
     }, z.string().nullable().optional())
     .describe(
-      "The path to your `supergraph.yml` file. \n" +
-        "Defaults to a `supergraph.yml` in the folder of your `apollo.config.js`, if there is one.",
+      "The path to your `supergraph.yaml` file. \n" +
+        "Defaults to a `supergraph.yaml` in the folder of your `apollo.config.js`, if there is one.",
     ),
   extraArgs: z
     .array(z.string())
@@ -124,24 +188,36 @@ const roverConfig = z.object({
 });
 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 || contextStore.getStore()?.apiKey,
-    z.string().optional(),
-  ),
-});
+export const engineConfig = z
+  .object({
+    endpoint: z
+      .string()
+      .default(
+        process.env.APOLLO_ENGINE_ENDPOINT ||
+          "https://graphql.api.apollographql.com/api/graphql",
+      )
+      .describe("The URL of the Apollo Studio API."),
+    apiKey: z
+      .preprocess(
+        (val) => val || contextStore.getStore()?.apiKey,
+        z.string().optional(),
+      )
+      .describe(
+        "The API key to use for Apollo Studio. If possible, use a `.env` file or `.env.local` file instead to store secrets like this.",
+      ),
+  })
+  .describe("Network configuration for Apollo Studio API.");
 export type EngineConfig = z.infer<typeof engineConfig>;
 
-const baseConfig = z.object({
+export const baseConfig = z.object({
   engine: engineConfig.default({}),
-  client: z.unknown().optional(),
-  rover: z.unknown().optional(),
+  client: z.unknown().optional().describe(clientConfig.description!),
+  ...ifRoverAvailable(
+    {
+      rover: z.unknown().optional(),
+    },
+    {},
+  ),
   service: ignoredFieldWarning(
     (path) =>
       `Service-type projects are no longer supported. Please remove the "${path}" field from your configuration file.`,
@@ -268,7 +344,7 @@ export abstract class ApolloConfig {
   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)
+      this.configURI.fsPath.match(/\.(ts|js|cjs|mjs|yaml|yml|json)$/i)
       ? URI.parse(dirname(this.configURI.fsPath))
       : this.configURI;
   }

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

@@ -1,4 +1,4 @@
-import { cosmiconfig, defaultLoaders } from "cosmiconfig";
+import { cosmiconfig, defaultLoaders, Loader } from "cosmiconfig";
 import { dirname, resolve } from "path";
 import { readFileSync, existsSync, lstatSync } from "fs";
 import {
@@ -9,18 +9,22 @@ import {
 import { getServiceFromKey } from "./utils";
 import { URI } from "vscode-uri";
 import { Debug } from "../utilities";
-import { loadTs } from "./loadTsConfig";
+import { ParseError, parse as parseJsonC } from "jsonc-parser";
+import { loadJs, loadTs } from "./loadTsConfig";
 
 // config settings
 const MODULE_NAME = "apollo";
-const defaultFileNames = [
+export const supportedConfigFileNames = [
   "package.json",
   `${MODULE_NAME}.config.js`,
   `${MODULE_NAME}.config.ts`,
   `${MODULE_NAME}.config.mjs`,
   `${MODULE_NAME}.config.cjs`,
+  `${MODULE_NAME}.config.yaml`,
+  `${MODULE_NAME}.config.yml`,
+  `${MODULE_NAME}.config.json`,
 ];
-const envFileNames = [".env", ".env.local"];
+export const envFileNames = [".env", ".env.local"];
 
 export const keyEnvVar = "APOLLO_KEY";
 
@@ -39,14 +43,31 @@ export type ConfigResult<T> = {
 
 // XXX load .env files automatically
 
+const loadJsonc: Loader = (filename, contents) => {
+  const errors: ParseError[] = [];
+  try {
+    return parseJsonC(contents, errors);
+  } finally {
+    if (errors.length) {
+      Debug.error(
+        `Error parsing JSONC file ${filename}, file might not be valid JSONC`,
+      );
+    }
+  }
+};
+
 export async function loadConfig({
   configPath,
 }: LoadConfigSettings): Promise<ApolloConfig | null> {
   const explorer = cosmiconfig(MODULE_NAME, {
-    searchPlaces: defaultFileNames,
+    searchPlaces: supportedConfigFileNames,
     loaders: {
       ...defaultLoaders,
-      [".ts"]: loadTs,
+      ".ts": loadTs,
+      ".mjs": loadJs,
+      ".cjs": loadJs,
+      ".js": loadJs,
+      ".json": loadJsonc,
     },
   });
 

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

@@ -1,56 +1,78 @@
-import { Loader, defaultLoaders } from "cosmiconfig";
+import { Loader } from "cosmiconfig";
 import { dirname } from "node:path";
-import { rm, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-
+import typescript from "typescript";
+import { pathToFileURL } from "node:url";
+import { register } from "node:module";
+import { ImportAttributes } from "./cache-busting-resolver.types";
 // implementation based on https://github.com/cosmiconfig/cosmiconfig/blob/a5a842547c13392ebb89a485b9e56d9f37e3cbd3/src/loaders.ts
 // Copyright (c) 2015 David Clark licensed MIT. Full license can be found here:
 // https://github.com/cosmiconfig/cosmiconfig/blob/a5a842547c13392ebb89a485b9e56d9f37e3cbd3/LICENSE
 
-let typescript: typeof import("typescript");
+if (process.env.JEST_WORKER_ID === undefined) {
+  register(
+    pathToFileURL(require.resolve("./config/cache-busting-resolver.js")),
+  );
+} else {
+  register(pathToFileURL(require.resolve("./cache-busting-resolver.js")));
+}
+
 export const loadTs: Loader = async function loadTs(filepath, content) {
   try {
-    return await defaultLoaders[".ts"](filepath, content);
+    return await load(filepath, content, "module", {
+      module: typescript.ModuleKind.ES2022,
+    });
   } catch (error) {
     if (
-      !(error instanceof Error) ||
-      !error.message.includes("module is not defined")
-    )
+      error instanceof Error &&
+      // [ERROR] ReferenceError: module is not defined in ES module scope
+      error.message.includes("module is not defined")
+    ) {
+      return await load(filepath, content, "commonjs", {
+        module: typescript.ModuleKind.CommonJS,
+      });
+    } else {
       throw error;
+    }
   }
+};
 
-  if (typescript === undefined) {
-    typescript = await import("typescript");
-  }
-  const compiledFilepath = `${filepath.slice(0, -2)}cjs`;
+async function load(
+  filepath: string,
+  content: string,
+  type: "module" | "commonjs",
+  compilerOptions: Partial<import("typescript").CompilerOptions>,
+) {
   let transpiledContent;
+
   try {
-    try {
-      const config = resolveTsConfig(dirname(filepath)) ?? {};
-      config.compilerOptions = {
-        ...config.compilerOptions,
-        module: typescript.ModuleKind.CommonJS,
-        moduleResolution: typescript.ModuleResolutionKind.Bundler,
-        target: typescript.ScriptTarget.ES2022,
-        noEmit: false,
-      };
-      transpiledContent = typescript.transpileModule(
-        content,
-        config,
-      ).outputText;
-      await writeFile(compiledFilepath, transpiledContent);
-    } catch (error: any) {
-      error.message = `TypeScript Error in ${filepath}:\n${error.message}`;
-      throw error;
-    }
-    // eslint-disable-next-line @typescript-eslint/return-await
-    return await defaultLoaders[".js"](compiledFilepath, transpiledContent);
-  } finally {
-    if (existsSync(compiledFilepath)) {
-      await rm(compiledFilepath);
-    }
+    const config = resolveTsConfig(dirname(filepath)) ?? {};
+    config.compilerOptions = {
+      ...config.compilerOptions,
+
+      moduleResolution: typescript.ModuleResolutionKind.Bundler,
+      target: typescript.ScriptTarget.ES2022,
+      noEmit: false,
+      ...compilerOptions,
+    };
+    transpiledContent = typescript.transpileModule(content, config).outputText;
+  } catch (error: any) {
+    error.message = `TypeScript Error in ${filepath}:\n${error.message}`;
+    throw error;
   }
-};
+  // eslint-disable-next-line @typescript-eslint/return-await
+  const imported = await import(
+    filepath,
+    //@ts-ignore
+    {
+      with: {
+        as: "cachebust",
+        contents: transpiledContent,
+        format: type,
+      } satisfies ImportAttributes,
+    }
+  );
+  return imported.default;
+}
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function resolveTsConfig(directory: string): any {
@@ -68,3 +90,17 @@ function resolveTsConfig(directory: string): any {
   }
   return;
 }
+
+export const loadJs: Loader = async function loadJs(filepath, contents) {
+  return (
+    await import(
+      filepath, // @ts-ignore
+      {
+        with: {
+          as: "cachebust",
+          contents,
+        } satisfies ImportAttributes,
+      }
+    )
+  ).default;
+};

package/src/language-server/project/base.ts

@@ -18,7 +18,13 @@ import { TextDocument } from "vscode-languageserver-textdocument";
 
 import type { LoadingHandler } from "../loadingHandler";
 import { FileSet } from "../fileSet";
-import { ApolloConfig, ClientConfig, RoverConfig } from "../config";
+import {
+  ApolloConfig,
+  ClientConfig,
+  envFileNames,
+  RoverConfig,
+  supportedConfigFileNames,
+} from "../config";
 import type { ProjectStats } from "../../messages";
 
 export type DocumentUri = string;
@@ -67,13 +73,7 @@ export abstract class GraphQLProject {
 
     this.configFileSet = new FileSet({
       rootURI: this.rootURI,
-      includes: [
-        ".env",
-        "apollo.config.js",
-        "apollo.config.cjs",
-        "apollo.config.mjs",
-        "apollo.config.ts",
-      ],
+      includes: supportedConfigFileNames.concat(envFileNames),
       excludes: [],
     });
 

package/src/language-server/project/rover/DocumentSynchronization.ts

@@ -99,10 +99,17 @@ export class DocumentSynchronization {
   private pendingDocumentChanges = new Map<DocumentUri, TextDocument>();
   private knownFiles = new Map<
     DocumentUri,
-    {
-      full: TextDocument;
-      parts: ReadonlyArray<FilePart>;
-    }
+    | {
+        source: "editor";
+        full: TextDocument;
+        parts: ReadonlyArray<FilePart>;
+      }
+    | {
+        source: "lsp";
+        full: Pick<TextDocument, "uri">;
+        parts?: undefined;
+        diagnostics?: Diagnostic[];
+      }
   >();
 
   constructor(
@@ -158,7 +165,11 @@ export class DocumentSynchronization {
     const newObj = Object.fromEntries(
       newParts.map((p) => [p.fractionalIndex, p]),
     );
-    this.knownFiles.set(document.uri, { full: document, parts: newParts });
+    this.knownFiles.set(document.uri, {
+      source: "editor",
+      full: document,
+      parts: newParts,
+    });
 
     for (const newPart of newParts) {
       const previousPart = previousObj[newPart.fractionalIndex];
@@ -198,7 +209,9 @@ export class DocumentSynchronization {
 
   async resendAllDocuments() {
     for (const file of this.knownFiles.values()) {
-      await this.sendDocumentChanges(file.full, []);
+      if (file.source === "editor") {
+        await this.sendDocumentChanges(file.full, []);
+      }
     }
   }
 
@@ -208,7 +221,7 @@ export class DocumentSynchronization {
     this.documentDidChange(params.document);
   };
 
-  onDidCloseTextDocument: NonNullable<GraphQLProject["onDidClose"]> = (
+  onDidCloseTextDocument: NonNullable<GraphQLProject["onDidClose"]> = async (
     params,
   ) => {
     const known = this.knownFiles.get(params.document.uri);
@@ -216,15 +229,15 @@ export class DocumentSynchronization {
       return;
     }
     this.knownFiles.delete(params.document.uri);
-    return Promise.all(
-      known.parts.map((part) =>
-        this.sendNotification(DidCloseTextDocumentNotification.type, {
+    if (known.source === "editor") {
+      for (const part of known.parts) {
+        await this.sendNotification(DidCloseTextDocumentNotification.type, {
           textDocument: {
             uri: getUri(known.full, part),
           },
-        }),
-      ),
-    );
+        });
+      }
+    }
   };
 
   async documentDidChange(document: TextDocument) {
@@ -254,7 +267,7 @@ export class DocumentSynchronization {
   ): Promise<T | undefined> {
     await this.synchronizedWithDocument(positionParams.textDocument.uri);
     const found = this.knownFiles.get(positionParams.textDocument.uri);
-    if (!found) {
+    if (!found || found.source !== "editor") {
       return;
     }
     const match = findContainedSourceAndPosition(
@@ -274,11 +287,14 @@ export class DocumentSynchronization {
   handlePartDiagnostics(params: PublishDiagnosticsParams) {
     DEBUG && console.log("Received diagnostics", params);
     const uriDetails = splitUri(params.uri);
-    if (!uriDetails) {
-      return;
-    }
     const found = this.knownFiles.get(uriDetails.uri);
-    if (!found) {
+    if (!found || found.source === "lsp") {
+      this.knownFiles.set(uriDetails.uri, {
+        source: "lsp",
+        full: { uri: uriDetails.uri },
+        diagnostics: params.diagnostics,
+      });
+      this.sendDiagnostics(params);
       return;
     }
     const part = found.parts.find(
@@ -304,13 +320,19 @@ export class DocumentSynchronization {
   }
 
   get openDocuments() {
-    return [...this.knownFiles.values()].map((f) => f.full);
+    return [...this.knownFiles.values()]
+      .filter((f) => f.source === "editor")
+      .map((f) => f.full);
   }
 
   clearAllDiagnostics() {
     for (const file of this.knownFiles.values()) {
-      for (const part of file.parts) {
-        part.diagnostics = [];
+      if (file.source === "editor") {
+        for (const part of file.parts) {
+          part.diagnostics = [];
+        }
+      } else {
+        file.diagnostics = [];
       }
       this.sendDiagnostics({ uri: file.full.uri, diagnostics: [] });
     }
@@ -332,7 +354,7 @@ export class DocumentSynchronization {
   ): Promise<SemanticTokens | null> {
     await this.synchronizedWithDocument(params.textDocument.uri);
     const found = this.knownFiles.get(params.textDocument.uri);
-    if (!found) {
+    if (!found || found.source !== "editor") {
       return null;
     }
     const allParts = await Promise.all(

package/src/language-server/project/rover/project.ts

@@ -24,6 +24,7 @@ import {
   SemanticTokensRegistrationType,
   SemanticTokensOptions,
   SemanticTokensRegistrationOptions,
+  DefinitionRequest,
 } from "vscode-languageserver/node";
 import cp from "node:child_process";
 import { GraphQLProjectConfig } from "../base";
@@ -281,6 +282,11 @@ export class RoverProject extends GraphQLProject {
       this.sendRequest(HoverRequest.type, virtualParams, token),
     );
 
+  onDefinition: GraphQLProject["onDefinition"] = async (params, token) =>
+    this.documents.insideVirtualDocument(params, (virtualParams) =>
+      this.sendRequest(DefinitionRequest.type, virtualParams, token),
+    );
+
   onUnhandledRequest: GraphQLProject["onUnhandledRequest"] = async (
     type,
     params,