Cache busting config reloading by using virtual files

.changeset/odd-apricots-learn.md

@@ -0,0 +1,5 @@
+---
+"vscode-apollo": patch
+---
+
+Fix a bug where config file changes could not be picked up

sampleWorkspace/localSchema/apollo.config.ts

@@ -0,0 +1,8 @@
+module.exports = {
+  client: {
+    service: {
+      name: "localSchema",
+      localSchemaFile: "./starwarsSchema.graphql",
+    },
+  },
+};

sampleWorkspace/rover/apollo.config.yaml

@@ -0,0 +1,2 @@
+rover:
+  profile: default

src/build.js

@@ -12,6 +12,7 @@ async function main() {
       "src/extension.ts",
       "src/language-server/server.ts",
       "src/language-server/config/config.ts",
+      "src/language-server/config/cache-busting-resolver.js",
     ],
     bundle: true,
     format: "cjs",

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

@@ -174,15 +174,18 @@ 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"} }`,
       });
       const config = await loadConfig({ configPath: dirPath });
       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"} }`,
       });

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

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 {};

src/language-server/config/loadConfig.ts

@@ -9,7 +9,7 @@ import {
 import { getServiceFromKey } from "./utils";
 import { URI } from "vscode-uri";
 import { Debug } from "../utilities";
-import { loadTs } from "./loadTsConfig";
+import { loadJs, loadTs } from "./loadTsConfig";
 
 // config settings
 const MODULE_NAME = "apollo";
@@ -49,7 +49,10 @@ export async function loadConfig({
     searchPlaces: supportedConfigFileNames,
     loaders: {
       ...defaultLoaders,
-      [".ts"]: loadTs,
+      ".ts": loadTs,
+      ".mjs": loadJs,
+      ".cjs": loadJs,
+      ".js": loadJs,
     },
   });
 

src/language-server/config/loadTsConfig.ts

@@ -1,15 +1,24 @@
-import { Loader, defaultLoaders } from "cosmiconfig";
+import { Loader } from "cosmiconfig";
 import { dirname } from "node:path";
-import { rm, writeFile } from "node:fs/promises";
 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
 
+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 load(filepath, content, ".vscode-extension-ignore.mjs", {
+    return await load(filepath, content, "module", {
       module: typescript.ModuleKind.ES2022,
     });
   } catch (error) {
@@ -18,7 +27,7 @@ export const loadTs: Loader = async function loadTs(filepath, content) {
       // [ERROR] ReferenceError: module is not defined in ES module scope
       error.message.includes("module is not defined")
     ) {
-      return await load(filepath, content, ".vscode-extension-ignore.cjs", {
+      return await load(filepath, content, "commonjs", {
         module: typescript.ModuleKind.CommonJS,
       });
     } else {
@@ -30,36 +39,39 @@ export const loadTs: Loader = async function loadTs(filepath, content) {
 async function load(
   filepath: string,
   content: string,
-  extension: string,
+  type: "module" | "commonjs",
   compilerOptions: Partial<import("typescript").CompilerOptions>,
 ) {
-  const compiledFilepath = `${filepath}${extension}`;
   let transpiledContent;
+
   try {
-    try {
-      const config = resolveTsConfig(dirname(filepath)) ?? {};
-      config.compilerOptions = {
-        ...config.compilerOptions,
+    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;
-      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 {
-    await rm(compiledFilepath, { force: true });
+      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
@@ -78,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;
+};

src/language-server/server.ts

@@ -192,9 +192,6 @@ documents.onDidClose(
 connection.onDidChangeWatchedFiles((params) => {
   const handledByProject = new Map<GraphQLProject, FileEvent[]>();
   for (const { uri, type } of params.changes) {
-    if (uri.match(/vscode-extension-ignore.[mc]?js$/)) {
-      continue;
-    }
     const fsPath = URI.parse(uri).fsPath;
     const fileName = basename(fsPath);
     if (