vscode-apollo 1.19.3 → 2.0.0

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

@@ -0,0 +1,86 @@
+import { Source, buildClientSchema } from "graphql";
+import { GraphQLDocument } from "../document";
+import { collectExecutableDefinitionDiagnositics } from "../diagnostics";
+import { starwarsSchema } from "./fixtures/starwarsSchema";
+
+const schema = buildClientSchema(starwarsSchema);
+
+const validDocument = new GraphQLDocument(
+  new Source(`
+    query HeroAndFriendsNames {
+      hero {
+        name
+        friends {
+          name
+        }
+      }
+    }`),
+);
+const invalidDocument = new GraphQLDocument(
+  new Source(`
+    query HeroAndFriendsNames {
+      hero {
+        nam         # Missing letter 'e'
+        friend {    # Missing letter 's'
+          name
+        }
+      }
+    }`),
+);
+const documentWithTypes = new GraphQLDocument(
+  new Source(`
+    type SomeType {
+      thing: String
+    }
+     enum SomeEnum {
+      THING_ONE
+      THING_TWO
+    }
+     query HeroAndFriendsNames {
+      hero {
+        name
+        friends {
+          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,
+      );
+      expect(diagnostics.length).toEqual(0);
+    });
+    it("returns two diagnostics for a document with two errors", () => {
+      const diagnostics = collectExecutableDefinitionDiagnositics(
+        schema,
+        invalidDocument,
+      );
+      expect(diagnostics.length).toEqual(2);
+    });
+    it("returns no diagnostics for a document that includes type definitions", () => {
+      const diagnostics = collectExecutableDefinitionDiagnositics(
+        schema,
+        documentWithTypes,
+      );
+      expect(diagnostics.length).toEqual(0);
+    });
+    it("correctly offsets locations", () => {
+      const diagnostics = collectExecutableDefinitionDiagnositics(
+        schema,
+        documentWithOffset,
+      );
+      expect(diagnostics.length).toEqual(1);
+      expect(diagnostics[0].range.start.character).toEqual(40);
+    });
+  });
+});

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

@@ -0,0 +1,187 @@
+import { extractGraphQLDocuments } from "../document";
+import { TextDocument, Position } from "vscode-languageserver";
+
+describe("extractGraphQLDocuments", () => {
+  describe("extracting documents from JavaScript template literals", () => {
+    const mockTextDocument = (text: string): TextDocument => ({
+      getText: jest.fn().mockReturnValue(text),
+      offsetAt(): number {
+        return 0;
+      },
+      positionAt(): Position {
+        return {
+          character: 0,
+          line: 0,
+        };
+      },
+      languageId: "javascript",
+      lineCount: 0,
+      uri: "",
+      version: 1,
+    });
+
+    it("works with placeholders that span multiple rows", () => {
+      const textDocument = mockTextDocument(`
+      gql\`
+        {
+          hero {
+            ...Hero_character
+          }
+        }
+
+        \${Hero.fragments
+          .character}
+      \`
+    `);
+      const documents = extractGraphQLDocuments(textDocument);
+
+      expect(documents?.length).toEqual(1);
+      expect(documents?.[0].syntaxErrors.length).toBe(0);
+      expect(documents?.[0].ast?.definitions.length).toBe(1);
+    });
+
+    it("works with multiple placeholders in a document", () => {
+      const textDocument = mockTextDocument(`
+      gql\`
+        {
+          hero {
+            ...Hero_character
+          }
+        }
+
+        \${Hero.fragments.character}
+
+        {
+          reviews(episode: NEWHOPE) {
+            ...ReviewList_reviews
+          }
+        }
+
+        \${ReviewList.fragments.reviews}
+      \`
+    `);
+      const documents = extractGraphQLDocuments(textDocument);
+
+      expect(documents?.length).toEqual(1);
+      expect(documents?.[0].syntaxErrors.length).toBe(0);
+      expect(documents?.[0].ast?.definitions.length).toBe(2);
+    });
+
+    it("works with a custom tagname", () => {
+      const textDocument = mockTextDocument(`
+      gqltag\`
+        {
+          hero {
+            ...Hero_character
+          }
+        }
+
+        \${Hero.fragments.character}
+
+        {
+          reviews(episode: NEWHOPE) {
+            ...ReviewList_reviews
+          }
+        }
+
+        \${ReviewList.fragments.reviews}
+      \`
+    `);
+      const documents = extractGraphQLDocuments(textDocument, "gqltag");
+
+      expect(documents?.length).toEqual(1);
+      expect(documents?.[0].syntaxErrors.length).toBe(0);
+      expect(documents?.[0].ast?.definitions.length).toBe(2);
+    });
+
+    it("works with parens", () => {
+      const textDocument = mockTextDocument(`
+      gql(\`
+        {
+          hero {
+            ...Hero_character
+          }
+        }
+
+        \${Hero.fragments.character}
+
+        {
+          reviews(episode: NEWHOPE) {
+            ...ReviewList_reviews
+          }
+        }
+
+      \${ReviewList.fragments.reviews}
+    \`)
+    `);
+      const documents = extractGraphQLDocuments(textDocument);
+
+      expect(documents?.length).toEqual(1);
+      expect(documents?.[0].syntaxErrors.length).toBe(0);
+      expect(documents?.[0].ast?.definitions.length).toBe(2);
+    });
+  });
+
+  describe("extracting documents from ReasonML extension nodes", () => {
+    const mockTextDocument = (text: string): TextDocument => ({
+      getText: jest.fn().mockReturnValue(text),
+      offsetAt(): number {
+        return 0;
+      },
+      positionAt(): Position {
+        return {
+          character: 0,
+          line: 0,
+        };
+      },
+      languageId: "reason",
+      lineCount: 0,
+      uri: "",
+      version: 1,
+    });
+
+    it("works with ReasonRelay nodes", () => {
+      const textDocument = mockTextDocument(`
+      module Query = [%relay.query
+      {|
+        query SomeQuery {
+          id
+        }
+      |}
+      ];
+
+      module Fragment = [%relay.fragment
+      {|
+        fragment X on Hero {
+          id
+        }
+      |}
+      ];
+    `);
+      const documents = extractGraphQLDocuments(textDocument);
+
+      expect(documents?.length).toEqual(2);
+      expect(documents?.[0].syntaxErrors.length).toBe(0);
+      expect(documents?.[1].syntaxErrors.length).toBe(0);
+      expect(documents?.[0].ast?.definitions.length).toBe(1);
+      expect(documents?.[1].ast?.definitions.length).toBe(1);
+    });
+
+    it("works with graphql_ppx style node", () => {
+      const textDocument = mockTextDocument(`
+      module Query = [%graphql
+      {|
+        query SomeQuery {
+          id
+        }
+      |}
+      ];
+    `);
+      const documents = extractGraphQLDocuments(textDocument);
+
+      expect(documents?.length).toEqual(1);
+      expect(documents?.[0].syntaxErrors.length).toBe(0);
+      expect(documents?.[0].ast?.definitions.length).toBe(1);
+    });
+  });
+});

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

