vscode-apollo 1.20.0 → 2.0.1

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

@@ -0,0 +1,147 @@
+import { TextEditor } from "vscode";
+import { closeAllEditors, openEditor, testCompletion, getHover } from "./utils";
+
+let editor: TextEditor;
+beforeAll(async () => {
+  closeAllEditors();
+  editor = await openEditor("clientSchema/src/test.js");
+});
+
+test("completion", async () => {
+  // dro|id
+  await testCompletion(editor, [4, 7], [["droid", "Droid"]]);
+  // na|me
+  await testCompletion(editor, [5, 8], [["name", "String!"]]);
+  // mo|del
+  await testCompletion(editor, [6, 8], [["model", "String"]]);
+});
+
+test("hover", async () => {
+  // featu|reFlagDefer
+  expect(await getHover(editor, [3, 10])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+Query.featureFlagDefer: Boolean!
+\`\`\`
+
+---
+
+\`Client-Only Field\` \`Resolved locally\`
+
+---
+
+Whether to use defer"
+`);
+
+  // @c|lient(always: false)
+  expect(await getHover(editor, [3, 24])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+@client(always: Boolean)
+\`\`\`
+
+---
+
+Direct the client to resolve this field locally, either from the cache or local resolvers."
+`);
+
+  // @client(alwa|ys: false)
+  expect(await getHover(editor, [3, 33])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+always: Boolean
+\`\`\`
+
+---
+
+When true, the client will never use the cache for this value. See
+https://www.apollographql.com/docs/react/local-state/local-resolvers/#forcing-resolvers-with-clientalways-true"
+`);
+
+  // @expo|rt(as: "defer")
+  expect(await getHover(editor, [3, 49])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+@export(as: String!)
+\`\`\`
+
+---
+
+Export this locally resolved field as a variable to be used in the remainder of this query. See
+https://www.apollographql.com/docs/react/local-state/local-resolvers/#using-client-fields-as-variables"
+`);
+  expect(await getHover(editor, [3, 53])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+as: String!
+\`\`\`
+
+---
+
+The variable name to export this field as."
+`);
+
+  // @nonre|active
+  expect(await getHover(editor, [7, 28])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+@nonreactive
+\`\`\`
+
+---
+
+The @nonreactive directive can be used to mark query fields or fragment spreads and is used to indicate that changes to the data contained within the subtrees marked @nonreactive should not trigger rerendering.
+This allows parent components to fetch data to be rendered by their children without rerendering themselves when the data corresponding with fields marked as @nonreactive change.
+https://www.apollographql.com/docs/react/data/directives#nonreactive"
+`);
+
+  // @def|er(if: $defer, label: "fc")
+  expect(await getHover(editor, [8, 14])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+@defer(if: Boolean, label: String)
+\`\`\`
+
+---
+
+This directive enables your queries to receive data for specific fields incrementally, instead of receiving all field data at the same time.
+This is helpful whenever some fields in a query take much longer to resolve than others.
+https://www.apollographql.com/docs/react/data/directives#defer"
+`);
+  //@defer(i|f: $defer, label: "fc")
+  expect(await getHover(editor, [8, 18])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+if: Boolean
+\`\`\`
+
+---
+
+When true fragment may be deferred, if omitted defaults to true."
+`);
+  //@defer(if: $defer, labe|l: "fc")
+  expect(await getHover(editor, [8, 33])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+label: String
+\`\`\`
+
+---
+
+A unique label across all @defer and @stream directives in an operation.
+This label should be used by GraphQL clients to identify the data from patch responses and associate it with the correct fragment.
+If provided, the GraphQL Server must add it to the payload."
+`);
+  // @connec|tion(key: "feed")
+  expect(await getHover(editor, [9, 53])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+@connection(key: String!, filter: [String!])
+\`\`\`
+
+---
+
+Specify a custom store key for this result. See
+https://www.apollographql.com/docs/react/caching/advanced-topics/#the-connection-directive"
+`);
+  // @connection(ke|y: "feed")
+  expect(await getHover(editor, [9, 61])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+key: String!
+\`\`\`
+
+---
+
+Specify the store key."
+`);
+});

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

