fix(): fix abstract resolvers, field resolver args

lib/decorators/resolver.decorator.ts

@@ -44,6 +44,12 @@ export function Resolver(): MethodDecorator & ClassDecorator;
  * Object resolver decorator.
  */
 export function Resolver(name: string): MethodDecorator & ClassDecorator;
+/**
+ * Object resolver decorator.
+ */
+export function Resolver(
+  options: ResolverOptions,
+): MethodDecorator & ClassDecorator;
 /**
  * Object resolver decorator.
  */
@@ -62,14 +68,19 @@ export function Resolver(
  * Object resolver decorator.
  */
 export function Resolver(
-  nameOrType?: string | ResolverTypeFn | Type<any>,
+  nameOrTypeOrOptions?: string | ResolverTypeFn | Type<any> | ResolverOptions,
   options?: ResolverOptions,
 ): MethodDecorator & ClassDecorator {
   return (
     target: Object | Function,
     key?: string | symbol,
     descriptor?: any,
   ) => {
+    const [nameOrType, resolverOptions] =
+      typeof nameOrTypeOrOptions === 'object' && nameOrTypeOrOptions !== null
+        ? [undefined, nameOrTypeOrOptions]
+        : [nameOrTypeOrOptions as string | ResolverTypeFn | Type<any>, options];
+
     let name = nameOrType && getClassName(nameOrType);
 
     if (isFunction(nameOrType)) {
@@ -85,7 +96,7 @@ export function Resolver(
         TypeMetadataStorage.addResolverMetadata({
           target: target as Function,
           typeFn: typeFn,
-          isAbstract: (options && options.isAbstract) || false,
+          isAbstract: (resolverOptions && resolverOptions.isAbstract) || false,
         });
       });
     }

lib/schema-builder/factories/object-type-definition.factory.ts

@@ -10,6 +10,7 @@ import { ObjectTypeMetadata } from '../metadata/object-type.metadata';
 import { OrphanedReferenceRegistry } from '../services/orphaned-reference.registry';
 import { TypeFieldsAccessor } from '../services/type-fields.accessor';
 import { TypeDefinitionsStorage } from '../storages/type-definitions.storage';
+import { ArgsFactory } from './args.factory';
 import { AstDefinitionNodeFactory } from './ast-definition-node.factory';
 import { OutputTypeFactory } from './output-type.factory';
 
@@ -28,6 +29,7 @@ export class ObjectTypeDefinitionFactory {
     private readonly typeFieldsAccessor: TypeFieldsAccessor,
     private readonly astDefinitionNodeFactory: AstDefinitionNodeFactory,
     private readonly orphanedReferenceRegistry: OrphanedReferenceRegistry,
+    private readonly argsFactory: ArgsFactory,
   ) {}
 
   public create(
@@ -105,6 +107,7 @@ export class ObjectTypeDefinitionFactory {
         );
         fields[field.schemaName] = {
           type,
+          args: this.argsFactory.create(field.methodArgs, options),
           resolve: undefined,
           description: field.description,
           deprecationReason: field.deprecationReason,

lib/schema-builder/storages/lazy-metadata.storage.ts

@@ -1,4 +1,5 @@
-import { Type } from '@nestjs/common';
+import { flatten, Type } from '@nestjs/common';
+import { isUndefined } from '@nestjs/common/utils/shared.utils';
 
 interface LazyMetadataHost {
   func: Function;
@@ -19,6 +20,7 @@ export class LazyMetadataStorageHost {
   }
 
   load(types: Function[] = []) {
+    types = this.concatPrototypes(types);
     this.storage.forEach(({ func, target }) => {
       if (target && types.includes(target)) {
         func();
@@ -27,6 +29,27 @@ export class LazyMetadataStorageHost {
       }
     });
   }
+
+  private concatPrototypes(types: Function[]): Function[] {
+    const typesWithPrototypes = types
+      .filter(type => type && type.prototype)
+      .map(type => {
+        const parentTypes = [];
+
+        let parent: Function = type;
+        while (!isUndefined(parent.prototype)) {
+          parent = Object.getPrototypeOf(parent);
+          if (parent === Function.prototype) {
+            break;
+          }
+          parentTypes.push(parent);
+        }
+        parentTypes.push(type);
+        return parentTypes;
+      });
+
+    return flatten(typesWithPrototypes);
+  }
 }
 
 export const LazyMetadataStorage = new LazyMetadataStorageHost();

tests/code-first/other/abstract.resolver.ts

@@ -5,7 +5,7 @@ import { Recipe } from './../recipes/models/recipe';
 @Resolver(() => Recipe, { isAbstract: true })
 export class AbstractResolver {
   @Query(returns => [Recipe])
-  absractRecipes(@Args() recipesArgs: RecipesArgs): Recipe[] {
+  abstractRecipes(@Args() recipesArgs: RecipesArgs): Recipe[] {
     return [];
   }
 }

tests/code-first/recipes/dto/filter-recipes-count.args.ts

@@ -0,0 +1,10 @@
+import { ArgsType, Field } from '../../../../lib';
+
+@ArgsType()
+export class FilterRecipesCountArgs {
+  @Field({ nullable: true })
+  type?: string;
+
+  @Field({ nullable: true })
+  status?: string;
+}

tests/code-first/recipes/recipes.resolver.ts

@@ -10,6 +10,7 @@ import {
   Subscription,
 } from '../../../lib';
 import { AuthGuard } from '../common/guards/auth.guard';
+import { FilterRecipesCountArgs } from './dto/filter-recipes-count.args';
 import { NewRecipeInput } from './dto/new-recipe.input';
 import { RecipesArgs } from './dto/recipes.args';
 import { Ingredient } from './models/ingredient';
@@ -70,6 +71,11 @@ export class RecipesResolver {
     return [new Ingredient({ name: 'cherry' })];
   }
 
+  @ResolveField(type => Number)
+  count(@Args() filters: FilterRecipesCountArgs) {
+    return 10;
+  }
+
   @ResolveField()
   rating(): number {
     return 10;

tests/e2e/code-first-schema.spec.ts

@@ -326,6 +326,31 @@ describe('Code-first - schema factory', () => {
                 },
               },
             },
+            {
+              args: [
+                {
+                  defaultValue: null,
+                  description: null,
+                  name: 'type',
+                  type: { kind: TypeKind.SCALAR, name: 'String', ofType: null },
+                },
+                {
+                  defaultValue: null,
+                  description: null,
+                  name: 'status',
+                  type: { kind: TypeKind.SCALAR, name: 'String', ofType: null },
+                },
+              ],
+              deprecationReason: null,
+              description: null,
+              isDeprecated: false,
+              name: 'count',
+              type: {
+                kind: TypeKind.NON_NULL,
+                name: null,
+                ofType: { kind: TypeKind.SCALAR, name: 'Float', ofType: null },
+              },
+            },
             {
               args: [],
               deprecationReason: null,

tests/utils/printed-schema.snapshot.ts

@@ -67,6 +67,7 @@ type Recipe implements IRecipe {
   lastRate: Float
   tags: [String!]!
   ingredients: [Ingredient!]!
+  count(type: String, status: String): Float!
   rating: Float!
 }