vscode-apollo 2.2.1 → 2.3.0

package/src/language-server/config/cache-busting-resolver.js

@@ -0,0 +1,65 @@
+// @ts-check
+const { pathToFileURL } = require("node:url");
+
+/** @import { ResolveContext, ResolutionResult, LoadResult, ImportContext } from "./cache-busting-resolver.types" */
+
+/**
+ * @param {string} specifier
+ * @returns {string}
+ */
+function bustFileName(specifier) {
+  const url = pathToFileURL(specifier);
+  url.pathname = url.pathname + "." + Date.now() + ".js";
+  return url.toString();
+}
+
+/**
+ *
+ * @param {string} specifier
+ * @param {ResolveContext} context
+ * @param {(specifier: string,context: ResolveContext) => Promise<ResolutionResult>} nextResolve
+ * @returns {Promise<ResolutionResult>}
+ */
+async function resolve(specifier, context, nextResolve) {
+  if (context.importAttributes.as !== "cachebust") {
+    return nextResolve(specifier, context);
+  }
+  if (context.importAttributes.format) {
+    // no need to resolve at all, we have all necessary information
+    return {
+      url: bustFileName(specifier),
+      format: context.importAttributes.format,
+      importAttributes: context.importAttributes,
+      shortCircuit: true,
+    };
+  }
+  const result = await nextResolve(specifier, context);
+  return {
+    ...result,
+    url: bustFileName(result.url),
+    importAttributes: context.importAttributes,
+  };
+}
+
+/**
+ *
+ * @param {string} url
+ * @param {ImportContext} context
+ * @param {(url: string, context: ImportContext) => Promise<LoadResult>} nextLoad
+ * @returns {Promise<LoadResult>}
+ */
+async function load(url, context, nextLoad) {
+  if (context.importAttributes.as !== "cachebust") {
+    return nextLoad(url, context);
+  }
+  return {
+    format: context.format || "module",
+    shortCircuit: true,
+    source: context.importAttributes.contents,
+  };
+}
+
+module.exports = {
+  resolve,
+  load,
+};

package/src/language-server/config/cache-busting-resolver.types.ts

@@ -0,0 +1,45 @@
+import { pathToFileURL } from "node:url";
+
+export type ImportAttributes =
+  | {
+      as: "cachebust";
+      contents: string;
+      format?: Format;
+    }
+  | { as?: undefined };
+
+type Format =
+  | "builtin"
+  | "commonjs"
+  | "json"
+  | "module"
+  | "wasm"
+  | null
+  | undefined;
+
+export interface ResolveContext {
+  conditions: string[];
+  importAttributes: ImportAttributes;
+  parentURL?: string;
+}
+
+export interface ImportContext {
+  conditions: string[];
+  importAttributes: ImportAttributes;
+  format: Format;
+}
+
+export interface ResolutionResult {
+  format: Format;
+  importAttributes?: ImportAttributes;
+  shortCircuit?: boolean;
+  url: string;
+}
+
+export interface LoadResult {
+  format: Format;
+  shortCircuit?: boolean;
+  source: string;
+}
+
+export {};

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,8 +167,9 @@ 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;
@@ -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/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,

package/src/language-server/server.ts

@@ -9,7 +9,8 @@ import {
   FileEvent,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import type { QuickPickItem } from "vscode";
+import { type QuickPickItem } from "vscode";
+import { basename } from "node:path";
 import { GraphQLWorkspace } from "./workspace";
 import { LanguageServerLoadingHandler } from "./loadingHandler";
 import { debounceHandler, Debug } from "./utilities";
@@ -23,6 +24,7 @@ import { isValidationError } from "zod-validation-error";
 import { GraphQLProject } from "./project/base";
 import type { LanguageIdExtensionMap } from "../tools/utilities/languageInformation";
 import { setLanguageIdExtensionMap } from "./utilities/languageIdForExtension";
+import { envFileNames, supportedConfigFileNames } from "./config";
 
 export type InitializationOptions = {
   languageIdExtensionMap: LanguageIdExtensionMap;
@@ -190,14 +192,13 @@ documents.onDidClose(
 connection.onDidChangeWatchedFiles((params) => {
   const handledByProject = new Map<GraphQLProject, FileEvent[]>();
   for (const { uri, type } of params.changes) {
+    const fsPath = URI.parse(uri).fsPath;
+    const fileName = basename(fsPath);
     if (
-      uri.endsWith("apollo.config.js") ||
-      uri.endsWith("apollo.config.cjs") ||
-      uri.endsWith("apollo.config.mjs") ||
-      uri.endsWith("apollo.config.ts") ||
-      uri.endsWith(".env")
+      supportedConfigFileNames.includes(fileName) ||
+      envFileNames.includes(fileName)
     ) {
-      workspace.reloadProjectForConfig(uri);
+      workspace.reloadProjectForConfigOrCompanionFile(uri);
     }
 
     // Don't respond to changes in files that are currently open,

package/src/language-server/workspace.ts

@@ -125,7 +125,7 @@ export class GraphQLWorkspace {
 
     */
     const apolloConfigFiles: string[] = globSync(
-      "**/apollo.config.@(js|ts|cjs|mjs)",
+      "**/apollo.config.@(js|ts|cjs|mjs|yaml|yml|json)",
       {
         cwd: URI.parse(folder.uri).fsPath,
         absolute: true,
@@ -197,7 +197,7 @@ export class GraphQLWorkspace {
     });
   }
 
-  async reloadProjectForConfig(configUri: DocumentUri) {
+  async reloadProjectForConfigOrCompanionFile(configUri: DocumentUri) {
     const configPath = dirname(URI.parse(configUri).fsPath);
     let config: ApolloConfig | null;
     let error;
@@ -215,9 +215,6 @@ export class GraphQLWorkspace {
     }
     // If project exists, update the config
     if (project && config) {
-      if (equal(project.config.rawConfig, config.rawConfig)) {
-        return;
-      }
       await Promise.all(project.updateConfig(config));
       this.reloadService();
     }

package/src/languageServerClient.ts

@@ -52,7 +52,9 @@ export function getLanguageServerClient(
     documentSelector: supportedLanguageIds,
     synchronize: {
       fileEvents: [
-        workspace.createFileSystemWatcher("**/.env?(.local)"),
+        workspace.createFileSystemWatcher(
+          "**/{.env?(.local),apollo.config.{json,yml,yaml}}",
+        ),
         workspace.createFileSystemWatcher(
           "**/*{" + supportedExtensions.join(",") + "}",
         ),