Feature - Refactoring more decorators

src/decorator.ts

@@ -3,17 +3,13 @@ import 'reflect-metadata';
 import * as graphql from 'graphql';
 
 import { GraphQLType } from 'graphql';
-import { IoCContainer } from './ioc-container';
 import { OrderByTypeFactory } from './order-by.type-factory';
 import { PageInfo } from './page-info.type';
 import { PaginationResponse } from './pagination.type';
 
 export * from './decorator/';
 export * from './metadata/options';
 
-export const GQ_QUERY_KEY = 'gq_query';
-export const GQ_MUTATION_KEY = 'gq_mutation';
-export const GQ_SUBSCRIPTION_KEY = 'gq_subscription';
 export const GQ_FIELDS_KEY = 'gq_fields';
 export const GQ_DESCRIPTION_KEY = 'gq_description';
 
@@ -403,82 +399,3 @@ export function Description(body: string) {
     } as Function;
 }
 
-export function Query(option?: DefaultOption) {
-    return function (target: any, propertyKey: any) {
-        if (Reflect.hasMetadata(GQ_QUERY_KEY, target)) {
-            let metadata = Reflect.getMetadata(GQ_QUERY_KEY, target);
-            metadata.push(propertyKey);
-            Reflect.defineMetadata(GQ_QUERY_KEY, metadata, target);
-        } else {
-            Reflect.defineMetadata(GQ_QUERY_KEY, [propertyKey], target);
-        }
-
-        if (option) {
-            // description
-            if (option.description) {
-                setDescriptionMetadata(option.description, target, propertyKey);
-            }
-        }
-
-    } as Function;
-}
-
-export function Mutation(option?: DefaultOption) {
-    return function (target: any, propertyKey: any) {
-        if (Reflect.hasMetadata(GQ_MUTATION_KEY, target)) {
-            let metadata = Reflect.getMetadata(GQ_MUTATION_KEY, target);
-            metadata.push(propertyKey);
-            Reflect.defineMetadata(GQ_MUTATION_KEY, metadata, target);
-        } else {
-            Reflect.defineMetadata(GQ_MUTATION_KEY, [propertyKey], target);
-        }
-
-        if (option) {
-            // description
-            if (option.description) {
-                setDescriptionMetadata(option.description, target, propertyKey);
-            }
-        }
-
-    } as Function;
-}
-
-export function Subscription(option?: DefaultOption) {
-    return function (target: any, propertyKey: any) {
-        if (Reflect.hasMetadata(GQ_SUBSCRIPTION_KEY, target)) {
-            let metadata = Reflect.getMetadata(GQ_SUBSCRIPTION_KEY, target);
-            metadata.push(propertyKey);
-            Reflect.defineMetadata(GQ_SUBSCRIPTION_KEY, metadata, target);
-        } else {
-            Reflect.defineMetadata(GQ_SUBSCRIPTION_KEY, [propertyKey], target);
-        }
-
-        if (option) {
-            // description
-            if (option.description) {
-                setDescriptionMetadata(option.description, target, propertyKey);
-            }
-        }
-
-    } as Function;
-}
-
-export function Schema(option?: SchemaOption) {
-    return function (target: Function) {
-        Reflect.defineMetadata('gq_schema', {}, target);
-
-        if (option) {
-            // description
-            if (option.description) {
-                setDescriptionMetadata(option.description, target);
-            }
-        }
-    } as Function;
-}
-
-export function UseContainer(container: any) {
-    return function (target: Function) {
-        IoCContainer.INSTANCE = container;
-    };
-}
-

src/decorator/entry-type.decorator.ts

@@ -0,0 +1,39 @@
+import { QueryOption, MutationOption, SubscriptionOption, EntryTypeOption } from '../metadata/options';
+import { EntryType } from '../metadata/args';
+import { getMetadataArgsStorage } from '../metadata-builder';
+
+/**
+ * It is used to create a root {@link GraphQLObjectType} object as a schema Query
+ * See [GraphQL Documentation - Queries and Mutations]{@http://graphql.org/learn/schema/#the-query-and-mutation-types}
+ */
+export function Query(option?: QueryOption) {
+  return entry(EntryType.Query, option);
+}
+
+/**
+ * It is used to create a root {@link GraphQLObjectType} object as a schema Mutation
+ * See [GraphQL Documentation - Queries and Mutations]{@http://graphql.org/learn/schema/#the-query-and-mutation-types}
+ */
+export function Mutation(option?: MutationOption) {
+  return entry(EntryType.Mutation, option);
+}
+
+/**
+ * It is used to create a root {@link GraphQLObjectType} object as a schema Subscription
+ * See [GraphQL Blog - Subscriptions in GraphQL and Relay]{@http://graphql.org/blog/subscriptions-in-graphql-and-relay/}
+ */
+export function Subscription(option?: SubscriptionOption) {
+  return entry(EntryType.Subscription, option);
+}
+
+function entry(type: EntryType, option?: EntryTypeOption) {
+    return function (target: any, propertyKey: any) {
+      getMetadataArgsStorage().entries.push({
+        target: target,
+        name: target.name,
+        description: option ? option.description : null,
+        property: propertyKey,
+        type: type,
+      });
+    };
+}

