feat: decorator support

Author: j

package.json

@@ -18,7 +18,7 @@
     "postinstall": "node ./dist/postinstall || exit 0"
   },
   "peerDependencies": {
-    "@types/graphql": "^14.0.7",
+    "@types/graphql": "^14.1.1",
     "graphql": "^14.1.1"
   },
   "dependencies": {
@@ -33,9 +33,10 @@
     "tslib": "^1.9.3"
   },
   "devDependencies": {
+    "@apollo/federation": "^0.6.8",
     "@types/express": "^4.16.1",
     "@types/express-graphql": "^0.6.2",
-    "@types/graphql": "^14.0.7",
+    "@types/graphql": "^14.1.1",
     "@types/gulp": "^4.0.6",
     "@types/gulp-replace": "0.0.31",
     "@types/gulp-shell": "0.0.31",

src/decorators/Directive.ts

@@ -0,0 +1,37 @@
+import { MethodAndPropDecorator } from "./types";
+import { SymbolKeysNotSupportedError } from "../errors";
+import { getMetadataStorage } from "../metadata/getMetadataStorage";
+
+export interface DirectiveArgs {
+  [arg: string]: any;
+}
+
+export function Directive(name: string, args?: DirectiveArgs): ClassDecorator;
+export function Directive(name: string, args?: DirectiveArgs): MethodAndPropDecorator;
+export function Directive(
+  name: string,
+  args?: DirectiveArgs,
+): MethodDecorator | PropertyDecorator | ClassDecorator {
+  return (targetOrPrototype, propertyKey, descriptor) => {
+    if (!propertyKey) {
+      getMetadataStorage().collectDirectiveClassMetadata({
+        target: targetOrPrototype as Function,
+        name,
+        args,
+      });
+
+      return;
+    }
+
+    if (typeof propertyKey === "symbol") {
+      throw new SymbolKeysNotSupportedError();
+    }
+
+    getMetadataStorage().collectDirectiveFieldMetadata({
+      target: targetOrPrototype.constructor,
+      field: propertyKey,
+      name,
+      args,
+    });
+  };
+}

src/decorators/ObjectType.ts

@@ -1,6 +1,7 @@
 import { getMetadataStorage } from "../metadata/getMetadataStorage";
 import { getNameDecoratorParams } from "../helpers/decorators";
 import { DescriptionOptions, AbstractClassOptions } from "./types";
+import { ObjectClassMetadata } from "../metadata/definitions/object-class-metdata";
 
 export type ObjectOptions = DescriptionOptions &
   AbstractClassOptions & {

src/decorators/federation.ts

@@ -0,0 +1,29 @@
+import { MethodAndPropDecorator } from "./types";
+import { Directive } from "./Directive";
+
+export interface FieldOptions {
+  fields: string;
+}
+
+export function FederationExtends(): ClassDecorator {
+  return Directive("extends");
+}
+
+export function FederationKey(opts: FieldOptions): ClassDecorator {
+  return Directive("key", opts);
+}
+
+export function FederationExternal(): MethodAndPropDecorator;
+export function FederationExternal(): MethodDecorator | PropertyDecorator {
+  return Directive("external") as MethodDecorator | PropertyDecorator;
+}
+
+export function FederationRequires(opts: FieldOptions): MethodAndPropDecorator;
+export function FederationRequires(opts: FieldOptions): MethodDecorator | PropertyDecorator {
+  return Directive("requires", opts) as MethodDecorator | PropertyDecorator;
+}
+
+export function FederationProvides(opts: FieldOptions): MethodAndPropDecorator;
+export function FederationProvides(opts: FieldOptions): MethodDecorator | PropertyDecorator {
+  return Directive("provides", opts) as MethodDecorator | PropertyDecorator;
+}

src/decorators/index.ts

@@ -20,3 +20,4 @@ export { Root } from "./Root";
 export { Subscription } from "./Subscription";
 export { createUnionType } from "./unions";
 export { UseMiddleware } from "./UseMiddleware";
+export * from "./federation";

src/metadata/definitions/class-metadata.ts

@@ -1,9 +1,11 @@
 import { FieldMetadata } from "./field-metadata";
+import { DirectiveClassMetadata } from "./directive-metadata";
 
 export interface ClassMetadata {
   name: string;
   target: Function;
   fields?: FieldMetadata[];
   description?: string;
   isAbstract?: boolean;
+  directives?: DirectiveClassMetadata[];
 }

src/metadata/definitions/directive-metadata.ts

@@ -0,0 +1,7 @@
+export interface DirectiveMetadata {
+  name: string;
+  args?: { [key: string]: any };
+}
+
+export type DirectiveClassMetadata = DirectiveMetadata & { target: Function };
+export type DirectiveFieldMetadata = DirectiveMetadata & { target: Function; field: string };

src/metadata/definitions/field-metadata.ts

@@ -2,6 +2,7 @@ import { ParamMetadata } from "./param-metadata";
 import { TypeValueThunk, TypeOptions } from "../../decorators/types";
 import { Middleware } from "../../interfaces/Middleware";
 import { Complexity } from "../../interfaces";
+import { DirectiveFieldMetadata } from "./directive-metadata";
 
 export interface FieldMetadata {
   target: Function;
@@ -15,4 +16,5 @@ export interface FieldMetadata {
   params?: ParamMetadata[];
   roles?: any[];
   middlewares?: Array<Middleware<any>>;
+  directives?: DirectiveFieldMetadata[];
 }

src/metadata/metadata-storage.ts

@@ -23,6 +23,7 @@ import {
 } from "./utils";
 import { ObjectClassMetadata } from "./definitions/object-class-metdata";
 import { InterfaceClassMetadata } from "./definitions/interface-class-metadata";
+import { DirectiveClassMetadata, DirectiveFieldMetadata } from "./definitions/directive-metadata";
 
 export class MetadataStorage {
   queries: ResolverMetadata[] = [];
@@ -37,6 +38,8 @@ export class MetadataStorage {
   enums: EnumMetadata[] = [];
   unions: UnionMetadataWithSymbol[] = [];
   middlewares: MiddlewareMetadata[] = [];
+  classDirectives: DirectiveClassMetadata[] = [];
+  fieldDirectives: DirectiveFieldMetadata[] = [];
 
   private resolverClasses: ResolverClassMetadata[] = [];
   private fields: FieldMetadata[] = [];
@@ -98,6 +101,13 @@ export class MetadataStorage {
     this.params.push(definition);
   }
 
+  collectDirectiveClassMetadata(definition: DirectiveClassMetadata) {
+    this.classDirectives.push(definition);
+  }
+  collectDirectiveFieldMetadata(definition: DirectiveFieldMetadata) {
+    this.fieldDirectives.push(definition);
+  }
+
   build() {
     // TODO: disable next build attempts
 
@@ -134,7 +144,7 @@ export class MetadataStorage {
     this.params = [];
   }
 
-  private buildClassMetadata(definitions: ClassMetadata[]) {
+  private buildClassMetadata(definitions: ClassMetadata[], withFederation: boolean = false) {
     definitions.forEach(def => {
       const fields = this.fields.filter(field => field.target === def.target);
       fields.forEach(field => {
@@ -147,8 +157,10 @@ export class MetadataStorage {
             middleware => middleware.target === field.target && middleware.fieldName === field.name,
           ),
         );
+        field.directives = this.findFieldDirectives(field.target, field.name);
       });
       def.fields = fields;
+      def.directives = this.findClassDirectives(def.target);
     });
   }
 
@@ -253,4 +265,15 @@ export class MetadataStorage {
     }
     return authorizedField.roles;
   }
+
+  private findClassDirectives(target: ClassMetadata["target"]): DirectiveClassMetadata[] {
+    return this.classDirectives.filter(it => it.target === target);
+  }
+
+  private findFieldDirectives(
+    target: FieldMetadata["target"],
+    name: FieldMetadata["name"],
+  ): DirectiveFieldMetadata[] {
+    return this.fieldDirectives.filter(field => field.target === target && field.field === name);
+  }
 }

src/schema/schema-generator.ts

@@ -15,6 +15,14 @@ import {
   GraphQLEnumValueConfigMap,
   GraphQLUnionType,
   GraphQLTypeResolver,
+  GraphQLDirective,
+  GraphQLNonNull,
+  DirectiveNode,
+  ObjectTypeExtensionNode,
+  ObjectTypeDefinitionNode,
+  FieldDefinitionNode,
+  specifiedDirectives,
+  ArgumentNode,
 } from "graphql";
 import { withFilter, ResolverFn } from "graphql-subscriptions";
 
@@ -40,9 +48,13 @@ import {
   ConflictingDefaultValuesError,
   InterfaceResolveTypeError,
 } from "../errors";
-import { ResolverFilterData, ResolverTopicData, TypeResolver } from "../interfaces";
+import { ResolverFilterData, ResolverTopicData, TypeResolver, Maybe } from "../interfaces";
 import { getFieldMetadataFromInputType, getFieldMetadataFromObjectType } from "./utils";
 import { ensureInstalledCorrectGraphQLPackage } from "../utils/graphql-version";
+import {
+  DirectiveClassMetadata,
+  DirectiveFieldMetadata,
+} from "../metadata/definitions/directive-metadata";
 
 interface AbstractInfo {
   isAbstract: boolean;
@@ -73,6 +85,7 @@ export interface SchemaGeneratorOptions extends BuildContextOptions {
    * Disable checking on build the correctness of a schema
    */
   skipCheck?: boolean;
+  directives?: GraphQLDirective[];
 }
 
 export abstract class SchemaGenerator {
@@ -104,6 +117,7 @@ export abstract class SchemaGenerator {
       mutation: this.buildRootMutationType(),
       subscription: this.buildRootSubscriptionType(),
       types: this.buildOtherTypes(),
+      directives: options.directives,
     });
 
     BuildContext.reset();
@@ -255,12 +269,66 @@ export abstract class SchemaGenerator {
         return superClassTypeInfo ? superClassTypeInfo.type : undefined;
       };
       const interfaceClasses = objectType.interfaceClasses || [];
+
+      const classDirectiveAstNodes = (
+        name: string,
+        classMetas?: DirectiveClassMetadata[],
+      ): ObjectTypeDefinitionNode | undefined => {
+        if (!classMetas || !classMetas.length) {
+          return;
+        }
+
+        const directives: DirectiveNode[] = classMetas.map(meta =>
+          this.createDirective(meta.name, meta.args),
+        );
+
+        return {
+          kind: "ObjectTypeDefinition",
+          name: {
+            kind: "Name",
+            value: name,
+          },
+          interfaces: [],
+          directives,
+        };
+      };
+
+      const fieldDirectiveAstNodes = (
+        name: string,
+        fieldMetas?: DirectiveFieldMetadata[],
+      ): FieldDefinitionNode | undefined => {
+        if (!fieldMetas || !fieldMetas.length) {
+          return;
+        }
+
+        const directives: DirectiveNode[] = fieldMetas.map(meta =>
+          this.createDirective(meta.name, meta.args),
+        );
+
+        return {
+          kind: "FieldDefinition",
+          type: {
+            kind: "NamedType",
+            name: {
+              kind: "Name",
+              value: name,
+            },
+          },
+          name: {
+            kind: "Name",
+            value: name,
+          },
+          directives,
+        };
+      };
+
       return {
         target: objectType.target,
         isAbstract: objectType.isAbstract || false,
         type: new GraphQLObjectType({
           name: objectType.name,
           description: objectType.description,
+          astNode: classDirectiveAstNodes(objectType.name, objectType.directives),
           interfaces: () => {
             let interfaces = interfaceClasses.map<GraphQLInterfaceType>(
               interfaceClass =>
@@ -295,6 +363,7 @@ export abstract class SchemaGenerator {
                     : createSimpleFieldResolver(field),
                   description: field.description,
                   deprecationReason: field.deprecationReason,
+                  astNode: fieldDirectiveAstNodes(field.name, field.directives),
                 };
                 return fieldsMap;
               },
@@ -604,4 +673,34 @@ export abstract class SchemaGenerator {
       return this.objectTypesInfo.find(objectType => objectType.target === resolvedType)!.type;
     };
   }
+
+  private static createDirective(name: string, args?: { [name: string]: any }): DirectiveNode {
+    const directiveArguments: ArgumentNode[] = [];
+
+    if (args) {
+      Object.keys(args).forEach(arg => {
+        directiveArguments.push({
+          kind: "Argument",
+          name: {
+            kind: "Name",
+            value: arg,
+          },
+          value: {
+            kind: "StringValue",
+            value: args[arg],
+            block: false,
+          },
+        });
+      });
+    }
+
+    return {
+      kind: "Directive",
+      name: {
+        kind: "Name",
+        value: name,
+      },
+      arguments: directiveArguments,
+    };
+  }
 }