Adding ability to add custom sort params to @OrderBy params

src/decorator.ts

@@ -26,6 +26,7 @@ export interface TypeMetadata {
     isPagination?: boolean;
     explicitType?: any;
     beforeMiddleware?: Middleware;
+    extraParams?: any;
 }
 
 export interface ArgumentMetadata extends TypeMetadata {
@@ -369,10 +370,11 @@ export function Ctx() {
     } as Function;
 }
 
-export function OrderBy() {
+export function OrderBy(extraColumnsToSortBy: string[] = []) {
     return function (target: any, propertyKey: any, index: number) {
         setArgumentMetadata(target, propertyKey, index, {
             name: 'orderBy',
+            extraParams: extraColumnsToSortBy,
         });
     } as Function;
 }

src/object_type_factory.ts

@@ -24,15 +24,15 @@ export function objectTypeFactory(target: Function, isInput?: boolean) {
     }
     if (!Reflect.hasMetadata(GQ_FIELDS_KEY, target.prototype)) {
         // tslint:disable-next-line:max-line-length
-        throw new SchemaFactoryError('Class annotated by @ObjectType() should has one or more fields annotated by @Filed()', SchemaFactoryErrorType.NO_FIELD);
+        throw new SchemaFactoryError('Class annotated by @ObjectType() should has one or more fields annotated by @Field()', SchemaFactoryErrorType.NO_FIELD);
     }
     const fieldMetadataList = Reflect.getMetadata(GQ_FIELDS_KEY, target.prototype) as FieldTypeMetadata[];
     const fields: {[key: string]: any} = {};
     fieldMetadataList.forEach(def => {
         let field = fieldTypeFactory(target, def, isInput);
         if (!field) {
             // tslint:disable-next-line:max-line-length
-            throw new SchemaFactoryError(`@ObjectType()'s ${def.name} is annotated by @Filed() but no type could be inferred`, SchemaFactoryErrorType.NO_FIELD);
+            throw new SchemaFactoryError(`@ObjectType()'s ${def.name} is annotated by @Field() but no type could be inferred`, SchemaFactoryErrorType.NO_FIELD);
         }
         fields[def.name] = field;
     });

src/order-by.type-factory.ts

@@ -63,6 +63,19 @@ export class OrderByTypeFactory {
                 orderByFieldArray.push(def);
             }
         });
+
+        if (metadata.args &&
+            metadata.args.length > 0) {
+
+          let sortArg = metadata.args.filter(arg => arg.name === 'orderBy')[0];
+          if ( sortArg && sortArg.extraParams && sortArg.extraParams.constructor === Array) {
+            sortArg.extraParams.filter((item: any) => item && item.constructor === String)
+            .forEach((item: string) => orderByFieldArray.push({
+              name: item,
+              description: item,
+            }));
+          }
+        }
         let orderBySortEnumObject = OrderByTypeFactory.orderByFieldEnumFactory(metadata.name, orderByFieldArray);
         let orderByDirectionEnumObject = OrderByTypeFactory.orderByDirectionEnumFactory(metadata.name);
         let orderByInputObject = OrderByTypeFactory.orderByInputObjectFactory(metadata.name, orderBySortEnumObject,

src/schema_factory.spec.ts

@@ -5,6 +5,8 @@ import * as graphql from 'graphql';
 
 import { SchemaFactoryError, SchemaFactoryErrorType, schemaFactory } from './schema_factory';
 
+import { GraphQLString } from 'graphql';
+import { OrderByItem } from './order-by-item';
 import { clearObjectTypeRepository } from './object_type_factory';
 import { execute } from 'graphql/execution';
 import { parse } from 'graphql/language';
@@ -130,4 +132,37 @@ describe('schemaFactory', function() {
         done();
     });
 
+    describe('Pagination', function() {
+
+      it('returns a GraphQL Pagination object with custom @OrberBy fields', async function() {
+
+          @D.ObjectType()
+          class Obj {
+            @D.Description('a field')
+            @D.Field({ type: GraphQLString })
+            aField: string;
+          }
+
+          @D.ObjectType() class Query {
+              @D.Field({ type: Obj })
+              @D.Pagination()
+              async paginate(
+                  @D.OrderBy(['extraField']) orderBy?: OrderByItem[],
+              ): Promise<[Obj, number]> {
+                return [{ aField: null }, 0];
+              }
+          }
+          @D.Schema() class Schema { @D.Query() query: Query; }
+          const schema = schemaFactory(Schema);
+          const ast = parse(`
+            query {
+              paginate(orderBy: [{sort: aField, direction: ASC}, {sort: extraField, direction: DESC}]) {
+                count
+              }
+            }`);
+          assert.deepEqual(validate(schema, ast), []);
+      });
+
+    });
+
 });