Promise-aware compute macros

-computed-promise.js

import computed from 'ember-macro-helpers/computed';

import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';

import { typeOf } from '@ember/utils';
import { all } from 'rsvp';

export default function(Proxy) {
  const PromiseProxy = Proxy.extend(PromiseProxyMixin);

  return function(...dependentKeys) {
    let callback = value => value;

    if (typeOf(dependentKeys[dependentKeys.length - 1]) === 'function') {
      callback = dependentKeys.pop();
    }

    return computed(...dependentKeys, function(...promises) {
      const promise = all(promises)
        .then(values => callback.apply(this, values));

      return PromiseProxy.create({ promise });
    });
  };
}

computed-promise-array.js

import buildComputedPromise from './-computed-promise';

import ArrayProxy from '@ember/array/proxy';

export default buildComputedPromise(ArrayProxy);

computed-promise-object.js

import buildComputedPromise from './-computed-promise';

import ObjectProxy from '@ember/object/proxy';

export default buildComputedPromise(ObjectProxy);

example-model.js

import Model from 'ember-data/model'; 

import { belongsTo, hasMany } from 'ember-data/relationships';
import computedPromiseArray from '../macros/computed-promise-array';
import computedPromiseObject from '../macros/computed-promise-object';

export default Model.extend({
  foo: belongsTo(),
  bars: hasMany(),
  
  fooDerivative: computedPromiseObject('foo', (foo) => {
    // foo is resolved here, not a promise of an object
  }),
  
  barsDerivative: computedPromiseArray('bars.[]', (bars) => {
    // bars is resolved here, not a promise of an array
  }),
});