vscode-apollo 1.19.3 → 1.20.1

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

@@ -0,0 +1,128 @@
+import { ApolloConfig, ApolloConfigFormat, DefaultConfigBase } from "../";
+import URI from "vscode-uri";
+
+describe("ApolloConfig", () => {
+  describe("confifDirURI", () => {
+    it("properly parses dir paths for configDirURI", () => {
+      const uri = URI.parse("/test/dir/name");
+      const config = new ApolloConfig(
+        { service: { name: "hai", ...DefaultConfigBase } },
+        uri
+      );
+      // can be either /test/dir/name or \\test\\dir\\name depending on platform
+      // this difference is fine :)
+      expect(config.configDirURI?.fsPath).toMatch(
+        /\/test\/dir\/name|\\test\\dir\\name/
+      );
+    });
+    it("properly parses filepaths for configDirURI", () => {
+      const uri = URI.parse("/test/dir/name/apollo.config.js");
+      const config = new ApolloConfig(
+        { service: { name: "hai", ...DefaultConfigBase } },
+        uri
+      );
+      // can be either /test/dir/name or \\test\\dir\\name depending on platform
+      // this difference is fine :)
+      expect(config.configDirURI?.fsPath).toMatch(
+        /\/test\/dir\/name|\\test\\dir\\name/
+      );
+    });
+  });
+
+  describe("projects", () => {
+    it("creates a ClientConfig when client is present", () => {
+      const rawConfig: ApolloConfigFormat = {
+        client: { service: "my-service", ...DefaultConfigBase },
+      };
+      const config = new ApolloConfig(rawConfig);
+      const projects = config.projects;
+      expect(projects).toHaveLength(1);
+      expect(projects[0].isClient).toBeTruthy();
+    });
+    it("creates a ServiceConfig when service is present", () => {
+      const rawConfig: ApolloConfigFormat = {
+        service: { name: "my-service", ...DefaultConfigBase },
+      };
+      const config = new ApolloConfig(rawConfig);
+      const projects = config.projects;
+
+      expect(projects).toHaveLength(1);
+      expect(projects[0].isService).toBeTruthy();
+    });
+    it("creates multiple configs when both client and service are present", () => {
+      const rawConfig: ApolloConfigFormat = {
+        client: { service: "my-service", ...DefaultConfigBase },
+        service: { name: "my-service", ...DefaultConfigBase },
+      };
+      const config = new ApolloConfig(rawConfig);
+      const projects = config.projects;
+
+      expect(projects).toHaveLength(2);
+      expect(projects.find((c) => c.isClient)).toBeTruthy();
+      expect(projects.find((c) => c.isService)).toBeTruthy();
+    });
+  });
+
+  describe("variant", () => {
+    it("gets default variant when none is set", () => {
+      const config = new ApolloConfig({
+        client: { service: "hai", ...DefaultConfigBase },
+      });
+      expect(config.variant).toEqual("current");
+    });
+
+    it("gets variant from service specifier", () => {
+      const config = new ApolloConfig({
+        client: { service: "hai@master", ...DefaultConfigBase },
+      });
+      expect(config.variant).toEqual("master");
+    });
+
+    it("can set and override variants", () => {
+      const config = new ApolloConfig({
+        client: { service: "hai@master", ...DefaultConfigBase },
+      });
+      config.variant = "new";
+      expect(config.variant).toEqual("new");
+    });
+  });
+
+  describe("setDefaults", () => {
+    it("can override engine defaults", () => {
+      const config = new ApolloConfig({ client: { ...DefaultConfigBase } });
+      const overrides = {
+        engine: {
+          endpoint: "https://test.apollographql.com/api/graphql",
+        },
+      };
+      config.setDefaults(overrides);
+      expect(config.engine).toEqual(overrides.engine);
+    });
+
+    it("can override client defaults", () => {
+      const config = new ApolloConfig({ client: { ...DefaultConfigBase } });
+      const overrides = {
+        client: {
+          name: "my-client",
+          service: "my-service@master",
+          ...DefaultConfigBase,
+        },
+      };
+      config.setDefaults(overrides);
+      expect(config.client).toEqual(overrides.client);
+    });
+
+    it("can override service defaults", () => {
+      const config = new ApolloConfig({ client: { ...DefaultConfigBase } });
+      const overrides = {
+        service: {
+          name: "my-service",
+          url: "localhost:9090",
+          ...DefaultConfigBase,
+        },
+      };
+      config.setDefaults(overrides);
+      expect(config.service).toEqual(config.service);
+    });
+  });
+});

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

