Add Extensions metadata Decorator

src/decorators/Extensions.ts

@@ -0,0 +1,28 @@
+import { MethodAndPropDecorator } from "./types";
+import { SymbolKeysNotSupportedError } from "../errors";
+import { getMetadataStorage } from "../metadata/getMetadataStorage";
+
+export function Extensions(
+  extensions: Record<string, any>,
+): MethodAndPropDecorator & ClassDecorator;
+export function Extensions(
+  extensions: Record<string, any>,
+): MethodDecorator | PropertyDecorator | ClassDecorator {
+  return (targetOrPrototype, propertyKey, descriptor) => {
+    if (typeof propertyKey === "symbol") {
+      throw new SymbolKeysNotSupportedError();
+    }
+    if (propertyKey) {
+      getMetadataStorage().collectExtensionsFieldMetadata({
+        target: targetOrPrototype.constructor,
+        fieldName: propertyKey,
+        extensions,
+      });
+    } else {
+      getMetadataStorage().collectExtensionsClassMetadata({
+        target: targetOrPrototype as Function,
+        extensions,
+      });
+    }
+  };
+}

src/decorators/index.ts

@@ -6,6 +6,7 @@ export { createParamDecorator } from "./createParamDecorator";
 export { createMethodDecorator } from "./createMethodDecorator";
 export { Ctx } from "./Ctx";
 export { Directive } from "./Directive";
+export { Extensions } from "./Extensions";
 export { registerEnumType } from "./enums";
 export { Field, FieldOptions } from "./Field";
 export { FieldResolver } from "./FieldResolver";

src/metadata/definitions/class-metadata.ts

@@ -8,5 +8,6 @@ export interface ClassMetadata {
   description?: string;
   isAbstract?: boolean;
   directives?: DirectiveMetadata[];
+  extensions?: Record<string, any>;
   simpleResolvers?: boolean;
 }

src/metadata/definitions/extensions-metadata.ts

@@ -0,0 +1,10 @@
+export interface ExtensionsClassMetadata {
+  target: Function;
+  extensions: Record<string, any>;
+}
+
+export interface ExtensionsFieldMetadata {
+  target: Function;
+  fieldName: string;
+  extensions: Record<string, any>;
+}

src/metadata/definitions/field-metadata.ts

@@ -17,5 +17,6 @@ export interface FieldMetadata {
   roles?: any[];
   middlewares?: Array<Middleware<any>>;
   directives?: DirectiveMetadata[];
+  extensions?: Record<string, any>;
   simple?: boolean;
 }

src/metadata/definitions/index.ts

@@ -2,6 +2,7 @@ export * from "./authorized-metadata";
 export * from "./class-metadata";
 export * from "./directive-metadata";
 export * from "./enum-metadata";
+export * from "./extensions-metadata";
 export * from "./field-metadata";
 export * from "./middleware-metadata";
 export * from "./param-metadata";

src/metadata/definitions/resolver-metadata.ts

@@ -22,6 +22,7 @@ export interface BaseResolverMetadata {
   roles?: any[];
   middlewares?: Array<Middleware<any>>;
   directives?: DirectiveMetadata[];
+  extensions?: Record<string, any>;
 }
 
 export interface ResolverMetadata extends BaseResolverMetadata {

src/metadata/metadata-storage.ts

@@ -1,6 +1,8 @@
 import {
   ResolverMetadata,
   ClassMetadata,
+  ExtensionsClassMetadata,
+  ExtensionsFieldMetadata,
   FieldMetadata,
   ParamMetadata,
   FieldResolverMetadata,
@@ -20,6 +22,7 @@ import {
   mapMiddlewareMetadataToArray,
   mapSuperFieldResolverHandlers,
   ensureReflectMetadataExists,
+  flattenExtensions,
 } from "./utils";
 import { ObjectClassMetadata } from "./definitions/object-class-metdata";
 import { InterfaceClassMetadata } from "./definitions/interface-class-metadata";
@@ -40,6 +43,8 @@ export class MetadataStorage {
   middlewares: MiddlewareMetadata[] = [];
   classDirectives: DirectiveClassMetadata[] = [];
   fieldDirectives: DirectiveFieldMetadata[] = [];
+  classExtensions: ExtensionsClassMetadata[] = [];
+  fieldExtensions: ExtensionsFieldMetadata[] = [];
 
   private resolverClasses: ResolverClassMetadata[] = [];
   private fields: FieldMetadata[] = [];
@@ -108,11 +113,20 @@ export class MetadataStorage {
     this.fieldDirectives.push(definition);
   }
 
+  collectExtensionsClassMetadata(definition: ExtensionsClassMetadata) {
+    this.classExtensions.push(definition);
+  }
+  collectExtensionsFieldMetadata(definition: ExtensionsFieldMetadata) {
+    this.fieldExtensions.push(definition);
+  }
+
   build() {
     // TODO: disable next build attempts
 
     this.classDirectives.reverse();
     this.fieldDirectives.reverse();
+    this.classExtensions.reverse();
+    this.fieldExtensions.reverse();
 
     this.buildClassMetadata(this.objectTypes);
     this.buildClassMetadata(this.inputTypes);
@@ -143,6 +157,8 @@ export class MetadataStorage {
     this.middlewares = [];
     this.classDirectives = [];
     this.fieldDirectives = [];
+    this.classExtensions = [];
+    this.fieldExtensions = [];
 
     this.resolverClasses = [];
     this.fields = [];
@@ -167,6 +183,7 @@ export class MetadataStorage {
           field.directives = this.fieldDirectives
             .filter(it => it.target === field.target && it.fieldName === field.name)
             .map(it => it.directive);
+          field.extensions = this.findFieldExtensions(field.target, field.name);
         });
         def.fields = fields;
       }
@@ -175,6 +192,9 @@ export class MetadataStorage {
           .filter(it => it.target === def.target)
           .map(it => it.directive);
       }
+      if (!def.extensions) {
+        def.extensions = this.findClassExtensions(def.target);
+      }
     });
   }
 
