Add service metadata parameter to gateway hooks (#416)

* Add service metadata parameter to gateway hooks

* Call the gateway hooks with the full service object in make-resolver

docs/hooks.md

@@ -81,8 +81,11 @@ In the `preGatewayExecution` hook, you can modify the following items by returni
 
 This hook will only be triggered in gateway mode. When in gateway mode, each hook definition will trigger multiple times in a single request just before executing remote GraphQL queries on the federated services.
 
+Note, this hook contains service metadata in the `service` parameter:
+- `name`: service name
+
 ```js
-fastify.graphql.addHook('preGatewayExecution', async (schema, document, context) => {
+fastify.graphql.addHook('preGatewayExecution', async (schema, document, context, service) => {
   const { modifiedDocument, errors } = await asyncMethod(document)
 
   return {
@@ -188,8 +191,11 @@ fastify.graphql.addHook('preSubscriptionExecution', async (schema, document, con
 
 This hook will only be triggered in gateway mode. When in gateway mode, each hook definition will trigger when creating a subscription with a federated service.
 
+Note, this hook contains service metadata in the `service` parameter:
+- `name`: service name
+
 ```js
-fastify.graphql.addHook('preGatewaySubscriptionExecution', async (schema, document, context) => {
+fastify.graphql.addHook('preGatewaySubscriptionExecution', async (schema, document, context, service) => {
   await asyncMethod()
 })
 ```

examples/hooks-gateway.js

@@ -202,8 +202,8 @@ async function start () {
     }
   })
 
-  gateway.graphql.addHook('preGatewayExecution', async function (schema, document, context) {
-    console.log('preGatewayExecution called')
+  gateway.graphql.addHook('preGatewayExecution', async function (schema, document, context, service) {
+    console.log('preGatewayExecution called', service.name)
     return {
       document,
       errors: [

index.d.ts

@@ -62,6 +62,13 @@ export interface MercuriusLoaders<TContext extends Record<string, any> = Mercuri
   };
 }
 
+/**
+ * Federated GraphQL Service metadata
+ */
+export interface MercuriusServiceMetadata {
+  name: string;
+}
+
 // ------------------------
 // Request Lifecycle hooks
 // ------------------------
@@ -108,12 +115,16 @@ export interface preExecutionHookHandler<TContext = MercuriusContext, TError ext
  *  - `document`
  *  - `errors`
  * This hook will only be triggered in gateway mode. When in gateway mode, each hook definition will trigger multiple times in a single request just before executing remote GraphQL queries on the federated services.
+ *
+ * Because it is a gateway hook, this hook contains service metadata in the `service` parameter:
+ *  - `name`: service name
  */
 export interface preGatewayExecutionHookHandler<TContext = MercuriusContext, TError extends Error = Error> {
   (
     schema: GraphQLSchema,
     source: DocumentNode,
     context: TContext,
+    service: MercuriusServiceMetadata
   ): Promise<PreExecutionHookResponse<TError> | void>;
 }
 
@@ -158,12 +169,16 @@ export interface preSubscriptionExecutionHookHandler<TContext = MercuriusContext
 /**
  * `preGatewaySubscriptionExecution` is the third hook to be executed in the GraphQL subscription lifecycle. The previous hook was `preSubscriptionExecution`, the next hook will be `onSubscriptionResolution`.
  * This hook will only be triggered in gateway mode when subscriptions are enabled.
+ *
+ * Because it is a gateway hook, this hook contains service metadata in the `service` parameter:
+ *  - `name`: service name
  */
 export interface preGatewaySubscriptionExecutionHookHandler<TContext = MercuriusContext> {
   (
     schema: GraphQLSchema,
     source: DocumentNode,
     context: TContext,
+    service: MercuriusServiceMetadata
   ): Promise<void>;
 }
 

lib/gateway.js

@@ -282,7 +282,8 @@ async function buildGateway (gatewayOpts, app) {
           ({ modifiedQuery } = await preGatewayExecutionHandler({
             schema: serviceDefinition.schema,
             document: parse(query),
-            context: queries[queryIndex].context
+            context: queries[queryIndex].context,
+            service: { name: service }
           }))
         }
 

lib/gateway/make-resolver.js

@@ -442,7 +442,7 @@ function makeResolver ({ service, createOperation, transformData, isQuery, isRef
     if (isSubscription) {
       // Trigger preGatewaySubscriptionExecution hook
       if (context.preGatewaySubscriptionExecution !== null) {
-        await preGatewaySubscriptionExecutionHandler({ schema, document: operation, context })
+        await preGatewaySubscriptionExecutionHandler({ schema, document: operation, context, service })
       }
       const subscriptionId = service.createSubscription(query, variables, pubsub.publish.bind(pubsub), context._connectionInit)
       return pubsub.subscribe(`${service.name}_${subscriptionId}`)
@@ -452,7 +452,7 @@ function makeResolver ({ service, createOperation, transformData, isQuery, isRef
       // Trigger preGatewayExecution hook
       let modifiedQuery
       if (context.preGatewayExecution !== null) {
-        ({ modifiedQuery } = await preGatewayExecutionHandler({ schema, document: operation, context }))
+        ({ modifiedQuery } = await preGatewayExecutionHandler({ schema, document: operation, context, service }))
       }
 
       const response = await service.sendRequest({

lib/handlers.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { hooksRunner, preExecutionHooksRunner, hookRunner, preParsingHookRunner, onResolutionHookRunner, onEndHookRunner } = require('./hooks')
+const { hooksRunner, preExecutionHooksRunner, preGatewayExecutionHooksRunner, gatewayHookRunner, hookRunner, preParsingHookRunner, onResolutionHookRunner, onEndHookRunner } = require('./hooks')
 const { addErrorsToContext } = require('./errors')
 const { print } = require('graphql')
 
@@ -35,7 +35,7 @@ async function preExecutionHandler (request) {
 }
 
 async function preGatewayExecutionHandler (request) {
-  const { errors, modifiedDocument } = await preExecutionHooksRunner(
+  const { errors, modifiedDocument } = await preGatewayExecutionHooksRunner(
     request.context.preGatewayExecution,
     request
   )
@@ -75,7 +75,7 @@ async function preSubscriptionExecutionHandler (request) {
 async function preGatewaySubscriptionExecutionHandler (request) {
   await hooksRunner(
     request.context.preGatewaySubscriptionExecution,
-    hookRunner,
+    gatewayHookRunner,
     request
   )
 }

lib/hooks.js

@@ -92,10 +92,34 @@ async function preExecutionHooksRunner (functions, request) {
   return { errors, modifiedDocument }
 }
 
+async function preGatewayExecutionHooksRunner (functions, request) {
+  let errors = []
+  let modifiedDocument
+
+  for (const fn of functions) {
+    const result = await fn(request.schema, modifiedDocument || request.document, request.context, request.service)
+
+    if (result) {
+      if (typeof result.document !== 'undefined') {
+        modifiedDocument = result.document
+      }
+      if (typeof result.errors !== 'undefined') {
+        errors = errors.concat(result.errors)
+      }
+    }
+  }
+
+  return { errors, modifiedDocument }
+}
+
 function hookRunner (fn, request) {
   return fn(request.schema, request.document, request.context)
 }
 
+function gatewayHookRunner (fn, request) {
+  return fn(request.schema, request.document, request.context, request.service)
+}
+
 function preParsingHookRunner (fn, request) {
   return fn(request.schema, request.source, request.context)
 }
@@ -114,6 +138,8 @@ module.exports = {
   hooksRunner,
   preExecutionHooksRunner,
   hookRunner,
+  gatewayHookRunner,
+  preGatewayExecutionHooksRunner,
   preParsingHookRunner,
   onResolutionHookRunner,
   onEndHookRunner,

test/gateway/hooks.js

@@ -952,6 +952,70 @@ test('gateway - preGatewayExecution hooks should be able to modify the request d
   })
 })
 
+test('gateway - preGatewayExecution hooks should contain service metadata', async (t) => {
+  t.plan(21)
+  const app = await createTestGatewayServer(t)
+
+  // Execution events:
+  //  - user service: once for user service query
+  //  - post service: once for post service query
+  //  - post service: once for reference type topPosts on User
+  //  - user service: once for reference type author on Post
+  app.graphql.addHook('preGatewayExecution', async function (schema, document, context, service) {
+    await immediate()
+    t.type(schema, GraphQLSchema)
+    t.type(document, 'object')
+    t.type(context, 'object')
+    if (typeof service === 'object' && service.name === 'user') {
+      t.is(service.name, 'user')
+    } else if (typeof service === 'object' && service.name === 'post') {
+      t.is(service.name, 'post')
+    } else {
+      t.fail('service metadata should be correctly populated')
+      return
+    }
+    t.ok('preGatewayExecution called')
+  })
+
+  const res = await app.inject({
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    url: '/graphql',
+    body: JSON.stringify({ query })
+  })
+
+  t.deepEqual(JSON.parse(res.body), {
+    data: {
+      me: {
+        id: 'u1',
+        name: 'John',
+        topPosts: [
+          {
+            pid: 'p1',
+            author: {
+              id: 'u1'
+            }
+          },
+          {
+            pid: 'p3',
+            author: {
+              id: 'u1'
+            }
+          }
+        ]
+      },
+      topPosts: [
+        {
+          pid: 'p1'
+        },
+        {
+          pid: 'p2'
+        }
+      ]
+    }
+  })
+})
+
 // -------------
 // onResolution
 // -------------

test/gateway/subscription-hooks.js

@@ -466,6 +466,86 @@ test('gateway - preGatewaySubscriptionExecution hooks should handle errors', asy
   }
 })
 
+test('gateway subscription - preGatewaySubscriptionExecution hooks should contain service metadata', async t => {
+  t.plan(8)
+  const gateway = await createTestGatewayServer(t)
+
+  const subscriptionQuery = query('u1')
+
+  gateway.graphql.addHook('preGatewaySubscriptionExecution', async (schema, document, context, service) => {
+    t.type(schema, GraphQLSchema)
+    t.type(document, 'object')
+    t.type(context, 'object')
+    t.type(service, 'object')
+    t.is(service.name, 'message')
+    t.ok('preGatewaySubscriptionExecution called')
+  })
+
+  await gateway.listen(0)
+
+  const { client } = createWebSocketClient(t, gateway)
+
+  client.write(JSON.stringify({
+    type: 'connection_init'
+  }))
+  client.write(JSON.stringify({
+    id: 1,
+    type: 'start',
+    payload: {
+      query: subscriptionQuery
+    }
+  }))
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.is(data.type, 'connection_ack')
+  }
+
+  gateway.inject({
+    method: 'POST',
+    url: '/graphql',
+    body: {
+      query: `
+        mutation {
+          sendMessage(message: {
+            text: "Hi there u1",
+            fromUserId: "u2",
+            toUserId: "u1"
+          }) {
+            id
+          }
+        }
+      `
+    }
+  })
+
+  {
+    const [chunk] = await once(client, 'data')
+    const data = JSON.parse(chunk)
+    t.deepEqual(data, {
+      id: 1,
+      type: 'data',
+      payload: {
+        data: {
+          newMessage: {
+            id: '2',
+            text: 'Hi there u1',
+            from: {
+              id: 'u2',
+              name: 'Jane'
+            },
+            to: {
+              id: 'u1',
+              name: 'John'
+            }
+          }
+        }
+      }
+    })
+  }
+})
+
 // -------------------------
 // onSubscriptionResolution
 // -------------------------

test/types/index.ts

@@ -517,3 +517,12 @@ app.graphql.addHook('onSubscriptionResolution', async function (execution, conte
 app.graphql.addHook('onSubscriptionEnd', async function (context) {
   console.log('onSubscriptionEnd called')
 })
+
+// Hooks containing service metadata
+app.graphql.addHook('preGatewayExecution', async function (schema, document, context, service) {
+  console.log('preGatewayExecution called')
+})
+
+app.graphql.addHook('preGatewaySubscriptionExecution', async function (schema, document, context, service) {
+  console.log('preGatewaySubscriptionExecution called')
+})