feat: only wrap affected resolver functions by using the 'onSchemaChange' hook with 'mapSchema' instead of the 'onResolverCalled' hook.

packages/graphql-server/src/plugins/useRedwoodDirective.ts

@@ -1,10 +1,14 @@
 import { Plugin } from '@envelop/types'
+import { mapSchema, MapperKind } from '@graphql-tools/utils'
 import {
+  defaultFieldResolver,
   DirectiveNode,
   DocumentNode,
   getDirectiveValues,
+  GraphQLFieldConfig,
   GraphQLObjectType,
   GraphQLResolveInfo,
+  GraphQLSchema,
 } from 'graphql'
 
 import { GlobalContext } from '../index'
@@ -91,79 +95,127 @@ export function hasDirective(info: GraphQLResolveInfo): boolean {
 }
 
 export function getDirectiveByName(
-  info: GraphQLResolveInfo,
-  name: string
+  fieldConfig: GraphQLFieldConfig<any, any, any>,
+  directiveName: string
 ): null | DirectiveNode {
-  try {
-    const { parentType, fieldName, schema } = info
-    const schemaType = schema.getType(parentType.name) as GraphQLObjectType
-    const field = schemaType.getFields()[fieldName]
-    const astNode = field.astNode
-    const associatedDirective = astNode?.directives?.find(
-      (directive) => directive.name.value === name
-    )
+  const associatedDirective = fieldConfig.astNode?.directives?.find(
+    (directive) => directive.name.value === directiveName
+  )
+  return associatedDirective ?? null
+}
 
-    return associatedDirective || null
-  } catch (error) {
-    console.error(error)
-    return null
-  }
+export function isPromise(value: any): value is Promise<unknown> {
+  return typeof value?.then === 'function'
 }
 
-export const useRedwoodDirective = (
+function wrapAffectedResolvers(
+  schema: GraphQLSchema,
   options: DirectivePluginOptions
-): Plugin<{
-  onResolverCalled: ValidatorDirectiveFunc | TransformerDirectiveFunc
-}> => {
-  return {
-    async onResolverCalled({ args, root, context, info }) {
-      const directiveNode = getDirectiveByName(info, options.name)
+): GraphQLSchema {
+  return mapSchema(schema, {
+    [MapperKind.OBJECT_FIELD](fieldConfig, _, __, schema) {
+      const directiveNode = getDirectiveByName(fieldConfig, options.name)
       const directive = directiveNode
-        ? info.schema.getDirective(directiveNode.name.value)
+        ? schema.getDirective(directiveNode.name.value)
         : null
-
       if (directiveNode && directive) {
         const directiveArgs =
-          getDirectiveValues(
-            directive,
-            { directives: [directiveNode] },
-            info.variableValues
-          ) || {}
-
+          getDirectiveValues(directive, { directives: [directiveNode] }) || {}
+        const originalResolve = fieldConfig.resolve ?? defaultFieldResolver
         if (_isValidator(options)) {
-          await options.onResolverCalled({
-            root,
-            args,
-            context,
-            info,
-            directiveNode,
-            directiveArgs,
-          })
+          return {
+            ...fieldConfig,
+            resolve: function useRedwoodDirectiveValidatorResolver(
+              root,
+              args,
+              context,
+              info
+            ) {
+              const result = options.onResolverCalled({
+                root,
+                args,
+                context,
+                info,
+                directiveNode,
+                directiveArgs,
+              })
+
+              if (isPromise(result)) {
+                return result.then(() =>
+                  originalResolve(root, args, context, info)
+                )
+              }
+              return originalResolve(root, args, context, info)
+            },
+          }
         }
-
-        // In order to change the value of the field, we have to return a function in this form
-        // ({result, setResult}) => { setResult(newValue)}
-        // Not super clear but mentioned here: https://www.envelop.dev/docs/plugins/lifecycle#onexecuteapi
-
         if (_isTransformer(options)) {
-          return ({ result, setResult }) => {
-            // @NOTE! A transformer cannot be async
-            const transformedValue = options.onResolverCalled({
+          return {
+            ...fieldConfig,
+            resolve: function useRedwoodDirectiveTransformerResolver(
               root,
               args,
               context,
-              info,
-              directiveNode,
-              directiveArgs,
-              resolvedValue: result,
-            })
-
-            setResult(transformedValue)
+              info
+            ) {
+              const resolvedValue = originalResolve(root, args, context, info)
+              if (isPromise(resolvedValue)) {
+                return resolvedValue.then((resolvedValue) =>
+                  options.onResolverCalled({
+                    root,
+                    args,
+                    context,
+                    info,
+                    directiveNode,
+                    directiveArgs,
+                    resolvedValue,
+                  })
+                )
+              }
+              return options.onResolverCalled({
+                root,
+                args,
+                context,
+                info,
+                directiveNode,
+                directiveArgs,
+                resolvedValue,
+              })
+            },
           }
         }
       }
+      return fieldConfig
+    },
+  })
+}
 
-      return
+export const useRedwoodDirective = (
+  options: DirectivePluginOptions
+): Plugin<{
+  onResolverCalled: ValidatorDirectiveFunc | TransformerDirectiveFunc
+}> => {
+  /**
+   * This symbol is added to the schema extensions for checking whether the transform got already applied.
+   */
+  const didMapSchemaSymbol = Symbol('useRedwoodDirective.didMapSchemaSymbol')
+  return {
+    onSchemaChange({ schema, replaceSchema }) {
+      /**
+       * Currently graphql-js extensions typings are limited to string keys.
+       * We are using symbols as each useRedwoodDirective plugin instance should use its own unique symbol.
+       */
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error See https://github.com/graphql/graphql-js/pull/3511 - remove this comments once merged
+      if (schema.extensions?.[didMapSchemaSymbol] === true) {
+        return
+      }
+      const transformedSchema = wrapAffectedResolvers(schema, options)
+      transformedSchema.extensions = {
+        ...schema.extensions,
+        [didMapSchemaSymbol]: true,
+      }
+      replaceSchema(transformedSchema)
     },
   }
 }