@@ -0,0 +1,21 @@
+import { TextEditor } from "vscode";
+import { closeAllEditors, openEditor, testCompletion, getHover } from "./utils";
+
+let editor: TextEditor;
+beforeAll(async () => {
+  closeAllEditors();
+  editor = await openEditor("httpSchema/src/test.js");
+});
+
+test("completion", async () => {
+  await testCompletion(editor, [3, 7], [["books", "[Book]"]]);
+  await testCompletion(editor, [5, 9], [["author", "String"]]);
+});
+
+test("hover", async () => {
+  expect(await getHover(editor, [5, 9])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+Book.author: String
+\`\`\`"
+`);
+});

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

@@ -0,0 +1,25 @@
+import { TextEditor } from "vscode";
+import { closeAllEditors, openEditor, testCompletion, getHover } from "./utils";
+
+let editor: TextEditor;
+beforeAll(async () => {
+  closeAllEditors();
+  editor = await openEditor("localSchema/src/test.js");
+});
+
+test("completion", async () => {
+  await testCompletion(editor, [3, 7], [["droid", "Droid"]]);
+  await testCompletion(editor, [4, 8], [["name", "String!"]]);
+});
+
+test("hover", async () => {
+  expect(await getHover(editor, [4, 8])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+Droid.name: String!
+\`\`\`
+
+---
+
+What others call this droid"
+`);
+});

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

@@ -0,0 +1,31 @@
+import { TextEditor } from "vscode";
+import { closeAllEditors, openEditor, testCompletion, getHover } from "./utils";
+
+let editor: TextEditor;
+beforeAll(async () => {
+  closeAllEditors();
+  editor = await openEditor("localSchemaArray/src/test.js");
+});
+
+test("completion", async () => {
+  await testCompletion(editor, [3, 7], [["droid", "Droid"]]);
+  await testCompletion(editor, [4, 8], [["name", "String!"]]);
+  await testCompletion(editor, [6, 7], [["planets", "[Planet]"]]);
+});
+
+test("hover", async () => {
+  expect(await getHover(editor, [4, 8])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+Droid.name: String!
+\`\`\`
+
+---
+
+What others call this droid"
+`);
+  expect(await getHover(editor, [6, 7])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+Query.planets: [Planet]
+\`\`\`"
+`);
+});

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

@@ -0,0 +1,65 @@
+import { TextEditor } from "vscode";
+import {
+  closeAllEditors,
+  openEditor,
+  testCompletion,
+  getHover,
+  getExtension,
+  getOutputChannelDocument,
+  reloadService,
+} from "./utils";
+import mocks from "../../__e2e__/mocks.js";
+import vscode from "vscode";
+import { scheduler } from "node:timers/promises";
+
+const mockPort = Number(process.env.MOCK_SERVER_PORT);
+beforeAll(async () => {
+  closeAllEditors();
+});
+
+test("completion", async () => {
+  const editor = await openEditor("spotifyGraph/src/test.js");
+  await testCompletion(editor, [4, 9], [["profile", "CurrentUserProfile!"]]);
+  await testCompletion(editor, [6, 15], [["displayName", "String"]]);
+});
+
+test("hover", async () => {
+  const editor = await openEditor("spotifyGraph/src/test.js");
+  expect(await getHover(editor, [4, 9])).toMatchInlineSnapshot(`
+"\`\`\`graphql
+CurrentUser.profile: CurrentUserProfile!
+\`\`\`
+
+---
+
+Get detailed profile information about the current user (including the current user's username)."
+`);
+});
+
+test("wrong token", async () => {
+  try {
+    await mocks.sendMock(mockPort, mocks.GetSchemaByTag_WRONG_TOKEN);
+    await mocks.sendMock(mockPort, mocks.SchemaTagsAndFieldStats_WRONG_TOKEN);
+
+    const ext = getExtension();
+    ext.outputChannel.clear();
+    const outputDoc = await getOutputChannelDocument();
+
+    await reloadService();
+    const output = outputDoc.getText();
+
+    // currently, this logs twice, along with a full stracktrace, but no indication of where it came from
+    // this should be improved on.
+    expect(output).toContain(
+      `
+[GraphQL error]: HTTP fetch failed from 'kotlin': 406: Not Acceptable
+[GraphQL error]: Invalid credentials provided
+ApolloError: HTTP fetch failed from 'kotlin': 406: Not Acceptable
+Invalid credentials provided
+    at new ApolloError`.trim(),
+    );
+  } finally {
+    await mocks.loadDefaultMocks(mockPort);
+    await reloadService();
+  }
+});

