vscode-apollo 1.19.3 → 2.0.0

package/src/language-server/workspace.ts

@@ -0,0 +1,254 @@
+import {
+  WorkspaceFolder,
+  NotificationHandler,
+  PublishDiagnosticsParams,
+} from "vscode-languageserver/node";
+import { QuickPickItem } from "vscode";
+import { GraphQLProject, DocumentUri } from "./project/base";
+import { dirname } from "path";
+import { globSync } from "glob";
+import { loadConfig, ApolloConfig, isClientConfig } from "./config";
+import { LanguageServerLoadingHandler } from "./loadingHandler";
+import { ServiceID, SchemaTag, ClientIdentity } from "./engine";
+import { GraphQLClientProject, isClientProject } from "./project/client";
+import { URI } from "vscode-uri";
+import { Debug } from "./utilities";
+import type { EngineDecoration } from "../messages";
+import { equal } from "@wry/equality";
+
+export interface WorkspaceConfig {
+  clientIdentity: ClientIdentity;
+}
+
+export class GraphQLWorkspace {
+  private _onDiagnostics?: NotificationHandler<PublishDiagnosticsParams>;
+  private _onDecorations?: NotificationHandler<EngineDecoration[]>;
+  private _onSchemaTags?: NotificationHandler<[ServiceID, SchemaTag[]]>;
+  private _onConfigFilesFound?: NotificationHandler<(ApolloConfig | Error)[]>;
+  private _projectForFileCache: Map<string, GraphQLProject> = new Map();
+
+  private projectsByFolderUri: Map<string, GraphQLProject[]> = new Map();
+
+  constructor(
+    private LanguageServerLoadingHandler: LanguageServerLoadingHandler,
+    private config: WorkspaceConfig,
+  ) {}
+
+  onDiagnostics(handler: NotificationHandler<PublishDiagnosticsParams>) {
+    this._onDiagnostics = handler;
+  }
+
+  onDecorations(handler: NotificationHandler<EngineDecoration[]>) {
+    this._onDecorations = handler;
+  }
+
+  onSchemaTags(handler: NotificationHandler<[ServiceID, SchemaTag[]]>) {
+    this._onSchemaTags = handler;
+  }
+
+  onConfigFilesFound(handler: NotificationHandler<(ApolloConfig | Error)[]>) {
+    this._onConfigFilesFound = handler;
+  }
+
+  private createProject({
+    config,
+    folder,
+  }: {
+    config: ApolloConfig;
+    folder: WorkspaceFolder;
+  }) {
+    const { clientIdentity } = this.config;
+    const project = isClientConfig(config)
+      ? new GraphQLClientProject({
+          config,
+          loadingHandler: this.LanguageServerLoadingHandler,
+          configFolderURI: URI.parse(folder.uri),
+          clientIdentity,
+        })
+      : (() => {
+          throw new Error("TODO rover project");
+        })();
+
+    project.onDiagnostics((params) => {
+      this._onDiagnostics && this._onDiagnostics(params);
+    });
+
+    if (isClientProject(project)) {
+      project.onDecorations((params) => {
+        this._onDecorations && this._onDecorations(params);
+      });
+
+      project.onSchemaTags((tags) => {
+        this._onSchemaTags && this._onSchemaTags(tags);
+      });
+    }
+
+    // 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());
+
+    return project;
+  }
+
+  async addProjectsInFolder(folder: WorkspaceFolder) {
+    // load all possible workspace projects (contains possible config)
+    // see if we can move this detection to cosmiconfig
+    /*
+
+      - monorepo (GraphQLWorkspace) as WorkspaceFolder
+        -- engine-api (GraphQLProject)
+        -- engine-frontend (GraphQLProject)
+
+      OR
+
+      - vscode workspace (fullstack)
+        -- ~/:user/client (GraphQLProject) as WorkspaceFolder
+        -- ~/:user/server (GraphQLProject) as WorkspaceFolder
+
+    */
+    const apolloConfigFiles: string[] = globSync(
+      "**/apollo.config.@(js|ts|cjs|mjs)",
+      {
+        cwd: URI.parse(folder.uri).fsPath,
+        absolute: true,
+        ignore: "**/node_modules/**",
+      },
+    );
+
+    // only have unique possible folders
+    const apolloConfigFolders = new Set<string>(apolloConfigFiles.map(dirname));
+
+    // go from possible folders to known array of configs
+    let foundConfigs: (ApolloConfig | Error)[] = [];
+
+    const projectConfigs = Array.from(apolloConfigFolders).map((configFolder) =>
+      loadConfig({ configPath: configFolder })
+        .then((config) => {
+          if (config) {
+            foundConfigs.push(config);
+            const projectForConfig = this.createProject({ config, folder });
+
+            const existingProjects =
+              this.projectsByFolderUri.get(folder.uri) || [];
+
+            this.projectsByFolderUri.set(folder.uri, [
+              ...existingProjects,
+              projectForConfig,
+            ]);
+          } else {
+            Debug.error(
+              `Workspace failed to load config from: ${configFolder}/`,
+            );
+          }
+        })
+        .catch((error) => foundConfigs.push(error)),
+    );
+
+    await Promise.all(projectConfigs);
+
+    if (this._onConfigFilesFound) {
+      this._onConfigFilesFound(foundConfigs);
+    }
+  }
+
+  reloadService() {
+    this._projectForFileCache.clear();
+    this.projectsByFolderUri.forEach((projects, uri) => {
+      this.projectsByFolderUri.set(
+        uri,
+        projects.map((project) => {
+          project.clearAllDiagnostics();
+          return this.createProject({
+            config: project.config,
+            folder: { uri } as WorkspaceFolder,
+          });
+        }),
+      );
+    });
+  }
+
+  async reloadProjectForConfig(configUri: DocumentUri) {
+    const configPath = dirname(URI.parse(configUri).fsPath);
+    let config: ApolloConfig | null;
+    let error;
+    try {
+      config = await loadConfig({ configPath });
+    } catch (e: any) {
+      config = null;
+      error = e;
+    }
+
+    const project = this.projectForFile(configUri);
+
+    if (this._onConfigFilesFound) {
+      this._onConfigFilesFound([config || error]);
+    }
+    // If project exists, update the config
+    if (project && config) {
+      if (equal(project.config.rawConfig, config.rawConfig)) {
+        return;
+      }
+      await Promise.all(project.updateConfig(config));
+      this.reloadService();
+    }
+
+    // If project doesn't exist (new config file), create the project and add to workspace
+    if (!project && config) {
+      const folderUri = URI.file(configPath).toString();
+
+      const newProject = this.createProject({
+        config,
+        folder: { uri: folderUri } as WorkspaceFolder,
+      });
+
+      const existingProjects = this.projectsByFolderUri.get(folderUri) || [];
+      this.projectsByFolderUri.set(folderUri, [
+        ...existingProjects,
+        newProject,
+      ]);
+      this.reloadService();
+    }
+  }
+
+  updateSchemaTag(selection: QuickPickItem) {
+    const serviceID = selection.detail;
+    if (!serviceID) return;
+
+    this.projectsByFolderUri.forEach((projects) => {
+      projects.forEach((project) => {
+        if (isClientProject(project) && project.serviceID === serviceID) {
+          project.updateSchemaTag(selection.label);
+        }
+      });
+    });
+  }
+
+  removeProjectsInFolder(folder: WorkspaceFolder) {
+    const projects = this.projectsByFolderUri.get(folder.uri);
+    if (projects) {
+      projects.forEach((project) => project.clearAllDiagnostics());
+      this.projectsByFolderUri.delete(folder.uri);
+    }
+  }
+
+  get projects(): GraphQLProject[] {
+    return Array.from(this.projectsByFolderUri.values()).flat();
+  }
+
+  projectForFile(uri: DocumentUri): GraphQLProject | undefined {
+    const cachedResult = this._projectForFileCache.get(uri);
+    if (cachedResult) {
+      return cachedResult;
+    }
+
+    for (const projects of this.projectsByFolderUri.values()) {
+      const project = projects.find((project) => project.includesFile(uri));
+      if (project) {
+        this._projectForFileCache.set(uri, project);
+        return project;
+      }
+    }
+    return undefined;
+  }
+}

