fix(core): return subscription resolver as object with 'subscribe' key

src/index.ts

@@ -110,14 +110,14 @@ export class MiddlewareError extends Error {
 function applyMiddlewareToField(
   field: GraphQLField<any, any, any>,
   middleware: IMiddlewareFunction,
-): GraphQLFieldResolver<any, any, any> {
-  let resolver = field.resolve
-
+):
+  | GraphQLFieldResolver<any, any, any>
+  | { subscribe: GraphQLFieldResolver<any, any, any> } {
   if (field.subscribe) {
-    resolver = field.subscribe
+    return { subscribe: wrapResolverInMiddleware(field.subscribe, middleware) }
   }
 
-  return wrapResolverInMiddleware(resolver, middleware)
+  return wrapResolverInMiddleware(field.resolve, middleware)
 }
 
 function applyMiddlewareToType(

test.js

@@ -1,6 +1,7 @@
 import test from 'ava'
-import { graphql } from 'graphql'
+import { graphql, subscribe, parse } from 'graphql'
 import { makeExecutableSchema } from 'graphql-tools'
+import { $$asyncIterator } from 'iterall'
 import { applyMiddleware, MiddlewareError } from './dist'
 
 // Setup ---------------------------------------------------------------------
@@ -24,6 +25,10 @@ const typeDefs = `
     null: String
     nested: Nothing!
   }
+  
+  type Subscription {
+    sub: String
+  }
 
   type Nothing {
     nothing: String!
@@ -35,7 +40,8 @@ const typeDefs = `
 
   schema {
     query: Query,
-    mutation: Mutation
+    mutation: Mutation,
+    subscription: Subscription
   }
 `
 
@@ -57,6 +63,19 @@ const resolvers = {
     null: () => null,
     nested: () => ({}),
   },
+  Subscription: {
+    sub: {
+      subscribe: async (parent, { arg }, ctx, info) => {
+        const iterator = {
+          next: () => Promise.resolve({ done: false, value: { sub: arg } }),
+          return: () => {},
+          throw: () => {},
+          [$$asyncIterator]: () => iterator,
+        }
+        return iterator
+      },
+    },
+  },
   Nothing: {
     nothing: () => 'nothing',
   },
@@ -89,6 +108,12 @@ const fieldMiddleware = {
       return 'changed'
     },
   },
+  Subscription: {
+    sub: async (resolve, parent, args, context, info) => {
+      const _args = { arg: 'changed' }
+      return resolve(parent, _args)
+    },
+  },
 }
 
 // Type Middleware
@@ -102,6 +127,10 @@ const typeMiddlewareBefore = {
     const _args = { arg: 'changed' }
     return resolve(parent, _args)
   },
+  Subscription: async (resolve, parent, args, context, info) => {
+    const _args = { arg: 'changed' }
+    return resolve(parent, _args)
+  },
 }
 
 const typeMiddlewareAfter = {
@@ -205,6 +234,28 @@ test('Field middleware - Mutation', async t => {
   })
 })
 
+test('Field middleware - Subscription', async t => {
+  const schema = getSchema()
+  const schemaWithMiddleware = applyMiddleware(schema, fieldMiddleware)
+
+  const query = `
+    subscription {
+      sub
+    }
+  `
+  const iterator = await subscribe(schemaWithMiddleware, parse(query))
+  const res = await iterator.next()
+
+  t.deepEqual(res, {
+    done: false,
+    value: {
+      data: {
+        sub: 'changed',
+      },
+    },
+  })
+})
+
 // Type
 
 test('Type middleware - Query before', async t => {
@@ -319,6 +370,28 @@ test('Type middleware - Mutation after', async t => {
   })
 })
 
+test('Type middleware - Subscription', async t => {
+  const schema = getSchema()
+  const schemaWithMiddleware = applyMiddleware(schema, typeMiddlewareBefore)
+
+  const query = `
+    subscription {
+      sub
+    }
+  `
+  const iterator = await subscribe(schemaWithMiddleware, parse(query))
+  const res = await iterator.next()
+
+  t.deepEqual(res, {
+    done: false,
+    value: {
+      data: {
+        sub: 'changed',
+      },
+    },
+  })
+})
+
 // Schema
 
 test('Schema middleware - Query before', async t => {
@@ -434,6 +507,28 @@ test('Schema middleware - Mutation after', async t => {
   })
 })
 
+test('Schema middleware - Subscription', async t => {
+  const schema = getSchema()
+  const schemaWithMiddleware = applyMiddleware(schema, schemaMiddlewareBefore)
+
+  const query = `
+    subscription {
+      sub
+    }
+  `
+  const iterator = await subscribe(schemaWithMiddleware, parse(query))
+  const res = await iterator.next()
+
+  t.deepEqual(res, {
+    done: false,
+    value: {
+      data: {
+        sub: 'changed',
+      },
+    },
+  })
+})
+
 test('Schema middleware - Uses default field resolver', async t => {
   const schema = getSchema()
   const schemaWithMiddleware = applyMiddleware(schema, schemaMiddlewareBefore)