vscode-apollo 1.19.3 → 1.20.0

package/src/language-server/workspace.ts

@@ -0,0 +1,262 @@
+import {
+  WorkspaceFolder,
+  NotificationHandler,
+  PublishDiagnosticsParams,
+} from "vscode-languageserver";
+import { QuickPickItem } from "vscode";
+import { GraphQLProject, DocumentUri } from "./project/base";
+import { dirname } from "path";
+import fg from "glob";
+import {
+  loadConfig,
+  ApolloConfig,
+  isClientConfig,
+  ServiceConfig,
+} from "./config";
+import { LanguageServerLoadingHandler } from "./loadingHandler";
+import { ServiceID, SchemaTag, ClientIdentity } from "./engine";
+import { GraphQLClientProject, isClientProject } from "./project/client";
+import { GraphQLServiceProject } from "./project/service";
+import URI from "vscode-uri";
+import { Debug } from "./utilities";
+import type { EngineDecoration } from "src/messages";
+
+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[]>;
+  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[]>) {
+    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,
+        })
+      : new GraphQLServiceProject({
+          config: config as ServiceConfig,
+          loadingHandler: this.LanguageServerLoadingHandler,
+          configFolderURI: URI.parse(folder.uri),
+          clientIdentity,
+        });
+
+    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[] = fg.sync(
+      "**/apollo.config.@(js|ts|cjs)",
+      {
+        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[] = [];
+
+    const projectConfigs = Array.from(apolloConfigFolders).map((configFolder) =>
+      loadConfig({ configPath: configFolder, requireConfig: true })
+        .then((config) => {
+          if (config) {
+            foundConfigs.push(config);
+            const projectsForConfig = config.projects.map((projectConfig) =>
+              this.createProject({ config, folder })
+            );
+
+            const existingProjects =
+              this.projectsByFolderUri.get(folder.uri) || [];
+
+            this.projectsByFolderUri.set(folder.uri, [
+              ...existingProjects,
+              ...projectsForConfig,
+            ]);
+          } else {
+            Debug.error(
+              `Workspace failed to load config from: ${configFolder}/`
+            );
+          }
+        })
+        .catch((error) => Debug.error(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, requireConfig: true });
+    } catch (e: any) {
+      config = null;
+      error = e;
+    }
+
+    const project = this.projectForFile(configUri);
+
+    if (!config && this._onConfigFilesFound) {
+      this._onConfigFilesFound(error);
+    }
+    // If project exists, update the config
+    if (project && config) {
+      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,7 +2,8 @@ import {
   ServerOptions,
   TransportKind,
   LanguageClientOptions,
-  LanguageClient
+  LanguageClient,
+  RevealOutputChannelOn,
 } from "vscode-languageclient";
 import { workspace, OutputChannel } from "vscode";
 
@@ -16,12 +17,12 @@ export function getLanguageServerClient(
     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,21 +48,27 @@ 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,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(

package/src/messages.ts

@@ -0,0 +1,84 @@
+import { MarkdownString } from "vscode";
+import type {
+  LanguageClient as GenericLanguageClient,
+  NotificationHandler,
+  NotificationHandler0,
+  NotificationType,
+  NotificationType0,
+  Range,
+} from "vscode-languageclient";
+import type { IConnection as GenericConnection } from "vscode-languageserver";
+
+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;
+    };
+
+type Messages = {
+  "apollographql/statsLoaded": ProjectStats;
+  "apollographql/configFilesFound": string;
+  "apollographql/tagsLoaded": string;
+  "apollographql/loadingComplete": number;
+  "apollographql/loading": { message: string; token: number };
+  "apollographql/engineDecorations": { decorations: EngineDecoration[] };
+  serverDebugMessage: {
+    type: "info" | "warning" | "error" | "errorTelemetry";
+    message: string;
+  };
+};
+
+export type LanguageClient = Omit<GenericLanguageClient, "onNotification"> & {
+  // Don't allow passing of generic string messages, restrict to only those
+  // listed in the Message type
+  onNotification<MessageType extends keyof Messages>(
+    messageType: MessageType,
+    handler: (value: Messages[MessageType]) => void
+  ): void;
+  // Allow other notification types
+  onNotification<RO>(
+    type: NotificationType0<RO>,
+    handler: NotificationHandler0
+  ): void;
+  onNotification<P, RO>(
+    type: NotificationType<P, RO>,
+    handler: NotificationHandler<P>
+  ): void;
+};
+
+export type Connection = Omit<GenericConnection, "sendNotification"> & {
+  // Don't allow passing of generic string messages, restrict to only those
+  // listed in the Message type
+  sendNotification<MessageType extends keyof Messages>(
+    messageType: MessageType,
+    value: Messages[MessageType]
+  ): void;
+  // Allow other notification types
+  sendNotification<RO>(type: NotificationType0<RO>): void;
+  sendNotification<P, RO>(type: NotificationType<P, RO>, params: P): void;
+};

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