package/src/languageServerClient.ts

@@ -2,26 +2,27 @@ import {
   ServerOptions,
   TransportKind,
   LanguageClientOptions,
-  LanguageClient
-} from "vscode-languageclient";
+  LanguageClient,
+  RevealOutputChannelOn,
+} from "vscode-languageclient/node";
 import { workspace, OutputChannel } from "vscode";
 
 const { version, referenceID } = require("../package.json");
 
 export function getLanguageServerClient(
   serverModule: string,
-  outputChannel: OutputChannel
+  outputChannel: OutputChannel,
 ) {
   const env = {
     APOLLO_CLIENT_NAME: "Apollo VS Code",
     APOLLO_CLIENT_VERSION: version,
     APOLLO_CLIENT_REFERENCE_ID: referenceID,
-    NODE_TLS_REJECT_UNAUTHORIZED: 0
+    NODE_TLS_REJECT_UNAUTHORIZED: 0,
   };
 
   const debugOptions = {
     execArgv: ["--nolazy", "--inspect=6009"],
-    env
+    env,
   };
 
   const serverOptions: ServerOptions = {
@@ -29,14 +30,14 @@ export function getLanguageServerClient(
       module: serverModule,
       transport: TransportKind.ipc,
       options: {
-        env
-      }
+        env,
+      },
     },
     debug: {
       module: serverModule,
       transport: TransportKind.ipc,
-      options: debugOptions
-    }
+      options: debugOptions,
+    },
   };
 
   const clientOptions: LanguageClientOptions = {
@@ -47,27 +48,33 @@ export function getLanguageServerClient(
       "javascriptreact",
       "typescriptreact",
       "vue",
+      "svelte",
       "python",
       "ruby",
       "dart",
       "reason",
-      "elixir"
+      "elixir",
     ],
     synchronize: {
       fileEvents: [
         workspace.createFileSystemWatcher("**/.env?(.local)"),
         workspace.createFileSystemWatcher(
-          "**/*.{graphql,js,ts,jsx,tsx,vue,py,rb,dart,re,ex,exs}"
-        )
-      ]
+          "**/*.{graphql,js,ts,cjs,mjs,jsx,tsx,vue,svelte,py,rb,dart,re,ex,exs}",
+        ),
+      ],
     },