@@ -196,6 +216,7 @@ export class MetadataStorage {
       def.directives = this.fieldDirectives
         .filter(it => it.target === def.target && it.fieldName === def.methodName)
         .map(it => it.directive);
+      def.extensions = this.findFieldExtensions(def.target, def.methodName);
     });
   }
 
@@ -206,6 +227,7 @@ export class MetadataStorage {
       def.directives = this.fieldDirectives
         .filter(it => it.target === def.target && it.fieldName === def.methodName)
         .map(it => it.directive);
+      def.extensions = this.findFieldExtensions(def.target, def.methodName);
       def.getObjectType =
         def.kind === "external"
           ? this.resolverClasses.find(resolver => resolver.target === def.target)!.getObjectType
@@ -236,6 +258,7 @@ export class MetadataStorage {
             middlewares: def.middlewares!,
             params: def.params!,
             directives: def.directives,
+            extensions: def.extensions,
           };
           this.collectClassFieldMetadata(fieldMetadata);
           objectType.fields!.push(fieldMetadata);
@@ -286,4 +309,16 @@ export class MetadataStorage {
     }
     return authorizedField.roles;
   }
+
+  private findClassExtensions(target: Function): Record<string, any> {
+    return this.classExtensions
+      .filter(entry => entry.target === target)
+      .reduce(flattenExtensions, {});
+  }
+
+  private findFieldExtensions(target: Function, fieldName: string): Record<string, any> {
+    return this.fieldExtensions
+      .filter(entry => entry.target === target && entry.fieldName === fieldName)
+      .reduce(flattenExtensions, {});
+  }
 }

src/metadata/utils.ts

@@ -3,6 +3,8 @@ import {
   BaseResolverMetadata,
   MiddlewareMetadata,
   FieldResolverMetadata,
+  ExtensionsClassMetadata,
+  ExtensionsFieldMetadata,
 } from "./definitions";
 import { Middleware } from "../interfaces/Middleware";
 import { isThrowing } from "../helpers/isThrowing";
@@ -57,3 +59,10 @@ export function ensureReflectMetadataExists() {
     throw new ReflectMetadataMissingError();
   }
 }
+
+export function flattenExtensions(
+  extensions: Record<string, any>,
+  entry: ExtensionsClassMetadata | ExtensionsFieldMetadata,
+): Record<string, any> {
+  return { ...extensions, ...entry.extensions };
+}

src/schema/schema-generator.ts

@@ -282,6 +282,7 @@ export abstract class SchemaGenerator {
           name: objectType.name,
           description: objectType.description,
           astNode: getObjectTypeDefinitionNode(objectType.name, objectType.directives),
+          extensions: objectType.extensions,
           interfaces: () => {
             let interfaces = interfaceClasses.map<GraphQLInterfaceType>(
               interfaceClass =>
@@ -331,6 +332,7 @@ export abstract class SchemaGenerator {
                   astNode: getFieldDefinitionNode(field.name, type, field.directives),
                   extensions: {
                     complexity: field.complexity,
+                    ...field.extensions,
                   },
                 };
                 return fieldsMap;
@@ -379,6 +381,7 @@ export abstract class SchemaGenerator {
         type: new GraphQLInputObjectType({
           name: inputType.name,
           description: inputType.description,
+          extensions: inputType.extensions,
           fields: () => {
             let fields = inputType.fields!.reduce<GraphQLInputFieldConfigMap>(
               (fieldsMap, field) => {
@@ -399,6 +402,7 @@ export abstract class SchemaGenerator {
                   type,
                   defaultValue: field.typeOptions.defaultValue,
                   astNode: getInputValueDefinitionNode(field.name, type, field.directives),
+                  extensions: field.extensions,
                 };
                 return fieldsMap;
               },
@@ -498,6 +502,7 @@ export abstract class SchemaGenerator {
         astNode: getFieldDefinitionNode(handler.schemaName, type, handler.directives),
         extensions: {
           complexity: handler.complexity,
+          ...handler.extensions,
         },
       };
       return fields;