vscode-apollo 2.2.1 → 2.3.1

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

@@ -8,6 +8,25 @@ function resolve(file: string) {
   return join(__dirname, "..", "..", "..", "sampleWorkspace", file);
 }
 
+export type GetPositionFn = ReturnType<typeof getPositionForEditor>;
+export function getPositionForEditor(editor: vscode.TextEditor) {
+  return function getPosition(cursor: `${string}|${string}`) {
+    if (cursor.indexOf("|") !== cursor.lastIndexOf("|")) {
+      throw new Error(
+        "`getPosition` cursor description can only contain one |",
+      );
+    }
+    const text = editor.document.getText();
+    const idx = text.indexOf(cursor.replace("|", ""));
+    if (idx !== text.lastIndexOf(cursor.replace("|", ""))) {
+      throw new Error("`getPosition` cursor description is not unique");
+    }
+    const cursorIndex = idx + cursor.indexOf("|");
+    const position = editor.document.positionAt(cursorIndex);
+    return position;
+  };
+}
+
 export async function closeAllEditors() {
   while (vscode.window.visibleTextEditors.length > 0) {
     await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
@@ -50,23 +69,28 @@ export function waitForLSP(file: string) {
   });
 }
 
-export async function testCompletion(
+export async function getCompletionItems(
   editor: vscode.TextEditor,
-  [line, character]: [number, number],
-  expected: Array<[label: string, detail: string]>,
+  position: vscode.Position,
 ) {
+  let result: { label: string; detail: string | undefined }[] | undefined = [];
   await waitFor(async () => {
-    editor.selection = new vscode.Selection(line, character, line, character);
+    editor.selection = new vscode.Selection(
+      position.line,
+      position.character,
+      position.line,
+      position.character,
+    );
     // without this, the completion list is not updated
     await scheduler.wait(300);
     const completions =
       await vscode.commands.executeCommand<vscode.CompletionList>(
         "vscode.executeCompletionItemProvider",
         editor.document.uri,
-        new vscode.Position(line, character),
+        position,
       );
-
-    const labels = completions.items.slice(0, expected.length).map((item) =>
+    expect(completions.items).not.toHaveLength(0);
+    const labels = completions.items.map((item) =>
       typeof item.label === "string"
         ? { label: item.label, detail: "" }
         : {
@@ -74,23 +98,27 @@ export async function testCompletion(
             detail: item.detail,
           },
     );
-    expect(labels).toStrictEqual(
-      expected.map(([label, detail]) => ({ label, detail })),
-    );
+    result = labels;
   });
+  return result;
 }
 
 export async function getHover(
   editor: vscode.TextEditor,
-  [line, character]: [number, number],
+  position: vscode.Position,
 ) {
-  editor.selection = new vscode.Selection(line, character, line, character);
+  editor.selection = new vscode.Selection(
+    position.line,
+    position.character,
+    position.line,
+    position.character,
+  );
   // without this, the completion list is not updated
   await scheduler.wait(300);
   const hovers = await vscode.commands.executeCommand<vscode.Hover[]>(
     "vscode.executeHoverProvider",
     editor.document.uri,
-    new vscode.Position(line, character),
+    position,
   );
 
   const item = hovers[0];
@@ -149,3 +177,76 @@ export async function reloadService() {
   await reloaded;
   await scheduler.wait(100);
 }
+
+export async function getFullSemanticTokens(editor: vscode.TextEditor) {
+  const legend = await vscode.commands.executeCommand<
+    vscode.SemanticTokensLegend | undefined
+  >(
+    // https://github.com/microsoft/vscode/blob/d90ab31527203cdb15056df0dc84ab9ddcbbde40/src/vs/workbench/api/common/extHostApiCommands.ts#L220
+    "vscode.provideDocumentSemanticTokensLegend",
+    editor.document.uri,
+  );
+  expect(legend).toBeDefined();
+  const tokens = await vscode.commands.executeCommand<
+    vscode.SemanticTokens | undefined
+  >(
+    // https://github.com/microsoft/vscode/blob/d90ab31527203cdb15056df0dc84ab9ddcbbde40/src/vs/workbench/api/common/extHostApiCommands.ts#L229
+    "vscode.provideDocumentSemanticTokens",
+    editor.document.uri,
+  );
+  expect(tokens).toBeDefined();
+
+  return decodeSemanticTokens(tokens!, legend!);
+}
+
+function decodeSemanticTokens(
+  tokens: vscode.SemanticTokens,
+  legend: vscode.SemanticTokensLegend,
+) {
+  const tokenArr = Array.from(tokens.data);
+  const decodedTokens: {
+    startPosition: vscode.Position;
+    endPosition: vscode.Position;
+    tokenType: string;
+    tokenModifiers: string[];
+  }[] = [];
+  let line = 0,
+    start = 0;
+  for (let pos = 0; pos < tokenArr.length; pos += 5) {
+    const [deltaLine, deltaStart, length, tokenType, tokenModifiers] =
+      tokenArr.slice(pos, pos + 5);
+    if (deltaLine) {
+      line += deltaLine;
+      start = 0;
+    }
+    start += deltaStart;
+    const decodedModifiers: string[] = [];
+    for (let modifiers = tokenModifiers; modifiers > 0; modifiers >>= 1) {
+      decodedModifiers.push(legend.tokenModifiers[modifiers & 0xf]);
+    }
+    const startPosition = new vscode.Position(line, start);
+    const endPosition = startPosition.translate(0, length);
+    decodedTokens.push({
+      startPosition,
+      endPosition,
+      tokenType: legend.tokenTypes[tokenType],
+      tokenModifiers: decodedModifiers,
+    });
+  }
+  return decodedTokens;
+}
+
+export async function getDefinitions(
+  editor: vscode.TextEditor,
+  position: vscode.Position,
+) {
+  return vscode.commands.executeCommand<
+    // this is not the correct type, but the best match with public types I could find
+    vscode.LocationLink[]
+  >(
+    // https://github.com/microsoft/vscode/blob/d90ab31527203cdb15056df0dc84ab9ddcbbde40/src/vs/workbench/api/common/extHostApiCommands.ts#L87
+    "vscode.executeDefinitionProvider",
+    editor.document.uri,
+    position,
+  );
+}

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

@@ -174,7 +174,10 @@ Object {
       expect(config?.client?.service).toEqual("hello");
     });
 
-    it("loads config from a cjs file", async () => {
+    // we skip these tests because ts-jest transpiles every `import` down to a `require` call,
+    // which messes up all the importing anyways.
+    // we have to rely on our E2E tests to ensure that config files resolve correctly
+    it.skip("loads config from a cjs file", async () => {
       writeFilesToDir(dir, {
         "apollo.config.cjs": `module.exports = {"client": {"service": "hello"} }`,
       });
@@ -182,13 +185,43 @@ Object {
       expect(config?.client?.service).toEqual("hello");
     });
 
-    it("loads config from a mjs file", async () => {
+    it.skip("loads config from a mjs file", async () => {
       writeFilesToDir(dir, {
         "apollo.config.mjs": `export default {"client": {"service": "hello"} }`,
       });
       const config = await loadConfig({ configPath: dirPath });
       expect(config?.client?.service).toEqual("hello");
     });
+
+    it("loads config from a yml file", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.yml": `
+client:
+  service: hello
+`,
+      });
+      const config = await loadConfig({ configPath: dirPath });
+      expect(config?.client?.service).toEqual("hello");
+    });
+
+    it("loads config from a yaml file", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.yaml": `
+client:
+  service: hello
+`,
+      });
+      const config = await loadConfig({ configPath: dirPath });
+      expect(config?.client?.service).toEqual("hello");
+    });
+
+    it("loads config from a json file", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.json": `{"client": /* testing jsonc */ {"service": "hello"} }`,
+      });
+      const config = await loadConfig({ configPath: dirPath });
+      expect(config?.client?.service).toEqual("hello");
+    });
   });
 
   describe("errors", () => {

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,
     },
   });