-    outputChannel
+    outputChannel,
+    revealOutputChannelOn: workspace
+      .getConfiguration("apollographql")
+      .get("debug.revealOutputOnLanguageServerError")
+      ? RevealOutputChannelOn.Error
+      : RevealOutputChannelOn.Never,
   };
 
   return new LanguageClient(
     "apollographql",
     "Apollo GraphQL",
     serverOptions,
-    clientOptions
+    clientOptions,
   );
 }

package/src/messages.ts

@@ -0,0 +1,75 @@
+import { QuickPickItem } from "vscode";
+import { NotificationType, RequestType } from "vscode-jsonrpc";
+import { Range } from "vscode-languageclient/node";
+
+export interface TypeStats {
+  service?: number;
+  client?: number;
+  total?: number;
+}
+
+export type ProjectStats =
+  | {
+      type: string;
+      loaded: true;
+      serviceId?: string;
+      types?: TypeStats;
+      tag?: string;
+      lastFetch?: number;
+    }
+  | { loaded: false };
+
+export type EngineDecoration =
+  | {
+      type: "text";
+      document: string;
+      message: string;
+      range: Range;
+    }
+  | {
+      type: "runGlyph";
+      document: string;
+      range: Range;
+      hoverMessage: string;
+    };
+
+export const LanguageServerRequests = {
+  FileStats: new RequestType<{ uri: string }, ProjectStats, unknown>(
+    "apollographql/fileStats",
+  ),
+};
+
+/**
+ * Notifications sent to the language server
+ */
+export const LanguageServerCommands = {
+  GetStats: new NotificationType<{ uri: string }>("apollographql/getStats"),
+  ReloadService: new NotificationType<void>("apollographql/reloadService"),
+  TagSelected: new NotificationType<QuickPickItem>("apollographql/tagSelected"),
+};
+
+/**
+ * Notifications sent from the language server
+ */
+export const LanguageServerNotifications = {
+  StatsLoaded: new NotificationType<ProjectStats>("apollographql/statsLoaded"),
+  ConfigFilesFound: new NotificationType<string>(
+    "apollographql/configFilesFound",
+  ),
+  TagsLoaded: new NotificationType<string>("apollographql/tagsLoaded"),
+  LoadingComplete: new NotificationType<number>(
+    "apollographql/loadingComplete",
+  ),
+  Loading: new NotificationType<{
+    message: string;
+    token: number;
+  }>("apollographql/loading"),
+  EngineDecorations: new NotificationType<{
+    decorations: EngineDecoration[];
+  }>("apollographql/engineDecorations"),
+  ServerDebugMessage: new NotificationType<{
+    type: "info" | "warning" | "error" | "errorTelemetry";
+    message: string;
+    stack?: string;
+  }>("serverDebugMessage"),
+};

package/src/statusBar.ts

@@ -24,7 +24,7 @@ export default class ApolloStatusBar {
   protected changeState({
     hasActiveTextEditor,
     text,
-    tooltip
+    tooltip,
   }: StateChangeInput) {
     if (!hasActiveTextEditor) {
       this.statusBarItem.hide();
@@ -39,25 +39,25 @@ export default class ApolloStatusBar {
   public showLoadingState({ hasActiveTextEditor }: LoadingInput) {
     this.changeState({
       hasActiveTextEditor,
-      text: ApolloStatusBar.loadingStateText
+      text: ApolloStatusBar.loadingStateText,
     });
   }
 
   public showLoadedState({ hasActiveTextEditor }: LoadingInput) {
     this.changeState({
       hasActiveTextEditor,
-      text: ApolloStatusBar.loadedStateText
+      text: ApolloStatusBar.loadedStateText,
     });
   }
 
   public showWarningState({
     hasActiveTextEditor,
-    tooltip
+    tooltip,
   }: LoadingInput & { tooltip: string }) {
     this.changeState({
       hasActiveTextEditor,
       text: ApolloStatusBar.warningText,
-      tooltip
+      tooltip,
     });
   }