@@ -0,0 +1,46 @@
+import { FileSet } from "../fileSet";
+import { URI } from "vscode-uri";
+
+describe("fileSet", () => {
+  describe("includesFile", () => {
+    it("matches includes starting with ./", () => {
+      const fileSet = new FileSet({
+        excludes: [],
+        includes: ["./src/**/*.tsx"],
+        rootURI: URI.parse("/project"),
+      });
+      const file = "file:///project/src/Component.tsx";
+      expect(fileSet.includesFile(file)).toBe(true);
+    });
+
+    it("matches includes not starting with ./", () => {
+      const fileSet = new FileSet({
+        excludes: [],
+        includes: ["src/**/*.tsx"],
+        rootURI: URI.parse("/project"),
+      });
+      const file = "file:///project/src/Component.tsx";
+      expect(fileSet.includesFile(file)).toBe(true);
+    });
+
+    it("does not match excludes starting with ./", () => {
+      const fileSet = new FileSet({
+        excludes: ["./src/Component.tsx"],
+        includes: ["./src/**/*.tsx"],
+        rootURI: URI.parse("/project"),
+      });
+      const file = "file:///project/src/Component.tsx";
+      expect(fileSet.includesFile(file)).toBe(false);
+    });
+
+    it("does not match excludes not starting with ./", () => {
+      const fileSet = new FileSet({
+        excludes: ["src/Component.tsx"],
+        includes: ["src/**/*.tsx"],
+        rootURI: URI.parse("/project"),
+      });
+      const file = "file:///project/src/Component.tsx";
+      expect(fileSet.includesFile(file)).toBe(false);
+    });
+  });
+});