vscode-apollo 1.19.3 → 2.0.0

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

@@ -0,0 +1,54 @@
+import { ClientConfig, parseApolloConfig } 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 = parseApolloConfig({ client: { service: "hai" } }, 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 = parseApolloConfig(
+        {
+          client: { service: "hai" },
+        },
+        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("variant", () => {
+    it("gets default variant when none is set", () => {
+      const config = parseApolloConfig({
+        client: { service: "hai" },
+      });
+      expect(config?.variant).toEqual("current");
+    });
+
+    it("gets variant from service specifier", () => {
+      const config = parseApolloConfig({
+        client: { service: "hai@master" },
+      });
+      expect(config?.variant).toEqual("master");
+    });
+
+    it("can set and override variants", () => {
+      const config = parseApolloConfig({
+        client: { service: "hai@master" },
+      });
+      config!.variant = "new";
+      expect(config?.variant).toEqual("new");
+    });
+  });
+});

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

@@ -0,0 +1,384 @@
+let { loadConfig } = require("../");
+let { ClientConfig, RoverConfig } = require("../config");
+import * as path from "path";
+import * as fs from "fs";
+
+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: any) {
+    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, {
+        "apollo.config.js": `
+          module.exports = {
+            client: {
+              service: 'hello'
+            }
+          }
+        `,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+      expect(config?.rawConfig).toMatchInlineSnapshot(`
+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 rover defaults from different dir", () =>
+      withFeatureFlags("rover", async () => {
+        writeFilesToDir(dir, {
+          "apollo.config.js": `
+          module.exports = {
+            rover: {
+            }
+          }
+        `,
+        });
+
+        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, {
+        "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": `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, { "apollo.config.js": `` });
+
+      const spy = jest.spyOn(console, "error");
+      // use this to keep the log quiet
+      spy.mockImplementation();
+
+      await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/config file failed to load/i),
+      );
+
+      spy.mockRestore();
+    });
+
+    it("throws when explorer.search fails", async () => {
+      writeFilesToDir(dir, { "apollo.config.js": `* 98375^%*&^ its lit` });
+
+      const error = await loadConfig({
+        configPath: dirPath,
+      }).catch((e: any) => e);
+
+      expect(error.message).toMatch(/config file failed to load/i);
+    });
+
+    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,
+      });
+
+      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, { "foo.config.js": `module.exports = {}` });
+
+      await loadConfig({
+        configPath: dirPath,
+        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 () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = {}`,
+      });
+
+      const error = await loadConfig({
+        configPath: dirPath,
+      }).catch((e: any) => e);
+
+      expect(error.message).toMatch(
+        /Config needs to contain a 'client' field./i,
+      );
+    });
+  });
+
+  describe("env loading", () => {
+    it("finds .env in config path & parses for key", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = { client: { name: 'hello' } }`,
+        ".env": `APOLLO_KEY=service:harambe:54378950jn`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect(config?.client?.service).toEqual("harambe");
+    });
+
+    it("finds .env.local in config path & parses for key", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = { client: { name: 'hello' } }`,
+        ".env.local": `APOLLO_KEY=service:harambe:54378950jn`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect(config?.client?.service).toEqual("harambe");
+    });
+
+    it("finds .env and .env.local in config path & parses for key, preferring .env.local", async () => {
+      writeFilesToDir(dir, {
+        "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,
+      });
+
+      expect(config?.client?.service).toEqual("yoshi");
+    });
+
+    // this doesn't work right now :)
+    it.skip("finds .env in cwd & parses for key", async () => {
+      writeFilesToDir(dir, {
+        "dir/apollo.config.js": `module.exports = { client: { name: 'hello' } }`,
+        ".env": `APOLLO_KEY=service:harambe:54378950jn`,
+      });
+      process.chdir(dir);
+      const config = await loadConfig({
+        configPath: "dir/",
+      });
+
+      process.chdir("../");
+      expect(config?.client?.service).toEqual("harambe");
+    });
+  });
+
+  describe("project type", () => {
+    it("infers client projects from config", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = { client: { service: 'hello' } }`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect(config).toBeInstanceOf(ClientConfig);
+    });
+
+    it("infers rover projects from config", () =>
+      withFeatureFlags("rover", async () => {
+        writeFilesToDir(dir, {
+          "apollo.config.js": `module.exports = { rover: {} }`,
+        });
+
+        const config = await loadConfig({
+          configPath: dirPath,
+        });
+
+        expect(config).toBeInstanceOf(RoverConfig);
+      }));
+  });
+
+  describe("service name", () => {
+    it("lets config service name take precedence for client project", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = { client: { service: 'hello' } }`,
+        ".env": `APOLLO_KEY=service:harambe:54378950jn`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect(config?.client?.service).toEqual("hello");
+    });
+
+    it("uses env var to determine service name when no other options", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = { client: {  } }`,
+        ".env": `APOLLO_KEY=service:harambe:54378950jn`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect(config?.client?.service).toEqual("harambe");
+    });
+  });
+
+  describe("default merging", () => {
+    it("merges service name and default config for client projects", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = { client: { service: 'hello' } }`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect((config?.rawConfig as any).client.includes).toEqual([
+        "src/**/*.{ts,tsx,js,jsx,graphql,gql}",
+      ]);
+    });
+
+    it("merges engine config defaults", async () => {
+      writeFilesToDir(dir, {
+        "apollo.config.js": `module.exports = { client: { service: 'wow' } }`,
+      });
+
+      const config = await loadConfig({
+        configPath: dirPath,
+      });
+
+      expect(config?.rawConfig?.engine?.endpoint).toEqual(
+        "https://graphql.api.apollographql.com/api/graphql",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,99 @@
+import {
+  getServiceFromKey,
+  getGraphIdFromConfig,
+  isClientConfig,
+  isLocalServiceConfig,
+  parseServiceSpecifier,
+  parseApolloConfig,
+  configSchema,
+} from "../";
+
+describe("getServiceFromKey", () => {
+  it("returns undefined with no provided key", () => {
+    expect(getServiceFromKey()).toBeUndefined();
+  });
+
+  it("returns service name from service api key", () => {
+    const key = "service:bob-123:489fhseo4";
+    expect(getServiceFromKey(key)).toEqual("bob-123");
+  });
+
+  it("returns nothing if key is not a service key", () => {
+    const key = "not-a-service:bob-123:489fhseo4";
+    expect(getServiceFromKey(key)).toBeUndefined();
+  });
+
+  it("returns nothing if key is malformed", () => {
+    const key = "service/bob-123:489fhseo4";
+    expect(getServiceFromKey(key)).toBeUndefined();
+  });
+});
+
+describe("getServiceName", () => {
+  describe("client config", () => {
+    it("finds service name when client.service is a string", () => {
+      const rawConfig = configSchema.parse({
+        client: { service: "my-service" },
+      });
+      expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
+
+      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 = configSchema.parse({
+        client: {
+          service: { name: "my-service", localSchemaFile: "./someFile" },
+        },
+      });
+      expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
+    });
+  });
+  describe("service config", () => {
+    it("finds service name from raw service config", () => {
+      const rawConfig = configSchema.parse({
+        client: {
+          service: {
+            name: "my-service",
+            localSchemaFile: "./someFile",
+          },
+          includes: [],
+          excludes: [],
+        },
+      });
+      expect(getGraphIdFromConfig(rawConfig)).toEqual("my-service");
+    });
+  });
+});
+
+describe("isClientConfig", () => {
+  it("identifies client config properly", () => {
+    const config = parseApolloConfig({
+      client: { service: "hello" },
+    });
+    expect(isClientConfig(config!)).toBeTruthy();
+  });
+});
+
+describe("isLocalServiceConfig", () => {
+  it("properly identifies a client config that uses localSchemaFiles", () => {
+    const clientServiceConfig = { name: "my-service", localSchemaFile: "okay" };
+    expect(isLocalServiceConfig(clientServiceConfig)).toBeTruthy();
+  });
+});
+
+describe("parseServiceSpecifier", () => {
+  it("parses service identifier for service id and tag properly", () => {
+    const [id, tag] = parseServiceSpecifier("my-service@master");
+    expect(id).toEqual("my-service");
+    expect(tag).toEqual("master");
+
+    const [idFromSimpleName, tagFromSimpleName] =
+      parseServiceSpecifier("my-service");
+    expect(idFromSimpleName).toEqual("my-service");
+    expect(tagFromSimpleName).toBeUndefined();
+  });
+});