vscode-apollo 1.19.3 → 2.0.0

package/src/language-server/utilities/__tests__/graphql.test.ts

@@ -0,0 +1,399 @@
+import gql from "graphql-tag";
+import { parse, print } from "graphql";
+import {
+  withTypenameFieldAddedWhereNeeded,
+  removeDirectiveAnnotatedFields,
+} from "../graphql";
+
+describe("withTypenameFieldAddedWhereNeeded", () => {
+  it("properly adds __typename to each selectionSet", () => {
+    const query = gql`
+      query Product {
+        product {
+          sku
+          color {
+            id
+            value
+          }
+        }
+      }
+    `;
+
+    const withTypenames = withTypenameFieldAddedWhereNeeded(query);
+
+    expect(print(withTypenames)).toMatchInlineSnapshot(`
+      "query Product {
+        product {
+          __typename
+          sku
+          color {
+            __typename
+            id
+            value
+          }
+        }
+      }"
+    `);
+  });
+
+  it("adds __typename to InlineFragment nodes (as ApolloClient does)", () => {
+    const query = gql`
+      query CartItems {
+        product {
+          items {
+            ... on Table {
+              material
+            }
+            ... on Paint {
+              color
+            }
+          }
+        }
+      }
+    `;
+
+    const withTypenames = withTypenameFieldAddedWhereNeeded(query);
+
+    expect(print(withTypenames)).toMatchInlineSnapshot(`
+      "query CartItems {
+        product {
+          __typename
+          items {
+            __typename
+            ... on Table {
+              __typename
+              material
+            }
+            ... on Paint {
+              __typename
+              color
+            }
+          }
+        }
+      }"
+    `);
+  });
+});
+
+describe("removeDirectiveAnnotatedFields", () => {
+  it("should remove fields with matching directives", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`query Query { fieldToKeep fieldToRemove @client }`),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+            "query Query {
+              fieldToKeep
+            }"
+        `);
+  });
+
+  it("trim selections sets that are client only", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            query Query {
+              fieldToKeep
+              fieldToRemove @client {
+                childField
+              }
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      "query Query {
+        fieldToKeep
+      }"
+    `);
+  });
+
+  it("should remove fragments when a directive is used on a fragment spread", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            {
+              me { name }
+              ...ClientFields @client
+            }
+            fragment ClientFields on Query {
+              hello
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+        "{
+          me {
+            name
+          }
+        }"
+    `);
+  });
+
+  it("should remove fragments when client directive is used inline", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            {
+              me { name }
+              ... on Query @client {
+                hello
+              }
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+            "{
+              me {
+                name
+              }
+            }"
+        `);
+  });
+
+  it("should remove fragments when the client directive is on the definition", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            fragment ClientObject on Query @client {
+              hello
+            }
+            {
+              me { name }
+              ... ClientObject
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      "{
+        me {
+          name
+        }
+      }"
+    `);
+  });
+
+  it("should remove fragments that become unused when antecendant directives are removed", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            fragment ClientObjectFragment on ClientObject {
+              string
+              number
+            }
+
+            fragment LaunchTile on Launch {
+              __typename
+              id
+              isBooked
+              rocket {
+                id
+                name
+              }
+              mission {
+                name
+                missionPatch
+              }
+            }
+
+            query LaunchDetails($launchId: ID!) {
+              launch(id: $launchId) {
+                isInCart @client
+                clientObject @client {
+                  ...ClientObjectFragment
+                }
+                site
+                rocket {
+                  type
+                }
+                ...LaunchTile
+              }
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      "fragment LaunchTile on Launch {
+        __typename
+        id
+        isBooked
+        rocket {
+          id
+          name
+        }
+        mission {
+          name
+          missionPatch
+        }
+      }
+
+      query LaunchDetails($launchId: ID!) {
+        launch(id: $launchId) {
+          site
+          rocket {
+            type
+          }
+          ...LaunchTile
+        }
+      }"
+    `);
+  });
+
+  it("should recursively remove fragments that become unused when antecendant directives are removed", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            fragment One on Node {
+              ...Two
+              user {
+                friends {
+                  name
+                  ...Two @client
+                }
+              }
+            }
+            fragment Two on Node {
+              id
+            }
+
+            query {
+              me {
+                ...One
+              }
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      "fragment One on Node {
+        ...Two
+        user {
+          friends {
+            name
+          }
+        }
+      }
+
+      fragment Two on Node {
+        id
+      }
+
+      {
+        me {
+          ...One
+        }
+      }"
+    `);
+  });
+
+  it("should remove fragment spreads from @client fragment definitions", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            fragment One on Node @client {
+              ...Two
+            }
+
+            fragment Two on Node {
+              id
+            }
+
+            query {
+              me {
+                name
+                ...One
+              }
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      "{
+        me {
+          name
+        }
+      }"
+    `);
+  });
+
+  it("should remove all operations that have no selection set after fragments are removed", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            fragment One on Node @client {
+              ...Two
+            }
+
+            fragment Two on Node {
+              id
+            }
+
+            {
+              name
+              me {
+                ...One
+              }
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      "{
+        name
+      }"
+    `);
+  });
+
+  it("should not remove fragment definitions that weren't removed by `removeDirectiveAnnotatedFields`", () => {
+    expect(
+      print(
+        removeDirectiveAnnotatedFields(
+          parse(`
+            fragment One on Node {
+              id
+            }
+
+            {
+              me {
+                name
+              }
+            }
+          `),
+          ["client"],
+        ),
+      ),
+    ).toMatchInlineSnapshot(`
+      "fragment One on Node {
+        id
+      }
+
+      {
+        me {
+          name
+        }
+      }"
+    `);
+  });
+});

package/src/language-server/utilities/__tests__/uri.ts

@@ -0,0 +1,55 @@
+import { normalizeURI } from "../uri";
+
+describe("Unix URIs", () => {
+  // this is the format that `glob` returns on unix
+  const uriToMatchForUnix = "/test/myFile.js";
+
+  // single forward slash (unix)
+  it("handles /Users/me URIs", () => {
+    const uri = "/test/myFile.js";
+    const parsed = normalizeURI(uri);
+    expect(parsed).toEqual(uriToMatchForUnix);
+  });
+
+  // single escaped backslash
+  // treat these as forward slashes?
+  it("handles \\Users\\me URIs", () => {
+    const uri = "\\test\\myFile.js";
+    const parsed = normalizeURI(uri);
+    expect(parsed).toEqual(uriToMatchForUnix);
+  });
+});
+
+describe("Windows URIs", () => {
+  // this is the format that `glob` returns for windows
+  const uriToMatchForWindows = "c:/test/myFile.js";
+
+  // this format is sent by the native extension notification system on windows
+  it("handles file:///c%3A/ URIs", () => {
+    const uri = "file:///c%3A/test/myFile.js";
+    const parsed = normalizeURI(uri);
+    expect(parsed).toEqual(uriToMatchForWindows);
+  });
+
+  // same as above without URI encoded :
+  it("handles handles file:///c:/ URIs", () => {
+    const uri = "file:///c:/test/myFile.js";
+    const parsed = normalizeURI(uri);
+    expect(parsed).toEqual(uriToMatchForWindows);
+  });
+
+  // result of glob.sync
+  it("handles c:/ URIs", () => {
+    const uri = "c:/test/myFile.js";
+    const parsed = normalizeURI(uri);
+    expect(parsed).toEqual(uriToMatchForWindows);
+  });
+
+  // from status bar notification
+  // single (escaped) backslash
+  it("handles c:\\ URIs", () => {
+    const uri = "c:\\test\\myFile.js";
+    const parsed = normalizeURI(uri);
+    expect(parsed).toEqual(uriToMatchForWindows);
+  });
+});

package/src/language-server/utilities/debouncer.ts

@@ -0,0 +1,8 @@
+import debounce from "lodash.debounce";
+
+export function debounceHandler(
+  handler: (...args: any[]) => any,
+  leading: boolean = true,
+) {
+  return debounce(handler, 250, { leading });
+}

package/src/language-server/utilities/debug.ts

@@ -0,0 +1,90 @@
+import { LanguageServerNotifications as Notifications } from "../../messages";
+import { Connection } from "vscode-languageserver/node";
+
+/**
+ * for errors (and other logs in debug mode) we want to print
+ * a stack trace showing where they were thrown. This uses an
+ * Error's stack trace, removes the three frames regarding
+ * this file (since they're useless) and returns the rest of the trace.
+ */
+const createAndTrimStackTrace = () => {
+  let stack: string | undefined = new Error().stack;
+  // remove the lines in the stack from _this_ function and the caller (in this file) and shorten the trace
+  return stack && stack.split("\n").length > 2
+    ? stack.split("\n").slice(3, 7).join("\n")
+    : stack;
+};
+
+type Logger = (message?: any) => void;
+
+export class Debug {
+  private static connection?: Connection;
+  private static infoLogger: Logger = (message) =>
+    console.log("[INFO] " + message);
+  private static warningLogger: Logger = (message) =>
+    console.warn("[WARNING] " + message);
+  private static errorLogger: Logger = (message) =>
+    console.error("[ERROR] " + message);
+
+  /**
+   * Setting a connection overrides the default info/warning/error
+   * loggers to pass a notification to the connection
+   */
+  public static SetConnection(conn: Connection) {
+    Debug.connection = conn;
+    Debug.infoLogger = (message) =>
+      Debug.connection!.sendNotification(Notifications.ServerDebugMessage, {
+        type: "info",
+        message: message,
+      });
+    Debug.warningLogger = (message) =>
+      Debug.connection!.sendNotification(Notifications.ServerDebugMessage, {
+        type: "warning",
+        message: message,
+      });
+    Debug.errorLogger = (message) =>
+      Debug.connection!.sendNotification(Notifications.ServerDebugMessage, {
+        type: "error",
+        message: message,
+      });
+  }
+
+  /**
+   * Allow callers to set their own error logging utils.
+   * These will default to console.log/warn/error
+   */
+  public static SetLoggers({
+    info,
+    warning,
+    error,
+  }: {
+    info?: Logger;
+    warning?: Logger;
+    error?: Logger;
+  }) {
+    if (info) Debug.infoLogger = info;
+    if (warning) Debug.warningLogger = warning;
+    if (error) Debug.errorLogger = error;
+  }
+
+  public static info(message: string) {
+    Debug.infoLogger(message);
+  }
+
+  public static error(message: string) {
+    const stack = createAndTrimStackTrace();
+    Debug.errorLogger(`${message}\n${stack}`);
+  }
+
+  public static warning(message: string) {
+    Debug.warningLogger(message);
+  }
+
+  public static sendErrorTelemetry(message: string) {
+    Debug.connection &&
+      Debug.connection.sendNotification(Notifications.ServerDebugMessage, {
+        type: "errorTelemetry",
+        message: message,
+      });
+  }
+}