Chaining promises with RxJS

Question

I'm new to RxJS and FRP in general. I had the idea of converting an existing promise chain in my ExpressJS application to be an observable for practice. I am aware that this probably isn't the best example but maybe someone can help shed some light.

What I'm trying to do:

1. I have two promises - prom1 and prom2
2. I want prom1 to run before prom2
3. If prom1 sends a reject(err), I want to cancel prom2 before it starts.
4. I want the error message prom1 returns to be available to the onError method on the observer.

---

var prom1 = new Promise(function(resolve, reject) {
    if (true) {
       reject('reason');
    }
    resolve(true);
});

var prom2 = new Promise(function(resolve, reject) {
    resolve(true);
});

// What do I do here? This is what I've tried so far...
var source1 = Rx.Observable.fromPromise(prom1);
var source2 = source1.flatMap(Rx.Observable.fromPromise(prom2));

var subscription = source2.subscribe(
    function (result) { console.log('Next: ' + result); },

    // I want my error 'reason' to be made available here
    function (err) { console.log('Error: ' + err); },

    function () { console.log('Completed'); });

Solution 1

If I understood what you are trying to do - you need to create two deferred observables from functions that return promises and concat them:

var shouldFail = false;

function action1() {
    return new Promise(function (resolve, reject) {    
        console.log('start action1');
        if (shouldFail) {
            reject('reason');
        }
        resolve(true);
    });
}

function action2() {
    return new Promise(function (resolve, reject) {    
        console.log('start action2');
        resolve(true);
    });
}

var source1 = Rx.Observable.defer(action1);
var source2 = Rx.Observable.defer(action2);

var combination = Rx.Observable.concat(source1, source2);

var logObserver = Rx.Observer.create(

function (result) {
    console.log('Next: ' + result);
},

function (err) {
    console.log('Error: ' + err);
},

function () {
    console.log('Completed');
});

then for normal case:

combination.subscribe(logObserver);
// start action1
// Next: true
// start action2
// Next: true
// Completed

And case where fisrt promise fails:

shouldFail = true;
combination.subscribe(logObserver);
// start action1
// Error: reason

http://jsfiddle.net/cL37tgva/

Solution 2

flatMap turns an Observable of Observables into an Observable. It's used in many examples with Promises because often you have an observable and in the map function you want to create a promise for each "item" the observable emmits. Because every fromPromise call creates a new Observable, that makes it an "observable of observables". flatMap reduces that to a "flat" observable.

In your example you do something different, you turn a single promise into an observable and want to chain it with another observable (also created form a single promise). Concat does what you are looking for, it chains two observables together.

The error case will work as you would expect.

Comments

[Pathsofdesign]

Thanks for this! I'm finding I don't need to use the the defer() bit but can pass the two promise functions in to concat() and get the results I need. Am I missing anything by doing it this way?

[Bogdan Savluk]

In that case both promises would be created(started) immediately(in point where you call concat, but not when you are actually subscribing) and second promise will not wait first one to resolve before start.

[Pathsofdesign]

With the defer()s, what if the second promise returns before the first? Is this where concat() keeps them in order?

[Pathsofdesign]

It looks like concat(a,b,c) is smart enough to run things synchronously. Even if b is finished first, it still runs in order a, b, c.

[piccy]

forkJoin might not be the right choice here, because forkJoin allows all its observables to run in parallel. The OP wanted the observables to run sequentially.