src/decorator/index.ts

@@ -1,3 +1,6 @@
 export * from './enum-type.decorator';
 export * from './union-type.decorator';
 export * from './object-type.decorator';
+export * from './entry-type.decorator';
+export * from './schema.decorator';
+export * from './use-container.decorator';

src/decorator/schema.decorator.ts

@@ -0,0 +1,18 @@
+import { getMetadataArgsStorage } from '../metadata-builder';
+import { SchemaOption } from '../metadata';
+
+/**
+ * GraphQL Schema entry point
+ * See [GraphQL Documentation - Schema]{@link http://graphql.org/learn/schema/}
+ *
+ * @param option Options for an Schema
+ */
+export function Schema(option?: SchemaOption) {
+  return function (target: any) {
+    getMetadataArgsStorage().schemas.push({
+          target: target,
+          name: target.name,
+          description: option ? option.description : null,
+      });
+  } as Function;
+}

src/decorator/use-container.decorator.ts

@@ -0,0 +1,11 @@
+import { IoCContainer } from '../ioc-container';
+
+/**
+ *  Sets the IoC container to be used in order to instantiate the decorated class
+ * @param container a [typedi]{@link https://github.com/pleerock/typedi} container
+ */
+export function UseContainer(container: any) {
+  return function (target: Function) {
+      IoCContainer.INSTANCE = container;
+  };
+}

src/field_type_factory.ts

@@ -11,7 +11,7 @@ import {
 } from './decorator';
 import { getMetadataArgsStorage } from './metadata-builder';
 
-import { SchemaFactoryError, SchemaFactoryErrorType } from './schema_factory';
+import { SchemaFactoryError, SchemaFactoryErrorType } from './type-factory';
 
 import { IoCContainer } from './ioc-container';
 import { OrderByTypeFactory } from './order-by.type-factory';

src/index.ts

@@ -1,4 +1,4 @@
 export * from './decorator';
-export { schemaFactory } from './schema_factory';
+export { schemaFactory } from './type-factory';
 export * from './order-by-item';
 export * from './pagination.type';

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