package/src/language-server/__e2e__/utils.ts

@@ -0,0 +1,151 @@
+import * as vscode from "vscode";
+import { join } from "node:path";
+import { scheduler } from "node:timers/promises";
+import { ProjectStats } from "src/messages";
+import { VSCodeGraphQLExtension } from "src/extension";
+
+function resolve(file: string) {
+  return join(__dirname, "..", "..", "..", "sampleWorkspace", file);
+}
+
+export async function closeAllEditors() {
+  while (vscode.window.visibleTextEditors.length > 0) {
+    await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
+  }
+}
+
+async function waitFor<T>(
+  fn: () => Promise<T>,
+  { retries = 15, delay = 200 } = {},
+) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i === retries - 1) {
+        throw error;
+      }
+      await scheduler.wait(delay);
+    }
+  }
+  throw "unreachable";
+}
+
+export async function openEditor(file: string) {
+  const textDocument = await vscode.workspace.openTextDocument(resolve(file));
+  const editor = await vscode.window.showTextDocument(textDocument);
+  await waitForLSP(file);
+  return editor;
+}
+
+export function waitForLSP(file: string) {
+  return waitFor(async () => {
+    const uri = vscode.Uri.file(resolve(file));
+    const stats = await vscode.commands.executeCommand<ProjectStats>(
+      "apollographql/fileStats",
+      uri.toString(),
+    );
+    expect(stats.loaded).toBe(true);
+    return stats;
+  });
+}
+
+export async function testCompletion(
+  editor: vscode.TextEditor,
+  [line, character]: [number, number],
+  expected: Array<[label: string, detail: string]>,
+) {
+  await waitFor(async () => {
+    editor.selection = new vscode.Selection(line, character, line, character);
+    // without this, the completion list is not updated
+    await scheduler.wait(300);
+    const completions =
+      await vscode.commands.executeCommand<vscode.CompletionList>(
+        "vscode.executeCompletionItemProvider",
+        editor.document.uri,
+        new vscode.Position(line, character),
+      );
+
+    const labels = completions.items.slice(0, expected.length).map((item) =>
+      typeof item.label === "string"
+        ? { label: item.label, detail: "" }
+        : {
+            label: item.label.label,
+            detail: item.detail,
+          },
+    );
+    expect(labels).toStrictEqual(
+      expected.map(([label, detail]) => ({ label, detail })),
+    );
+  });
+}
+
+export async function getHover(
+  editor: vscode.TextEditor,
+  [line, character]: [number, number],
+) {
+  editor.selection = new vscode.Selection(line, character, line, character);
+  // without this, the completion list is not updated
+  await scheduler.wait(300);
+  const hovers = await vscode.commands.executeCommand<vscode.Hover[]>(
+    "vscode.executeHoverProvider",
+    editor.document.uri,
+    new vscode.Position(line, character),
+  );
+
+  const item = hovers[0];
+  const content = item.contents[0];
+  const label = typeof content === "string" ? content : content.value;
+  return label;
+}
+
+export function getExtension(): VSCodeGraphQLExtension {
+  return vscode.extensions.getExtension("apollographql.vscode-apollo")!.exports;
+}
+
+export async function getOutputChannelDocument() {
+  const ext = getExtension();
+  ext.outputChannel.show();
+  await scheduler.wait(300);
+  const doc = vscode.workspace.textDocuments.find((d) =>
+    d.uri.path.startsWith("extension-output-apollographql.vscode-apollo"),
+  );
+  if (!doc) {
+    throw new Error("Output channel document not found");
+  }
+  return doc;
+}
+
+export function getReloadPromise() {
+  const disposables: vscode.Disposable[] = [];
+  const ext = getExtension();
+  const waitingTokens = new Set<number>();
+  disposables.push(
+    ext.client.onNotification(
+      ext.LanguageServerNotifications.Loading,
+      ({ token }) => {
+        waitingTokens.add(token);
+      },
+    ),
+  );
+  return new Promise<void>((resolve) => {
+    disposables.push(
+      ext.client.onNotification(
+        ext.LanguageServerNotifications.LoadingComplete,
+        (token) => {
+          waitingTokens.delete(token);
+          if (waitingTokens.size === 0) resolve();
+        },
+      ),
+    );
+  }).finally(() => disposables.forEach((d) => d.dispose()));
+}
+
+export async function reloadService() {
+  const reloaded = getReloadPromise();
+
+  vscode.commands.executeCommand("apollographql/reloadService");
+
+  await reloaded;
+  await scheduler.wait(100);
+}

