vscode-apollo 2.0.1 → 2.1.0

package/src/language-server/server.ts

@@ -6,11 +6,12 @@ import {
   FileChangeType,
   ServerCapabilities,
   TextDocumentSyncKind,
+  SymbolInformation,
+  FileEvent,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import type { QuickPickItem } from "vscode";
 import { GraphQLWorkspace } from "./workspace";
-import { GraphQLLanguageProvider } from "./languageProvider";
 import { LanguageServerLoadingHandler } from "./loadingHandler";
 import { debounceHandler, Debug } from "./utilities";
 import { URI } from "vscode-uri";
@@ -20,6 +21,8 @@ import {
   LanguageServerRequests as Requests,
 } from "../messages";
 import { isValidationError } from "zod-validation-error";
+import { Trie } from "@wry/trie";
+import { GraphQLProject } from "./project/base";
 
 const connection = createConnection(ProposedFeatures.all);
 
@@ -85,6 +88,7 @@ connection.onInitialize(async ({ capabilities, workspaceFolders }) => {
   hasWorkspaceFolderCapability = !!(
     capabilities.workspace && capabilities.workspace.workspaceFolders
   );
+  workspace.capabilities = capabilities;
 
   if (workspaceFolders) {
     // We wait until all projects are added, because after `initialize` returns we can get additional requests
@@ -142,21 +146,30 @@ function isFile(uri: string) {
   return URI.parse(uri).scheme === "file";
 }
 
-documents.onDidChangeContent(
-  debounceHandler((params) => {
-    const project = workspace.projectForFile(params.document.uri);
-    if (!project) return;
+documents.onDidChangeContent((params) => {
+  const project = workspace.projectForFile(params.document.uri);
+  if (!project) return;
 
-    // Only watch changes to files
-    if (!isFile(params.document.uri)) {
-      return;
-    }
+  // Only watch changes to files
+  if (!isFile(params.document.uri)) {
+    return;
+  }
+
+  project.documentDidChange(params.document);
+});
 
-    project.documentDidChange(params.document);
-  }),
+documents.onDidOpen(
+  (params) =>
+    workspace.projectForFile(params.document.uri)?.onDidOpen?.(params),
+);
+
+documents.onDidClose(
+  (params) =>
+    workspace.projectForFile(params.document.uri)?.onDidClose?.(params),
 );
 
 connection.onDidChangeWatchedFiles((params) => {
+  const handledByProject = new Map<GraphQLProject, FileEvent[]>();
   for (const { uri, type } of params.changes) {
     if (
       uri.endsWith("apollo.config.js") ||
@@ -182,75 +195,79 @@ connection.onDidChangeWatchedFiles((params) => {
     const project = workspace.projectForFile(uri);
     if (!project) continue;
 
-    switch (type) {
-      case FileChangeType.Created:
-        project.fileDidChange(uri);
-        break;
-      case FileChangeType.Deleted:
-        project.fileWasDeleted(uri);
-        break;
-    }
+    handledByProject.set(project, handledByProject.get(project) || []);
+    handledByProject.get(project)!.push({ uri, type });
+  }
+  for (const [project, changes] of handledByProject) {
+    project.onDidChangeWatchedFiles({ changes });
   }
 });
 
-const languageProvider = new GraphQLLanguageProvider(workspace);
-
-connection.onHover((params, token) =>
-  languageProvider.provideHover(
-    params.textDocument.uri,
-    params.position,
-    token,
-  ),
+connection.onHover(
+  (params, token, workDoneProgress, resultProgress) =>
+    workspace
+      .projectForFile(params.textDocument.uri)
+      ?.onHover?.(params, token, workDoneProgress, resultProgress) ?? null,
 );
 
-connection.onDefinition((params, token) =>
-  languageProvider.provideDefinition(
-    params.textDocument.uri,
-    params.position,
-    token,
-  ),
+connection.onDefinition(
+  (params, token, workDoneProgress, resultProgress) =>
+    workspace
+      .projectForFile(params.textDocument.uri)
+      ?.onDefinition?.(params, token, workDoneProgress, resultProgress) ?? null,
 );
 
-connection.onReferences((params, token) =>
-  languageProvider.provideReferences(
-    params.textDocument.uri,
-    params.position,
-    params.context,
-    token,
-  ),
+connection.onReferences(
+  (params, token, workDoneProgress, resultProgress) =>
+    workspace
+      .projectForFile(params.textDocument.uri)
+      ?.onReferences?.(params, token, workDoneProgress, resultProgress) ?? null,
 );
 
-connection.onDocumentSymbol((params, token) =>
-  languageProvider.provideDocumentSymbol(params.textDocument.uri, token),
+connection.onDocumentSymbol(
+  (params, token, workDoneProgress, resultProgress) =>
+    workspace
+      .projectForFile(params.textDocument.uri)
+      ?.onDocumentSymbol?.(params, token, workDoneProgress, resultProgress) ??
+    [],
 );
 
-connection.onWorkspaceSymbol((params, token) =>
-  languageProvider.provideWorkspaceSymbol(params.query, token),
-);
+connection.onWorkspaceSymbol(async (params, token) => {
+  const symbols: SymbolInformation[] = [];
+  const symbolPromises = workspace.projects.map(
+    (project) =>
+      project.provideSymbol?.(params.query, token) || Promise.resolve([]),
+  );
+  for (const projectSymbols of await Promise.all(symbolPromises)) {
+    symbols.push(...projectSymbols);
+  }
+  return symbols;
+});
 
 connection.onCompletion(
-  debounceHandler((params, token) =>
-    languageProvider.provideCompletionItems(
-      params.textDocument.uri,
-      params.position,
-      token,
-    ),
+  debounceHandler(
+    (params, token, workDoneProgress, resultProgress) =>
+      workspace
+        .projectForFile(params.textDocument.uri)
+        ?.onCompletion?.(params, token, workDoneProgress, resultProgress) ?? [],
   ),
 );
 
 connection.onCodeLens(
-  debounceHandler((params, token) =>
-    languageProvider.provideCodeLenses(params.textDocument.uri, token),
+  debounceHandler(
+    (params, token, workDoneProgress, resultProgress) =>
+      workspace
+        .projectForFile(params.textDocument.uri)
+        ?.onCodeLens?.(params, token, workDoneProgress, resultProgress) ?? [],
   ),
 );
 
 connection.onCodeAction(
-  debounceHandler((params, token) =>
-    languageProvider.provideCodeAction(
-      params.textDocument.uri,
-      params.range,
-      token,
-    ),
+  debounceHandler(
+    (params, token, workDoneProgress, resultProgress) =>
+      workspace
+        .projectForFile(params.textDocument.uri)
+        ?.onCodeAction?.(params, token, workDoneProgress, resultProgress) ?? [],
   ),
 );
 
@@ -263,12 +280,62 @@ connection.onNotification(Commands.TagSelected, (selection: QuickPickItem) =>
 );
 
 connection.onNotification(Commands.GetStats, async ({ uri }) => {
-  const status = await languageProvider.provideStats(uri);
-  connection.sendNotification(Notifications.StatsLoaded, status);
+  const status = await workspace.projectForFile(uri)?.getProjectStats();
+  connection.sendNotification(
+    Notifications.StatsLoaded,
+    status ?? {
+      loaded: false,
+    },
+  );
 });
 connection.onRequest(Requests.FileStats, async ({ uri }) => {
-  return languageProvider.provideStats(uri);
+  return workspace.projectForFile(uri)?.getProjectStats() ?? { loaded: false };
+});
+
+connection.onRequest((method, params, token) => {
+  return getProjectFromUnknownParams(params, workspace)?.onUnhandledRequest?.(
+    method,
+    params,
+    token,
+  );
+});
+
+connection.onNotification((method, params) => {
+  return getProjectFromUnknownParams(
+    params,
+    workspace,
+  )?.onUnhandledNotification?.(connection, method, params);
 });
 
 // Listen on the connection
 connection.listen();
+
+// ------------------------------ utility functions ------------------------------
+
+function getProjectFromUnknownParams(
+  params: object | any[] | undefined,
+  workspace: GraphQLWorkspace,
+) {
+  const param0 = Array.isArray(params) ? params[0] : params;
+  if (!param0) return;
+  let uri: string | undefined;
+  if (typeof param0 === "string" && param0.startsWith("file://")) {
+    uri = param0;
+  } else if (
+    typeof param0 === "object" &&
+    "uri" in param0 &&
+    param0.uri &&
+    typeof param0.uri === "string"
+  ) {
+    uri = param0.uri;
+  } else if (
+    typeof param0 === "object" &&
+    param0.textDocument &&
+    typeof param0.textDocument === "object" &&
+    param0.textDocument.uri &&
+    typeof param0.textDocument.uri === "string"
+  ) {
+    uri = param0.textDocument.uri;
+  }
+  return uri ? workspace.projectForFile(uri) : undefined;
+}

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

@@ -0,0 +1,162 @@
+import { extractGraphQLSources } from "../../document";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import {
+  findContainedSourceAndPosition,
+  positionFromPositionInContainingDocument,
+  positionInContainingDocument,
+} from "../source";
+import { handleFilePartUpdates } from "../../project/rover/DocumentSynchronization";
+
+const testText = `import gql from "graphql-tag";
+
+const foo = 1
+
+gql\`
+  query Test {
+    droid(id: "2000") {
+      name
+    }
+
+}\`;
+
+const verylonglala = gql\`type Foo { baaaaaar: String }\`
+`;
+describe("positionFromPositionInContainingDocument", () => {
+  const sources = extractGraphQLSources(
+    TextDocument.create("uri", "javascript", 1, testText),
+    "gql",
+  )!;
+
+  test("should return the correct position inside a document", () => {
+    expect(
+      positionFromPositionInContainingDocument(sources[0], {
+        line: 5,
+        character: 3,
+      }),
+    ).toEqual({ line: 1, character: 3 });
+  });
+
+  test("should return the correct position on the first line of a document", () => {
+    expect(
+      positionFromPositionInContainingDocument(sources[0], {
+        line: 4,
+        character: 4,
+      }),
+    ).toEqual({ line: 0, character: 0 });
+  });
+
+  test("should return the correct position on a single line document", () => {
+    expect(
+      positionFromPositionInContainingDocument(sources[1], {
+        line: 12,
+        character: 46,
+      }),
+    ).toEqual({ line: 0, character: 21 });
+  });
+});
+
+describe("findContainedSourceAndPosition", () => {
+  const parts = handleFilePartUpdates(
+    extractGraphQLSources(
+      TextDocument.create("uri", "javascript", 1, testText),
+      "gql",
+    )!,
+    [],
+  );
+
+  test("should return the correct position inside a document", () => {
+    expect(
+      findContainedSourceAndPosition(parts, {
+        line: 5,
+        character: 3,
+      }),
+    ).toEqual({ ...parts[0], position: { line: 1, character: 3 } });
+  });
+
+  test("should return the correct position on the first line of a document", () => {
+    expect(
+      findContainedSourceAndPosition(parts, {
+        line: 4,
+        character: 4,
+      }),
+    ).toEqual({ ...parts[0], position: { line: 0, character: 0 } });
+  });
+
+  test("should return the correct position on the last line of a document", () => {
+    expect(
+      findContainedSourceAndPosition(parts, {
+        line: 10,
+        character: 0,
+      }),
+    ).toEqual({ ...parts[0], position: { line: 6, character: 0 } });
+  });
+
+  test("should return null if the position is outside of the document", () => {
+    expect(
+      findContainedSourceAndPosition(parts, {
+        line: 4,
+        character: 3,
+      }),
+    ).toBeNull();
+    expect(
+      findContainedSourceAndPosition(parts, {
+        line: 10,
+        character: 1,
+      }),
+    ).toBeNull();
+  });
+
+  test("should return the correct position on a single line document", () => {
+    expect(
+      findContainedSourceAndPosition(parts, {
+        line: 12,
+        character: 46,
+      }),
+    ).toEqual({ ...parts[1], position: { line: 0, character: 21 } });
+  });
+});
+describe("positionInContainingDocument", () => {
+  const parts = handleFilePartUpdates(
+    extractGraphQLSources(
+      TextDocument.create("uri", "javascript", 1, testText),
+      "gql",
+    )!,
+    [],
+  );
+
+  test("should return the correct position inside a document", () => {
+    expect(
+      positionInContainingDocument(parts[0].source, {
+        line: 1,
+        character: 3,
+      }),
+    ).toEqual({ line: 5, character: 3 });
+  });
+
+  test("should return the correct position on the first line of a document", () => {
+    expect(
+      positionInContainingDocument(parts[0].source, {
+        line: 0,
+        character: 0,
+      }),
+    ).toEqual({ line: 4, character: 4 });
+  });
+
+  test("should return the correct position on the last line of a document", () => {
+    expect(
+      positionInContainingDocument(parts[0].source, {
+        line: 6,
+        character: 0,
+      }),
+    ).toEqual({ line: 10, character: 0 });
+  });
+
+  test("should return the correct position on a single line document", () => {
+    expect(
+      positionInContainingDocument(parts[1].source, {
+        line: 0,
+        character: 21,
+      }),
+    ).toEqual({ line: 12, character: 46 });
+  });
+});

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

@@ -65,14 +65,48 @@ export function visitWithTypeInfo(
   };
 }
 
+export function findContainedSourceAndPosition<T extends { source: Source }>(
+  parts: ReadonlyArray<T>,
+  absolutePosition: Position,
+) {
+  for (const part of parts) {
+    const lines = part.source.body.split("\n");
+    const position = positionFromPositionInContainingDocument(
+      part.source,
+      absolutePosition,
+    );
+
+    // we are in a sub-document that's beyond the position we're looking for
+    // exit early to save on computing time
+    if (position.line < 0) return null;
+
+    if (
+      position.line >= 0 &&
+      position.line < lines.length &&
+      position.character >= 0 &&
+      (position.line < lines.length - 1 ||
+        position.character < lines[position.line].length)
+    ) {
+      return {
+        ...part,
+        position,
+      };
+    }
+  }
+  return null;
+}
+
 export function positionFromPositionInContainingDocument(
   source: Source,
   position: Position,
 ) {
   if (!source.locationOffset) return position;
+  const line = position.line - (source.locationOffset.line - 1);
   return Position.create(
-    position.line - (source.locationOffset.line - 1),
-    position.character,
+    line,
+    line === 0
+      ? position.character - (source.locationOffset.column - 1)
+      : position.character,
   );
 }
 
@@ -83,7 +117,8 @@ export function positionInContainingDocument(
   if (!source.locationOffset) return position;
   return Position.create(
     source.locationOffset.line - 1 + position.line,
-    position.character,
+    (position.line === 0 ? source.locationOffset.column - 1 : 0) +
+      position.character,
   );
 }
 

package/src/language-server/workspace.ts

@@ -2,6 +2,7 @@ import {
   WorkspaceFolder,
   NotificationHandler,
   PublishDiagnosticsParams,
+  ClientCapabilities,
 } from "vscode-languageserver/node";
 import { QuickPickItem } from "vscode";
 import { GraphQLProject, DocumentUri } from "./project/base";
@@ -15,6 +16,7 @@ import { URI } from "vscode-uri";
 import { Debug } from "./utilities";
 import type { EngineDecoration } from "../messages";
 import { equal } from "@wry/equality";
+import { isRoverConfig, RoverProject } from "./project/rover/project";
 
 export interface WorkspaceConfig {
   clientIdentity: ClientIdentity;
@@ -26,6 +28,7 @@ export class GraphQLWorkspace {
   private _onSchemaTags?: NotificationHandler<[ServiceID, SchemaTag[]]>;
   private _onConfigFilesFound?: NotificationHandler<(ApolloConfig | Error)[]>;
   private _projectForFileCache: Map<string, GraphQLProject> = new Map();
+  public capabilities?: ClientCapabilities;
 
   private projectsByFolderUri: Map<string, GraphQLProject[]> = new Map();
 
@@ -65,8 +68,15 @@ export class GraphQLWorkspace {
           configFolderURI: URI.parse(folder.uri),
           clientIdentity,
         })
+      : isRoverConfig(config)
+      ? new RoverProject({
+          config,
+          loadingHandler: this.LanguageServerLoadingHandler,
+          configFolderURI: URI.parse(folder.uri),
+          capabilities: this.capabilities!, // TODO?
+        })
       : (() => {
-          throw new Error("TODO rover project");
+          throw new Error("Impossible config!");
         })();
 
     project.onDiagnostics((params) => {
@@ -86,7 +96,7 @@ export class GraphQLWorkspace {
     // after a project has loaded, we do an initial validation to surface errors
     // on the start of the language server. Instead of doing this in the
     // base class which is used by codegen and other tools
-    project.whenReady.then(() => project.validate());
+    project.whenReady.then(() => project.validate?.());
 
     return project;
   }
@@ -157,12 +167,24 @@ export class GraphQLWorkspace {
     this.projectsByFolderUri.forEach((projects, uri) => {
       this.projectsByFolderUri.set(
         uri,
-        projects.map((project) => {
-          project.clearAllDiagnostics();
-          return this.createProject({
-            config: project.config,
-            folder: { uri } as WorkspaceFolder,
-          });
+        projects.map((oldProject) => {
+          oldProject.clearAllDiagnostics();
+
+          try {
+            const newProject = this.createProject({
+              config: oldProject.config,
+              folder: { uri } as WorkspaceFolder,
+            });
+            if (
+              oldProject instanceof RoverProject &&
+              newProject instanceof RoverProject
+            ) {
+              newProject.restoreFromPreviousProject(oldProject);
+            }
+            return newProject;
+          } finally {
+            oldProject.dispose?.();
+          }
         }),
       );
     });
@@ -227,7 +249,10 @@ export class GraphQLWorkspace {
   removeProjectsInFolder(folder: WorkspaceFolder) {
     const projects = this.projectsByFolderUri.get(folder.uri);
     if (projects) {
-      projects.forEach((project) => project.clearAllDiagnostics());
+      projects.forEach((project) => {
+        project.clearAllDiagnostics();
+        project.dispose?.();
+      });
       this.projectsByFolderUri.delete(folder.uri);
     }
   }

package/syntaxes/graphql.js.json

@@ -3,43 +3,40 @@
   "injectionSelector": "L:source -string -comment",
   "patterns": [
     {
-      "name": "taggedTemplates",
       "contentName": "meta.embedded.block.graphql",
-      "begin": "(Relay\\.QL|gql|graphql(\\.experimental)?)\\(?(`)",
+      "begin": "(?:Relay\\.QL|gql|graphql(\\.experimental)?)\\s*(?:<.*?>\\s*)?`",
+      "end": "`",
+      "patterns": [{ "include": "source.graphql" }]
+    },
+    {
+      "contentName": "meta.embedded.block.graphql",
+      "begin": "`(\\s*#[ ]*(gql|graphql|GraphQL))",
       "beginCaptures": {
         "1": {
-          "name": "entity.name.function.tagged-template.js"
+          "name": "meta.embedded.block.graphql comment.line.graphql.js"
         },
         "2": {
-          "name": "punctuation.definition.string.template.begin.js"
-        }
-      },
-      "end": "`\\)?",
-      "endCaptures": {
-        "0": {
-          "name": "punctuation.definition.string.template.end.js"
+          "name": "markup.italic"
         }
       },
+      "end": "`",
       "patterns": [{ "include": "source.graphql" }]
     },
     {
-      "name": "taggedTemplates",
       "contentName": "meta.embedded.block.graphql",
-      "begin": "(`)(#graphql)",
+      "begin": "(?:gql|graphql)\\s*(?:<.*?>\\s*)?\\(\\s*`",
+      "end": "`\\s*\\)",
+      "patterns": [{ "include": "source.graphql" }]
+    },
+    {
+      "contentName": "meta.embedded.block.graphql",
+      "begin": "(?:\\/\\*[\\s\\*]*(gql|graphql|GraphQL)\\s*\\*\\/)\\s*(`)",
       "beginCaptures": {
         "1": {
-          "name": "punctuation.definition.string.template.begin.js"
-        },
-        "2": {
-          "name": "comment.line.graphql.js"
+          "name": "markup.italic"
         }
       },
       "end": "`",
-      "endCaptures": {
-        "0": {
-          "name": "punctuation.definition.string.template.end.js"
-        }
-      },
       "patterns": [{ "include": "source.graphql" }]
     }
   ],