Tg feature resolvers types

src/resolver.ts

@@ -1,10 +1,28 @@
 import { getPromise } from './promise';
 import { isFunction, Promisify, isNotNullOrUndefined } from './util';
 
+const Promise = getPromise();
 
-export const createResolver = (resFn, errFn) => {
+export interface ResultFunction<ResulType> {
+  (root, args, context, info): Promise<ResulType> | ResulType | void
+}
+
+export interface ErrorFunction<ErrorType> {
+  (root, args, context, err): ErrorType | void
+}
+
+export interface CreateResolverFunction {
+  <R, E>(resFn: ResultFunction<R>, errFn?: ErrorFunction<E>): Resolver<R>
+}
+
+export interface Resolver<ResulType> {
+  (root, args: {}, context: {}, info: {}): Promise<ResulType>
+  createResolver?: CreateResolverFunction
+}
+
+export const createResolver: CreateResolverFunction = <R, E>(resFn: ResultFunction<R>, errFn: ErrorFunction<E>) => {
   const Promise = getPromise();
-  const baseResolver = (root, args = {}, context = {}, info = {}) => {
+  const baseResolver: Resolver<R> = (root, args = {}, context = {}, info = {}) => {
     // Return resolving promise with `null` if the resolver function param is not a function
     if (!isFunction(resFn)) return Promise.resolve(null);
     return Promisify(resFn)(root, args, context, info).catch(e => {
@@ -20,7 +38,7 @@ export const createResolver = (resFn, errFn) => {
       });
     });
   };
-  baseResolver['createResolver'] = (cResFn, cErrFn) => {
+  baseResolver.createResolver = (cResFn, cErrFn) => {
     const Promise = getPromise();
 
     const childResFn = (root, args, context, info = {}) => {

src/util.ts

@@ -1,6 +1,6 @@
 import { getPromise } from './promise';
 
-export const isFunction = fn => typeof fn === 'function';
+export const isFunction = fn => typeof fn === 'function' || fn instanceof Function;
 
 export const Promisify = fn => {
   const Promise = getPromise();