Merge pull request #7 from graphcool/subscriptions

feat: added subscriptions support

package.json

@@ -31,7 +31,8 @@
   },
   "dependencies": {
     "@types/graphql": "0.11.7",
-    "graphql": "^0.12.3",
-    "graphql-tools": "^2.14.1"
+    "graphql": "0.12.3",
+    "graphql-tools": "2.16.0",
+    "iterall": "^1.1.3"
   }
 }

src/Binding.ts

@@ -1,51 +1,67 @@
 import { buildInfo } from './info'
 import { GraphQLResolveInfo, graphql, GraphQLSchema } from 'graphql'
 import { delegateToSchema } from 'graphql-tools'
-import { makeProxy } from './proxy'
-import { QueryMap, BindingOptions, FragmentReplacements } from './types'
+import { makeProxy, makeSubscriptionProxy } from './proxy'
+import {
+  QueryMap,
+  BindingOptions,
+  FragmentReplacements,
+  SubscriptionMap,
+  Operation,
+} from './types'
 
 export class Binding {
   query: QueryMap
   mutation: QueryMap
+  subscription: SubscriptionMap
   schema: GraphQLSchema
+  before: () => void
 
   private fragmentReplacements: FragmentReplacements
 
-  constructor({ schema, fragmentReplacements }: BindingOptions) {
+  constructor({ schema, fragmentReplacements, before }: BindingOptions) {
     this.fragmentReplacements = fragmentReplacements || {}
     this.schema = schema
+    this.before = before || (() => undefined)
 
     this.query = makeProxy<QueryMap>({
       schema: this.schema,
       fragmentReplacements: this.fragmentReplacements,
-      operation: 'query'
+      operation: 'query',
+      before: this.before,
     })
     this.mutation = makeProxy<QueryMap>({
       schema: this.schema,
       fragmentReplacements: this.fragmentReplacements,
-      operation: 'mutation'
+      operation: 'mutation',
+      before: this.before,
+    })
+    this.subscription = makeSubscriptionProxy<SubscriptionMap>({
+      schema: this.schema,
+      fragmentReplacements: this.fragmentReplacements,
+      before: this.before,
     })
   }
 
   async request<T = any>(
     query: string,
-    variables?: { [key: string]: any }
+    variables?: { [key: string]: any },
   ): Promise<T> {
     return graphql(this.schema, query, null, null, variables).then(
-      r => r.data![Object.keys(r.data!)[0]]
+      r => r.data![Object.keys(r.data!)[0]],
     )
   }
 
   async delegate(
-    operation: 'query' | 'mutation',
+    operation: Operation,
     fieldName: string,
     args: {
       [key: string]: any
     },
     context: {
       [key: string]: any
     },
-    info?: GraphQLResolveInfo | string
+    info?: GraphQLResolveInfo | string,
   ) {
     info = buildInfo(fieldName, operation, this.schema, info)
 
@@ -56,7 +72,7 @@ export class Binding {
       fieldName,
       args,
       context,
-      info
+      info,
     )
   }
 }

src/handler.ts

@@ -1,20 +1,24 @@
 import { GraphQLResolveInfo, ExecutionResult, GraphQLSchema } from 'graphql'
 import { delegateToSchema } from 'graphql-tools'
+import { $$asyncIterator } from 'iterall'
 import { FragmentReplacements } from './types'
 import { buildInfo } from './info'
 
 export class Handler<T extends object> implements ProxyHandler<T> {
   constructor(
     private schema: GraphQLSchema,
     private fragmentReplacements: FragmentReplacements,
-    private operation: 'query' | 'mutation'
+    private operation: 'query' | 'mutation',
+    private before: () => void,
   ) {}
 
   get(target: T, rootFieldName: string) {
     return (
       args?: { [key: string]: any },
-      info?: GraphQLResolveInfo | string
+      info?: GraphQLResolveInfo | string,
     ): Promise<ExecutionResult> => {
+      this.before()
+
       const operation = this.operation
       info = buildInfo(rootFieldName, operation, this.schema, info)
 
@@ -25,8 +29,59 @@ export class Handler<T extends object> implements ProxyHandler<T> {
         rootFieldName,
         args || {},
         {},
-        info
+        info,
+      )
+    }
+  }
+}
+
+export class SubscriptionHandler<T extends object> implements ProxyHandler<T> {
+  constructor(
+    private schema: GraphQLSchema,
+    private fragmentReplacements: FragmentReplacements,
+    private before: () => void,
+  ) {}
+
+  get(target: T, rootFieldName: string) {
+    return async (
+      args?: { [key: string]: any },
+      infoOrQuery?: GraphQLResolveInfo | string,
+    ): Promise<AsyncIterator<any>> => {
+      this.before()
+
+      const info = buildInfo(
+        rootFieldName,
+        'subscription',
+        this.schema,
+        infoOrQuery,
+      )
+
+      const iterator = await delegateToSchema(
+        this.schema,
+        this.fragmentReplacements,
+        'subscription',
+        rootFieldName,
+        args || {},
+        {},
+        info,
       )
+
+      return {
+        async next() {
+          const { value } = await iterator.next()
+          const data = { [info.fieldName]: value.data[rootFieldName] }
+          return { value: data, done: false }
+        },
+        return() {
+          return Promise.resolve({ value: undefined, done: true })
+        },
+        throw(error) {
+          return Promise.reject(error)
+        },
+        [$$asyncIterator]() {
+          return this
+        },
+      }
     }
   }
 }

src/info.ts

@@ -7,13 +7,14 @@ import {
   parse,
   validate,
 } from 'graphql'
+import { Operation } from './types'
 import { isScalar, getTypeForRootFieldName } from './utils'
 
 export function buildInfo(
   rootFieldName: string,
-  operation: 'query' | 'mutation',
+  operation: Operation,
   schema: GraphQLSchema,
-  info?: GraphQLResolveInfo | string
+  info?: GraphQLResolveInfo | string,
 ): GraphQLResolveInfo {
   if (!info) {
     info = buildInfoForAllScalars(rootFieldName, schema, operation)
@@ -26,7 +27,7 @@ export function buildInfo(
 export function buildInfoForAllScalars(
   rootFieldName: string,
   schema: GraphQLSchema,
-  operation: 'query' | 'mutation',
+  operation: Operation,
 ): GraphQLResolveInfo {
   const fieldNodes: FieldNode[] = []
   const type = getTypeForRootFieldName(rootFieldName, operation, schema)
@@ -51,8 +52,11 @@ export function buildInfoForAllScalars(
     fieldNodes.push(fieldNode)
   }
 
-  const parentType =
-    operation === 'query' ? schema.getQueryType() : schema.getMutationType()!
+  const parentType = {
+    query: () => schema.getQueryType(),
+    mutation: () => schema.getMutationType()!,
+    subscription: () => schema.getSubscriptionType()!,
+  }[operation]()
 
   return {
     fieldNodes,
@@ -62,7 +66,7 @@ export function buildInfoForAllScalars(
     returnType: type,
     parentType,
     path: undefined,
-    rootValue: null,
+    rootValue: undefined,
     operation: {
       kind: 'OperationDefinition',
       operation,
@@ -75,7 +79,7 @@ export function buildInfoForAllScalars(
 export function buildInfoFromFragment(
   rootFieldName: string,
   schema: GraphQLSchema,
-  operation: 'query' | 'mutation',
+  operation: Operation,
   query: string,
 ): GraphQLResolveInfo {
   const type = getTypeForRootFieldName(
@@ -97,7 +101,7 @@ export function buildInfoFromFragment(
     returnType: type,
     parentType: schema.getQueryType(),
     path: undefined,
-    rootValue: null,
+    rootValue: undefined,
     operation: {
       kind: 'OperationDefinition',
       operation,

src/proxy.ts

@@ -1,18 +1,35 @@
 import { GraphQLSchema } from 'graphql'
 import { FragmentReplacements } from './types'
-import { Handler } from './handler'
+import { Handler, SubscriptionHandler } from './handler'
 
 export function makeProxy<T extends object = any>({
   schema,
   fragmentReplacements,
-  operation
+  operation,
+  before,
 }: {
   schema: GraphQLSchema
   fragmentReplacements: FragmentReplacements
   operation: 'query' | 'mutation'
+  before: () => void
 }): T {
   return new Proxy(
     {} as T,
-    new Handler<T>(schema, fragmentReplacements, operation)
+    new Handler<T>(schema, fragmentReplacements, operation, before),
+  )
+}
+
+export function makeSubscriptionProxy<T extends object = any>({
+  schema,
+  fragmentReplacements,
+  before,
+}: {
+  schema: GraphQLSchema
+  fragmentReplacements: FragmentReplacements
+  before: () => void
+}): T {
+  return new Proxy(
+    {} as T,
+    new SubscriptionHandler<T>(schema, fragmentReplacements, before),
   )
 }

src/types.ts

@@ -1,5 +1,7 @@
 import { GraphQLResolveInfo, GraphQLSchema, InlineFragmentNode } from 'graphql'
 
+export type Operation = 'query' | 'mutation' | 'subscription'
+
 export interface FragmentReplacements {
   [typeName: string]: {
     [fieldName: string]: InlineFragmentNode
@@ -9,11 +11,19 @@ export interface FragmentReplacements {
 export interface QueryMap {
   [rootField: string]: (
     args?: any,
-    info?: GraphQLResolveInfo | string
+    info?: GraphQLResolveInfo | string,
   ) => Promise<any>
 }
 
+export interface SubscriptionMap {
+  [rootField: string]: (
+    args?: any,
+    info?: GraphQLResolveInfo | string,
+  ) => AsyncIterator<any> | Promise<AsyncIterator<any>>
+}
+
 export interface BindingOptions {
   fragmentReplacements?: FragmentReplacements
   schema: GraphQLSchema
+  before?: () => void
 }

src/utils.ts

@@ -10,6 +10,7 @@ import {
   GraphQLSchema,
   getNamedType,
 } from 'graphql'
+import { Operation } from './types'
 
 export function isScalar(t: GraphQLOutputType): boolean {
   if (t instanceof GraphQLScalarType || t instanceof GraphQLEnumType) {
@@ -40,19 +41,24 @@ export function isScalar(t: GraphQLOutputType): boolean {
 
 export function getTypeForRootFieldName(
   rootFieldName: string,
-  operation: 'query' | 'mutation',
+  operation: Operation,
   schema: GraphQLSchema,
 ): GraphQLOutputType {
   if (operation === 'mutation' && !schema.getMutationType()) {
     throw new Error(`Schema doesn't have mutation type`)
   }
 
-  const rootFields =
-    operation === 'query'
-      ? schema.getQueryType().getFields()
-      : schema.getMutationType()!.getFields()
+  if (operation === 'subscription' && !schema.getSubscriptionType()) {
+    throw new Error(`Schema doesn't have subscription type`)
+  }
+
+  const rootType = {
+    query: () => schema.getQueryType(),
+    mutation: () => schema.getMutationType()!,
+    subscription: () => schema.getSubscriptionType()!,
+  }[operation]()
 
-  const rootField = rootFields[rootFieldName]
+  const rootField = rootType.getFields()[rootFieldName]
 
   if (!rootField) {
     throw new Error(`No such root field found: ${rootFieldName}`)