rebase

Author: mringer

src/helper.ts

@@ -30,34 +30,28 @@ export const or = (...conditions) => resolver => (...query) => {
   });
 }
 
-export class Composable {
-  resolver: any; // stricter types won't pass the compiler because createResolver is unexpected on Funciton.
-
-  /**
-   * 
-   * @param resolver 
-   * TODO: a Resolver type is probably needed, but outside the scope of this PR because it requires refactoring resolver.ts
-   */
-  constructor(resFn, errFn) {
-    this.resolver = createResolver(resFn, errFn);
-  }
-
-  /**
-   * 
-   * @param resolvers 
-   */
-  public compose( resolvers: {} ) {
+/**
+ * Constructs a composable resolver with the same arguments as createResolver.
+ * The composable resolver provides the compose method which takes an object of named resolver functions.
+ * @param resFn resolver function
+ * @param errFn error handler
+ */
+export const composable  = (resFn, errFn) => {
+  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) 
-        ? this.resolver.createResolver(resolver.resolve, resolver.error)
-        : this.resolver.createResolver(resolver);
+      // composed[key] = baseResolver['createResolver'](resolver);
+      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;
   }
 
+  return baseResolver;
 }

test/unit/helper_spec.js

@@ -2,7 +2,7 @@ import { expect } from 'chai';
 import { stub } from 'sinon';
 
 import {
-  combineResolvers, and, or, compose, Composable
+  combineResolvers, and, or, compose, composable
 } from '../../dist/helper';
 import { createResolver } from '../../dist/resolver';
 import { resolveAll } from 'jspm-config';
@@ -190,7 +190,7 @@ describe('(unit) src/helper.js', () => {
 
       stub(b, 'resolve', b.resolve);
 
-      const base = new Composable(b.resolve, b.error);
+      const base = composable(b.resolve, b.error);
       const comp = base.compose({ 
         r1: () => true,
         r2: () => true,
@@ -232,7 +232,7 @@ describe('(unit) src/helper.js', () => {
       stub(b, 'error', b.error);
       stub(r1, 'error', r1.error);
 
-      const base = new Composable(b.resolve, b.error);
+      const base = composable(b.resolve, b.error);
       const comp = base.compose( { r1: r1 } );
 
       comp.r1()
@@ -245,7 +245,6 @@ describe('(unit) src/helper.js', () => {
     });
 
     it('when child throws, parent error is called ', () => {
-      
       const b = {
         resolve: null,
         error: d => null
@@ -259,7 +258,7 @@ describe('(unit) src/helper.js', () => {
       stub(b, 'error', b.error);
       stub(r1, 'error', r1.error);
 
-      const base = new Composable(b.resolve, b.error);
+      const base = composable(b.resolve, b.error);
       const comp = base.compose( { r1: r1 } );
 
       comp.r1()
@@ -270,5 +269,69 @@ describe('(unit) src/helper.js', () => {
         });
     });
 
+    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 this throw an exception since it is not a resolver or createResolver params?
+      });
+
+      console.log(typeof Function);
+      expect(comp.r1).to.be.a(typeof Function);
+      expect(comp.r2).to.be.a(typeof Function);
+      expect(comp.r3).to.be.a(typeof Function);
+
+    });
+
   });
 });