Display status of loading tasks for config and Engine stats (#536)

shadaj · web-flow · commit 0c7279420e5f · 2018-08-09T11:10:45.000-07:00
* Display status of loading tasks for config and Engine stats

* Simplify config loading code

* Remove unused import
diff --git a/packages/apollo-language-server/copy-apollo-libs.sh b/packages/apollo-language-server/copy-apollo-libs.sh
@@ -1,5 +1,10 @@
 #!/bin/bash
 
+# When we copy the apollo-language-server into the extension, we also need to make sure
+# that the Lerna-managed dependencies are up to date with the local packages, not what's published
+# to NPM. So we copy all the local lib folders into the installed NPM packages to get them up to date
+# with what we have in the Lerna build.
+
 cp -r ../apollo-cli/lib ../apollo-vscode/server/node_modules/apollo
 cp -r ../apollo-codegen-core/lib ../apollo-vscode/server/node_modules/apollo-codegen-core
 cp -r ../apollo-codegen-flow-legacy/lib ../apollo-vscode/server/node_modules/apollo-codegen-flow-legacy
diff --git a/packages/apollo-language-server/src/languageProvider.ts b/packages/apollo-language-server/src/languageProvider.ts
@@ -11,6 +11,7 @@ import {
   InsertTextFormat
 } from "vscode-languageserver";
 
+// should eventually be moved into this package, since we're overriding a lot of the existing behavior here
 import { getAutocompleteSuggestions } from "@apollographql/graphql-language-service-interface";
 import {
   getTokenAtPosition,
diff --git a/packages/apollo-language-server/src/project.ts b/packages/apollo-language-server/src/project.ts
@@ -52,6 +52,7 @@ export type DocumentUri = string;
 import "core-js/fn/array/flat-map";
 import { rangeForASTNode } from "./utilities/source";
 import { formatMS } from "./format";
+import { LoadingHandler } from "./server";
 declare global {
   interface Array<T> {
     flatMap<U>(
@@ -114,11 +115,22 @@ export class GraphQLProject {
     Map<string, Map<string, number>>
   > = new Map();
 
-  constructor(config: ApolloConfig, public configFile: string) {
+  constructor(
+    config: ApolloConfig,
+    public configFile: string,
+    private loadingHandler: LoadingHandler
+  ) {
     this.updateConfig(config);
   }
 
   updateConfig(newConfig: ApolloConfig) {
+    if (
+      this.config &&
+      JSON.stringify(this.config) === JSON.stringify(newConfig)
+    ) {
+      return;
+    }
+
     this.needsValidation = true;
     this.config = newConfig;
 
@@ -169,85 +181,96 @@ export class GraphQLProject {
   }
 
   async loadEngineStats() {
-    await Promise.all(
-      Object.values(this.config.schemas!).map(async schemaDef => {
-        if (schemaDef.engineKey) {
-          const engineData = await toPromise(
-            execute(engineLink, {
-              query: engineStatsQuery,
-              variables: {
-                id: getIdFromKey(schemaDef.engineKey!)
-              },
-              context: {
-                headers: { ["x-api-key"]: schemaDef.engineKey },
-                ...(this.config.engineEndpoint && {
-                  uri: this.config.engineEndpoint
-                })
+    await this.loadingHandler.handle(
+      `Loading Apollo Engine stats for ${this.config.name!}`,
+      Promise.all(
+        Object.values(this.config.schemas!).map(async schemaDef => {
+          if (schemaDef.engineKey) {
+            const engineData = await toPromise(
+              execute(engineLink, {
+                query: engineStatsQuery,
+                variables: {
+                  id: getIdFromKey(schemaDef.engineKey!)
+                },
+                context: {
+                  headers: { ["x-api-key"]: schemaDef.engineKey },
+                  ...(this.config.engineEndpoint && {
+                    uri: this.config.engineEndpoint
+                  })
+                }
+              })
+            );
+
+            const schemaEngineStats = new Map<string, Map<string, number>>();
+            engineData.data!.service.report.usageStats.types.forEach(
+              (typ: any) => {
+                const fieldsMap = new Map<string, number>();
+                typ.fields.forEach((field: any) => {
+                  fieldsMap.set(
+                    field.name,
+                    field.latencyHistogram.serviceTimeP95
+                  );
+                });
+
+                schemaEngineStats.set(typ.name, fieldsMap);
               }
-            })
-          );
+            );
 
-          const schemaEngineStats = new Map<string, Map<string, number>>();
-          engineData.data!.service.report.usageStats.types.forEach(
-            (typ: any) => {
-              const fieldsMap = new Map<string, number>();
-              typ.fields.forEach((field: any) => {
-                fieldsMap.set(
-                  field.name,
-                  field.latencyHistogram.serviceTimeP95
-                );
-              });
-
-              schemaEngineStats.set(typ.name, fieldsMap);
-            }
-          );
-
-          this.engineStats.set(schemaDef.engineKey, schemaEngineStats);
+            this.engineStats.set(schemaDef.engineKey, schemaEngineStats);
 
-          return;
-        } else {
-          return;
-        }
-      })
+            return;
+          } else {
+            return;
+          }
+        })
+      )
     );
 
     return;
   }
 
   async scanAllIncludedFiles() {
-    console.time(`scanAllIncludedFiles - ${this.displayName}`);
-
-    this.documentSets = await resolveDocumentSets(this.config, true);
-
-    for (const set of this.documentSets) {
-      if (!set.schema!.getQueryType()!.astNode) {
-        const schemaSource = printSchema(set.schema!);
-
-        set.schema = buildSchema(
-          new Source(
-            schemaSource,
-            `graphql-schema:/schema.graphql?${encodeURIComponent(schemaSource)}`
-          )
-        );
-      }
+    await this.loadingHandler.handle(
+      `Loading queries and schemas for ${this.config.name!}`,
+      (async () => {
+        console.time(`scanAllIncludedFiles - ${this.displayName}`);
+        this.documentSets = await resolveDocumentSets(this.config, true);
+
+        for (const set of this.documentSets) {
+          if (!set.schema!.getQueryType()!.astNode) {
+            const schemaSource = printSchema(set.schema!);
+
+            set.schema = buildSchema(
+              // rebuild the schema from a generated source file and attach the source to a graphql-schema
+              // URI that can be loaded as an in-memory file by VSCode
+              new Source(
+                schemaSource,
+                `graphql-schema:/schema.graphql?${encodeURIComponent(
+                  schemaSource
+                )}`
+              )
+            );
+          }
 
-      this.setToResolved.set(set.originalSet, set);
+          this.setToResolved.set(set.originalSet, set);
 
-      for (const filePath of set.documentPaths) {
-        const uri = Uri.file(filePath).toString();
+          for (const filePath of set.documentPaths) {
+            const uri = Uri.file(filePath).toString();
 
-        // If we already have query documents for this file, that means it was either
-        // opened or changed before we got a chance to read it.
-        if (this.documentsByFile.has(uri)) continue;
+            // If we already have query documents for this file, that means it was either
+            // opened or changed before we got a chance to read it.
+            if (this.documentsByFile.has(uri)) continue;
 
-        this.fileDidChange(uri, set);
-      }
-    }
+            this.fileDidChange(uri, set);
+          }
+        }
 
-    console.timeEnd(`scanAllIncludedFiles - ${this.displayName}`);
+        console.timeEnd(`scanAllIncludedFiles - ${this.displayName}`);
 
-    this.isReady = true;
-    this.validateIfNeeded();
+        this.isReady = true;
+        this.validateIfNeeded();
+      })()
+    );
   }
 
   fileDidChange(uri: DocumentUri, set?: ResolvedDocumentSet) {
diff --git a/packages/apollo-language-server/src/server.ts b/packages/apollo-language-server/src/server.ts
@@ -31,7 +31,60 @@ const connection = createConnection(ProposedFeatures.all);
 
 let hasWorkspaceFolderCapability = false;
 
-const workspace = new GraphQLWorkspace();
+export class LoadingHandler {
+  private latestLoadingToken = 0;
+  async handle<T>(message: string, value: Promise<T>): Promise<T> {
+    const token = this.latestLoadingToken;
+    this.latestLoadingToken += 1;
+    connection.sendNotification(
+      new NotificationType<any, void>("apollographql/loading"),
+      { message, token }
+    );
+
+    try {
+      const ret = await value;
+      connection.sendNotification(
+        new NotificationType<any, void>("apollographql/loadingComplete"),
+        token
+      );
+      return ret;
+    } catch (e) {
+      connection.sendNotification(
+        new NotificationType<any, void>("apollographql/loadingComplete"),
+        token
+      );
+      connection.window.showErrorMessage(`Error in "${message}": ${e}`);
+      throw e;
+    }
+  }
+
+  handleSync<T>(message: string, value: () => T): T {
+    const token = this.latestLoadingToken;
+    this.latestLoadingToken += 1;
+    connection.sendNotification(
+      new NotificationType<any, void>("apollographql/loading"),
+      { message, token }
+    );
+
+    try {
+      const ret = value();
+      connection.sendNotification(
+        new NotificationType<any, void>("apollographql/loadingComplete"),
+        token
+      );
+      return ret;
+    } catch (e) {
+      connection.sendNotification(
+        new NotificationType<any, void>("apollographql/loadingComplete"),
+        token
+      );
+      connection.window.showErrorMessage(`Error in "${message}": ${e}`);
+      throw e;
+    }
+  }
+}
+
+const workspace = new GraphQLWorkspace(new LoadingHandler());
 
 workspace.onDiagnostics(params => {
   connection.sendDiagnostics(params);
@@ -41,6 +94,21 @@ workspace.onDecorations(decs => {
   connection.sendNotification("apollographql/engineDecorations", decs);
 });
 
+const hasInitializedPromise = new Promise(resolve => {
+  connection.onInitialized(async () => {
+    resolve();
+
+    if (hasWorkspaceFolderCapability) {
+      connection.workspace.onDidChangeWorkspaceFolders(event => {
+        event.removed.forEach(folder =>
+          workspace.removeProjectsInFolder(folder)
+        );
+        event.added.forEach(folder => workspace.addProjectsInFolder(folder));
+      });
+    }
+  });
+});
+
 connection.onInitialize(async params => {
   let capabilities = params.capabilities;
   hasWorkspaceFolderCapability = !!(
@@ -49,7 +117,9 @@ connection.onInitialize(async params => {
 
   const workspaceFolders = params.workspaceFolders;
   if (workspaceFolders) {
-    workspaceFolders.forEach(folder => workspace.addProjectsInFolder(folder));
+    hasInitializedPromise.then(() => {
+      workspaceFolders.forEach(folder => workspace.addProjectsInFolder(folder));
+    });
   }
 
   return {
@@ -75,15 +145,6 @@ connection.onInitialize(async params => {
   };
 });
 
-connection.onInitialized(async () => {
-  if (hasWorkspaceFolderCapability) {
-    connection.workspace.onDidChangeWorkspaceFolders(event => {
-      event.removed.forEach(folder => workspace.removeProjectsInFolder(folder));
-      event.added.forEach(folder => workspace.addProjectsInFolder(folder));
-    });
-  }
-});
-
 const documents: TextDocuments = new TextDocuments();
 
 // Make the text document manager listen on the connection
diff --git a/packages/apollo-language-server/src/workspace.ts b/packages/apollo-language-server/src/workspace.ts
@@ -11,12 +11,15 @@ import * as fg from "glob";
 import { findAndLoadConfig } from "apollo/lib/config";
 import { GraphQLDocument } from "./document";
 import { Source, buildSchema } from "graphql";
+import { LoadingHandler } from "./server";
 
 export class GraphQLWorkspace {
   private _onDiagnostics?: NotificationHandler<PublishDiagnosticsParams>;
   private _onDecorations?: (any: any) => void;
   public projectsByFolderUri: Map<string, GraphQLProject[]> = new Map();
 
+  constructor(private loadingHandler: LoadingHandler) {}
+
   onDiagnostics(handler: NotificationHandler<PublishDiagnosticsParams>) {
     this._onDiagnostics = handler;
   }
@@ -46,19 +49,25 @@ export class GraphQLWorkspace {
 
     const projectConfigs = Array.from(apolloConfigFolders).flatMap(
       configFolder => {
-        try {
-          return [findAndLoadConfig(configFolder, false, true)];
-        } catch (e) {
-          console.error(e);
-          return [];
-        }
+        return this.loadingHandler.handleSync(
+          `Loading Apollo Config in folder ${configFolder}`,
+          () => {
+            try {
+              return [findAndLoadConfig(configFolder, false, true)];
+            } catch (e) {
+              console.error(e);
+              return [];
+            }
+          }
+        );
       }
     );
 
     const projects = projectConfigs.map(projectConfig => {
       const project = new GraphQLProject(
         projectConfig,
-        projectConfig.configFile
+        projectConfig.configFile,
+        this.loadingHandler
       );
 
       project.onDiagnostics(params => {
diff --git a/packages/apollo-vscode/src/extension.ts b/packages/apollo-vscode/src/extension.ts
