compiler: support .then() and .catch()

[josephjclark]

Tricky one this.

Every operation is a promise*. So we should be able to do this in our job code:

fn(s => s).then(s)

This pattern eliminates the need for callbacks. Which is great, because operations with an optional options object and optional callback (which happens a lot) have really ugly signatures.

It also enables this:

fn(s => s).catch(s)

Which is badass! Suddenly I can catch any error I want! Which is covered by OpenFn/adaptors#496 (an issue we have with this is that really I want to pass state and error into the catch, like catch( (e, s) => {}) - but I'm not quite sure how to do that technically. Maybe a custom promise?)

The PROBLEM is that the compiler hates this.

The compiler wants to move all top-level operations into an array, like this:

export default [fn(s => s).then(s)]

First off I think this breaks everything in the runtime, because that function must be deferred. The .then() will immediately invoke it. So I think the compiler needs to do this?

export default [() => fn(s => s).then(s)]

I don't know, I need to wrap my brain around that.

But secondly, and what this issue is about, is the compiler doesn't recognise x.then() as an operation. It recognises it as a method call and ignores it.

I think basically the compiler needs to treat x().then() and x().catch() specially and do some kind of magic wrapping around them to make them work properly.

• Every job compiles to an array of functions, where each function returns an Operation (a function which takes state and returns state and may itself be a promise). Each of those operations is actually wrapped by our own Promise. So even if an operation is fn(), which is not a promise, that will be wrapped in a promise at execution time. Hurrah!

[josephjclark]

If I can get this working, we can open up a debate about removing callbacks from all operations except iterators. Which I think would be a HUGE win

[josephjclark]

This has taken some working out, and I'm still sure I'm there

fn(args).then(whatever)

Must compile to:

const f = fn(args)

export default [
  (s) => promisify(f(s)).then(whatever)
]

Which boils down to:

export default [ (s) => promisify(fn(args)(s)).then(whatever) ]

Where promisify will take the Operation returned by the operation factory (the function returned by fn(), and if the result of that operation is not a promise, it will be converted into a promise.

It's hairy and complex.

But this has to be compiler magic. I don't want special runtime requirements.

[josephjclark]

Ah, Promise.resolve would mean I don't need to create that silly helper:

So the long form is:

export default [
	(s) => {
		const operation = fn(args)
		const result = operation(s);
		return Promise.resolve(result).then(whatever)
	}
]

Which boils down to:

export default [
	(s) => Promise.resolve(fn(args)(s)).then(whatever)
]

Still a little hairy but it should work.

If the operation returns a value, it'll be passed into Promise.resolve, and straight onto the .then

If the operation returns a promise, it'll wait for that to return before triggering the then.