vscode-apollo 2.0.1 → 2.2.0

package/src/language-server/server.ts

@@ -4,13 +4,13 @@ import {
   ProposedFeatures,
   TextDocuments,
   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,8 +20,16 @@ import {
   LanguageServerRequests as Requests,
 } from "../messages";
 import { isValidationError } from "zod-validation-error";
+import { GraphQLProject } from "./project/base";
+import type { LanguageIdExtensionMap } from "../tools/utilities/languageInformation";
+import { setLanguageIdExtensionMap } from "./utilities/languageIdForExtension";
+
+export type InitializationOptions = {
+  languageIdExtensionMap: LanguageIdExtensionMap;
+};
 
 const connection = createConnection(ProposedFeatures.all);
+export type VSCodeConnection = typeof connection;
 
 Debug.SetConnection(connection);
 const { sendNotification: originalSendNotification } = connection;
@@ -34,8 +42,8 @@ connection.sendNotification = async (...args: [any, ...any[]]) => {
 let hasWorkspaceFolderCapability = false;
 
 // Awaitable promise for sending messages before the connection is initialized
-let initializeConnection: () => void;
-const whenConnectionInitialized: Promise<void> = new Promise(
+let initializeConnection: (c: typeof connection) => void;
+const whenConnectionInitialized: Promise<typeof connection> = new Promise(
   (resolve) => (initializeConnection = resolve),
 );
 
@@ -52,6 +60,7 @@ const workspace = new GraphQLWorkspace(
         require("../../package.json").version,
     },
   },
+  whenConnectionInitialized,
 );
 
 workspace.onDiagnostics((params) => {
@@ -81,45 +90,52 @@ workspace.onConfigFilesFound(async (params) => {
   );
 });
 
-connection.onInitialize(async ({ capabilities, workspaceFolders }) => {
-  hasWorkspaceFolderCapability = !!(
-    capabilities.workspace && capabilities.workspace.workspaceFolders
-  );
+connection.onInitialize(
+  async ({ capabilities, workspaceFolders, initializationOptions }) => {
+    const { languageIdExtensionMap } =
+      initializationOptions as InitializationOptions;
+    setLanguageIdExtensionMap(languageIdExtensionMap);
 
-  if (workspaceFolders) {
-    // We wait until all projects are added, because after `initialize` returns we can get additional requests
-    // like `textDocument/codeLens`, and that way these can await `GraphQLProject#whenReady` to make sure
-    // we provide them eventually.
-    await Promise.all(
-      workspaceFolders.map((folder) => workspace.addProjectsInFolder(folder)),
+    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
+      // like `textDocument/codeLens`, and that way these can await `GraphQLProject#whenReady` to make sure
+      // we provide them eventually.
+      await Promise.all(
+        workspaceFolders.map((folder) => workspace.addProjectsInFolder(folder)),
+      );
+    }
 
-  return {
-    capabilities: {
-      hoverProvider: true,
-      completionProvider: {
-        resolveProvider: false,
-        triggerCharacters: ["...", "@"],
-      },
-      definitionProvider: true,
-      referencesProvider: true,
-      documentSymbolProvider: true,
-      workspaceSymbolProvider: true,
-      codeLensProvider: {
-        resolveProvider: false,
+    return {
+      capabilities: {
+        hoverProvider: true,
+        completionProvider: {
+          resolveProvider: false,
+          triggerCharacters: ["...", "@"],
+        },
+        definitionProvider: true,
+        referencesProvider: true,
+        documentSymbolProvider: true,
+        workspaceSymbolProvider: true,
+        codeLensProvider: {
+          resolveProvider: false,
+        },
+        codeActionProvider: true,
+        executeCommandProvider: {
+          commands: [],
+        },
+        textDocumentSync: TextDocumentSyncKind.Full,
       },
-      codeActionProvider: true,
-      executeCommandProvider: {
-        commands: [],
-      },
-      textDocumentSync: TextDocumentSyncKind.Full,
-    } as ServerCapabilities,
-  };
-});
+    };
+  },
+);
 
 connection.onInitialized(async () => {
-  initializeConnection();
+  initializeConnection(connection);
   if (hasWorkspaceFolderCapability) {
     connection.workspace.onDidChangeWorkspaceFolders(async (event) => {
       await Promise.all([
@@ -142,21 +158,37 @@ 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,
+    params.document.languageId,
+  );
+  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);
+});
+
+documents.onDidOpen(
+  (params) =>
+    workspace
+      .projectForFile(params.document.uri, params.document.languageId)
+      ?.onDidOpen?.(params),
+);
 
-    project.documentDidChange(params.document);
-  }),
+documents.onDidClose(
+  (params) =>
+    workspace
+      .projectForFile(params.document.uri, params.document.languageId)
+      ?.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 +214,82 @@ 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) ??
+      []) satisfies Parameters<typeof connection.onCompletion>[0],
   ),
 );
 
 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) ??
+      []) satisfies Parameters<typeof connection.onCodeLens>[0],
   ),
 );
 
 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) ??
+      []) satisfies Parameters<typeof connection.onCodeAction>[0],
   ),
 );
 
@@ -263,12 +302,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/languageIdForExtension.ts

@@ -0,0 +1,39 @@
+import {
+  FileExtension,
+  LanguageIdExtensionMap,
+  supportedLanguageIds,
+} from "../../tools/utilities/languageInformation";
+
+let languageIdPerExtension: Record<FileExtension, string> | undefined;
+let supportedExtensions: FileExtension[] | undefined;
+
+export function setLanguageIdExtensionMap(map: LanguageIdExtensionMap) {
+  languageIdPerExtension = Object.fromEntries(
+    Object.entries(map).flatMap(([languageId, extensions]) =>
+      extensions.map((extension) => [extension, languageId]),
+    ),
+  );
+  supportedExtensions = supportedLanguageIds.flatMap(
+    (languageId) => map[languageId],
+  );
+}
+
+/**
+ * @throws if called before the language server has received options via `onInitialize`.
+ */
+export function getLanguageIdForExtension(ext: FileExtension) {
+  if (!languageIdPerExtension) {
+    throw new Error("LanguageIdExtensionMap not set");
+  }
+  return languageIdPerExtension[ext];
+}
+
+/**
+ * @throws if called before the language server has received options via `onInitialize`.
+ */
+export function getSupportedExtensions() {
+  if (!supportedExtensions) {
+    throw new Error("LanguageIdExtensionMap not set");
+  }
+  return supportedExtensions;
+}

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,
   );
 }