Arguments for fields of interfaces

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 <!-- here goes all the unreleased changes descriptions -->
 ### Features
+- add support for arguments in fields of interfaces (#284)
 - add postinstall script for printing info on console about supporting the project
 - add support for setting default nullability for fields and return types (#297)
 - add `skipCheck` option in `buildSchema` to disable checking the correctness of a schema

docs/interfaces.md

@@ -32,13 +32,27 @@ We can then we use this "interface" in the object type class definition:
 
 ```typescript
 @ObjectType({ implements: IPerson })
-class Person implements IPerson {
+class Person extends IPerson {
   id: string;
   name: string;
   age: number;
 }
 ```
 
+We can also define dynamic fields for an interface using the same syntax you would use when defining one for your object types:
+
+```typescript
+@InterfaceType()
+abstract class IPerson {
+  // ...
+
+  @Field()
+  avatar(@Arg("size") size: number): string {
+    return `http://i.pravatar.cc/${size}`;
+  }
+}
+```
+
 The only difference is that we have to let TypeGraphQL know that this `ObjectType` is implementing the `InterfaceType`. We do this by passing the param `({ implements: IPerson })` to the decorator. If we implement multiple interfaces, we pass an array of interfaces like so: `({ implements: [IPerson, IAnimal, IMachine] })`.
 
 We can also omit the decorators since the GraphQL types will be copied from the interface definition - this way we won't have to maintain two definitions and solely rely on TypeScript type checking for correct interface implementation.

examples/interfaces-inheritance/person/person.interface.ts

@@ -1,4 +1,4 @@
-import { InterfaceType, Field, Int, ID } from "../../../src";
+import { InterfaceType, Field, Int, ID, Arg } from "../../../src";
 
 import { IResource } from "../resource/resource.interface";
 
@@ -12,4 +12,9 @@ export abstract class IPerson implements IResource {
 
   @Field(type => Int)
   age: number;
+
+  @Field()
+  avatar(@Arg("size") size: number): string {
+    throw new Error("Method not implemented.");
+  }
 }

examples/interfaces-inheritance/person/person.type.ts

@@ -1,4 +1,4 @@
-import { ObjectType } from "../../../src";
+import { ObjectType, Field, Arg } from "../../../src";
 
 import { IPerson } from "./person.interface";
 
@@ -7,4 +7,9 @@ export class Person implements IPerson {
   id: string;
   name: string;
   age: number;
+
+  @Field()
+  avatar(@Arg("size") size: number): string {
+    return `http://i.pravatar.cc/${size}`;
+  }
 }

src/schema/schema-generator.ts

@@ -206,9 +206,22 @@ export abstract class SchemaGenerator {
             fields: () => {
               let fields = interfaceType.fields!.reduce<GraphQLFieldConfigMap<any, any>>(
                 (fieldsMap, field) => {
+                  const fieldResolverMetadata = getMetadataStorage().fieldResolvers.find(
+                    resolver =>
+                      resolver.getObjectType!() === interfaceType.target &&
+                      resolver.methodName === field.name &&
+                      (resolver.resolverClassMetadata === undefined ||
+                        resolver.resolverClassMetadata.isAbstract === false),
+                  );
                   fieldsMap[field.schemaName] = {
-                    description: field.description,
                     type: this.getGraphQLOutputType(field.name, field.getType(), field.typeOptions),
+                    complexity: field.complexity,
+                    args: this.generateHandlerArgs(field.params!),
+                    resolve: fieldResolverMetadata
+                      ? createAdvancedFieldResolver(fieldResolverMetadata)
+                      : createSimpleFieldResolver(field),
+                    description: field.description,
+                    deprecationReason: field.deprecationReason,
                   };
                   return fieldsMap;
                 },