Bring attachDirectiveResolvers to graphql-tools

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ### VNEXT
 
+* Added support for custom Directives on FIELD [Issue #212](https://github.com/apollographql/graphql-tools/issues/212) [PR #518](https://github.com/apollographql/graphql-tools/pull/518)
 * Allow passing in a string `schema` to `makeRemoteExecutableSchema` [PR #521](https://github.com/apollographql/graphql-tools/pull/521)
 * ...
 

src/Interfaces.ts

@@ -76,6 +76,7 @@ export interface IExecutableSchemaDefinition {
   logger?: ILogger;
   allowUndefinedInResolve?: boolean;
   resolverValidationOptions?: IResolverValidationOptions;
+  directiveResolvers?: IDirectiveResolvers<any, any>;
 }
 
 export type IFieldIteratorFn = (
@@ -84,6 +85,19 @@ export type IFieldIteratorFn = (
   fieldName: string,
 ) => void;
 
+export type NextResolverFn = () => Promise<any>;
+export type DirectiveResolverFn<TSource, TContext> = (
+  next: NextResolverFn,
+  source: TSource,
+  args: { [argName: string]: any },
+  context: TContext,
+  info: GraphQLResolveInfo,
+) => any;
+
+export interface IDirectiveResolvers<TSource, TContext> {
+  [directiveName: string]: DirectiveResolverFn<TSource, TContext>;
+}
+
 /* XXX on mocks, args are optional, Not sure if a bug. */
 export type IMockFn = GraphQLFieldResolver<any, any>;
 export type IMocks = { [key: string]: IMockFn };

src/schemaGenerator.ts

@@ -13,6 +13,7 @@ import {
   print,
   Kind,
   DefinitionNode,
+  DirectiveNode,
   defaultFieldResolver,
   buildASTSchema,
   extendSchema,
@@ -27,6 +28,7 @@ import {
   GraphQLInterfaceType,
   GraphQLFieldMap,
 } from 'graphql';
+import { getArgumentValues } from 'graphql/execution/values';
 import {
   IExecutableSchemaDefinition,
   ILogger,
@@ -38,6 +40,7 @@ import {
   IConnector,
   IConnectorCls,
   IResolverValidationOptions,
+  IDirectiveResolvers,
 } from './Interfaces';
 
 import { deprecated } from 'deprecated-decorator';
@@ -62,6 +65,7 @@ function _generateSchema(
   // TODO: rename to allowUndefinedInResolve to be consistent
   allowUndefinedInResolve: boolean,
   resolverValidationOptions: IResolverValidationOptions,
+  directiveResolvers: IDirectiveResolvers<any, any>,
 ) {
   if (typeof resolverValidationOptions !== 'object') {
     throw new SchemaError(
@@ -95,6 +99,10 @@ function _generateSchema(
     addErrorLoggingToSchema(schema, logger);
   }
 
+  if (directiveResolvers) {
+    attachDirectiveResolvers(schema, directiveResolvers);
+  }
+
   return schema;
 }
 
@@ -105,13 +113,15 @@ function makeExecutableSchema({
   logger,
   allowUndefinedInResolve = true,
   resolverValidationOptions = {},
+  directiveResolvers = null,
 }: IExecutableSchemaDefinition) {
   const jsSchema = _generateSchema(
     typeDefs,
     resolvers,
     logger,
     allowUndefinedInResolve,
     resolverValidationOptions,
+    directiveResolvers,
   );
   if (typeof resolvers['__schema'] === 'function') {
     // TODO a bit of a hack now, better rewrite generateSchema to attach it there.
@@ -637,6 +647,52 @@ function runAtMostOncePerRequest(
   };
 }
 
+function attachDirectiveResolvers(
+  schema: GraphQLSchema,
+  directiveResolvers: IDirectiveResolvers<any, any>,
+) {
+  if (typeof directiveResolvers !== 'object') {
+    throw new Error(
+      `Expected directiveResolvers to be of type object, got ${typeof directiveResolvers}`,
+    );
+  }
+  if (Array.isArray(directiveResolvers)) {
+    throw new Error('Expected directiveResolvers to be of type object, got Array');
+  }
+  forEachField(schema, (field: GraphQLField<any, any>) => {
+    const directives = field.astNode.directives;
+    directives.forEach((directive: DirectiveNode) => {
+      const directiveName = directive.name.value;
+      const resolver = directiveResolvers[directiveName];
+
+      if (resolver) {
+        const originalResolver = field.resolve || defaultFieldResolver;
+        const Directive = schema.getDirective(directiveName);
+        if (typeof Directive === 'undefined') {
+          throw new Error(`Directive @${directiveName} is undefined. ` +
+            'Please define in schema before using');
+        }
+        const directiveArgs = getArgumentValues(Directive, directive);
+
+        field.resolve = (...args: any[]) => {
+          const [source, , context, info] = args;
+          return resolver(() => {
+            try {
+              const promise = originalResolver.call(field, ...args);
+              if (promise instanceof Promise) {
+                return promise;
+              }
+              return Promise.resolve(promise);
+            } catch (error) {
+              return Promise.reject(error);
+            }
+          }, source, directiveArgs, context, info);
+        };
+      }
+    });
+  });
+}
+
 export {
   makeExecutableSchema,
   SchemaError,
@@ -650,4 +706,5 @@ export {
   addSchemaLevelResolveFunction,
   attachConnectorsToContext,
   concatenateTypeDefs,
+  attachDirectiveResolvers,
 };