interate compose method into createResolver instead of a separate helper

Author: mringer

src/helper.ts

@@ -1,4 +1,4 @@
-import { createResolver } from "./resolver";
+import { createResolver, ResultFunction, ErrorFunction, Resolver } from "./resolver";
 import * as merge from "deepmerge";
 import { isFunction } from "./util";
 
@@ -41,21 +41,21 @@ export const or = (...conditions) => resolver => (...query) => {
  * @param errFn: error handler
  * @returns resolverFn: { createResolver(resFn, errFn), compose({ resolvers }): { composed resolvers } ...}
  */
-export const composable  = (resFn, errFn) => {
-  const baseResolver = createResolver(resFn, errFn);
+// export const composable = <R,E>(resFn: ResultFunction<R>, errFn:  ErrorFunction<E>) => {
+//   const baseResolver = createResolver(resFn, errFn);
 
-  baseResolver['compose'] = ( resolvers: {} ) => {
-    const composed = {};
-    Object.keys(resolvers).forEach(key => {
-      const resolver = resolvers[key];
-      composed[key] = (resolver.resolve || resolver.error)
-        // supports syntax: compose( { myResolver: { resolve: resFn, error: errFn } } )
-        ? baseResolver['createResolver'](resolver.resolve, resolver.error)
-        // suports syntax: compose( { myResolver: resolver } )
-        : baseResolver['createResolver'](resolver);
-    });
-    return composed;
-  }
+//   baseResolver['compose'] = ( resolvers: {} ) => {
+//     const composed = {};
+//     Object.keys(resolvers).forEach(key => {
+//       const _resolver = resolvers[key];
+//       composed[key] = (_resolver.resolve || _resolver.error)
+//         // supports syntax: compose( { myResolver: { resolve: resFn, error: errFn } } )
+//         ? baseResolver.createResolver(_resolver.resolve, _resolver.error)
+//         // supports syntax: compose( { myResolver: resolver } )
+//         : baseResolver.createResolver(_resolver);
+//     });
+//     return composed;
+//   }
 
-  return baseResolver;
-}
+//   return baseResolver;
+// }

src/resolver.ts

@@ -15,9 +15,14 @@ export interface CreateResolverFunction {
   <R, E>(resFn: ResultFunction<R>, errFn?: ErrorFunction<E>): Resolver<R>
 }
 
+export interface ComposeResolversFunction {
+  ( resolvers: any ): {} // { [name: string]: Resolver<R> | {} }
+}
+
 export interface Resolver<ResulType> {
   (root, args: {}, context: {}, info: {}): Promise<ResulType>
   createResolver?: CreateResolverFunction
+  compose?: ComposeResolversFunction
 }
 
 export const createResolver: CreateResolverFunction = <R, E>(resFn: ResultFunction<R>, errFn: ErrorFunction<E>) => {
@@ -38,6 +43,7 @@ export const createResolver: CreateResolverFunction = <R, E>(resFn: ResultFuncti
       });
     });
   };
+
   baseResolver.createResolver = (cResFn, cErrFn) => {
     const Promise = getPromise();
 
@@ -74,5 +80,18 @@ export const createResolver: CreateResolverFunction = <R, E>(resFn: ResultFuncti
     return createResolver(childResFn, childErrFn);
   }
 
+  baseResolver.compose = ( resolvers: {} ) => {
+    const composed = {};
+    Object.keys(resolvers).forEach(key => {
+      const _resolver = resolvers[key];
+      composed[key] = (_resolver.resolve || _resolver.error)
+        // supports syntax: compose( { myResolver: { resolve: resFn, error: errFn } } )
+        ? baseResolver.createResolver(_resolver.resolve, _resolver.error)
+        // supports syntax: compose( { myResolver: resolver } )
+        : baseResolver.createResolver(_resolver);
+    });
+    return composed;
+  }
+
   return baseResolver;
 };

test/unit/helper_spec.js

@@ -175,165 +175,4 @@ describe('(unit) src/helper.js', () => {
     });
 
   });
