Add a @DirectiveResolver decorator about graphql HOT 12 CLOSED

@Module({
    imports: [
        GraphQLModule.forRootAsync({
            useFactory(factory: DirectivesFactory) {
                return {
                    typePaths: ['./**/*.graphql'],
                    debug: true,
                    playground: true,
                    installSubscriptionHandlers: true,
                    definitions: {
                        path: join(process.cwd(), 'src/graphql.schema.ts'),
                        outputAs: 'class',
                    },
                    transformSchema: (schema: GraphQLSchema) => {
                        return mergeSchemas({schemas: [schema], schemaDirectives: factory.register() });
                    }
                };
            },
            imports: [DirectivesModule],
            inject: [DirectivesFactory]
        }),

import {HttpModule, Module} from '@nestjs/common';
import {DirectivesFactory} from "./directives.factory";

@Module({
    imports: [HttpModule],
    providers: [ DirectivesFactory],
    exports: [ DirectivesFactory ]
})
export class DirectivesModule {}

import {Inject, Injectable} from "@nestjs/common";
import {SchemaDirectiveVisitor} from "graphql-tools";
import {RestDirective} from "./rest-directive";

@Injectable()
export class DirectivesFactory {

    @Inject()
    restDirective: RestDirective;

    register() {
        return {
            rest: this.restDirective.build()
        }
    }
}

import {HttpService, Inject, Injectable} from "@nestjs/common";
import {SchemaDirectiveVisitor} from "graphql-tools";

type DirectiveArguments = {
    [name: string]: any;
}

@Injectable()
export class RestDirective {
    @Inject()
    private http: HttpService;

    async visitFieldDefinition(args: DirectiveArguments){
        const { url } = args;
        const response = await this.http.get(url).toPromise();
        return response.data;
    }

    build(): typeof SchemaDirectiveVisitor {
        const rest = this;
        class Directive extends SchemaDirectiveVisitor {
            public visitFieldDefinition(field) {
                field.resolve = async () => await rest.visitFieldDefinition(this.args);
            }
        }

        return Directive
    }
}

directive @rest(url: String) on FIELD_DEFINITION

# the schema allows the following query:
type Query {
    getWeather: WeatherResponse @rest(url: "https://samples.openweathermap.org/data/2.5/weather?lat=35&lon=139&appid=b6907d289e10d714a6e88b30761fae22")
}

configure() {
   const self = this;
    // @note: we need an unbound function here, not a () =>
    this.graphQLFactory.createSchema = function(
      schemaDefintion = { typeDefs: [] },
    ) {
      return makeExecutableSchema({
        ...schemaDefintion,
        directiveResolvers: self.directiveResolvers,
        resolvers: {
          ...this.resolversExplorerService.explore(), // ignore private error, its a hack anyway!
          ...(schemaDefintion.resolvers || {}),
        },
      });
    };

    const schema = this.graphQLFactory.createSchema({ typeDefs });
   ....
}