Implement defaultValue for @Arg

src/domains/arg/compiler.ts

@@ -114,6 +114,7 @@ function convertArgsArrayToArgsMap(
     argsMap[argName] = {
       type: finalType,
       description: argConfig.description,
+      defaultValue: argConfig.defaultValue,
     };
   });
   return argsMap;

src/domains/arg/options.ts

@@ -2,6 +2,7 @@ export interface ArgOptions {
   description?: string;
   type?: any;
   isNullable?: boolean;
+  defaultValue?: any;
 }
 
 export const defaultArgOptions: ArgOptions = {

src/domains/arg/registry.ts

@@ -4,6 +4,7 @@ export interface ArgInnerConfig {
   description?: string;
   isNullable?: boolean;
   type?: any;
+  defaultValue?: any;
 }
 
 export const argRegistry = new DeepWeakMap<

src/test/arg/basics.spec.ts

@@ -1,5 +1,13 @@
-import { GraphQLString, GraphQLNonNull } from 'graphql';
-import { Field, ObjectType, compileObjectType, Arg } from '~/domains';
+import { graphql, GraphQLString, GraphQLNonNull } from 'graphql';
+import {
+  Field,
+  ObjectType,
+  compileObjectType,
+  Arg,
+  SchemaRoot,
+  Query,
+  compileSchema,
+} from '~/domains';
 
 describe('Arguments with @Arg', () => {
   it('Allows setting argument with @Arg decorator', () => {
@@ -91,25 +99,73 @@ describe('Arguments with @Arg', () => {
   });
 
   it('Will allow registering argument at runtime', () => {
+    @ObjectType()
+    class Foo {
+      @Field()
+      bar(baz: string, bazRequired: string): string {
+        return baz;
+      }
+    }
+
+    Arg({ type: String, isNullable: true })(Foo.prototype, 'bar', 0);
+    Arg({ type: String, isNullable: false })(Foo.prototype, 'bar', 1);
+
+    const [bazArg, bazRequiredArg] = compileObjectType(
+      Foo,
+    ).getFields().bar.args;
+
+    expect(bazArg.type).toBe(GraphQLString);
+    expect(bazRequiredArg.type).toEqual(new GraphQLNonNull(GraphQLString));
+  });
+
+  it('Respects unset defaultValue @Arg option', () => {
     @ObjectType()
     class Foo {
       @Field()
       bar(
+        @Arg({ isNullable: true })
         baz: string,
+        @Arg({ isNullable: false })
         bazRequired: string,
       ): string {
         return baz;
       }
     }
-
-    Arg({type: String, isNullable: true})(Foo.prototype, 'bar', 0);
-    Arg({type: String, isNullable: false})(Foo.prototype, 'bar', 1);
-
     const [bazArg, bazRequiredArg] = compileObjectType(
       Foo,
     ).getFields().bar.args;
-
     expect(bazArg.type).toBe(GraphQLString);
+    expect(bazArg.defaultValue).toBe(undefined);
     expect(bazRequiredArg.type).toEqual(new GraphQLNonNull(GraphQLString));
   });
+
+  it('Respects defaultValue @Arg option', async () => {
+    @ObjectType()
+    class Foo {
+      @Field()
+      bar(
+        @Arg({ isNullable: true, defaultValue: 'default' })
+        baz: string,
+      ): string {
+        return baz;
+      }
+    }
+    @SchemaRoot()
+    class FooSchema {
+      @Query()
+      foo(): Foo {
+        return new Foo();
+      }
+    }
+
+    const compiledObject = compileObjectType(Foo);
+    const [bazArg] = compiledObject.getFields().bar.args;
+    expect(bazArg.type).toBe(GraphQLString);
+    expect(bazArg.defaultValue).toBe('default');
+
+    const compiledSchema = compileSchema({ roots: [FooSchema] });
+    expect(await graphql(compiledSchema, '{ foo { bar } }')).toEqual({
+      data: { foo: { bar: 'default' } },
+    });
+  });
 });