@@ -1,8 +1,11 @@
 import {
   EnumTypeArg,
   EnumValueArg,
-  UnionTypeArgs,
+  UnionTypeArg,
   ObjectTypeArg,
+  EntryTypeArg,
+  EntryType,
+  SchemaArg,
 } from '../metadata/args';
 
 /**
@@ -20,8 +23,10 @@ export function getMetadataArgsStorage(): MetadataArgsStorage {
 export class MetadataArgsStorage {
   enums: EnumTypeArg[] = [];
   enumValues: EnumValueArg[] = [];
-  union: UnionTypeArgs[] = [];
+  union: UnionTypeArg[] = [];
   objects: ObjectTypeArg[] = [];
+  entries: EntryTypeArg[] = [];
+  schemas: SchemaArg[] = [];
 
   filterEnumsByClass(target: any): EnumTypeArg[] {
     return this.enums.filter(item => item.target === target);
@@ -31,12 +36,20 @@ export class MetadataArgsStorage {
     return this.enumValues.filter(item => item.target === target.prototype);
   }
 
-  filterUnionTypeByClass(target: any): UnionTypeArgs[] {
+  filterUnionTypeByClass(target: any): UnionTypeArg[] {
     return this.union.filter(item => item.target === target);
   }
 
   filterObjectTypeByClass(target: any): ObjectTypeArg[] {
     return this.objects.filter(item => item.target === target);
   }
+
+  filterEntryTypesByClassAndType(target: any, type: EntryType): EntryTypeArg[] {
+    return this.entries.filter(item => item.target === target.prototype && item.type === type);
+  }
+
+  filterSchemaByClass(target: any): SchemaArg[] {
+    return this.schemas.filter(item => item.target === target);
+  }
 }
 

src/metadata-builder/metadata.builder.ts

@@ -1,10 +1,13 @@
 import {
+  EntryTypeMetadata,
   EnumTypeMetadata,
   EnumValueMetadata,
-  UnionTypeMetadata,
   ObjectTypeMetadata,
+  SchemaMetadata,
+  UnionTypeMetadata,
 } from '../metadata/types';
 
+import { EntryType } from '../metadata/args';
 import { getMetadataArgsStorage } from './metadata-args.storage';
 
 /**
@@ -55,6 +58,28 @@ export class MetadataBuilder {
       }));
   }
 
+  buildEntryTypeMetadata(target: any, type: EntryType): EntryTypeMetadata[] | undefined {
+    return getMetadataArgsStorage()
+      .filterEntryTypesByClassAndType(target, type)
+      .map(queryArg => ({
+        target: queryArg.target,
+        name: queryArg.name,
+        description: queryArg.description,
+        property: queryArg.property,
+        isSubscription: type === EntryType.Subscription,
+      }));
+  }
+
+  buildSchemaMetadata(target: any): SchemaMetadata[] | undefined {
+    return getMetadataArgsStorage()
+      .filterSchemaByClass(target)
+      .map(queryArg => ({
+        target: queryArg.target,
+        name: queryArg.name,
+        description: queryArg.description,
+      }));
+  }
+
   protected buildEnumValueMetadata(target: any): EnumValueMetadata[] | undefined {
     return getMetadataArgsStorage()
       .filterEnumValuesByClass(target)

src/metadata/args/default.arg.ts

@@ -0,0 +1,5 @@
+export interface DefaultArg {
+  target: any;
+  name: string;
+  description?: string;
+}

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

@@ -0,0 +1,12 @@
+import { DefaultArg } from './default.arg';
+
+export enum EntryType {
+  Query         = <any>'Query',
+  Mutation      = <any>'Mutation',
+  Subscription  = <any>'Subscription',
+}
+
+export interface EntryTypeArg extends DefaultArg {
+  type: EntryType;
+  property: string;
+}

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

@@ -1,13 +1,8 @@
-export interface EnumTypeArg {
-  target: any;
-  name: string;
-  description?: string;
-}
+import { DefaultArg } from './default.arg';
+
+export interface EnumTypeArg extends DefaultArg { }
 
-export interface EnumValueArg {
-  target: any;
-  name: string;
-  description?: string;
+export interface EnumValueArg extends DefaultArg {
   value: any;
 }
 

src/metadata/args/index.ts

@@ -1,3 +1,5 @@
 export * from './enum-type.arg';
 export * from './union-type.arg';
 export * from './object-type.arg';
+export * from './entry-type.arg';
+export * from './schema.arg';

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

@@ -1,6 +1,5 @@
-export interface ObjectTypeArg {
-  target: any;
-  name: string;
-  description?: string;
+import { DefaultArg } from './default.arg';
+
+export interface ObjectTypeArg extends DefaultArg {
   isInput: boolean;
 }

src/metadata/args/schema.arg.ts

@@ -0,0 +1,3 @@
+import { DefaultArg } from './default.arg';
+
+export interface SchemaArg extends DefaultArg { }

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

@@ -1,7 +1,6 @@
-export interface UnionTypeArgs {
-  target: any;
-  name: string;
+import { DefaultArg } from './default.arg';
+
+export interface UnionTypeArg extends DefaultArg {
   types: any[];
-  description?: string;
   resolver: (obj: any, context: any, info: any) => Promise<string> | string | null;
 }

src/metadata/options/default.option.ts

@@ -0,0 +1,6 @@
+export interface DefaultOption {
+  /**
+   * (Optional) Description
+   */
+  description?: string;
+}

src/metadata/options/entry.option.ts

@@ -0,0 +1,18 @@
+import { DefaultOption } from './default.option';
+
+export interface EntryTypeOption extends DefaultOption { }
+
+/**
+ * Arguments for a {@link Query} type on graphql schema
+ */
+export interface QueryOption extends EntryTypeOption { }
+
+/**
+ * Arguments for a {@link Mutation} type on graphql schema
+ */
+export interface MutationOption extends EntryTypeOption { }
+
+/**
+ * Arguments for a {@link Subscription} type on graphql schema
+ */
+export interface SubscriptionOption extends EntryTypeOption { }

src/metadata/options/enum.option.ts

@@ -1,15 +1,11 @@
+import { DefaultOption } from './default.option';
+
 /**
  * Arguments for an Enum type on graphql schema
  */
-export interface EnumOption {
-  /**
-   * (Optional) Description
-   */
-  description?: string;
-}
+export interface EnumOption extends DefaultOption { }
 
 /**
  * Arguments for an Enum value on graphql schema
  */
-export interface EnumValueOption extends EnumOption {
-}
+export interface EnumValueOption extends DefaultOption { }