vscode-apollo 1.20.0 → 2.0.1

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

@@ -1,19 +1,30 @@
-import { loadConfig } from "../";
+let { loadConfig } = require("../");
+let { ClientConfig, RoverConfig } = require("../config");
 import * as path from "path";
 import * as fs from "fs";
-import {
-  DefaultClientConfig,
-  DefaultServiceConfig,
-  DefaultEngineConfig,
-} from "../config";
-import { Debug } from "../../utilities";
+
+async function withFeatureFlags(flags: string, fn: () => void) {
+  const FF = process.env.APOLLO_FEATURE_FLAGS;
+  try {
+    process.env.APOLLO_FEATURE_FLAGS = flags;
+    jest.resetModules();
+    ({ loadConfig } = require("../"));
+    ({ ClientConfig, RoverConfig } = require("../config"));
+    return await fn();
+  } finally {
+    process.env.APOLLO_FEATURE_FLAGS = FF;
+    jest.resetModules();
+    ({ loadConfig } = require("../"));
+    ({ ClientConfig, RoverConfig } = require("../config"));
+  }
+}
 
 const makeNestedDir = (dir: string) => {
   if (fs.existsSync(dir)) return;
 
   try {
     fs.mkdirSync(dir);
-  } catch (err) {
+  } catch (err: any) {
     if (err.code == "ENOENT") {
       makeNestedDir(path.dirname(dir)); //create parent dir
       makeNestedDir(dir); //create dir
@@ -69,7 +80,7 @@ describe("loadConfig", () => {
   describe("finding files", () => {
     it("loads with client defaults from different dir", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `
+        "apollo.config.js": `
           module.exports = {
             client: {
               service: 'hello'
@@ -80,77 +91,50 @@ describe("loadConfig", () => {
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
       expect(config?.rawConfig).toMatchInlineSnapshot(`
-        Object {
-          "client": Object {
-            "addTypename": true,
-            "clientOnlyDirectives": Array [
-              "connection",
-              "type",
-            ],
-            "clientSchemaDirectives": Array [
-              "client",
-              "rest",
-            ],
-            "excludes": Array [
-              "**/node_modules",
-              "**/__tests__",
-            ],
-            "includes": Array [
-              "src/**/*.{ts,tsx,js,jsx,graphql,gql}",
-            ],
-            "service": "hello",
-            "statsWindow": Object {
-              "from": -86400,
-              "to": -0,
-            },
-            "tagName": "gql",
-          },
-          "engine": Object {
-            "endpoint": "https://graphql.api.apollographql.com/api/graphql",
-          },
-        }
-      `);
+Object {
+  "client": Object {
+    "excludes": Array [
+      "**/node_modules",
+      "**/__tests__",
+    ],
+    "includes": Array [
+      "src/**/*.{ts,tsx,js,jsx,graphql,gql}",
+    ],
+    "service": "hello",
+    "tagName": "gql",
+  },
+  "engine": Object {
+    "endpoint": "https://graphql.api.apollographql.com/api/graphql",
+  },
+}
+`);
     });
 
-    it("loads with service defaults from different dir", async () => {
-      writeFilesToDir(dir, {
-        "my.config.js": `
+    it("loads with rover defaults from different dir", () =>
+      withFeatureFlags("rover", async () => {
+        writeFilesToDir(dir, {
+          "apollo.config.js": `
           module.exports = {
-            service: {
-              name: 'hello'
+            rover: {
             }
           }
         `,
-      });
-
-      const config = await loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js",
-      });
-      expect(config?.rawConfig).toMatchInlineSnapshot(`
-        Object {
-          "engine": Object {
-            "endpoint": "https://graphql.api.apollographql.com/api/graphql",
-          },
-          "service": Object {
-            "endpoint": Object {
-              "url": "http://localhost:4000/graphql",
-            },
-            "excludes": Array [
-              "**/node_modules",
-              "**/__tests__",
-            ],
-            "includes": Array [
-              "src/**/*.{ts,tsx,js,jsx,graphql,gql}",
-            ],
-            "name": "hello",
-          },
-        }
-      `);
-    });
+        });
+
+        const config = await loadConfig({
+          configPath: dirPath,
+        });
+        expect(config?.rawConfig).toMatchInlineSnapshot(`
+Object {
+  "engine": Object {
+    "endpoint": "https://graphql.api.apollographql.com/api/graphql",
+  },
+  "rover": Object {},
+}
+`);
+      }));
 
     it("[deprecated] loads config from package.json", async () => {
       writeFilesToDir(dir, {
@@ -169,17 +153,40 @@ describe("loadConfig", () => {
 
     it("loads config from a ts file", async () => {
       writeFilesToDir(dir, {
-        "apollo.config.ts": `module.exports = {"client": {"service": "hello"}`,
+        "apollo.config.ts": `export default {"client": {"service": "hello"} }`,
       });
       const config = await loadConfig({ configPath: dirPath });
+      expect(config?.client?.service).toEqual("hello");
+    });
 
+    it("loads config from a ts file with CommonJs", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.ts": `module.exports = {"client": {"service": "hello"} }`,
+      });
+      const config = await loadConfig({ configPath: dirPath });
+      expect(config?.client?.service).toEqual("hello");
+    });
+
+    it("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 () => {
+      writeFilesToDir(dir, {
+        "apollo.config.mjs": `export default {"client": {"service": "hello"} }`,
+      });
+      const config = await loadConfig({ configPath: dirPath });
       expect(config?.client?.service).toEqual("hello");
     });
   });
 
   describe("errors", () => {
     it("throws when config file is empty", async () => {
-      writeFilesToDir(dir, { "my.config.js": `` });
+      writeFilesToDir(dir, { "apollo.config.js": `` });
 
       const spy = jest.spyOn(console, "error");
       // use this to keep the log quiet
@@ -187,33 +194,23 @@ describe("loadConfig", () => {
 
       await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
       expect(spy).toHaveBeenCalledWith(
-        expect.stringMatching(/config file failed to load/i)
+        expect.stringMatching(/config file failed to load/i),
       );
 
       spy.mockRestore();
     });
 
     it("throws when explorer.search fails", async () => {
-      writeFilesToDir(dir, { "my.config.js": `* 98375^%*&^ its lit` });
+      writeFilesToDir(dir, { "apollo.config.js": `* 98375^%*&^ its lit` });
 
-      const spy = jest.spyOn(console, "error");
-      // use this to keep the log quiet
-      spy.mockImplementation();
-
-      await loadConfig({
+      const error = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
-      });
+      }).catch((e: any) => e);
 
-      expect(spy).toHaveBeenCalledWith(
-        expect.stringMatching(/config file failed to load/i)
-      );
-
-      spy.mockRestore();
+      expect(error.message).toMatch(/config file failed to load/i);
     });
 
     it("issues a deprecation warning when loading config from package.json", async () => {
@@ -226,11 +223,10 @@ describe("loadConfig", () => {
 
       await loadConfig({
         configPath: dirPath,
-        configFileName: "package.json",
       });
 
       expect(spy).toHaveBeenCalledWith(
-        expect.stringMatching(/The "apollo" package.json configuration/i)
+        expect.stringMatching(/The "apollo" package.json configuration/i),
       );
 
       spy.mockRestore();
@@ -240,49 +236,43 @@ describe("loadConfig", () => {
       const spy = jest.spyOn(console, "error");
       spy.mockImplementation();
 
-      writeFilesToDir(dir, { "my.config.js": `module.exports = {}` });
+      writeFilesToDir(dir, { "foo.config.js": `module.exports = {}` });
 
       await loadConfig({
-        configFileName: "my.TYPO.js",
+        configPath: dirPath,
         requireConfig: true, // this is what we're testing
       });
 
       expect(spy).toHaveBeenCalledWith(
-        expect.stringMatching(/no apollo config/i)
+        expect.stringMatching(/no apollo config/i),
       );
       spy.mockRestore();
     });
 
     it("throws if project type cant be resolved", async () => {
-      const spy = jest.spyOn(console, "error");
-      spy.mockImplementation();
-
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = {}`,
+        "apollo.config.js": `module.exports = {}`,
       });
 
-      await loadConfig({
+      const error = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
-      });
+      }).catch((e: any) => e);
 
-      expect(spy).toHaveBeenCalledWith(
-        expect.stringMatching(/unable to resolve/i)
+      expect(error.message).toMatch(
+        /Config needs to contain a 'client' field./i,
       );
-      spy.mockRestore();
     });
   });
 
   describe("env loading", () => {
     it("finds .env in config path & parses for key", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { name: 'hello' } }`,
+        "apollo.config.js": `module.exports = { client: { name: 'hello' } }`,
         ".env": `APOLLO_KEY=service:harambe:54378950jn`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
       expect(config?.client?.service).toEqual("harambe");
@@ -290,13 +280,12 @@ describe("loadConfig", () => {
 
     it("finds .env.local in config path & parses for key", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { name: 'hello' } }`,
+        "apollo.config.js": `module.exports = { client: { name: 'hello' } }`,
         ".env.local": `APOLLO_KEY=service:harambe:54378950jn`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
       expect(config?.client?.service).toEqual("harambe");
@@ -304,66 +293,27 @@ describe("loadConfig", () => {
 
     it("finds .env and .env.local in config path & parses for key, preferring .env.local", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { name: 'hello' } }`,
+        "apollo.config.js": `module.exports = { client: { name: 'hello' } }`,
         ".env": `APOLLO_KEY=service:hamato:54378950jn`,
         ".env.local": `APOLLO_KEY=service:yoshi:65489061ko`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
       expect(config?.client?.service).toEqual("yoshi");
     });
 
-    it("Allows setting ENGINE_API_KEY with a deprecation warning", async () => {
-      writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { name: 'hello' } }`,
-        ".env.local": `ENGINE_API_KEY=service:yoshi:65489061ko`,
-      });
-
-      const spy = jest.spyOn(Debug, "warning");
-
-      const config = await loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js",
-      });
-
-      expect(config?.client?.service).toEqual("yoshi");
-      expect(spy).toHaveBeenCalledWith(
-        expect.stringMatching(/Deprecation warning/i)
-      );
-    });
-
-    it("Uses new key when .env defined both legacy and new key", async () => {
-      writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { name: 'hello' } }`,
-        ".env.local": `ENGINE_API_KEY=service:yoshi:65489061ko\nAPOLLO_KEY=service:yoshi:65489061ko`,
-      });
-      const spy = jest.spyOn(Debug, "warning");
-
-      const config = await loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js",
-      });
-
-      expect(config?.engine.apiKey).toEqual("service:yoshi:65489061ko");
-      expect(spy).toHaveBeenCalledWith(
-        expect.stringMatching(/Both ENGINE_API_KEY and APOLLO_KEY were found/i)
-      );
-    });
-
     // this doesn't work right now :)
-    xit("finds .env in cwd & parses for key", async () => {
+    it.skip("finds .env in cwd & parses for key", async () => {
       writeFilesToDir(dir, {
-        "dir/my.config.js": `module.exports = { client: { name: 'hello' } }`,
+        "dir/apollo.config.js": `module.exports = { client: { name: 'hello' } }`,
         ".env": `APOLLO_KEY=service:harambe:54378950jn`,
       });
       process.chdir(dir);
       const config = await loadConfig({
         configPath: "dir/",
-        configFileName: "my.config.js",
       });
 
       process.chdir("../");
@@ -372,73 +322,41 @@ describe("loadConfig", () => {
   });
 
   describe("project type", () => {
-    it("uses passed in type when config doesnt have client/service", async () => {
-      writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { engine: { endpoint: 'http://a.a' } }`,
-      });
-
-      const config = await loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js",
-        type: "client",
-      });
-
-      expect(config?.isClient).toEqual(true);
-    });
-
     it("infers client projects from config", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { service: 'hello' } }`,
+        "apollo.config.js": `module.exports = { client: { service: 'hello' } }`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
-      expect(config?.isClient).toEqual(true);
+      expect(config).toBeInstanceOf(ClientConfig);
     });
 
-    it("infers service projects from config", async () => {
-      writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { service: 'wow' }`,
-      });
+    it("infers rover projects from config", () =>
+      withFeatureFlags("rover", async () => {
+        writeFilesToDir(dir, {
+          "apollo.config.js": `module.exports = { rover: {} }`,
+        });
 
-      const config = await loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js",
-      });
+        const config = await loadConfig({
+          configPath: dirPath,
+        });
 
-      expect(config?.isService).toEqual(true);
-    });
+        expect(config).toBeInstanceOf(RoverConfig);
+      }));
   });
 
   describe("service name", () => {
     it("lets config service name take precedence for client project", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { service: 'hello' } }`,
-        ".env": `APOLLO_KEY=service:harambe:54378950jn`,
-      });
-
-      const config = await loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js",
-        name: "not-it",
-      });
-
-      expect(config?.client?.service).toEqual("hello");
-    });
-
-    it("lets name passed in take precedence over env var", async () => {
-      writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: {  } }`,
+        "apollo.config.js": `module.exports = { client: { service: 'hello' } }`,
         ".env": `APOLLO_KEY=service:harambe:54378950jn`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
-        name: "hello",
       });
 
       expect(config?.client?.service).toEqual("hello");
@@ -446,13 +364,12 @@ describe("loadConfig", () => {
 
     it("uses env var to determine service name when no other options", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: {  } }`,
+        "apollo.config.js": `module.exports = { client: {  } }`,
         ".env": `APOLLO_KEY=service:harambe:54378950jn`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
       expect(config?.client?.service).toEqual("harambe");
@@ -462,46 +379,29 @@ describe("loadConfig", () => {
   describe("default merging", () => {
     it("merges service name and default config for client projects", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { service: 'hello' } }`,
+        "apollo.config.js": `module.exports = { client: { service: 'hello' } }`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
-      expect(config?.rawConfig?.client?.includes).toEqual(
-        DefaultClientConfig.includes
-      );
-    });
-
-    it("merges service name and default config for service projects", async () => {
-      writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { service: { name: 'wow' } }`,
-      });
-
-      const config = await loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js",
-      });
-
-      expect(config?.rawConfig?.service?.includes).toEqual(
-        DefaultServiceConfig.includes
-      );
+      expect((config?.rawConfig as any).client.includes).toEqual([
+        "src/**/*.{ts,tsx,js,jsx,graphql,gql}",
+      ]);
     });
 
     it("merges engine config defaults", async () => {
       writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { client: { service: 'wow' } }`,
+        "apollo.config.js": `module.exports = { client: { service: 'wow' } }`,
       });
 
       const config = await loadConfig({
         configPath: dirPath,
-        configFileName: "my.config.js",
       });
 
       expect(config?.rawConfig?.engine?.endpoint).toEqual(
-        DefaultEngineConfig.endpoint
+        "https://graphql.api.apollographql.com/api/graphql",
       );
     });
   });

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

@@ -1,13 +1,11 @@
 import {
-  ApolloConfig,
-  ApolloConfigFormat,
   getServiceFromKey,
   getGraphIdFromConfig,
   isClientConfig,
   isLocalServiceConfig,
-  isServiceConfig,
   parseServiceSpecifier,
-  DefaultConfigBase,
+  parseApolloConfig,
+  configSchema,
 } from "../";
 
 describe("getServiceFromKey", () => {
@@ -34,36 +32,38 @@ describe("getServiceFromKey", () => {
 describe("getServiceName", () => {
   describe("client config", () => {
     it("finds service name when client.service is a string", () => {
-      const rawConfig: ApolloConfigFormat = {
-        client: { service: "my-service", ...DefaultConfigBase },
-      };
+      const rawConfig = configSchema.parse({
+        client: { service: "my-service" },
+      });
       expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
 
-      const rawConfigWithTag: ApolloConfigFormat = {
-        client: { service: "my-service@master", ...DefaultConfigBase },
-      };
+      const rawConfigWithTag = configSchema.parse({
+        client: { service: "my-service@master" },
+      });
       expect(getGraphIdFromConfig(rawConfigWithTag)).toEqual("my-service");
     });
 
     it("finds service name when client.service is an object", () => {
-      const rawConfig: ApolloConfigFormat = {
+      const rawConfig = configSchema.parse({
         client: {
           service: { name: "my-service", localSchemaFile: "./someFile" },
-          ...DefaultConfigBase,
         },
-      };
+      });
       expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
     });
   });
   describe("service config", () => {
     it("finds service name from raw service config", () => {
-      const rawConfig: ApolloConfigFormat = {
-        service: {
-          name: "my-service",
-          localSchemaFile: "./someFile",
-          ...DefaultConfigBase,
+      const rawConfig = configSchema.parse({
+        client: {
+          service: {
+            name: "my-service",
+            localSchemaFile: "./someFile",
+          },
+          includes: [],
+          excludes: [],
         },
-      };
+      });
       expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
     });
   });
@@ -71,10 +71,10 @@ describe("getServiceName", () => {
 
 describe("isClientConfig", () => {
   it("identifies client config properly", () => {
-    const config = new ApolloConfig({
-      client: { service: "hello", ...DefaultConfigBase },
+    const config = parseApolloConfig({
+      client: { service: "hello" },
     });
-    expect(isClientConfig(config)).toBeTruthy();
+    expect(isClientConfig(config!)).toBeTruthy();
   });
 });
 
@@ -85,13 +85,6 @@ describe("isLocalServiceConfig", () => {
   });
 });
 
-describe("isServiceConfig", () => {
-  it("identifies service config properly", () => {
-    const config = new ApolloConfig({ service: { ...DefaultConfigBase } });
-    expect(isServiceConfig(config)).toBeTruthy();
-  });
-});
-
 describe("parseServiceSpecifier", () => {
   it("parses service identifier for service id and tag properly", () => {
     const [id, tag] = parseServiceSpecifier("my-service@master");