Converting callback to Promise when I dont have the return value

Question

I am working on server that uses hapi and executes rules from node-rules.

I have a callback which is called by the R.execute method from node-rules. I need to return a Promise from the exec method as the result of executing the callback.

Code

const callback = data => {
  const {matchPath, result} = data
  descision.setMatchPath(matchPath)
  if (!result) {
    descision.addMessage(
      'No match could be found in the rules provided, either incorrect or non-matching information was provided'
    )
  }
}

function exec (input) {
  const {medicineType, facts: data} = input
  const R = new RuleEngine()
  R.register(rules)
  if (medicineType !== 'generic') {
    const facts = {
      data
    }
    R.execute(facts, callback)
  }
}

I noticed from the source code that R.execute does not return anything that I can use. I notice that in execute calls this function here recursively but does not terminate without the callback.

How can I convert this to a function that returns a Promise?

Why do you want to return a `Promise` instead of working with the `callback` function? — ishmaelMakitla, Jul 31 '17 at 06:56
@ishmaelMakitla the `hapi` server is awaiting the result of the rule engine so that it can respond with a value, so I need to return a `Promise`. — vamsiampolu, Jul 31 '17 at 06:58
`execute` might not return anything, but it calls the `callback` given to it. Ain't that enough? — Bergi, Jul 31 '17 at 09:14

score 0 · Answer 1 · answered Jul 31 '17 at 07:08

Not sure if i understand correctly but something like this might do

function exec(input) {
    const { medicineType, facts: data } = input
    const R = new RuleEngine()
    R.register(rules)

    return new Promise(function(resolve, reject) {
        if (medicineType !== 'generic') {
            const facts = {
                data
            }
            R.execute(facts, function(data) {
                const { matchPath, result } = data
                descision.setMatchPath(matchPath)
                if (!result) {
                    descision.addMessage(
                        'No match could be found in the rules provided, either incorrect or non-matching information was provided'
                    )
                }
                resolve('<return here whatever you want>')
                // or
                // reject('<return some error>')
            });
        } else {
            reject('<return some error>')
        }
    })
}

vamsiampolu · Accepted Answer · 2017-08-04T03:31:03.317

While browsing through some of the answers for other questions, I remembered the $.deferredand Q.defer API, I found a solution that resembles them:

creates a deferred
passes the deferred to the callback
uses the deferred and resolve the promise
and most importantly, return the promise that was created by the deferred

I did not want a custom Promise implementation or to monkey-patch the Promise API. If the latter is not a problem, there are several modules on npm which do this and polyfill Promise.defer.

The defer function is from here

The code now looks like:

/* eslint-disable promise/param-names */
function defer () {
  let resolve, reject
  const promise = new Promise(function (...args) {
    resolve = args[0]
    reject = args[1]
  })
  return {resolve, reject, promise}
}

/* eslint-enable promise/param-names */

const makeCallback = deferred => data => {
  const {matchPath, result} = data
  descision.setMatchPath(matchPath)
  if (!result) {
    descision.addMessage(
      'No match could be found in the rules provided, either incorrect or non-matching information was provided'
    )
  }
  deferred.resolve(descision)
}

function exec (input) {
  const {medicineType, facts: data} = input
  const R = new RuleEngine()
  R.register(rules)
  if (lenderType !== 'generic') {
    const facts = {
      data
    }
    const deferred = defer()
    const callback = makeCallback(deferred)
    R.execute(facts, callback)
    return deferred.promise
  }
}

Regarding your edit, you misunderstood how `await` work. It needs to get a promise, and `R.execute` with a callback doesn't return one. — Bergi, Aug 01 '17 at 03:23
@Bergi I agree that it should not work because there is no return value from the `R.execute` or the `callback` and no Promise was used, this is a bit of concern for me as well. The library calls the callback using `process.nextTick`, is that a possible reason for it to wait until callback is invoked. — vamsiampolu, Aug 02 '17 at 00:11
@Bergi Removed, the false positive was because the callback finished before the next line could be reached as I did not have a sufficient number of rules to do a real test. — vamsiampolu, Aug 04 '17 at 03:32

Converting callback to Promise when I dont have the return value

2 Answers2