Initial commit for @interface decorator

Author: felipesabino

src/array.utils.ts

@@ -0,0 +1,25 @@
+/**
+ * Concats two arrays
+ * @param itemsA fist array argument
+ * @param itemsB second array argument
+ */
+export const concat = (itemsA: any[], itemsB: any[]) => itemsA.concat(itemsB);
+
+/**
+ * Executes a flatMap modifier function to each elements of the array
+ * @param λ the flatMap function
+ * @param collection the array to apply the flatMap funtion to
+ */
+export const flatMap = (λ: (item: any) => any, collection: any[]) => collection.map(λ).reduce(concat, []);
+
+/**
+ * Flattens an array with nested arrays
+ * @param collection the array argument
+ */
+export const flatten = (collection: any[]) => flatMap(items => {
+  if (items.constructor === Array) {
+    return flatMap(item => item, items);
+  } else {
+    return items;
+  }
+}, collection);

src/decorator/index.ts

@@ -8,3 +8,4 @@ export * from './context.decorator';
 export * from './field.decorator';
 export * from './order-by.decorator';
 export * from './before.decorator';
+export * from './interface-type.decorator';

src/decorator/interface-type.decorator.ts

@@ -0,0 +1,19 @@
+import { getMetadataArgsStorage } from '../metadata-builder';
+import { InterfaceOption } from '../index';
+
+/**
+ * Union Type.
+ * See [GraphQL Documentation - Union Types]{@link http://graphql.org/learn/schema/#union-types}
+ *
+ * @param option Options for an Union Type
+ */
+export function InterfaceType<T>(option: InterfaceOption<T>) {
+  return function (target: any) {
+    getMetadataArgsStorage().interfaces.push({
+      target: target,
+      name: target.name,
+      resolver: option.resolver,
+      description: option.description,
+    });
+  } as Function;
+}

src/decorator/object-type.decorator.ts

@@ -1,3 +1,5 @@
+import { SchemaFactoryError, SchemaFactoryErrorType } from '../type-factory';
+
 import { ObjectOption } from '../metadata/options';
 import { getMetadataArgsStorage } from '../metadata-builder';
 
@@ -23,11 +25,20 @@ export function InputObjectType(option?: ObjectOption) {
 
 function CreateObjectType(isInput: boolean, option?: ObjectOption) {
   return function (target: any) {
+
+    if (isInput && option && option.interfaces) {
+      throw new SchemaFactoryError(`Input types are not allowed to have interfaces: '${target.name}'`,
+        SchemaFactoryErrorType.INPUT_FIELD_SHOULD_NOT_HAVE_INTERFACE);
+    }
+
     getMetadataArgsStorage().objects.push({
       target: target,
       name: target.name,
       description: option ? option.description : null,
       isInput: isInput,
+      interfaces: option && option.interfaces ? (
+        option.interfaces.constructor !== Array ? [option.interfaces as Function] : option.interfaces as Function[]
+      ) : [],
     });
   };
 }

src/metadata-builder/metadata-args.storage.ts

@@ -12,6 +12,7 @@ import {
   RootArg,
   SchemaArg,
   UnionTypeArg,
+  InterfaceTypeArg,
 } from '../metadata/args';
 
 import { MetadataUtils } from './metadata.utils';
@@ -29,6 +30,7 @@ export class MetadataArgsStorage {
   roots: RootArg[] = [];
   orderBys: OrderByArg[] = [];
   befores: BeforeArg[] = [];
+  interfaces: InterfaceTypeArg[] = [];
 
   filterEnumsByClass(target: any): EnumTypeArg[] {
     return this.enums.filter(item => item.target === target);
@@ -42,6 +44,10 @@ export class MetadataArgsStorage {
     return this.union.filter(item => item.target === target);
   }
 
+  filterInterfaceTypeByClass(target: any): InterfaceTypeArg[] {
+    return this.interfaces.filter(item => item.target === target);
+  }
+
   filterObjectTypeByClass(target: any): ObjectTypeArg[] {
     return this.objects.filter(item => item.target === target);
   }

src/metadata-builder/metadata.builder.ts

@@ -11,6 +11,7 @@ import {
   RootMetadata,
   SchemaMetadata,
   UnionTypeMetadata,
+  InterfaceTypeMetadata,
 } from '../metadata/types';
 
 import { EntryType } from '../metadata/args';
@@ -41,6 +42,17 @@ export class MetadataBuilder {
       }));
   }
 
+  buildInterfaceTypeMetadata(target: any): InterfaceTypeMetadata[] | undefined {
+    return getMetadataArgsStorage()
+      .filterInterfaceTypeByClass(target)
+      .map(arg => ({
+        target: arg.target,
+        name: arg.name,
+        resolver: arg.resolver,
+        description: arg.description,
+      }));
+  }
+
   buildObjectTypeMetadata(target: any): ObjectTypeMetadata[] | undefined {
     return getMetadataArgsStorage()
       .filterObjectTypeByClass(target)
@@ -49,6 +61,7 @@ export class MetadataBuilder {
         name: arg.name,
         description: arg.description,
         isInput: arg.isInput,
+        interfaces: Array.prototype.concat.apply([], arg.interfaces.map(this.buildInterfaceTypeMetadata)),
       }));
   }
 

src/metadata/args/index.ts

@@ -9,3 +9,4 @@ export * from './context.arg';
 export * from './root.arg';
 export * from './order-by.arg';
 export * from './before.arg';
+export * from './interface-type.arg';

src/metadata/args/interface-type.arg.ts

@@ -0,0 +1,5 @@
+import { Argument } from './argument';
+
+export interface InterfaceTypeArg extends Argument {
+  resolver: (obj: any, context: any, info: any) => Promise<string> | string | null;
+}

src/metadata/args/object-type.arg.ts

@@ -2,4 +2,5 @@ import { Argument } from './argument';
 
 export interface ObjectTypeArg extends Argument {
   isInput: boolean;
+  interfaces: Function[];
 }

src/metadata/options/index.ts

@@ -7,3 +7,4 @@ export * from './field.option';
 export * from './argument.option';
 export * from './order-by.option';
 export * from './before.option';
+export * from './interface.option';