-
-  describe('Compose resolvers', () => {
-    const compositionErr = new Error('composition error');
-    const successResolver = createResolver(() => null, () => null);
-    const failureResolver = createResolver(() => { throw compositionErr; }, () => null);
-
-    it('composed resolvers are chained, and base resolver is called for each', () => {
-
-      const b = {
-        resolve: () => {},
-        error: d => compositionErr
-      };
-
-      stub(b, 'resolve', b.resolve);
-      
-      const base = composable(b.resolve, b.error);
-      const comp = base.compose({ 
-        r1: () => true,
-        r2: () => true,
-        r3: () => true,
-       });
-
-      return Promise.all([
-
-        comp.r1().then(r => {
-          expect(b.resolve.calledThrice).to.be.true;
-          expect(r).to.be.true;
-        }),
-
-        comp.r2().then(r => {
-          expect(b.resolve.calledThrice).to.be.true;
-          expect(r).to.be.true;
-        }),
-
-        comp.r3().then(r => {
-          expect(r).to.be.true;
-          expect(b.resolve.calledThrice).to.be.true;
-        })
-
-      ]);
-    });
-
-    it('when base throws, child is not called ', () => {
-      
-      const b = {
-        resolve: null,
-        error: d => compositionErr
-      };
-
-      const r1 = { 
-        resolve: () => true,
-        error: () => compositionErr
-      };
-      
-      stub(b, 'error', b.error);
-      stub(r1, 'error', r1.error);
-
-      const base = composable(b.resolve, b.error);
-      const comp = base.compose( { r1: r1 } );
-
-      comp.r1()
-        .catch( e => {
-          expect(b.error.calledOnce).to.be.true;
-          expect(r1.resolve.notCalled).to.be.true;
-          expect(r1.error.notCalled).to.be.true;
-          expect(e).to.equal(compositionErr);
-        });
-    });
-
-    it('when child throws, parent error is called ', () => {
-      const b = {
-        resolve: null,
-        error: d => null
-      };
-
-      const r1 = { 
-        resolve: () => true,
-        error: () => compositionErr
-      };
-      
-      stub(b, 'error', b.error);
-      stub(r1, 'error', r1.error);
-
-      const base = composable(b.resolve, b.error);
-      const comp = base.compose( { r1: r1 } );
-
-      comp.r1()
-        .catch( e => {
-          expect(b.error.calledOnce).to.be.true;
-          expect(r1.error.calledOnce).to.be.true;
-          expect(e).to.equal(compositionErr);
-        });
-    });
-
-    it('composed resolvers with { resolve: resFn, error: resFn } syntax, resolve and bubble errors correctly', () => {
-
-      const b = {
-        resolve: () => {},
-        error: d => compositionErr
-      };
-
-      const r1 = { 
-        resolve: () => { throw Error('some other error') },
-        error: () => compositionErr };
-
-      const r2 = { resolve: () => 'r2Result', error: () => compositionErr };
-      
-      stub(b, 'resolve', b.resolve);
-      stub(r1, 'error', r1.error);
-      stub(r1, 'resolve', r1.resolve);
-      stub(r2, 'resolve', r2.resolve);
-      stub(r2, 'error', r2.error);
-      
-      const base = composable(b.resolve, b.error);
-      const comp = base.compose({ 
-        r1: r1,
-        r2: r2,
-       });
-
-      return Promise.all([
-        comp.r1().catch(e => {
-          expect(e).to.equal(compositionErr);
-        }),
-        comp.r2().then(r => {
-          expect(r).to.equal('r2Result');
-        }),
-
-      ]).then(()=> {
-        expect(r1.resolve.calledOnce).to.be.true;
-        expect(r1.error.calledOnce).to.be.true;
-        expect(r2.resolve.calledOnce).to.be.true;
-        expect(r2.error.notCalled).to.be.true;
-      });
-    });
-
-    it('composed result has correct structure', () => {
-
-      const b = {
-        resolve: () => {},
-        error: d => compositionErr
-      };
-
-      stub(b, 'resolve', b.resolve);
-      
-      const base = composable(b.resolve, b.error);
-      const comp = base.compose({
-        r1: { resolve: () => { throw Error('some other error') }, error: () => compositionErr },
-        r2: { resolve: () => 'r2Result', error: () => compositionErr },
-        r3: {} // should we throw an exception since it is not a resolver or createResolver params?
-      });
-
-      const composed = { r0: () => {}, ...comp };
-
-      expect(composed.r0).to.be.a(typeof Function);
-      expect(composed.r1).to.be.a(typeof Function);
-      expect(composed.r2).to.be.a(typeof Function);
-      expect(composed.r3).to.be.a(typeof Function);
-
-    });
-
-  });
 });