vscode-apollo 1.19.3 → 2.0.0

package/src/tools/buildServiceDefinition.ts

@@ -0,0 +1,241 @@
+import {
+  GraphQLSchema,
+  DocumentNode,
+  TypeDefinitionNode,
+  DirectiveDefinitionNode,
+  isTypeDefinitionNode,
+  TypeExtensionNode,
+  isTypeExtensionNode,
+  GraphQLError,
+  buildASTSchema,
+  Kind,
+  extendSchema,
+  isObjectType,
+  SchemaDefinitionNode,
+  OperationTypeNode,
+  SchemaExtensionNode,
+} from "graphql";
+import { isNode, isDocumentNode } from "./utilities/graphql";
+import { GraphQLResolverMap } from "./schema/resolverMap";
+import { isNotNullOrUndefined } from "./utilities/predicates";
+
+export interface GraphQLSchemaModule {
+  typeDefs: DocumentNode;
+  resolvers?: GraphQLResolverMap<any>;
+}
+
+interface GraphQLServiceDefinition {
+  schema?: GraphQLSchema;
+  errors?: GraphQLError[];
+}
+
+export function buildServiceDefinition(
+  modules: GraphQLSchemaModule[],
+): GraphQLServiceDefinition {
+  const errors: GraphQLError[] = [];
+
+  const typeDefinitionsMap: {
+    [name: string]: TypeDefinitionNode[];
+  } = Object.create(null);
+
+  const typeExtensionsMap: {
+    [name: string]: TypeExtensionNode[];
+  } = Object.create(null);
+
+  const directivesMap: {
+    [name: string]: DirectiveDefinitionNode[];
+  } = Object.create(null);
+
+  const schemaDefinitions: SchemaDefinitionNode[] = [];
+  const schemaExtensions: SchemaExtensionNode[] = [];
+
+  for (let module of modules) {
+    if (isNode(module) && isDocumentNode(module)) {
+      module = { typeDefs: module };
+    }
+    for (const definition of module.typeDefs.definitions) {
+      if (isTypeDefinitionNode(definition)) {
+        const typeName = definition.name.value;
+
+        if (typeDefinitionsMap[typeName]) {
+          typeDefinitionsMap[typeName].push(definition);
+        } else {
+          typeDefinitionsMap[typeName] = [definition];
+        }
+      } else if (isTypeExtensionNode(definition)) {
+        const typeName = definition.name.value;
+
+        if (typeExtensionsMap[typeName]) {
+          typeExtensionsMap[typeName].push(definition);
+        } else {
+          typeExtensionsMap[typeName] = [definition];
+        }
+      } else if (definition.kind === Kind.DIRECTIVE_DEFINITION) {
+        const directiveName = definition.name.value;
+
+        if (directivesMap[directiveName]) {
+          directivesMap[directiveName].push(definition);
+        } else {
+          directivesMap[directiveName] = [definition];
+        }
+      } else if (definition.kind === Kind.SCHEMA_DEFINITION) {
+        schemaDefinitions.push(definition);
+      } else if (definition.kind === Kind.SCHEMA_EXTENSION) {
+        schemaExtensions.push(definition);
+      }
+    }
+  }
+
+  for (const [typeName, typeDefinitions] of Object.entries(
+    typeDefinitionsMap,
+  )) {
+    if (typeDefinitions.length > 1) {
+      errors.push(
+        new GraphQLError(
+          `Type "${typeName}" was defined more than once.`,
+          typeDefinitions,
+        ),
+      );
+    }
+  }
+
+  for (const [directiveName, directives] of Object.entries(directivesMap)) {
+    if (directives.length > 1) {
+      errors.push(
+        new GraphQLError(
+          `Directive "${directiveName}" was defined more than once.`,
+          directives,
+        ),
+      );
+    }
+  }
+
+  let operationTypeMap: { [operation in OperationTypeNode]?: string };
+
+  if (schemaDefinitions.length > 0 || schemaExtensions.length > 0) {
+    operationTypeMap = {};
+
+    // We should report an error if more than one schema definition is included,
+    // but this matches the current 'last definition wins' behavior of `buildASTSchema`.
+    const schemaDefinition = schemaDefinitions[schemaDefinitions.length - 1];
+
+    const operationTypes = [schemaDefinition, ...schemaExtensions]
+      .map((node) => node.operationTypes)
+      .filter(isNotNullOrUndefined)
+      .flat();
+
+    for (const operationType of operationTypes) {
+      const typeName = operationType.type.name.value;
+      const operation = operationType.operation;
+
+      if (operationTypeMap[operation]) {
+        throw new GraphQLError(
+          `Must provide only one ${operation} type in schema.`,
+          [schemaDefinition],
+        );
+      }
+      if (!(typeDefinitionsMap[typeName] || typeExtensionsMap[typeName])) {
+        throw new GraphQLError(
+          `Specified ${operation} type "${typeName}" not found in document.`,
+          [schemaDefinition],
+        );
+      }
+      operationTypeMap[operation] = typeName;
+    }
+  } else {
+    operationTypeMap = {
+      query: "Query",
+      mutation: "Mutation",
+      subscription: "Subscription",
+    };
+  }
+
+  for (const [typeName, typeExtensions] of Object.entries(typeExtensionsMap)) {
+    if (!typeDefinitionsMap[typeName]) {
+      if (Object.values(operationTypeMap).includes(typeName)) {
+        typeDefinitionsMap[typeName] = [
+          {
+            kind: Kind.OBJECT_TYPE_DEFINITION,
+            name: {
+              kind: Kind.NAME,
+              value: typeName,
+            },
+          },
+        ];
+      } else {
+        errors.push(
+          new GraphQLError(
+            `Cannot extend type "${typeName}" because it does not exist in the existing schema.`,
+            typeExtensions,
+          ),
+        );
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    return { errors };
+  }
+
+  try {
+    const typeDefinitions = Object.values(typeDefinitionsMap).flat();
+    const directives = Object.values(directivesMap).flat();
+
+    let schema = buildASTSchema({
+      kind: Kind.DOCUMENT,
+      definitions: [...typeDefinitions, ...directives],
+    });
+
+    const typeExtensions = Object.values(typeExtensionsMap).flat();
+
+    if (typeExtensions.length > 0) {
+      schema = extendSchema(schema, {
+        kind: Kind.DOCUMENT,
+        definitions: typeExtensions,
+      });
+    }
+
+    for (const module of modules) {
+      if (!module.resolvers) continue;
+
+      addResolversToSchema(schema, module.resolvers);
+    }
+
+    return { schema };
+  } catch (error: any) {
+    return { errors: [error] };
+  }
+}
+
+function addResolversToSchema(
+  schema: GraphQLSchema,
+  resolvers: GraphQLResolverMap<unknown>,
+) {
+  for (const [typeName, fieldConfigs] of Object.entries(resolvers)) {
+    const type = schema.getType(typeName);
+    if (!isObjectType(type)) continue;
+
+    const fieldMap = type.getFields();
+
+    for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) {
+      if (fieldName.startsWith("__")) {
+        (type as any)[fieldName.substring(2)] = fieldConfig;
+        continue;
+      }
+
+      const field = fieldMap[fieldName];
+      if (!field) continue;
+
+      if (typeof fieldConfig === "function") {
+        field.resolve = fieldConfig;
+      } else {
+        if (fieldConfig.resolve) {
+          field.resolve = fieldConfig.resolve;
+        }
+        if (fieldConfig.subscribe) {
+          field.subscribe = fieldConfig.subscribe;
+        }
+      }
+    }
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,6 @@
+import "../env";
+
+export * from "./utilities";
+
+export * from "./schema";
+export * from "./buildServiceDefinition";

package/src/tools/schema/index.ts

@@ -0,0 +1,2 @@
+export * from "./resolverMap";
+export * from "./resolveObject";

package/src/tools/schema/resolveObject.ts

@@ -0,0 +1,18 @@
+import { GraphQLResolveInfo, FieldNode } from "graphql";
+
+export type GraphQLObjectResolver<TSource, TContext> = (
+  source: TSource,
+  fields: Record<string, ReadonlyArray<FieldNode>>,
+  context: TContext,
+  info: GraphQLResolveInfo,
+) => any;
+
+declare module "graphql/type/definition" {
+  interface GraphQLObjectType {
+    resolveObject?: GraphQLObjectResolver<any, any>;
+  }
+
+  interface GraphQLObjectTypeConfig<TSource, TContext> {
+    resolveObject?: GraphQLObjectResolver<TSource, TContext>;
+  }
+}

package/src/tools/schema/resolverMap.ts

@@ -0,0 +1,23 @@
+import { GraphQLFieldResolver } from "graphql";
+
+export interface GraphQLResolverMap<TContext> {
+  [typeName: string]: {
+    [fieldName: string]:
+      | GraphQLFieldResolver<unknown, TContext>
+      | {
+          requires?: string;
+          resolve: GraphQLFieldResolver<unknown, TContext>;
+          subscribe?: undefined;
+        }
+      | {
+          requires?: string;
+          resolve?: undefined;
+          subscribe: GraphQLFieldResolver<unknown, TContext>;
+        }
+      | {
+          requires?: string;
+          resolve: GraphQLFieldResolver<unknown, TContext>;
+          subscribe: GraphQLFieldResolver<unknown, TContext>;
+        };
+  };
+}

package/src/tools/utilities/graphql.ts

@@ -0,0 +1,22 @@
+import {
+  ASTNode,
+  TypeDefinitionNode,
+  TypeExtensionNode,
+  DocumentNode,
+  Kind,
+} from "graphql";
+
+// FIXME: We should add proper type guards for these predicate functions
+// to `@types/graphql`.
+declare module "graphql/language/predicates" {
+  function isTypeDefinitionNode(node: ASTNode): node is TypeDefinitionNode;
+  function isTypeExtensionNode(node: ASTNode): node is TypeExtensionNode;
+}
+
+export function isNode(maybeNode: any): maybeNode is ASTNode {
+  return maybeNode && typeof maybeNode.kind === "string";
+}
+
+export function isDocumentNode(node: ASTNode): node is DocumentNode {
+  return isNode(node) && node.kind === Kind.DOCUMENT;
+}

package/src/tools/utilities/index.ts

@@ -0,0 +1,3 @@
+export * from "./invariant";
+export * from "./predicates";
+export * from "./graphql";

package/src/tools/utilities/invariant.ts

@@ -0,0 +1,5 @@
+export function invariant(condition: any, message: string) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}

package/src/tools/utilities/predicates.ts

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

package/src/utils.ts

@@ -1,4 +1,5 @@
-import { LanguageClient } from "vscode-languageclient";
+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,32 +18,17 @@ export const timeSince = (date: number) => {
 
 export const printNoFileOpenMessage = (
   client: LanguageClient,
-  extVersion: string
+  extVersion: string,
 ) => {
   client.outputChannel.appendLine("------------------------------");
   client.outputChannel.appendLine(`🚀 Apollo GraphQL v${extVersion}`);
   client.outputChannel.appendLine("------------------------------");
 };
 
-export interface TypeStats {
-  service?: number;
-  client?: number;
-  total?: number;
-}
-
-export interface ProjectStats {
-  type: string;
-  loaded: boolean;
-  serviceId?: string;
-  types?: TypeStats;
-  tag?: string;
-  lastFetch?: number;
-}
-
 export const printStatsToClientOutputChannel = (
   client: LanguageClient,
   stats: ProjectStats,
-  extVersion: string
+  extVersion: string,
 ) => {
   client.outputChannel.appendLine("------------------------------");
   client.outputChannel.appendLine(`🚀 Apollo GraphQL v${extVersion}`);
@@ -52,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;
   }
@@ -69,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/syntaxes/graphql.js.json

@@ -1,11 +1,11 @@
 {
-  "fileTypes": ["js", "jsx", "ts", "tsx", "vue"],
+  "fileTypes": ["js", "jsx", "ts", "tsx", "vue", "svelte"],
   "injectionSelector": "L:source -string -comment",
   "patterns": [
     {
       "name": "taggedTemplates",
       "contentName": "meta.embedded.block.graphql",
-      "begin": "(Relay\\.QL|gql|graphql(\\.experimental)?)(`)",
+      "begin": "(Relay\\.QL|gql|graphql(\\.experimental)?)\\(?(`)",
       "beginCaptures": {
         "1": {
           "name": "entity.name.function.tagged-template.js"
@@ -14,7 +14,7 @@
           "name": "punctuation.definition.string.template.begin.js"
         }
       },
-      "end": "`",
+      "end": "`\\)?",
       "endCaptures": {
         "0": {
           "name": "punctuation.definition.string.template.end.js"

package/syntaxes/graphql.json

@@ -65,7 +65,7 @@
       "patterns": [
         {
           "begin": "\\s*\\b(implements)\\b\\s*",
-          "end": "\\s*(?={)",
+          "end": "\\s*(?=[{@])",
           "beginCaptures": {
             "1": { "name": "keyword.implements.graphql.RRR" }
           },
@@ -119,15 +119,16 @@
         { "include": "#graphql-type-object" },
         { "include": "#graphql-colon" },
         { "include": "#graphql-input-types" },
-        { "include": "#graphql-directive"},
+        { "include": "#graphql-directive" },
         { "include": "#literal-quasi-embedded" }
       ]
     },
     "graphql-schema": {
-      "begin": "\\s*\\b(schema)\\b",
-      "end": "(?<=})",
+      "begin": "\\s*\\b(extend)?\\b\\s*\\b(schema)\\b",
+      "end": "\\s*(?!\\s|#|{|@|$)",
       "beginCaptures": {
-        "1": { "name": "keyword.schema.graphql" }
+        "1": { "name": "keyword.extend.graphql" },
+        "2": { "name": "keyword.schema.graphql" }
       },
       "patterns": [
         {
@@ -165,6 +166,7 @@
             { "include": "#graphql-skip-newlines" }
           ]
         },
+        { "include": "#graphql-directive" },
         { "include": "#graphql-comment" },
         { "include": "#graphql-skip-newlines" }
       ]
@@ -261,7 +263,8 @@
         { "include": "#graphql-input-types" },
         { "include": "#graphql-variable-assignment" },
         { "include": "#literal-quasi-embedded" },
-        { "include": "#graphql-skip-newlines" }
+        { "include": "#graphql-skip-newlines" },
+        { "include": "#graphql-directive" }
       ]
     },
     "graphql-input-types": {
@@ -295,7 +298,7 @@
       "match": "\\s*\\b(scalar)\\b\\s*([_A-Za-z][_0-9A-Za-z]*)",
       "captures": {
         "1": { "name": "keyword.scalar.graphql" },
-        "2": { "name": "entity.scalar.graphql" }
+        "2": { "name": "support.type.enum.graphql" }
       }
     },
     "graphql-scalar-type": {
@@ -533,12 +536,13 @@
           },
           "patterns": [
             { "include": "#graphql-object-type" },
-
+            { "include": "#graphql-directive" },
             { "include": "#graphql-comment" },
             { "include": "#graphql-enum-value" },
             { "include": "#literal-quasi-embedded" }
           ]
-        }
+        },
+        { "include": "#graphql-directive" }
       ]
     },
     "graphql-enum-value": {

package/syntaxes/graphql.lua.json

@@ -0,0 +1,51 @@
+{
+  "fileTypes": ["lua", "luau"],
+  "injectionSelector": "L:source -string -comment",
+  "patterns": [
+    {
+      "contentName": "meta.embedded.block.graphql",
+      "begin": "(--\\[\\[)\\s*(gql)\\s*(\\]\\])\\s*(\\[\\[)",
+      "beginCaptures": {
+        "1": {
+          "name": "comment.block.lua"
+        },
+        "2": {
+          "name": "entity.name.function.lua"
+        },
+        "3": {
+          "name": "comment.block.lua"
+        },
+        "4": {
+          "name": "string.quoted.double.lua"
+        }
+      },
+      "end": "(\\]\\])",
+      "endCaptures": {
+        "1": {
+          "name": "string.quoted.double.lua"
+        }
+      },
+      "patterns": [{ "include": "source.graphql" }]
+    },
+    {
+      "contentName": "meta.embedded.block.graphql",
+      "begin": "(gql)\\(?\\s*(\\[\\[)",
+      "beginCaptures": {
+        "1": {
+          "name": "entity.name.function.lua"
+        },
+        "2": {
+          "name": "string.quoted.double.lua"
+        }
+      },
+      "end": "(\\]\\])",
+      "endCaptures": {
+        "1": {
+          "name": "string.quoted.double.lua"
+        }
+      },
+      "patterns": [{ "include": "source.graphql" }]
+    }
+  ],
+  "scopeName": "inline.graphql.lua"
+}

package/syntaxes/graphql.rb.json

@@ -4,7 +4,7 @@
   "patterns": [
     {
       "contentName": "meta.embedded.block.graphql",
-      "begin": "(?=(?><<[-~](['\"]?)((?:[_\\w]+_|)GRAPHQL)\\b\\1))",
+      "begin": "(?><<[-~](['\"`]?)((?:[_\\w]+_|)GRAPHQL)\\b\\1)",
       "beginCaptures": {
         "0": {
           "name": "punctuation.definition.string.begin.ruby"

package/tsconfig.build.json

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

package/tsconfig.json

@@ -1,12 +1,27 @@
 {
-  "extends": "../../tsconfig.base",
   "compilerOptions": {
     "rootDir": "./src",
-    "outDir": "./lib"
+    "outDir": "./lib",
+    "target": "es2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "removeComments": true,
+    "allowJs": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedParameters": false,
+    "noUnusedLocals": false,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["es2020", "esnext.asynciterable"],
+    "types": ["node", "jest"],
+    "baseUrl": "."
   },
-  "exclude": ["**/__tests__/*", "**/__mocks__/*", "./lib"],
-  "references": [
-    { "path": "../apollo-env" },
-    { "path": "../apollo-language-server" }
-  ]
+  "include": ["./src"],
+  "exclude": ["./lib", "jest.config.ts", "./sampleWorkspace"]
 }

package/create-server-symlink.js

@@ -1,8 +0,0 @@
-const symlinkDir = require("symlink-dir");
-
-symlinkDir(
-  "../apollo-language-server",
-  "./node_modules/apollo-language-server"
-).then(result => {
-  console.log(result);
-});

package/lib/debug.d.ts

@@ -1,11 +0,0 @@
-import { OutputChannel } from "vscode";
-export declare class Debug {
-    private static outputConsole?;
-    static SetOutputConsole(outputConsole: OutputChannel): void;
-    static info(message: string, _stack?: string): void;
-    static error(message: string, stack?: string): void;
-    static warning(message: string, _stack?: string): void;
-    static clear(): void;
-    private static showConsole;
-}
-//# sourceMappingURL=debug.d.ts.map

package/lib/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,aAAa,EAAE,MAAM,QAAQ,CAAC;AAmB1D,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAgB;WAE/B,gBAAgB,CAAC,aAAa,EAAE,aAAa;WAO7C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;WAarC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;WAarC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;WAexC,KAAK;IAMnB,OAAO,CAAC,MAAM,CAAC,WAAW;CAI3B"}