vscode-apollo 1.20.0 → 2.0.1

package/src/language-server/workspace.ts

@@ -2,41 +2,36 @@ import {
   WorkspaceFolder,
   NotificationHandler,
   PublishDiagnosticsParams,
-} from "vscode-languageserver";
+} from "vscode-languageserver/node";
 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 { 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 { GraphQLServiceProject } from "./project/service";
-import URI from "vscode-uri";
+import { URI } from "vscode-uri";
 import { Debug } from "./utilities";
-import type { EngineDecoration } from "src/messages";
+import type { EngineDecoration } from "../messages";
+import { equal } from "@wry/equality";
 
 export interface WorkspaceConfig {
-  clientIdentity?: ClientIdentity;
+  clientIdentity: ClientIdentity;
 }
 
 export class GraphQLWorkspace {
   private _onDiagnostics?: NotificationHandler<PublishDiagnosticsParams>;
   private _onDecorations?: NotificationHandler<EngineDecoration[]>;
   private _onSchemaTags?: NotificationHandler<[ServiceID, SchemaTag[]]>;
-  private _onConfigFilesFound?: NotificationHandler<ApolloConfig[]>;
+  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
+    private config: WorkspaceConfig,
   ) {}
 
   onDiagnostics(handler: NotificationHandler<PublishDiagnosticsParams>) {
@@ -51,7 +46,7 @@ export class GraphQLWorkspace {
     this._onSchemaTags = handler;
   }
 
-  onConfigFilesFound(handler: NotificationHandler<ApolloConfig[]>) {
+  onConfigFilesFound(handler: NotificationHandler<(ApolloConfig | Error)[]>) {
     this._onConfigFilesFound = handler;
   }
 
@@ -70,12 +65,9 @@ export class GraphQLWorkspace {
           configFolderURI: URI.parse(folder.uri),
           clientIdentity,
         })
-      : new GraphQLServiceProject({
-          config: config as ServiceConfig,
-          loadingHandler: this.LanguageServerLoadingHandler,
-          configFolderURI: URI.parse(folder.uri),
-          clientIdentity,
-        });
+      : (() => {
+          throw new Error("TODO rover project");
+        })();
 
     project.onDiagnostics((params) => {
       this._onDiagnostics && this._onDiagnostics(params);
@@ -115,44 +107,42 @@ export class GraphQLWorkspace {
         -- ~/:user/server (GraphQLProject) as WorkspaceFolder
 
     */
-    const apolloConfigFiles: string[] = fg.sync(
-      "**/apollo.config.@(js|ts|cjs)",
+    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[] = [];
+    let foundConfigs: (ApolloConfig | Error)[] = [];
 
     const projectConfigs = Array.from(apolloConfigFolders).map((configFolder) =>
-      loadConfig({ configPath: configFolder, requireConfig: true })
+      loadConfig({ configPath: configFolder })
         .then((config) => {
           if (config) {
             foundConfigs.push(config);
-            const projectsForConfig = config.projects.map((projectConfig) =>
-              this.createProject({ config, folder })
-            );
+            const projectForConfig = this.createProject({ config, folder });
 
             const existingProjects =
               this.projectsByFolderUri.get(folder.uri) || [];
 
             this.projectsByFolderUri.set(folder.uri, [
               ...existingProjects,
-              ...projectsForConfig,
+              projectForConfig,
             ]);
           } else {
             Debug.error(
-              `Workspace failed to load config from: ${configFolder}/`
+              `Workspace failed to load config from: ${configFolder}/`,
             );
           }
         })
-        .catch((error) => Debug.error(error))
+        .catch((error) => foundConfigs.push(error)),
     );
 
     await Promise.all(projectConfigs);
@@ -173,18 +163,17 @@ export class GraphQLWorkspace {
             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 });
+      config = await loadConfig({ configPath });
     } catch (e: any) {
       config = null;
       error = e;
@@ -192,11 +181,14 @@ export class GraphQLWorkspace {
 
     const project = this.projectForFile(configUri);
 
-    if (!config && this._onConfigFilesFound) {
-      this._onConfigFilesFound(error);
+    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();
     }

package/src/languageServerClient.ts

@@ -4,14 +4,14 @@ import {
   LanguageClientOptions,
   LanguageClient,
   RevealOutputChannelOn,
-} from "vscode-languageclient";
+} 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",
@@ -59,7 +59,7 @@ export function getLanguageServerClient(
       fileEvents: [
         workspace.createFileSystemWatcher("**/.env?(.local)"),
         workspace.createFileSystemWatcher(
-          "**/*.{graphql,js,ts,jsx,tsx,vue,svelte,py,rb,dart,re,ex,exs}"
+          "**/*.{graphql,js,ts,cjs,mjs,jsx,tsx,vue,svelte,py,rb,dart,re,ex,exs}",
         ),
       ],
     },
@@ -75,6 +75,6 @@ export function getLanguageServerClient(
     "apollographql",
     "Apollo GraphQL",
     serverOptions,
-    clientOptions
+    clientOptions,
   );
 }

package/src/messages.ts

@@ -1,13 +1,6 @@
-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";
+import { QuickPickItem } from "vscode";
+import { NotificationType, RequestType } from "vscode-jsonrpc";
+import { Range } from "vscode-languageclient/node";
 
 export interface TypeStats {
   service?: number;
@@ -40,45 +33,43 @@ export type EngineDecoration =
       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 const LanguageServerRequests = {
+  FileStats: new RequestType<{ uri: string }, ProjectStats, unknown>(
+    "apollographql/fileStats",
+  ),
 };
 
-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;
+/**
+ * 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"),
 };
 
-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;
+/**
+ * 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/tools/__tests__/buildServiceDefinition.test.ts

@@ -169,11 +169,11 @@ Array [
       const schema = service.schema!;
 
       expect(schema.getDirective("something")).toMatchInlineSnapshot(
-        `"@something"`
+        `"@something"`,
       );
 
       expect(schema.getDirective("another")).toMatchInlineSnapshot(
-        `"@another"`
+        `"@another"`,
       );
     });
 

package/src/tools/buildServiceDefinition.ts

@@ -30,7 +30,7 @@ interface GraphQLServiceDefinition {
 }
 
 export function buildServiceDefinition(
-  modules: GraphQLSchemaModule[]
+  modules: GraphQLSchemaModule[],
 ): GraphQLServiceDefinition {
   const errors: GraphQLError[] = [];
 
@@ -87,14 +87,14 @@ export function buildServiceDefinition(
   }
 
   for (const [typeName, typeDefinitions] of Object.entries(
-    typeDefinitionsMap
+    typeDefinitionsMap,
   )) {
     if (typeDefinitions.length > 1) {
       errors.push(
         new GraphQLError(
           `Type "${typeName}" was defined more than once.`,
-          typeDefinitions
-        )
+          typeDefinitions,
+        ),
       );
     }
   }
@@ -104,8 +104,8 @@ export function buildServiceDefinition(
       errors.push(
         new GraphQLError(
           `Directive "${directiveName}" was defined more than once.`,
-          directives
-        )
+          directives,
+        ),
       );
     }
   }
@@ -131,13 +131,13 @@ export function buildServiceDefinition(
       if (operationTypeMap[operation]) {
         throw new GraphQLError(
           `Must provide only one ${operation} type in schema.`,
-          [schemaDefinition]
+          [schemaDefinition],
         );
       }
       if (!(typeDefinitionsMap[typeName] || typeExtensionsMap[typeName])) {
         throw new GraphQLError(
           `Specified ${operation} type "${typeName}" not found in document.`,
-          [schemaDefinition]
+          [schemaDefinition],
         );
       }
       operationTypeMap[operation] = typeName;
@@ -166,8 +166,8 @@ export function buildServiceDefinition(
         errors.push(
           new GraphQLError(
             `Cannot extend type "${typeName}" because it does not exist in the existing schema.`,
-            typeExtensions
-          )
+            typeExtensions,
+          ),
         );
       }
     }
@@ -209,7 +209,7 @@ export function buildServiceDefinition(
 
 function addResolversToSchema(
   schema: GraphQLSchema,
-  resolvers: GraphQLResolverMap<unknown>
+  resolvers: GraphQLResolverMap<unknown>,
 ) {
   for (const [typeName, fieldConfigs] of Object.entries(resolvers)) {
     const type = schema.getType(typeName);

package/src/tools/schema/resolveObject.ts

@@ -4,7 +4,7 @@ export type GraphQLObjectResolver<TSource, TContext> = (
   source: TSource,
   fields: Record<string, ReadonlyArray<FieldNode>>,
   context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => any;
 
 declare module "graphql/type/definition" {

package/src/tools/utilities/predicates.ts

@@ -1,5 +1,5 @@
 export function isNotNullOrUndefined<T>(
-  value: T | null | undefined
+  value: T | null | undefined,
 ): value is T {
   return value !== null && typeof value !== "undefined";
 }

package/src/utils.ts

@@ -1,4 +1,5 @@
-import type { LanguageClient, ProjectStats } from "./messages";
+import { LanguageClient } from "vscode-languageclient/node";
+import type { ProjectStats } from "./messages";
 
 export const timeSince = (date: number) => {
   const seconds = Math.floor((+new Date() - date) / 1000);
@@ -17,7 +18,7 @@ export const timeSince = (date: number) => {
 
 export const printNoFileOpenMessage = (
   client: LanguageClient,
-  extVersion: string
+  extVersion: string,
 ) => {
   client.outputChannel.appendLine("------------------------------");
   client.outputChannel.appendLine(`🚀 Apollo GraphQL v${extVersion}`);
@@ -27,7 +28,7 @@ export const printNoFileOpenMessage = (
 export const printStatsToClientOutputChannel = (
   client: LanguageClient,
   stats: ProjectStats,
-  extVersion: string
+  extVersion: string,
 ) => {
   client.outputChannel.appendLine("------------------------------");
   client.outputChannel.appendLine(`🚀 Apollo GraphQL v${extVersion}`);
@@ -37,7 +38,7 @@ export const printStatsToClientOutputChannel = (
     client.outputChannel.appendLine(
       "❌ Service stats could not be loaded. This may be because you're missing an apollo.config.js file " +
         "or it is misconfigured. For more information about configuring Apollo projects, " +
-        "see the guide here (https://go.apollo.dev/t/config)."
+        "see the guide here (https://go.apollo.dev/t/config).",
     );
     return;
   }
@@ -54,12 +55,12 @@ export const printStatsToClientOutputChannel = (
       client.outputChannel.appendLine(
         `📈 Number of Types: ${stats.types.total} (${
           stats.types.client
-        } client ${stats.types.client === 1 ? "type" : "types"})`
+        } client ${stats.types.client === 1 ? "type" : "types"})`,
       );
 
     if (stats.lastFetch && timeSince(stats.lastFetch)) {
       client.outputChannel.appendLine(
-        `🗓 Last Fetched ${timeSince(stats.lastFetch)} Ago`
+        `🗓 Last Fetched ${timeSince(stats.lastFetch)} Ago`,
       );
     }
     client.outputChannel.appendLine("------------------------------");

package/syntaxes/graphql.dart.json

@@ -1,7 +1,5 @@
 {
-  "fileTypes": [
-    "dart"
-  ],
+  "fileTypes": ["dart"],
   "injectionSelector": "L:source -string -comment",
   "patterns": [
     {
@@ -37,4 +35,4 @@
     }
   ],
   "scopeName": "inline.graphql.dart"
-}
+}

package/syntaxes/graphql.ex.json

@@ -1,8 +1,5 @@
 {
-  "fileTypes": [
-    "ex",
-    "exs"
-  ],
+  "fileTypes": ["ex", "exs"],
   "injectionSelector": "L:source -string -comment",
   "patterns": [
     {

package/tsconfig.build.json

@@ -1,4 +1,11 @@
 {
   "extends": "./tsconfig.json",
-  "exclude": ["./lib", "**/__tests__/*", "**/__mocks__/*", "jest.config.ts"]
+  "exclude": [
+    "./lib",
+    "**/__tests__/*",
+    "**/__e2e__/*",
+    "**/__mocks__/*",
+    "./sampleWorkspace",
+    "jest.config.ts"
+  ]
 }

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "rootDir": "./src",
     "outDir": "./lib",
-    "target": "es2017",
+    "target": "es2020",
     "module": "commonjs",
     "moduleResolution": "node",
     "esModuleInterop": true,
@@ -10,6 +10,7 @@
     "declaration": true,
     "declarationMap": true,
     "removeComments": true,
+    "allowJs": true,
     "strict": true,
     "noImplicitAny": true,
     "noImplicitReturns": true,
@@ -17,9 +18,10 @@
     "noUnusedParameters": false,
     "noUnusedLocals": false,
     "forceConsistentCasingInFileNames": true,
-    "lib": ["es2017", "esnext.asynciterable"],
+    "lib": ["es2020", "esnext.asynciterable"],
     "types": ["node", "jest"],
     "baseUrl": "."
   },
-  "exclude": ["./lib", "jest.config.ts"]
+  "include": ["./src"],
+  "exclude": ["./lib", "jest.config.ts", "./sampleWorkspace"]
 }

package/src/env/fetch/fetch.ts

@@ -1,32 +0,0 @@
-import { Agent as HttpAgent } from "http";
-import { Agent as HttpsAgent } from "https";
-
-export type RequestAgent = HttpAgent | HttpsAgent;
-
-export type ReferrerPolicy =
-  | ""
-  | "no-referrer"
-  | "no-referrer-when-downgrade"
-  | "same-origin"
-  | "origin"
-  | "strict-origin"
-  | "origin-when-cross-origin"
-  | "strict-origin-when-cross-origin"
-  | "unsafe-url";
-
-export {
-  default as fetch,
-  Request,
-  Response,
-  Headers,
-  ResponseInit,
-  BodyInit,
-  RequestInfo,
-  HeadersInit,
-  Body,
-  RequestInit,
-  RequestMode,
-  RequestCredentials,
-  RequestCache,
-  RequestRedirect,
-} from "node-fetch";

package/src/env/fetch/global.ts

@@ -1,30 +0,0 @@
-declare function fetch(
-  input?: RequestInfo,
-  init?: RequestInit
-): Promise<Response>;
-
-declare interface GlobalFetch {
-  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
-}
-
-declare interface WindowOrWorkerGlobalScope {
-  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
-}
-
-type RequestInfo = import("./fetch").RequestInfo;
-type Headers = import("./fetch").Headers;
-type HeadersInit = import("./fetch").HeadersInit;
-type Body = import("./fetch").Body;
-type Request = import("./fetch").Request;
-type RequestAgent = import("./fetch").RequestAgent;
-type RequestInit = import("./fetch").RequestInit;
-type RequestMode = import("./fetch").RequestMode;
-type RequestCredentials = import("./fetch").RequestCredentials;
-type RequestCache = import("./fetch").RequestCache;
-type RequestRedirect = import("./fetch").RequestRedirect;
-type ReferrerPolicy = import("./fetch").ReferrerPolicy;
-type Response = import("./fetch").Response;
-type ResponseInit = import("./fetch").ResponseInit;
-type BodyInit = import("./fetch").BodyInit;
-type URLSearchParams = import("./url").URLSearchParams;
-type URLSearchParamsInit = import("./url").URLSearchParamsInit;

package/src/env/fetch/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./fetch";
-export * from "./url";

package/src/env/fetch/index.ts

@@ -1,2 +0,0 @@
-export * from "./fetch";
-export * from "./url";

package/src/env/fetch/url.ts

@@ -1,9 +0,0 @@
-import { URLSearchParams } from "url";
-export { URL, URLSearchParams } from "url";
-
-export type URLSearchParamsInit =
-  | URLSearchParams
-  | string
-  | { [key: string]: Object | Object[] | undefined }
-  | Iterable<[string, Object]>
-  | Array<[string, Object]>;

package/src/env/polyfills/array.ts

@@ -1,17 +0,0 @@
-/// <reference lib="esnext.array" />
-import "core-js/features/array/flat";
-import "core-js/features/array/flat-map";
-
-// The built-in Array.flat typings don't contain an overload for ReadonlyArray<U>[],
-// which means the return type is inferred to be any[] instead of U[], hence this augmentation.
-declare global {
-  interface Array<T> {
-    /**
-     * Returns a new array with all sub-array elements concatenated into it recursively up to the
-     * specified depth.
-     *
-     * @param depth The maximum recursion depth
-     */
-    flat<U>(this: ReadonlyArray<U>[], depth?: 1): U[];
-  }
-}

package/src/env/polyfills/index.ts

@@ -1,2 +0,0 @@
-import "./array";
-import "./object";

package/src/env/polyfills/object.ts

@@ -1,7 +0,0 @@
-import "core-js/features/object/from-entries";
-
-declare global {
-  interface ObjectConstructor {
-    fromEntries<K extends string, V>(map: [K, V][]): Record<K, V>;
-  }
-}