package/src/language-server/__tests__/diagnostics.test.ts

@@ -14,7 +14,7 @@ const validDocument = new GraphQLDocument(
           name
         }
       }
-    }`)
+    }`),
 );
 const invalidDocument = new GraphQLDocument(
   new Source(`
@@ -25,7 +25,7 @@ const invalidDocument = new GraphQLDocument(
           name
         }
       }
-    }`)
+    }`),
 );
 const documentWithTypes = new GraphQLDocument(
   new Source(`
@@ -43,41 +43,41 @@ const documentWithTypes = new GraphQLDocument(
           name
         }
       }
-    }`)
+    }`),
 );
 const documentWithOffset = new GraphQLDocument(
   new Source(`query QueryWithOffset { hero { nam } }`, "testDocument", {
     line: 5,
     column: 10,
-  })
+  }),
 );
 describe("Language server diagnostics", () => {
   describe("#collectExecutableDefinitionDiagnositics", () => {
     it("returns no diagnostics for a correct document", () => {
       const diagnostics = collectExecutableDefinitionDiagnositics(
         schema,
-        validDocument
+        validDocument,
       );
       expect(diagnostics.length).toEqual(0);
     });
     it("returns two diagnostics for a document with two errors", () => {
       const diagnostics = collectExecutableDefinitionDiagnositics(
         schema,
-        invalidDocument
+        invalidDocument,
       );
       expect(diagnostics.length).toEqual(2);
     });
     it("returns no diagnostics for a document that includes type definitions", () => {
       const diagnostics = collectExecutableDefinitionDiagnositics(
         schema,
-        documentWithTypes
+        documentWithTypes,
       );
       expect(diagnostics.length).toEqual(0);
     });
     it("correctly offsets locations", () => {
       const diagnostics = collectExecutableDefinitionDiagnositics(
         schema,
-        documentWithOffset
+        documentWithOffset,
       );
       expect(diagnostics.length).toEqual(1);
       expect(diagnostics[0].range.start.character).toEqual(40);

package/src/language-server/__tests__/fileSet.test.ts

@@ -1,5 +1,5 @@
 import { FileSet } from "../fileSet";
-import URI from "vscode-uri";
+import { URI } from "vscode-uri";
 
 describe("fileSet", () => {
   describe("includesFile", () => {

package/src/language-server/__tests__/fixtures/starwarsSchema.ts

@@ -1,6 +1,6 @@
 import { IntrospectionQuery } from "graphql";
 
-export const starwarsSchema: IntrospectionQuery = {
+export const starwarsSchema = {
   __schema: {
     queryType: {
       name: "Query",
@@ -1914,4 +1914,4 @@ export const starwarsSchema: IntrospectionQuery = {
       },
     ],
   },
-};
+} as IntrospectionQuery;

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

@@ -1,128 +1,54 @@
-import { ApolloConfig, ApolloConfigFormat, DefaultConfigBase } from "../";
-import URI from "vscode-uri";
+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 = new ApolloConfig(
-        { service: { name: "hai", ...DefaultConfigBase } },
-        uri
-      );
+      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/
+      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
+      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/
+      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 },
+      const config = parseApolloConfig({
+        client: { service: "hai" },
       });
-      expect(config.variant).toEqual("current");
+      expect(config?.variant).toEqual("current");
     });
 
     it("gets variant from service specifier", () => {
-      const config = new ApolloConfig({
-        client: { service: "hai@master", ...DefaultConfigBase },
+      const config = parseApolloConfig({
+        client: { service: "hai@master" },
       });
-      expect(config.variant).toEqual("master");
+      expect(config?.variant).toEqual("master");
     });
 
     it("can set and override variants", () => {
-      const config = new ApolloConfig({
-        client: { service: "hai@master", ...DefaultConfigBase },
+      const config = parseApolloConfig({
+        client: { service: "hai@master" },
       });
-      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);
+      config!.variant = "new";
+      expect(config?.variant).toEqual("new");
     });
   });
 });