@@ -0,0 +1,508 @@
+import { loadConfig } from "../";
+import * as path from "path";
+import * as fs from "fs";
+import {
+  DefaultClientConfig,
+  DefaultServiceConfig,
+  DefaultEngineConfig,
+} from "../config";
+import { Debug } from "../../utilities";
+
+const makeNestedDir = (dir: string) => {
+  if (fs.existsSync(dir)) return;
+
+  try {
+    fs.mkdirSync(dir);
+  } catch (err) {
+    if (err.code == "ENOENT") {
+      makeNestedDir(path.dirname(dir)); //create parent dir
+      makeNestedDir(dir); //create dir
+    }
+  }
+};
+
+const deleteFolderRecursive = (path: string) => {
+  // don't delete files on windows -- will get a resource locked error
+  if (require("os").type().includes("Windows")) {
+    return;
+  }
+
+  if (fs.existsSync(path)) {
+    fs.readdirSync(path).forEach(function (file, index) {
+      var curPath = path + "/" + file;
+      if (fs.lstatSync(curPath).isDirectory()) {
+        // recurse
+        deleteFolderRecursive(curPath);
+      } else {
+        // delete file
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(path);
+  }
+};
+
+const writeFilesToDir = (dir: string, files: Record<string, string>) => {
+  Object.keys(files).forEach((key) => {
+    if (key.includes("/")) makeNestedDir(path.dirname(key));
+    fs.writeFileSync(`${dir}/${key}`, files[key]);
+  });
+};
+
+describe("loadConfig", () => {
+  let dir: string;
+  let dirPath: string;
+
+  // set up a temp dir
+  beforeEach(() => {
+    dir = fs.mkdtempSync("__tmp__");
+    dirPath = `${process.cwd()}/${dir}`;
+  });
+
+  // clean up our temp dir
+  afterEach(() => {
+    if (dir) {
+      deleteFolderRecursive(dir);
+    }
+  });
+
+  describe("finding files", () => {
+    it("loads with client defaults from different dir", async () => {
+      writeFilesToDir(dir, {
+        "my.config.js": `
+          module.exports = {
+            client: {
+              service: 'hello'
+            }
+          }
+        `,
+      });
+
+      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",
+          },
+        }
+      `);
+    });
+
+    it("loads with service defaults from different dir", async () => {
+      writeFilesToDir(dir, {
+        "my.config.js": `
+          module.exports = {
+            service: {
+              name: 'hello'
+            }
+          }
+        `,
+      });
+
+      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",
+          },
+        }
+      `);
+    });
+
+    it("[deprecated] loads config from package.json", async () => {
+      writeFilesToDir(dir, {
+        "package.json": `{"apollo":{"client": {"service": "hello"}} }`,
+      });
+
+      // silence the warning
+      const spy = jest.spyOn(console, "warn");
+      spy.mockImplementationOnce(() => {});
+
+      const config = await loadConfig({ configPath: dirPath });
+
+      spy.mockRestore();
+      expect(config?.client?.service).toEqual("hello");
+    });
+
+    it("loads config from a ts file", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.ts": `module.exports = {"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": `` });
+
+      const spy = jest.spyOn(console, "error");
+      // use this to keep the log quiet
+      spy.mockImplementation();
+
+      await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js",
+      });
+
+      expect(spy).toHaveBeenCalledWith(
+        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` });
+
+      const spy = jest.spyOn(console, "error");
+      // use this to keep the log quiet
+      spy.mockImplementation();
+
+      await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js",
+      });
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/config file failed to load/i)
+      );
+
+      spy.mockRestore();
+    });
+
+    it("issues a deprecation warning when loading config from package.json", async () => {
+      const spy = jest.spyOn(console, "warn");
+      spy.mockImplementation();
+
+      writeFilesToDir(dir, {
+        "package.json": `{"apollo":{"client": {"service": "hello"}} }`,
+      });
+
+      await loadConfig({
+        configPath: dirPath,
+        configFileName: "package.json",
+      });
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/The "apollo" package.json configuration/i)
+      );
+
+      spy.mockRestore();
+    });
+
+    it("throws if a config file was expected but not found", async () => {
+      const spy = jest.spyOn(console, "error");
+      spy.mockImplementation();
+
+      writeFilesToDir(dir, { "my.config.js": `module.exports = {}` });
+
+      await loadConfig({
+        configFileName: "my.TYPO.js",
+        requireConfig: true, // this is what we're testing
+      });
+
+      expect(spy).toHaveBeenCalledWith(
+        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 = {}`,
+      });
+
+      await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js",
+      });
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/unable to resolve/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' } }`,
+        ".env": `APOLLO_KEY=service:harambe:54378950jn`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js",
+      });
+
+      expect(config?.client?.service).toEqual("harambe");
+    });
+
+    it("finds .env.local in config path & parses for key", async () => {
+      writeFilesToDir(dir, {
+        "my.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");
+    });
+
+    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' } }`,
+        ".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 () => {
+      writeFilesToDir(dir, {
+        "dir/my.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("../");
+      expect(config?.client?.service).toEqual("harambe");
+    });
+  });
+
+  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' } }`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js",
+      });
+
+      expect(config?.isClient).toEqual(true);
+    });
+
+    it("infers service projects from config", async () => {
+      writeFilesToDir(dir, {
+        "my.config.js": `module.exports = { service: 'wow' }`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js",
+      });
+
+      expect(config?.isService).toEqual(true);
+    });
+  });
+
+  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: {  } }`,
+        ".env": `APOLLO_KEY=service:harambe:54378950jn`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js",
+        name: "hello",
+      });
+
+      expect(config?.client?.service).toEqual("hello");
+    });
+
+    it("uses env var to determine service name when no other options", async () => {
+      writeFilesToDir(dir, {
+        "my.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");
+    });
+  });
+
+  describe("default merging", () => {
+    it("merges service name and default config for client projects", async () => {
+      writeFilesToDir(dir, {
+        "my.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
+      );
+    });
+
+    it("merges engine config defaults", async () => {
+      writeFilesToDir(dir, {
+        "my.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
+      );
+    });
+  });
+});