vscode-apollo 2.2.0 → 2.3.0

package/schemas/apollo.config.schema.json

@@ -0,0 +1,184 @@
+{
+  "allOf": [
+    {
+      "$ref": "#/definitions/baseConfig"
+    },
+    {
+      "type": "object",
+      "properties": {
+        "client": {
+          "$ref": "#/definitions/clientConfig"
+        }
+      },
+      "required": [
+        "client"
+      ]
+    }
+  ],
+  "definitions": {
+    "clientConfig": {
+      "type": "object",
+      "properties": {
+        "service": {
+          "anyOf": [
+            {
+              "type": "string",
+              "description": "The name of the Apollo Studio graph to use. Alternatively pass in an object to configure a local schema."
+            },
+            {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "The name your project will be referred to by the Apollo GraphQL extension."
+                },
+                "url": {
+                  "type": "string",
+                  "description": "URL of a GraphQL to use for the GraphQL Schema for this project. Needs introspection enabled."
+                },
+                "headers": {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  },
+                  "default": {},
+                  "description": "Additional headers to send to the server."
+                },
+                "skipSSLValidation": {
+                  "type": "boolean",
+                  "default": false,
+                  "description": "Skip SSL validation. May be required for self-signed certificates."
+                }
+              },
+              "required": [
+                "url"
+              ],
+              "additionalProperties": false,
+              "description": "Configuration for using a local schema from a URL."
+            },
+            {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "The name your project will be referred to by the Apollo GraphQL extension."
+                },
+                "localSchemaFile": {
+                  "anyOf": [
+                    {
+                      "type": "string",
+                      "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."
+                    },
+                    {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      },
+                      "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."
+                    }
+                  ],
+                  "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."
+                }
+              },
+              "required": [
+                "localSchemaFile"
+              ],
+              "additionalProperties": false,
+              "description": "Configuration for using a local schema from a file."
+            }
+          ],
+          "description": "A string to refer to a graph in Apollo Studio, or an object for a local schema."
+        },
+        "validationRules": {
+          "anyOf": [
+            {
+              "type": "array",
+              "description": "Additional validation rules to check for. To use this feature, please use a configuration file format that allows passing JavaScript objects."
+            }
+          ],
+          "description": "Additional validation rules to check for. To use this feature, please use a configuration file format that allows passing JavaScript objects."
+        },
+        "includes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "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."
+        },
+        "excludes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [
+            "**/node_modules",
+            "**/__tests__"
+          ],
+          "description": "Files to exclude from this project. The Apollo GraphQL extension will not provide IntelliSense-like features in these files."
+        },
+        "tagName": {
+          "type": "string",
+          "default": "gql",
+          "description": "The name of the template literal tag or function used in JavaScript files to declare GraphQL Documents."
+        },
+        "clientOnlyDirectives": {
+          "description": "This option is no longer supported, please remove it from your configuration file."
+        },
+        "clientSchemaDirectives": {
+          "description": "This option is no longer supported, please remove it from your configuration file."
+        },
+        "statsWindow": {
+          "description": "This option is no longer supported, please remove it from your configuration file."
+        },
+        "name": {
+          "description": "This option is no longer supported, please remove it from your configuration file."
+        },
+        "referenceId": {
+          "description": "This option is no longer supported, please remove it from your configuration file."
+        },
+        "version": {
+          "description": "This option is no longer supported, please remove it from your configuration file."
+        }
+      },
+      "required": [
+        "service"
+      ],
+      "additionalProperties": false,
+      "description": "Configuration for a Client project."
+    },
+    "engineConfig": {
+      "type": "object",
+      "properties": {
+        "endpoint": {
+          "type": "string",
+          "default": "https://graphql.api.apollographql.com/api/graphql",
+          "description": "The URL of the Apollo Studio API."
+        },
+        "apiKey": {
+          "type": "string",
+          "description": "The API key to use for Apollo Studio. If possible, use a `.env` file or `.env.local` file instead to store secrets like this."
+        }
+      },
+      "additionalProperties": false,
+      "description": "Network configuration for Apollo Studio API."
+    },
+    "baseConfig": {
+      "type": "object",
+      "properties": {
+        "engine": {
+          "$ref": "#/definitions/engineConfig",
+          "default": {},
+          "description": "Network configuration for Apollo Studio API."
+        },
+        "client": {
+          "description": "Configuration for a Client project."
+        },
+        "service": {
+          "description": "This option is no longer supported, please remove it from your configuration file."
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/src/__e2e__/mockServer.js

@@ -1,19 +1,43 @@
 // @ts-check
-const http = require("http");
 const {
   parseRequestParams,
   createHandler,
 } = require("graphql-http/lib/use/http");
 const { buildSchema } = require("graphql");
 const { Trie } = require("@wry/trie");
+const { readFileSync } = require("fs");
+const { join } = require("path");
 
-function runMockServer(
+async function runMockServer(
   /** @type {number}  */ port,
-  onStart = (/** @type {number}  */ port) => {},
+  useSelfSignedCert = false,
+  onStart = (/** @type {string}  */ baseUri) => {},
 ) {
   const mocks = new Trie(false);
 
-  const server = http.createServer(async (req, res) => {
+  /**
+   *
+   * @param {import('node:http').RequestListener} listener
+   * @returns
+   */
+  function createServer(listener) {
+    if (useSelfSignedCert) {
+      return require("node:https").createServer(
+        {
+          key: readFileSync(
+            join(__dirname, "../../sampleWorkspace/httpSchema/self-signed.key"),
+          ),
+          cert: readFileSync(
+            join(__dirname, "../../sampleWorkspace/httpSchema/self-signed.crt"),
+          ),
+        },
+        listener,
+      );
+    }
+    return require("node:http").createServer(listener);
+  }
+
+  const server = createServer(async (req, res) => {
     if (req.url === "/apollo") {
       if (req.method === "POST") {
         await handleApolloPost(req, res);
@@ -33,8 +57,9 @@ function runMockServer(
 
   console.log("Starting server...");
   server.listen(port);
-  onStart(port);
-  console.log(`Server ready at: http://localhost:${port}`);
+  const baseUri = `${useSelfSignedCert ? "https" : "http"}://localhost:${port}`;
+  await onStart(baseUri);
+  console.log(`Server ready at: ${baseUri}`);
   return {
     [Symbol.dispose]() {
       console.log("Closing server...");
@@ -45,8 +70,8 @@ function runMockServer(
 
   /**
    * Mock GraphQL Endpoint Handler
-   * @param {http.IncomingMessage} req
-   * @param {http.ServerResponse} res
+   * @param {import('node:http').IncomingMessage} req
+   * @param {import('node:http').ServerResponse} res
    */
   async function handleApolloPost(req, res) {
     const { operationName, variables } =
@@ -79,8 +104,8 @@ function runMockServer(
 
   /**
    * Handler to accept new GraphQL Mocks
-   * @param {http.IncomingMessage} req
-   * @param {http.ServerResponse} res
+   * @param {import('node:http').IncomingMessage} req
+   * @param {import('node:http').ServerResponse} res
    */
   async function handleApolloPut(req, res) {
     const body = await new Promise((resolve) => {
@@ -111,7 +136,8 @@ const schemaHandler = createHandler({
 });
 
 if (require.main === module) {
-  runMockServer(7096, require("./mocks.js").loadDefaultMocks);
+  runMockServer(7096, false, require("./mocks.js").loadDefaultMocks);
+  runMockServer(7097, true, require("./mocks.js").loadDefaultMocks);
 }
 
 module.exports.runMockServer = runMockServer;

package/src/__e2e__/mocks.js

@@ -1,26 +1,30 @@
 // @ts-check
-
-async function loadDefaultMocks(/** @type {number} */ port) {
-  await sendMock(port, FrontendUrlRoot);
-  await sendMock(port, SchemaTagsAndFieldStats);
-  await sendMock(port, GetSchemaByTag);
+async function loadDefaultMocks(/** @type {string} */ baseUri) {
+  await sendMock(baseUri, FrontendUrlRoot);
+  await sendMock(baseUri, SchemaTagsAndFieldStats);
+  await sendMock(baseUri, GetSchemaByTag);
 }
 
 function sendMock(
-  /** @type {number} */ port,
+  /** @type {string} */ baseUri,
   /** @type { { operationName: string, variables: Record<string, string>, response: unknown }} */ {
     operationName,
     variables,
     response,
   },
 ) {
-  return fetch(`http://localhost:${port}/apollo`, {
+  return require("undici").fetch(`${baseUri}/apollo`, {
     method: "PUT",
     body: JSON.stringify({
       operationName,
       variables,
       response,
     }),
+    dispatcher: new (require("undici").Agent)({
+      connect: {
+        rejectUnauthorized: false,
+      },
+    }),
   });
 }
 

package/src/__e2e__/runTests.js

@@ -5,7 +5,7 @@ const { runMockServer } = require("./mockServer.js");
 const { loadDefaultMocks } = require("./mocks.js");
 
 async function main() {
-  let disposable;
+  const disposables = /**{@type Disposable[]}*/ [];
   try {
     // The folder containing the Extension Manifest package.json
     // Passed to `--extensionDevelopmentPath`
@@ -18,8 +18,12 @@ async function main() {
     const TEST_PORT = 7096;
     process.env.APOLLO_ENGINE_ENDPOINT = "http://localhost:7096/apollo";
     process.env.MOCK_SERVER_PORT = String(TEST_PORT);
-    disposable = runMockServer(TEST_PORT);
-    await loadDefaultMocks(TEST_PORT);
+    disposables.push(
+      ...(await Promise.all([
+        runMockServer(TEST_PORT, false, loadDefaultMocks),
+        runMockServer(TEST_PORT + 1, true, loadDefaultMocks),
+      ])),
+    );
     // Download VS Code, unzip it and run the integration test
     const exitCode = await runTests({
       extensionDevelopmentPath,
@@ -35,9 +39,7 @@ async function main() {
     console.error("Failed to run tests");
     process.exit(1);
   } finally {
-    if (disposable) {
-      disposable[Symbol.dispose]();
-    }
+    disposables.forEach((d) => d[Symbol.dispose]());
   }
 }
 

package/src/build.js

@@ -1,11 +1,19 @@
 const esbuild = require("esbuild");
+const { zodToJsonSchema } = require("zod-to-json-schema");
+const { writeFileSync } = require("fs");
+const importFresh = require("import-fresh");
 
 const production = process.argv.includes("--production");
 const watch = process.argv.includes("--watch");
 
 async function main() {
   const ctx = await esbuild.context({
-    entryPoints: ["src/extension.ts", "src/language-server/server.ts"],
+    entryPoints: [
+      "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",
     minify: production,
@@ -19,6 +27,8 @@ async function main() {
     plugins: [
       /* add to the end of plugins array */
       esbuildProblemMatcherPlugin,
+      buildJsonSchemaPlugin,
+      resolvePlugin,
     ],
   });
   if (watch) {
@@ -51,6 +61,48 @@ const esbuildProblemMatcherPlugin = {
   },
 };
 
+const buildJsonSchemaPlugin = {
+  name: "build-json-schema",
+  setup(build) {
+    build.onEnd(() => {
+      const {
+        configSchema,
+        clientConfig,
+        // roverConfig,
+        engineConfig,
+        baseConfig,
+        // @ts-ignore
+      } = importFresh("../lib/language-server/config/config.js");
+
+      const jsonSchema = zodToJsonSchema(configSchema, {
+        errorMessages: true,
+        definitions: {
+          clientConfig,
+          //roverConfig,
+          engineConfig,
+          baseConfig,
+        },
+      });
+      writeFileSync(
+        "./schemas/apollo.config.schema.json",
+        JSON.stringify(jsonSchema, null, 2),
+      );
+    });
+  },
+};
+
+const resolvePlugin = {
+  name: "resolve",
+  setup(build) {
+    build.onResolve(
+      { filter: /^jsonc-parser$/ },
+      async ({ path, ...options }) => {
+        return build.resolve("jsonc-parser/lib/esm/main.js", options);
+      },
+    );
+  },
+};
+
 main().catch((e) => {
   console.error(e);
   process.exit(1);

package/src/language-server/__e2e__/studioGraph.e2e.ts

@@ -37,9 +37,10 @@ Get detailed profile information about the current user (including the current u
 });
 
 test("wrong token", async () => {
+  const baseUri = `http://localhost:${mockPort}`;
   try {
-    await mocks.sendMock(mockPort, mocks.GetSchemaByTag_WRONG_TOKEN);
-    await mocks.sendMock(mockPort, mocks.SchemaTagsAndFieldStats_WRONG_TOKEN);
+    await mocks.sendMock(baseUri, mocks.GetSchemaByTag_WRONG_TOKEN);
+    await mocks.sendMock(baseUri, mocks.SchemaTagsAndFieldStats_WRONG_TOKEN);
 
     const ext = getExtension();
     ext.outputChannel.clear();
@@ -59,7 +60,7 @@ Invalid credentials provided
     at new ApolloError`.trim(),
     );
   } finally {
-    await mocks.loadDefaultMocks(mockPort);
+    await mocks.loadDefaultMocks(baseUri);
     await reloadService();
   }
 });

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