Repository: ViacomInc/data-point
Pull request #446 (2019-10-22 18:56:05)

feat(data-point): migrate to async/await
<!--
Thanks for your interest in the project. We appreciate bugs filed and PRs submitted!

Please make sure that you are familiar with and follow the Code of Conduct for
this project (found in the CODE_OF_CONDUCT.md file).

Also, please make sure you're familiar with and follow the instructions in the
contributing guidelines (found in the CONTRIBUTING.md file).

Please fill out the information below to expedite the review and (hopefully)
merge of your pull request!

BREAKING CHANGES:

If your PR includes a breaking change, please submit it with a codemod under
data-point-codemods that will help users upgrade their codebase.

Breaking changes without a codemod will not be accepted unless a codemod is not
viable or does not apply to the specific situation.
-->

<!-- What changes are being made? (What feature/bug is being fixed here?) -->
**What**:

Migrate data-point package to async/await - drops bluebird dependency

re: #434

<!-- Why are these changes necessary? -->
**Why**:

<!-- How were these changes implemented? -->
**How**:

<!-- Have you done all of these things?  -->
**Checklist**:
<!-- add "N/A" to the end of each line that's irrelevant to your changes -->
<!-- to check an item, place an "x" in the box like so: "- [x] Documentation" -->
- [ ] Has Breaking changes
- [ ] Documentation
- [X] Tests
- [X] Ready to be merged <!-- In your opinion, is this ready to be merged as soon as it's reviewed? -->
- [ ] Added username to **all-contributors** list

<!-- feel free to add additional comments -->


codecov[bot]: # [Codecov](https://codecov.io/gh/ViacomInc/data-point/pull/446?src=pr&el=h1) Report
> Merging [#446](https://codecov.io/gh/ViacomInc/data-point/pull/446?src=pr&el=desc) into [master](https://codecov.io/gh/ViacomInc/data-point/commit/60267a2d2a01b39410f20c8953f6b71430d4d6ed?src=pr&el=desc) will **not change** coverage.
> The diff coverage is `100%`.

[![Impacted file tree graph](https://codecov.io/gh/ViacomInc/data-point/pull/446/graphs/tree.svg?width=650&token=LYxItnrx4i&height=150&src=pr)](https://codecov.io/gh/ViacomInc/data-point/pull/446?src=pr&el=tree)

```diff
@@          Coverage Diff          @@
##           master   #446   +/-   ##
=====================================
  Coverage     100%   100%           
=====================================
  Files         139    139           
  Lines        1990   1972   -18     
  Branches      182    195   +13     
=====================================
- Hits         1990   1972   -18
```


| [Impacted Files](https://codecov.io/gh/ViacomInc/data-point/pull/446?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [...ta-point/lib/reducer-types/reducer-list/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvcmVkdWNlci10eXBlcy9yZWR1Y2VyLWxpc3QvcmVzb2x2ZS5qcw==) | `100% <100%> (ø)` | :arrow_up: |
| [packages/data-point/lib/helpers/helpers.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvaGVscGVycy9oZWxwZXJzLmpz) | `100% <100%> (ø)` | :arrow_up: |
| [...er-types/reducer-helpers/reducer-filter/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvcmVkdWNlci10eXBlcy9yZWR1Y2VyLWhlbHBlcnMvcmVkdWNlci1maWx0ZXIvcmVzb2x2ZS5qcw==) | `100% <100%> (ø)` | :arrow_up: |
| [...ucer-types/reducer-helpers/reducer-find/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvcmVkdWNlci10eXBlcy9yZWR1Y2VyLWhlbHBlcnMvcmVkdWNlci1maW5kL3Jlc29sdmUuanM=) | `100% <100%> (ø)` | :arrow_up: |
| [...-types/reducer-helpers/reducer-constant/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvcmVkdWNlci10eXBlcy9yZWR1Y2VyLWhlbHBlcnMvcmVkdWNlci1jb25zdGFudC9yZXNvbHZlLmpz) | `100% <100%> (ø)` | :arrow_up: |
| [packages/data-point/lib/reducer-types/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvcmVkdWNlci10eXBlcy9yZXNvbHZlLmpz) | `100% <100%> (ø)` | :arrow_up: |
| [...data-point/lib/entity-types/base-entity/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvZW50aXR5LXR5cGVzL2Jhc2UtZW50aXR5L3Jlc29sdmUuanM=) | `100% <100%> (ø)` | :arrow_up: |
| [...a-point/lib/entity-types/entity-control/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvZW50aXR5LXR5cGVzL2VudGl0eS1jb250cm9sL3Jlc29sdmUuanM=) | `100% <100%> (ø)` | :arrow_up: |
| [packages/data-point/lib/core/transform.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvY29yZS90cmFuc2Zvcm0uanM=) | `100% <100%> (ø)` | :arrow_up: |
| [...-point/lib/reducer-types/reducer-object/resolve.js](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree#diff-cGFja2FnZXMvZGF0YS1wb2ludC9saWIvcmVkdWNlci10eXBlcy9yZWR1Y2VyLW9iamVjdC9yZXNvbHZlLmpz) | `100% <100%> (ø)` | :arrow_up: |
| ... and [12 more](https://codecov.io/gh/ViacomInc/data-point/pull/446/diff?src=pr&el=tree-more) | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/ViacomInc/data-point/pull/446?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/ViacomInc/data-point/pull/446?src=pr&el=footer). Last update [60267a2...d705022](https://codecov.io/gh/ViacomInc/data-point/pull/446?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).


Patch:
diff --git a/packages/data-point/lib/core/transform.js b/packages/data-point/lib/core/transform.js
index c112636..4ca21fe 100644
--- a/packages/data-point/lib/core/transform.js
+++ b/packages/data-point/lib/core/transform.js
@@ -1,5 +1,4 @@
 const _ = require("lodash");
-const Promise = require("bluebird");
 
 const Reducer = require("../reducer-types");
 const AccumulatorFactory = require("../accumulator/factory");
@@ -26,7 +25,7 @@ function resolveFromAccumulator(manager, reducerSource, context) {
 
 module.exports.resolveFromAccumulator = resolveFromAccumulator;
 
-function reducerResolve(manager, reducerSource, value, options) {
+async function reducerResolve(manager, reducerSource, value, options) {
   const contextOptions = getOptions(options);
   const context = AccumulatorFactory.create({
     value,
@@ -36,25 +35,41 @@ function reducerResolve(manager, reducerSource, value, options) {
     values: manager.values.getStore()
   });
 
-  const result = resolveFromAccumulator(manager, reducerSource, context).then(
-    resolvedValue => utils.set(context, "value", resolvedValue)
+  const resolvedValue = await resolveFromAccumulator(
+    manager,
+    reducerSource,
+    context
   );
 
-  return !context.trace ? result : result.then(Trace.traceReducer);
+  const resolvedContext = utils.set(context, "value", resolvedValue);
+
+  return !context.trace ? resolvedContext : Trace.traceReducer(resolvedContext);
 }
 
-function transform(manager, reducerSource, value, options, done) {
-  return Promise.resolve()
-    .then(() => reducerResolve(manager, reducerSource, value, options))
-    .asCallback(done);
+async function transform(manager, reducerSource, value, options, done) {
+  let acc;
+  try {
+    acc = await reducerResolve(manager, reducerSource, value, options);
+    if (done) {
+      done(null, acc);
+      return undefined;
+    }
+  } catch (error) {
+    if (done) {
+      done(error);
+    } else {
+      throw error;
+    }
+  }
+
+  return acc;
 }
 
 module.exports.transform = transform;
 
-function resolve(manager, reducerSource, value, options) {
-  return Promise.resolve()
-    .then(() => reducerResolve(manager, reducerSource, value, options))
-    .then(acc => acc.value);
+async function resolve(manager, reducerSource, value, options) {
+  const acc = await reducerResolve(manager, reducerSource, value, options);
+  return acc.value;
 }
 
 module.exports.resolve = _.curry(resolve, 3);
diff --git a/packages/data-point/lib/entity-types/base-entity/resolve.js b/packages/data-point/lib/entity-types/base-entity/resolve.js
index 9106de7..e62785a 100644
--- a/packages/data-point/lib/entity-types/base-entity/resolve.js
+++ b/packages/data-point/lib/entity-types/base-entity/resolve.js
@@ -1,7 +1,6 @@
 const debug = require("debug");
 const memoize = require("lodash/memoize");
 const merge = require("lodash/merge");
-const Promise = require("bluebird");
 
 const middleware = require("../../middleware");
 const utils = require("../../utils");
@@ -18,56 +17,6 @@ function createDebugEntity(entityType) {
 // per entity type
 const debugEntity = memoize(createDebugEntity);
 
-/**
- * @param {Object} manager
- * @param {Error} error
- * @param {Accumulator} accumulator
- * @param {Function} resolveReducer
- * @returns {Promise}
- */
-function resolveErrorReducers(manager, error, accumulator, resolveReducer) {
-  const errorReducer = accumulator.reducer.spec.error;
-  if (!errorReducer) {
-    return Promise.reject(error);
-  }
-
-  const errorAccumulator = utils.set(accumulator, "value", error);
-  return resolveReducer(manager, errorAccumulator, errorReducer);
-}
-
-module.exports.resolveErrorReducers = resolveErrorReducers;
-
-/**
- * @param {Promise} promise
- * @param {*} condition
- * @param {Accumulator} accumulator
- * @param {Function} callback
- * @returns {Promise}
- */
-function addToPromiseChain(promise, condition, accumulator, callback) {
-  if (!condition) {
-    return promise;
-  }
-
-  return promise.then(result => {
-    return callback(utils.set(accumulator, "value", result));
-  });
-}
-
-/**
- * @param {Error} error
- * @returns {*} bypass value
- * @throws rethrows error if bypass was not found
- */
-function handleByPassError(error) {
-  // checking if this is an error to bypass the `then` chain
-  if (error.bypass === true) {
-    return error.bypassValue;
-  }
-
-  throw error;
-}
-
 /**
  * @param {Reducer} reducer
  * @param {Object} entity
@@ -128,57 +77,14 @@ function createCurrentAccumulator(accumulator, reducer, entity) {
 
 module.exports.createCurrentAccumulator = createCurrentAccumulator;
 
-/**
- * Resolves a middleware, this method contains a 'hack'
- * which consists in using an error to bypass the
- * chain of promise then that come after it.
- *
- * If there is a better/faster more elegant way to do this
- * then pls let me know and send a PR
- *
- * @param {Object} manager - dataPoint instance
- * @param {Promise} promise - should resolve to the current accumulator
- * @param {string} name - name of middleware to execute
- * @returns {Promise}
- */
-function resolveMiddleware(manager, accumulator, name) {
-  return middleware
-    .resolve(manager, name, accumulator)
-    .then(middlewareResult => {
-      // eslint-disable-next-line no-underscore-dangle
-      if (middlewareResult.___resolve === true) {
-        accumulator.debug(accumulator.uid, "- will bypass");
-        // doing this until proven wrong :)
-        const err = new Error("bypassing middleware");
-        err.name = "bypass";
-        err.bypass = true;
-        err.bypassValue = middlewareResult.value;
-        throw err;
-      }
-
-      return middlewareResult.value;
-    });
-}
-
-module.exports.resolveMiddleware = resolveMiddleware;
-
-/**
- * @param {Object} manager
- * @param {Accumulator} accumulator
- * @param {Reducer} reducer
- * @param {Function} resolveReducer
- * @returns {Promise}
- */
-function typeCheck(manager, accumulator, reducer, resolveReducer) {
-  // returns original accumulator if there's no error
-  // this helps prevent type check reducers from mutating the value, but
-  // it's still possible to modify the value by reference when it's an object
-  return resolveReducer(manager, accumulator, reducer).return(
-    accumulator.value
+function resolveMiddleware(manager, middlewareName, accumulator, value) {
+  return middleware.resolve(
+    manager,
+    middlewareName,
+    utils.set(accumulator, "value", value)
   );
 }
 
-module.exports.typeCheck = typeCheck;
 /**
  * @param {Object} manager
  * @param {Function} resolveReducer
@@ -187,20 +93,20 @@ module.exports.typeCheck = typeCheck;
  * @param {Object} entity
  * @returns {Promise}
  */
-function resolveEntity(manager, resolveReducer, accumulator, reducer, entity) {
+async function resolveEntity(
+  manager,
+  resolveReducer,
+  accumulator,
+  reducer,
+  entity
+) {
   const currentAccumulator = createCurrentAccumulator(
     accumulator,
     reducer,
     entity
   );
 
-  const {
-    inputType,
-    value,
-    before,
-    after,
-    outputType
-  } = currentAccumulator.reducer.spec;
+  const spec = currentAccumulator.reducer.spec;
 
   const trace = currentAccumulator.context.params.trace === true;
 
@@ -213,98 +119,147 @@ function resolveEntity(manager, resolveReducer, accumulator, reducer, entity) {
 
   currentAccumulator.debug(currentAccumulator.uid, "- resolve:start");
 
-  let result = Promise.resolve(currentAccumulator.value);
+  let value = currentAccumulator.value;
 
-  result = addToPromiseChain(result, inputType, currentAccumulator, acc =>
-    typeCheck(manager, acc, inputType, resolveReducer)
-  );
-
-  result = addToPromiseChain(
-    result,
-    manager.middleware.store.has("before"),
-    currentAccumulator,
-    acc => resolveMiddleware(manager, acc, "before")
-  );
+  let byPass = false;
 
-  const middlewareEntityBefore = `${reducer.entityType}:before`;
-  result = addToPromiseChain(
-    result,
-    manager.middleware.store.has(middlewareEntityBefore),
-    currentAccumulator,
-    acc => resolveMiddleware(manager, acc, middlewareEntityBefore)
-  );
-
-  result = addToPromiseChain(result, before, currentAccumulator, acc =>
-    resolveReducer(manager, acc, before)
-  );
+  try {
+    if (spec.inputType) {
+      await resolveReducer(manager, currentAccumulator, spec.inputType);
+    }
 
-  result = addToPromiseChain(result, value, currentAccumulator, acc =>
-    resolveReducer(manager, acc, value)
-  );
+    if (manager.middleware.store.has("before")) {
+      const middlewareResult = await resolveMiddleware(
+        manager,
+        "before",
+        currentAccumulator,
+        value
+      );
 
-  result = result.then(resultValue => {
-    currentAccumulator.debug(currentAccumulator.uid, "- resolve");
-    const acc = utils.set(currentAccumulator, "value", resultValue);
-    return entity.resolve(acc, resolveReducer.bind(null, manager));
-  });
+      // eslint-disable-next-line no-underscore-dangle
+      if (middlewareResult.___resolve === true) {
+        byPass = true;
+        value = middlewareResult.value;
+      }
+    }
 
-  result = addToPromiseChain(result, after, currentAccumulator, acc =>
-    resolveReducer(manager, acc, after)
-  );
+    const middlewareEntityBefore = `${reducer.entityType}:before`;
+    if (!byPass && manager.middleware.store.has(middlewareEntityBefore)) {
+      const middlewareResult = await resolveMiddleware(
+        manager,
+        middlewareEntityBefore,
+        currentAccumulator,
+        value
+      );
 
-  const middlewareEntityAfter = `${reducer.entityType}:after`;
-  result = addToPromiseChain(
-    result,
-    manager.middleware.store.has(middlewareEntityAfter),
-    currentAccumulator,
-    acc => resolveMiddleware(manager, acc, middlewareEntityAfter)
-  );
+      // eslint-disable-next-line no-underscore-dangle
+      if (middlewareResult.___resolve === true) {
+        byPass = true;
+        value = middlewareResult.value;
+      }
+    }
 
-  result = addToPromiseChain(
-    result,
-    manager.middleware.store.has("after"),
-    currentAccumulator,
-    acc => resolveMiddleware(manager, acc, "after")
-  );
+    if (!byPass) {
+      if (spec.before) {
+        value = await resolveReducer(
+          manager,
+          utils.set(currentAccumulator, "value", value),
+          spec.before
+        );
+      }
 
-  result = result.catch(handleByPassError);
+      if (spec.value) {
+        value = await resolveReducer(
+          manager,
+          utils.set(currentAccumulator, "value", value),
+          spec.value
+        );
+      }
 
-  result = addToPromiseChain(result, outputType, currentAccumulator, acc =>
-    typeCheck(manager, acc, outputType, resolveReducer)
-  );
+      currentAccumulator.debug(currentAccumulator.uid, "- resolve");
+      value = await entity.resolve(
+        utils.set(currentAccumulator, "value", value),
+        resolveReducer.bind(null, manager)
+      );
 
-  return result
-    .catch(error => {
-      // attach entity information to help debug
-      // eslint-disable-next-line no-param-reassign
-      error.entityId = currentAccumulator.reducer.spec.id;
+      if (spec.after) {
+        value = await resolveReducer(
+          manager,
+          utils.set(currentAccumulator, "value", value),
+          spec.after
+        );
+      }
+    }
 
-      let errorResult = resolveErrorReducers(
+    const middlewareEntityAfter = `${reducer.entityType}:after`;
+    if (manager.middleware.store.has(middlewareEntityAfter)) {
+      const middlewareResult = await resolveMiddleware(
         manager,
-        error,
+        middlewareEntityAfter,
         currentAccumulator,
-        resolveReducer
+        value
       );
 
-      errorResult = addToPromiseChain(
-        errorResult,
-        outputType,
+      // eslint-disable-next-line no-underscore-dangle
+      if (middlewareResult.___resolve === true) {
+        byPass = true;
+        value = middlewareResult.value;
+      }
+    }
+
+    if (!byPass && manager.middleware.store.has("after")) {
+      const middlewareResult = await resolveMiddleware(
+        manager,
+        "after",
         currentAccumulator,
-        acc => typeCheck(manager, acc, outputType, resolveReducer)
+        value
       );
 
-      return errorResult;
-    })
-    .then(finalValue => {
-      if (trace === true) {
-        // eslint-disable-next-line no-console
-        console.timeEnd(timeId);
+      // eslint-disable-next-line no-underscore-dangle
+      if (middlewareResult.___resolve === true) {
+        byPass = true;
+        value = middlewareResult.value;
       }
+    }
 
-      currentAccumulator.debug(currentAccumulator.uid, `- resolve:end`);
+    if (spec.outputType) {
+      await resolveReducer(
+        manager,
+        utils.set(currentAccumulator, "value", value),
+        spec.outputType
+      );
+    }
+  } catch (error) {
+    // attach entity information to help debug
+    // eslint-disable-next-line no-param-reassign
+    error.entityId = currentAccumulator.reducer.spec.id;
 
-      return finalValue;
-    });
+    if (!spec.error) {
+      throw error;
+    }
+
+    value = await resolveReducer(
+      manager,
+      utils.set(currentAccumulator, "value", error),
+      spec.error
+    );
+
+    if (spec.outputType) {
+      await resolveReducer(
+        manager,
+        utils.set(currentAccumulator, "value", value),
+        spec.outputType
+      );
+    }
+  } finally {
+    if (trace === true) {
+      // eslint-disable-next-line no-console
+      console.timeEnd(timeId);
+    }
+    currentAccumulator.debug(currentAccumulator.uid, `- resolve:end`);
+  }
+
+  return value;
 }
 
 module.exports.resolveEntity = resolveEntity;
@@ -317,11 +272,11 @@ module.exports.resolveEntity = resolveEntity;
  * @param {Object} entity
  * @returns {Promise<Accumulator>}
  */
-function resolve(manager, resolveReducer, accumulator, reducer, entity) {
+async function resolve(manager, resolveReducer, accumulator, reducer, entity) {
   const hasEmptyConditional = reducer.hasEmptyConditional;
 
   if (hasEmptyConditional && utils.isFalsy(accumulator.value)) {
-    return Promise.resolve(accumulator.value);
+    return accumulator.value;
   }
 
   if (!reducer.asCollection) {
@@ -329,10 +284,10 @@ function resolve(manager, resolveReducer, accumulator, reducer, entity) {
   }
 
   if (!Array.isArray(accumulator.value)) {
-    return Promise.resolve(undefined);
+    return undefined;
   }
 
-  return Promise.map(accumulator.value, itemValue => {
+  const promises = accumulator.value.map(itemValue => {
     if (hasEmptyConditional && utils.isFalsy(itemValue)) {
       return itemValue;
     }
@@ -340,6 +295,8 @@ function resolve(manager, resolveReducer, accumulator, reducer, entity) {
     const itemCtx = utils.set(accumulator, "value", itemValue);
     return resolveEntity(manager, resolveReducer, itemCtx, reducer, entity);
   });
+
+  return Promise.all(promises);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/entity-types/entity-control/resolve.js b/packages/data-point/lib/entity-types/entity-control/resolve.js
index a791724..b92bf4c 100644
--- a/packages/data-point/lib/entity-types/entity-control/resolve.js
+++ b/packages/data-point/lib/entity-types/entity-control/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 /**
  *
  * @param {Array<Object>} caseStatements
@@ -7,32 +5,18 @@ const Promise = require("bluebird");
  * @param {Function} resolveReducer
  * @return {Promise}
  */
-function getMatchingCaseStatement(caseStatements, acc, resolveReducer) {
-  return Promise.reduce(
-    caseStatements,
-    (result, statement) => {
-      if (result) {
-        // doing this until proven wrong :)
-        const err = new Error("bypassing");
-        err.name = "bypass";
-        err.bypass = true;
-        err.bypassValue = result;
-        return Promise.reject(err);
-      }
+async function getMatchingCaseStatement(caseStatements, acc, resolveReducer) {
+  for (let index = 0; index < caseStatements.length; index += 1) {
+    const statement = caseStatements[index];
 
-      return resolveReducer(acc, statement.case).then(value => {
-        return value ? statement : false;
-      });
-    },
-    null
-  ).catch(error => {
-    // checking if this is an error to bypass the `then` chain
-    if (error.bypass === true) {
-      return error.bypassValue;
+    // eslint-disable-next-line no-await-in-loop
+    const value = await resolveReducer(acc, statement.case);
+    if (value) {
+      return statement;
     }
+  }
 
-    throw error;
-  });
+  return undefined;
 }
 module.exports.getMatchingCaseStatement = getMatchingCaseStatement;
 
@@ -41,20 +25,22 @@ module.exports.getMatchingCaseStatement = getMatchingCaseStatement;
  * @param {Function} resolveReducer
  * @return {Promise}
  */
-function resolve(acc, resolveReducer) {
+async function resolve(acc, resolveReducer) {
   const selectControl = acc.reducer.spec.select;
   const caseStatements = selectControl.cases;
   const defaultTransform = selectControl.default;
 
-  return getMatchingCaseStatement(caseStatements, acc, resolveReducer).then(
-    caseStatement => {
-      if (caseStatement) {
-        return resolveReducer(acc, caseStatement.do);
-      }
-
-      return resolveReducer(acc, defaultTransform);
-    }
+  const caseStatement = await getMatchingCaseStatement(
+    caseStatements,
+    acc,
+    resolveReducer
   );
+
+  if (caseStatement) {
+    return resolveReducer(acc, caseStatement.do);
+  }
+
+  return resolveReducer(acc, defaultTransform);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/entity-types/entity-request/resolve.js b/packages/data-point/lib/entity-types/entity-request/resolve.js
index 708899c..cb6858d 100644
--- a/packages/data-point/lib/entity-types/entity-request/resolve.js
+++ b/packages/data-point/lib/entity-types/entity-request/resolve.js
@@ -1,6 +1,5 @@
 const _ = require("lodash");
 const fp = require("lodash/fp");
-const Promise = require("bluebird");
 const rp = require("request-promise");
 
 const utils = require("../../utils");
@@ -81,13 +80,12 @@ module.exports.resolveUrl = resolveUrl;
  * @param {Function} resolveReducer
  * @return {Promise<Accumulator>}
  */
-function resolveOptions(accumulator, resolveReducer) {
+async function resolveOptions(accumulator, resolveReducer) {
   const url = resolveUrl(accumulator);
   const specOptions = accumulator.reducer.spec.options;
-  return resolveReducer(accumulator, specOptions).then(value => {
-    const options = getRequestOptions(url, value);
-    return utils.assign(accumulator, { options });
-  });
+  const value = await resolveReducer(accumulator, specOptions);
+  const options = getRequestOptions(url, value);
+  return utils.assign(accumulator, { options });
 }
 
 module.exports.resolveOptions = resolveOptions;
@@ -153,43 +151,45 @@ module.exports.inspect = inspect;
  * @param {Function} resolveReducer
  * @return {Promise<Accumulator>}
  */
-function resolveRequest(acc) {
+async function resolveRequest(acc) {
   const options = Object.assign({}, acc.options, {
     resolveWithFullResponse: true
   });
 
-  const request = rp(options);
-  inspect(acc, request);
-  return request
-    .then(res => res.body)
-    .catch(error => {
-      // remove auth objects from acc and error for printing to console
-      const redactedAcc = fp.set("options.auth", "[omitted]", acc);
-      const redactedError = fp.set("options.auth", "[omitted]", error);
-
-      const message = [
-        "Entity info:",
-        "\n  - Id: ",
-        _.get(redactedAcc, "reducer.spec.id"),
-        "\n",
-        utils.inspectProperties(
-          redactedAcc,
-          ["options", "params", "value"],
-          "  "
-        ),
-        "\n  Request:\n",
-        utils.inspectProperties(
-          redactedError,
-          ["error", "message", "statusCode", "options", "body"],
-          "  "
-        )
-      ].join("");
-
-      // attaching to error so it can be exposed by a handler outside datapoint
-      // eslint-disable-next-line no-param-reassign
-      error.message = `${error.message}\n\n${message}`;
-      throw error;
-    });
+  try {
+    const request = rp(options);
+    inspect(acc, request);
+
+    const response = await request;
+    return response.body;
+  } catch (error) {
+    // remove auth objects from acc and error for printing to console
+    const redactedAcc = fp.set("options.auth", "[omitted]", acc);
+    const redactedError = fp.set("options.auth", "[omitted]", error);
+
+    const message = [
+      "Entity info:",
+      "\n  - Id: ",
+      _.get(redactedAcc, "reducer.spec.id"),
+      "\n",
+      utils.inspectProperties(
+        redactedAcc,
+        ["options", "params", "value"],
+        "  "
+      ),
+      "\n  Request:\n",
+      utils.inspectProperties(
+        redactedError,
+        ["error", "message", "statusCode", "options", "body"],
+        "  "
+      )
+    ].join("");
+
+    // attaching to error so it can be exposed by a handler outside datapoint
+    // eslint-disable-next-line no-param-reassign
+    error.message = `${error.message}\n\n${message}`;
+    throw error;
+  }
 }
 
 module.exports.resolveRequest = resolveRequest;
@@ -199,10 +199,9 @@ module.exports.resolveRequest = resolveRequest;
  * @param {Function} resolveReducer
  * @return {Promise<Accumulator>}
  */
-function resolve(acc, resolveReducer) {
-  return Promise.resolve(acc)
-    .then(itemContext => resolveOptions(itemContext, resolveReducer))
-    .then(itemContext => resolveRequest(itemContext, resolveReducer));
+async function resolve(acc, resolveReducer) {
+  const itemContext = await resolveOptions(acc, resolveReducer);
+  return resolveRequest(itemContext, resolveReducer);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/entity-types/entity-schema/resolve.js b/packages/data-point/lib/entity-types/entity-schema/resolve.js
index 6730160..650e8a8 100644
--- a/packages/data-point/lib/entity-types/entity-schema/resolve.js
+++ b/packages/data-point/lib/entity-types/entity-schema/resolve.js
@@ -1,24 +1,23 @@
 const _ = require("lodash");
-const Promise = require("bluebird");
 const Ajv = require("ajv");
 
-function validateContext(acc) {
+async function validateContext(acc) {
   const ajv = new Ajv(acc.reducer.spec.options);
   const validate = ajv.compile(acc.reducer.spec.schema);
 
-  return Promise.resolve(validate(acc.value)).then(valid => {
-    if (!valid) {
-      const messages = _.map(validate.errors, "message");
-      const messageListStr = messages.join("\n -");
-      const error = new Error(`Errors Found:\n - ${messageListStr}`);
-      error.name = "InvalidSchema";
-      error.errors = validate.errors;
-      return Promise.reject(error);
-    }
+  const valid = await validate(acc.value);
 
-    // no error, just return value
-    return acc.value;
-  });
+  if (!valid) {
+    const messages = _.map(validate.errors, "message");
+    const messageListStr = messages.join("\n -");
+    const error = new Error(`Errors Found:\n - ${messageListStr}`);
+    error.name = "InvalidSchema";
+    error.errors = validate.errors;
+    throw error;
+  }
+
+  // no error, just return value
+  return acc.value;
 }
 
 module.exports.validateContext = validateContext;
diff --git a/packages/data-point/lib/helpers/helpers.js b/packages/data-point/lib/helpers/helpers.js
index a296900..a510bdc 100644
--- a/packages/data-point/lib/helpers/helpers.js
+++ b/packages/data-point/lib/helpers/helpers.js
@@ -1,5 +1,5 @@
 const _ = require("lodash");
-const Promise = require("bluebird");
+const util = require("util");
 const resolveReducer = require("../reducer-types").resolve;
 const AccumulatorFactory = require("../accumulator/factory");
 
@@ -51,9 +51,10 @@ function reducifyAll(source, methodList) {
 
 module.exports.reducifyAll = reducifyAll;
 
-function mockReducer(reducer, acc) {
-  const pcb = Promise.promisify(reducer);
-  return pcb(acc.value, acc).then(val => ({ value: val }));
+async function mockReducer(reducer, acc) {
+  const pcb = util.promisify(reducer);
+  const value = await pcb(acc.value, acc);
+  return { value };
 }
 
 module.exports.mockReducer = mockReducer;
diff --git a/packages/data-point/lib/middleware-control/middleware.js b/packages/data-point/lib/middleware-control/middleware.js
index e967693..ec82616 100644
--- a/packages/data-point/lib/middleware-control/middleware.js
+++ b/packages/data-point/lib/middleware-control/middleware.js
@@ -1,7 +1,7 @@
 const once = require("lodash/once");
 const attempt = require("lodash/attempt");
 const isError = require("lodash/isError");
-const Promise = require("bluebird");
+const util = require("util");
 
 /**
  *
@@ -54,4 +54,4 @@ function run(accumulator, stackSpec, done) {
   return next();
 }
 
-module.exports.execute = Promise.promisify(run);
+module.exports.execute = util.promisify(run);
diff --git a/packages/data-point/lib/reducer-types/reducer-function/factory.js b/packages/data-point/lib/reducer-types/reducer-function/factory.js
index 1f326f2..56ae39c 100644
--- a/packages/data-point/lib/reducer-types/reducer-function/factory.js
+++ b/packages/data-point/lib/reducer-types/reducer-function/factory.js
@@ -1,5 +1,5 @@
 const _ = require("lodash");
-const Promise = require("bluebird");
+const util = require("util");
 
 const REDUCER_FUNCTION = "ReducerFunction";
 
@@ -58,7 +58,7 @@ function create(createReducer, source) {
   // if the arity is 3, we expect a Node Style
   // callback function with the form of (value, acc, done)
   if (source.length === 3) {
-    reducer.body = Promise.promisify(source);
+    reducer.body = util.promisify(source);
   } else {
     reducer.body = source;
   }
diff --git a/packages/data-point/lib/reducer-types/reducer-function/resolve.js b/packages/data-point/lib/reducer-types/reducer-function/resolve.js
index a75c399..b81cda9 100644
--- a/packages/data-point/lib/reducer-types/reducer-function/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-function/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 /**
  * @param {Object} manager
  * @param {Function} resolveReducer
@@ -7,8 +5,8 @@ const Promise = require("bluebird");
  * @param {ReducerObject} reducer
  * @returns {Promise}
  */
-function resolve(manager, resolveReducer, accumulator, reducer) {
-  return Promise.try(() => reducer.body(accumulator.value, accumulator));
+async function resolve(manager, resolveReducer, accumulator, reducer) {
+  return reducer.body(accumulator.value, accumulator);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.js
index 6c577e0..c289572 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.js
@@ -5,11 +5,10 @@
  * @param {ReducerAssign} reducerAssign
  * @returns {Promise}
  */
-function resolve(manager, resolveReducer, accumulator, reducerAssign) {
+async function resolve(manager, resolveReducer, accumulator, reducerAssign) {
   const reducer = reducerAssign.reducer;
-  return resolveReducer(manager, accumulator, reducer).then(value => {
-    return Object.assign({}, accumulator.value, value);
-  });
+  const value = await resolveReducer(manager, accumulator, reducer);
+  return Object.assign({}, accumulator.value, value);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.js
index 5c561d6..b9ef299 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 /**
  * @param {Object} manager
  * @param {Function} resolveReducer
@@ -8,7 +6,7 @@ const Promise = require("bluebird");
  * @returns {Promise}
  */
 function resolve(manager, resolveReducer, accumulator, reducerConstant) {
-  return Promise.resolve(reducerConstant.value);
+  return reducerConstant.value;
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.js
index cec05ad..84f4fee 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 const utils = require("../../../utils");
 const { reducerPredicateIsTruthy } = require("../utils");
 
@@ -10,14 +8,33 @@ const { reducerPredicateIsTruthy } = require("../utils");
  * @param {ReducerFilter} reducerFilter
  * @returns {Promise}
  */
-function resolve(manager, resolveReducer, accumulator, reducerFilter) {
+async function resolve(manager, resolveReducer, accumulator, reducerFilter) {
   const reducer = reducerFilter.reducer;
-  return Promise.filter(accumulator.value, itemValue => {
+
+  if (!Array.isArray(accumulator.value)) {
+    throw new Error(
+      `Expecting an array or an iterable object but got ${accumulator.value}`
+    );
+  }
+
+  const promises = accumulator.value.map(async itemValue => {
     const itemContext = utils.set(accumulator, "value", itemValue);
-    return resolveReducer(manager, itemContext, reducer).then(value => {
-      return reducerPredicateIsTruthy(reducer, value);
-    });
+    const resolvedValue = await resolveReducer(manager, itemContext, reducer);
+    return {
+      value: itemValue,
+      match: reducerPredicateIsTruthy(reducer, resolvedValue)
+    };
   });
+
+  const values = await Promise.all(promises);
+
+  return values.reduce((matches, result) => {
+    if (result.match) {
+      matches.push(result.value);
+    }
+
+    return matches;
+  }, []);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.js
index 341b0d9..257b3de 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 const utils = require("../../../utils");
 const { reducerPredicateIsTruthy } = require("../utils");
 
@@ -10,31 +8,25 @@ const { reducerPredicateIsTruthy } = require("../utils");
  * @param {ReducerFind} reducerFind
  * @returns {Promise}
  */
-function resolve(manager, resolveReducer, accumulator, reducerFind) {
+async function resolve(manager, resolveReducer, accumulator, reducerFind) {
   if (accumulator.value.length === 0) {
-    return Promise.resolve(undefined);
+    return undefined;
   }
 
-  let hasResult = false;
   const reducer = reducerFind.reducer;
-  return Promise.reduce(
-    accumulator.value,
-    (result, itemValue) => {
-      if (hasResult) {
-        return result;
-      }
-      const itemContext = utils.set(accumulator, "value", itemValue);
-      return resolveReducer(manager, itemContext, reducer).then(value => {
-        if (reducerPredicateIsTruthy(reducer, value)) {
-          hasResult = true;
-          return itemValue;
-        }
 
-        return undefined;
-      });
-    },
-    null
-  );
+  for (let index = 0; index < accumulator.value.length; index += 1) {
+    const itemValue = accumulator.value[index];
+    const itemContext = utils.set(accumulator, "value", itemValue);
+    // eslint-disable-next-line no-await-in-loop
+    const result = await resolveReducer(manager, itemContext, reducer);
+
+    if (reducerPredicateIsTruthy(reducer, result)) {
+      return itemValue;
+    }
+  }
+
+  return undefined;
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.js
index 3431e1a..a6eaed3 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.js
@@ -1,4 +1,3 @@
-const Promise = require("bluebird");
 const utils = require("../../../utils");
 
 /**
@@ -10,10 +9,13 @@ const utils = require("../../../utils");
  */
 function resolve(manager, resolveReducer, accumulator, reducerMap) {
   const reducer = reducerMap.reducer;
-  return Promise.map(accumulator.value, itemValue => {
+
+  const promises = accumulator.value.map(itemValue => {
     const itemContext = utils.set(accumulator, "value", itemValue);
     return resolveReducer(manager, itemContext, reducer);
   });
+
+  return Promise.all(promises);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.js
index 836d620..3cf89ea 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.js
@@ -1,4 +1,3 @@
-const Promise = require("bluebird");
 const omit = require("lodash/omit");
 
 /**
@@ -9,7 +8,7 @@ const omit = require("lodash/omit");
  * @returns {Promise}
  */
 function resolve(manager, resolveReducer, accumulator, reducerOmit) {
-  return Promise.resolve(omit(accumulator.value, reducerOmit.keys));
+  return omit(accumulator.value, reducerOmit.keys);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.js
index f62b676..fe4c558 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 /**
  * @param {Object} manager
  * @param {Function} resolveReducer
@@ -8,9 +6,11 @@ const Promise = require("bluebird");
  * @returns {Promise}
  */
 function resolve(manager, resolveReducer, accumulator, reducerParallel) {
-  return Promise.map(reducerParallel.reducers, reducer => {
+  const promises = reducerParallel.reducers.map(reducer => {
     return resolveReducer(manager, accumulator, reducer);
   });
+
+  return Promise.all(promises);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.js
index e2e8f9f..0d2983c 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.js
@@ -1,4 +1,3 @@
-const Promise = require("bluebird");
 const pick = require("lodash/pick");
 
 /**
@@ -9,7 +8,7 @@ const pick = require("lodash/pick");
  * @returns {Promise}
  */
 function resolve(manager, resolveReducer, accumulator, reducerPick) {
-  return Promise.resolve(pick(accumulator.value, reducerPick.keys));
+  return pick(accumulator.value, reducerPick.keys);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-list/resolve.js b/packages/data-point/lib/reducer-types/reducer-list/resolve.js
index e477dfc..85d2e8f 100644
--- a/packages/data-point/lib/reducer-types/reducer-list/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-list/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 const utils = require("../../utils");
 
 /**
@@ -9,24 +7,22 @@ const utils = require("../../utils");
  * @param {ReducerList} reducerList
  * @returns {Promise}
  */
-function resolve(manager, resolveReducer, accumulator, reducerList) {
+async function resolve(manager, resolveReducer, accumulator, reducerList) {
   const reducers = reducerList.reducers;
   if (reducers.length === 0) {
-    return Promise.resolve(undefined);
+    return undefined;
   }
 
-  const initialValue =
-    accumulator.value === undefined ? null : accumulator.value;
-  const result = Promise.reduce(
-    reducers,
-    (value, reducer) => {
-      const itemContext = utils.set(accumulator, "value", value);
-      return resolveReducer(manager, itemContext, reducer);
-    },
-    initialValue
-  );
+  let value = accumulator.value === undefined ? null : accumulator.value;
+
+  for (let index = 0; index < reducers.length; index += 1) {
+    const reducer = reducers[index];
+    const itemContext = utils.set(accumulator, "value", value);
+    // eslint-disable-next-line no-await-in-loop
+    value = await resolveReducer(manager, itemContext, reducer);
+  }
 
-  return result;
+  return value;
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-object/resolve.js b/packages/data-point/lib/reducer-types/reducer-object/resolve.js
index c8cc0d8..4054396 100644
--- a/packages/data-point/lib/reducer-types/reducer-object/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-object/resolve.js
@@ -1,4 +1,3 @@
-const Promise = require("bluebird");
 const set = require("lodash/set");
 
 /**
@@ -8,17 +7,23 @@ const set = require("lodash/set");
  * @param {ReducerObject} reducer
  * @returns {Promise}
  */
-function resolve(manager, resolveReducer, accumulator, reducer) {
+async function resolve(manager, resolveReducer, accumulator, reducer) {
   const result = reducer.source();
+
   if (reducer.reducers.length === 0) {
-    return Promise.resolve(result);
+    return result;
   }
 
-  return Promise.map(reducer.reducers, ({ reducer: itemReducer, path }) => {
-    return resolveReducer(manager, accumulator, itemReducer).then(value => {
-      set(result, path, value);
-    });
-  }).then(() => result);
+  const promises = reducer.reducers.map(
+    async ({ reducer: itemReducer, path }) => {
+      const value = await resolveReducer(manager, accumulator, itemReducer);
+      return set(result, path, value);
+    }
+  );
+
+  await Promise.all(promises);
+
+  return result;
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/reducer-path/resolve.js b/packages/data-point/lib/reducer-types/reducer-path/resolve.js
index 43383e1..3c41311 100644
--- a/packages/data-point/lib/reducer-types/reducer-path/resolve.js
+++ b/packages/data-point/lib/reducer-types/reducer-path/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 /**
  * @param {Object} manager
  * @param {Function} resolveReducer
@@ -8,7 +6,7 @@ const Promise = require("bluebird");
  * @returns {Promise}
  */
 function resolve(manager, resolveReducer, accumulator, reducer) {
-  return Promise.resolve(reducer.body(accumulator));
+  return reducer.body(accumulator);
 }
 
 module.exports.resolve = resolve;
diff --git a/packages/data-point/lib/reducer-types/resolve.js b/packages/data-point/lib/reducer-types/resolve.js
index 3b0f2d7..f7b3cdc 100644
--- a/packages/data-point/lib/reducer-types/resolve.js
+++ b/packages/data-point/lib/reducer-types/resolve.js
@@ -1,5 +1,3 @@
-const Promise = require("bluebird");
-
 const ReducerEntity = require("./reducer-entity");
 const ReducerEntityId = require("./reducer-entity-id");
 const ReducerFunction = require("./reducer-function");
@@ -54,12 +52,12 @@ function getResolveFunction(reducer) {
  * @param {Reducer} reducer
  * @returns {Promise}
  */
-function resolveReducer(manager, accumulator, reducer) {
+async function resolveReducer(manager, accumulator, reducer) {
   // this conditional is here because BaseEntity#resolve
   // does not check that lifecycle methods are defined
   // before trying to resolve them
   if (!reducer) {
-    return Promise.resolve(accumulator.value);
+    return accumulator.value;
   }
 
   const isTracing = accumulator.trace;
@@ -73,17 +71,17 @@ function resolveReducer(manager, accumulator, reducer) {
   const resolve = getResolveFunction(reducer);
 
   // NOTE: recursive call
-  let result = resolve(manager, resolveReducer, acc, reducer);
+  let result = await resolve(manager, resolveReducer, acc, reducer);
 
   if (hasDefault(reducer)) {
     // eslint-disable-next-line no-underscore-dangle
     const _default = reducer[DEFAULT_VALUE].value;
     const resolveDefault = reducers.ReducerDefault.resolve;
-    result = result.then(value => resolveDefault(value, _default));
+    result = await resolveDefault(result, _default);
   }
 
   if (isTracing) {
-    result = result.then(trace.augmentTraceNodeDuration(traceNode));
+    await trace.augmentTraceNodeDuration(traceNode)();
   }
 
   return result;
diff --git a/packages/data-point/lib/trace/trace-graph.js b/packages/data-point/lib/trace/trace-graph.js
index 79e95b6..d3e4aa1 100644
--- a/packages/data-point/lib/trace/trace-graph.js
+++ b/packages/data-point/lib/trace/trace-graph.js
@@ -1,12 +1,12 @@
 const fs = require("fs");
-const Promise = require("bluebird");
+const util = require("util");
 
 // this module is used to cover circular references
 const stringify = require("json-stringify-safe");
 
 const { NS_PER_SEC, nanoToMillisecond } = require("./time-helpers");
 
-const writeFileP = Promise.promisify(fs.writeFile);
+const writeFileP = util.promisify(fs.writeFile);
 module.exports.writeFileP = writeFileP;
 
 /**
@@ -123,8 +123,10 @@ function writeTraceGraph(traceGraph) {
 
 module.exports.writeTraceGraph = writeTraceGraph;
 
-function traceReducer(acc) {
-  return writeTraceGraph(acc.traceGraph).return(acc);
+async function traceReducer(acc) {
+  await writeTraceGraph(acc.traceGraph);
+
+  return acc;
 }
 
 module.exports.traceReducer = traceReducer;
diff --git a/packages/data-point/package.json b/packages/data-point/package.json
index 7c59035..009d8f5 100644
--- a/packages/data-point/package.json
+++ b/packages/data-point/package.json
@@ -49,7 +49,6 @@
   ],
   "dependencies": {
     "ajv": "5.2.3",
-    "bluebird": "3.5.0",
     "debug": "3.x",
     "deep-freeze": "0.0.1",
     "json-stringify-safe": "^5.0.1",


Test patch:
diff --git a/packages/data-point/lib/core/__snapshots__/transform.test.js.snap b/packages/data-point/lib/core/__snapshots__/transform.test.js.snap
index b081341..1df3b20 100644
--- a/packages/data-point/lib/core/__snapshots__/transform.test.js.snap
+++ b/packages/data-point/lib/core/__snapshots__/transform.test.js.snap
@@ -1,9 +1,9 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`transform - throw error in invalid id(promise) 1`] = `
-[Error: Invalid reducer type. Could not find a matching reducer type while parsing the value:
+exports[`transform transform - throw error in invalid id(promise) 1`] = `
+"Invalid reducer type. Could not find a matching reducer type while parsing the value:
  'INVALID'
 Try using an Array, String, Object, or Function.
 More info: https://github.com/ViacomInc/data-point/tree/master/packages/data-point#reducers
-]
+"
 `;
diff --git a/packages/data-point/lib/core/transform.test.js b/packages/data-point/lib/core/transform.test.js
index e05514d..aa59dfa 100644
--- a/packages/data-point/lib/core/transform.test.js
+++ b/packages/data-point/lib/core/transform.test.js
@@ -22,138 +22,94 @@ beforeAll(() => {
   });
 });
 
-test("transform - throw error in invalid id(promise)", () => {
-  return Transform.transform(dataPoint, "INVALID", TestData, {})
-    .catch(err => err)
-    .then(res => {
-      expect(res).toBeInstanceOf(Error);
-      expect(res).toMatchSnapshot();
-    });
-});
-
-describe("transform - should attach input value to accumulator", () => {
-  test("passing undefined", () => {
-    return Transform.transform(dataPoint, value => {
-      expect(value).toBe(undefined);
+describe("transform", () => {
+  test("transform - throw error in invalid id(promise)", async () => {
+    await expect(
+      Transform.transform(dataPoint, "INVALID", TestData, {})
+    ).rejects.toThrowErrorMatchingSnapshot();
+  });
+
+  describe("transform - should attach input value to accumulator", () => {
+    const expectedReceivedMatrix = [
+      ["undefined", undefined, undefined],
+      ["zero", 0, 0],
+      ["number", 1, 1],
+      ["empty string", "", ""],
+      ["string", "Hello World", "Hello World"],
+      ["false", false, false],
+      ["true", true, true],
+      ["array", ["a", "b"], ["a", "b"]],
+      ["Object", { a: true }, { a: true }]
+    ];
+
+    expectedReceivedMatrix.forEach(([type, input, output]) => {
+      test(`passing ${type}`, async () => {
+        const result = await Transform.transform(
+          dataPoint,
+          value => value,
+          input
+        );
+        expect(result.value).toEqual(output);
+      });
     });
   });
 
-  test("passing 0", () => {
-    return Transform.transform(
-      dataPoint,
-      value => {
-        expect(value).toBe(0);
-      },
-      0
-    );
-  });
-
-  test("passing 1", () => {
-    return Transform.transform(
-      dataPoint,
-      value => {
-        expect(value).toBe(1);
-      },
-      1
-    );
-  });
-
-  test("passing empty string", () => {
-    return Transform.transform(
-      dataPoint,
-      value => {
-        expect(value).toBe("");
-      },
-      ""
-    );
-  });
-
-  test("passing a string", () => {
-    return Transform.transform(
-      dataPoint,
-      value => {
-        expect(value).toBe("Hello World");
-      },
-      "Hello World"
-    );
-  });
-
-  test("passing false", () => {
-    return Transform.transform(
-      dataPoint,
-      value => {
-        expect(value).toBe(false);
-      },
-      false
-    );
+  test("transform - single reducer", async () => {
+    const reducer = value => {
+      return `${value} World`;
+    };
+    const res = await Transform.transform(dataPoint, reducer, "Hello");
+    expect(res.value).toEqual("Hello World");
   });
 
-  test("passing true", () => {
-    return Transform.transform(
-      dataPoint,
-      value => {
-        expect(value).toBe(true);
-      },
-      true
-    );
+  test("transform - reducer chain", async () => {
+    const testReducers = [value => `${value} World`, value => `${value}!!`];
+    const res = await Transform.transform(dataPoint, testReducers, "Hello");
+    expect(res.value).toEqual("Hello World!!");
   });
 
-  test("passing an array", () => {
-    return Transform.transform(
-      dataPoint,
-      value => {
-        expect(value).toEqual(["Hello World"]);
-      },
-      ["Hello World"]
-    );
+  test("transform - reducer path", async () => {
+    const res = await Transform.transform(dataPoint, "$a.b.c", TestData);
+    expect(res.value).toEqual([1, 2, 3]);
   });
 
-  test("passing an object", () => {
-    return Transform.transform(
+  test("transform - reducer mixed", async () => {
+    const getMax = value => {
+      return Math.max.apply(null, value);
+    };
+    const res = await Transform.transform(
       dataPoint,
-      value => {
-        expect(value).toEqual({ message: "Hello World" });
-      },
-      { message: "Hello World" }
+      ["$a.b.c", getMax],
+      TestData
     );
-  });
-});
 
-test("transform - single reducer", () => {
-  const reducer = value => {
-    return `${value} World`;
-  };
-  return Transform.transform(dataPoint, reducer, "Hello").then(res => {
-    expect(res.value).toEqual("Hello World");
+    expect(res.value).toEqual(3);
   });
-});
 
-test("transform - reducer chain", () => {
-  const testReducers = [value => `${value} World`, value => `${value}!!`];
-  return Transform.transform(dataPoint, testReducers, "Hello").then(res => {
-    expect(res.value).toEqual("Hello World!!");
+  test("should handle callback signature", done => {
+    const reducer = value => {
+      return `${value} World`;
+    };
+    Transform.transform(dataPoint, reducer, "Hello", null, (error, res) => {
+      expect(res.value).toEqual("Hello World");
+      done();
+    });
   });
-});
 
-test("transform - reducer path", () => {
-  return Transform.transform(dataPoint, "$a.b.c", TestData).then(res => {
-    expect(res.value).toEqual([1, 2, 3]);
+  test("should handle callback signature with error", done => {
+    const reducer = () => {
+      throw new Error("test");
+    };
+    Transform.transform(dataPoint, reducer, "Hello", null, (error, res) => {
+      expect(error).toMatchInlineSnapshot(`[Error: test]`);
+      expect(res).toEqual(undefined);
+      done();
+    });
   });
 });
 
-test("transform - reducer mixed", () => {
-  const getMax = value => {
-    return Math.max.apply(null, value);
-  };
-  return Transform.transform(dataPoint, ["$a.b.c", getMax], TestData).then(
-    res => {
-      expect(res.value).toEqual(3);
-    }
-  );
-});
-
 describe("options argument", () => {
-  test("passing locals", () => {
+  test("passing locals", async () => {
     const reducer = (value, acc) => {
       return `${acc.locals.greeting} World`;
     };
@@ -164,51 +120,46 @@ describe("options argument", () => {
       }
     };
 
-    return Transform.transform(dataPoint, reducer, {}, options).then(res => {
-      expect(res.value).toEqual("Hello World");
-    });
+    const res = await Transform.transform(dataPoint, reducer, {}, options);
+    expect(res.value).toEqual("Hello World");
   });
 });
 
 describe("resolve", () => {
-  test("transform - resolve", () => {
-    return Transform.resolve(dataPoint, "$a.b.c", TestData).then(value => {
-      expect(value).toEqual([1, 2, 3]);
-    });
+  test("transform - resolve", async () => {
+    const value = await Transform.resolve(dataPoint, "$a.b.c", TestData);
+    expect(value).toEqual([1, 2, 3]);
   });
-  test("transform - options is last argument", () => {
+  test("transform - options is last argument", async () => {
     const options = {
       locals: {
         foo: "bar"
       }
     };
-    return Transform.resolve(dataPoint, "$..locals.foo", {}, options).then(
-      value => {
-        expect(value).toEqual("bar");
-      }
+    const value = await Transform.resolve(
+      dataPoint,
+      "$..locals.foo",
+      {},
+      options
     );
+
+    expect(value).toEqual("bar");
   });
 
-  test("transform - execute with 3 arguments", () => {
+  test("transform - execute with 3 arguments", async () => {
     const value = {
       foo: "bar"
     };
-    return Promise.resolve(value)
-      .then(Transform.resolve(dataPoint, "$foo"))
-      .then(resolvedValue => {
-        expect(resolvedValue).toEqual("bar");
-      });
+    const curried = Transform.resolve(dataPoint, "$foo");
+    const resolvedValue = await curried(value);
+    expect(resolvedValue).toEqual("bar");
   });
 });
 
 describe("dataPoint.createReducer", () => {
-  test("it should evaluate an existing reducer", () => {
+  test("it should evaluate an existing reducer", async () => {
     const reducer = DataPoint.createReducer(["$a", input => input + 1]);
-    return dataPoint
-      .resolve(reducer, { a: 5 })
-      .catch(err => err)
-      .then(output => {
-        expect(output).toBe(6);
-      });
+    const output = await dataPoint.resolve(reducer, { a: 5 });
+    expect(output).toBe(6);
   });
 });
diff --git a/packages/data-point/lib/entity-types/__snapshots__/integrations.test.js.snap b/packages/data-point/lib/entity-types/__snapshots__/integrations.test.js.snap
index 2778eef..0845005 100644
--- a/packages/data-point/lib/entity-types/__snapshots__/integrations.test.js.snap
+++ b/packages/data-point/lib/entity-types/__snapshots__/integrations.test.js.snap
@@ -1,5 +1,10 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`Entry#resolve - run schema, fail if invalid 1`] = `
+"Errors Found:
+ - should be number"
+`;
+
 exports[`trace feature trace via options parameter 1`] = `
 Array [
   Array [
diff --git a/packages/data-point/lib/entity-types/base-entity/__snapshots__/resolve.test.js.snap b/packages/data-point/lib/entity-types/base-entity/__snapshots__/resolve.test.js.snap
index d5a6c2f..e57ed59 100644
--- a/packages/data-point/lib/entity-types/base-entity/__snapshots__/resolve.test.js.snap
+++ b/packages/data-point/lib/entity-types/base-entity/__snapshots__/resolve.test.js.snap
@@ -17,75 +17,75 @@ Array [
 `;
 
 exports[`ResolveEntity.resolveEntity inputType - throws error if inputType does not pass 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: number
 Actual type: string
-Input value: 'foo']
+Input value: 'foo'"
 `;
 
 exports[`ResolveEntity.resolveEntity outputType fails if error method catches typeCheck errors and returns bad value 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 2]
+Input value: 2"
 `;
 
-exports[`ResolveEntity.resolveEntity outputType is bypassed if error throws error 1`] = `[Error: error from before method]`;
+exports[`ResolveEntity.resolveEntity outputType is bypassed if error throws error 1`] = `"error from before method"`;
 
 exports[`ResolveEntity.resolveEntity outputType throws error if after method returns value that does not pass typeCheck 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
 
 exports[`ResolveEntity.resolveEntity outputType throws error if after middleware returns value that does not pass typeCheck 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
 
 exports[`ResolveEntity.resolveEntity outputType throws error if before method returns value that does not pass typeCheck 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
 
-exports[`ResolveEntity.resolveEntity outputType throws error if custom typeCheck fails 1`] = `[Error: custom type error]`;
+exports[`ResolveEntity.resolveEntity outputType throws error if custom typeCheck fails 1`] = `"custom type error"`;
 
 exports[`ResolveEntity.resolveEntity outputType throws error if global after middleware returns value that does not pass typeCheck 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
 
 exports[`ResolveEntity.resolveEntity outputType throws error if global before middleware returns value that does not pass typeCheck 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
 
 exports[`ResolveEntity.resolveEntity outputType throws error if middleware before returns value that does not pass typeCheck 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
 
 exports[`ResolveEntity.resolveEntity outputType throws error if value does not pass typeCheck 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
 
 exports[`ResolveEntity.resolveEntity outputType throws if error method does not return value with correct type 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: string
 Actual type: number
-Input value: 1]
+Input value: 1"
 `;
diff --git a/packages/data-point/lib/entity-types/base-entity/resolve.test.js b/packages/data-point/lib/entity-types/base-entity/resolve.test.js
index 05d4228..f431403 100644
--- a/packages/data-point/lib/entity-types/base-entity/resolve.test.js
+++ b/packages/data-point/lib/entity-types/base-entity/resolve.test.js
@@ -1,7 +1,5 @@
 /* eslint-env jest */
 
-const Promise = require("bluebird");
-
 const ResolveEntity = require("./resolve");
 const createReducer = require("../../reducer-types").create;
 const resolveReducer = require("../../reducer-types").resolve;
@@ -35,51 +33,6 @@ afterEach(() => {
   dataPoint.middleware.clear();
 });
 
-describe("ResolveEntity.resolveErrorReducers", () => {
-  test("It should reject if no reducer is provided", () => {
-    const error = new Error("Test");
-    const accumulator = helpers.createAccumulator(
-      {},
-      {
-        context: {
-          error: null
-        }
-      }
-    );
-    return ResolveEntity.resolveErrorReducers(
-      dataPoint,
-      error,
-      accumulator,
-      resolveReducer
-    )
-      .catch(err => err)
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-        expect(result).toHaveProperty("message", "Test");
-      });
-  });
-
-  test("It should handle error if reducer is provided", () => {
-    const err = new Error("Test");
-    const accumulator = helpers.createAccumulator(
-      {},
-      {
-        context: {
-          error: createReducer((value, acc, next) => next(null, "pass"))
-        }
-      }
-    );
-    return ResolveEntity.resolveErrorReducers(
-      dataPoint,
-      err,
-      accumulator,
-      resolveReducer
-    ).then(result => {
-      expect(result).toEqual("pass");
-    });
-  });
-});
-
 describe("getCurrentReducer", () => {
   it("should return reducer as is if type=ReducerEntity", () => {
     const reducer = {
@@ -162,239 +115,176 @@ describe("ResolveEntity.createCurrentAccumulator", () => {
   });
 });
 
-describe("ResolveEntity.resolveMiddleware", () => {
-  test("It should execute a middleware", () => {
-    dataPoint.middleware.use("request:before", (acc, next) => {
-      acc.value = "bar";
-      next(null);
-    });
-
-    const acc = helpers.createAccumulator("foo");
-    return ResolveEntity.resolveMiddleware(
-      dataPoint,
-      acc,
-      "request:before"
-    ).then(result => {
-      expect(result).toEqual("bar");
-    });
-  });
-
-  test("It should execute a middleware that forces an error to bypass the promise chain", () => {
-    dataPoint.middleware.use("request:before", (acc, next) => {
-      next(null, "bar");
-    });
-
-    const acc = helpers.createAccumulator("foo");
-    return ResolveEntity.resolveMiddleware(dataPoint, acc, "request:before")
-      .catch(reason => reason)
-      .then(reason => {
-        expect(reason).toBeInstanceOf(Error);
-        expect(reason).toHaveProperty("name", "bypass");
-        expect(reason).toHaveProperty("bypass", true);
-        expect(reason).toHaveProperty("bypassValue", "bar");
-      });
-  });
-});
-
 describe("ResolveEntity.resolveEntity", () => {
-  test("It should resolve entity", () => {
-    return resolveEntity("model:asIs", "foo").then(result => {
-      expect(result).toBe("foo");
-    });
+  test("It should resolve entity", async () => {
+    const result = await resolveEntity("model:asIs", "foo");
+    expect(result).toBe("foo");
   });
 
-  test("It should attach entityId to error", () => {
+  test("It should attach entityId to error", async () => {
     const rejectResolver = () => Promise.reject(new Error("test"));
-    return resolveEntity("hash:asIs", undefined, undefined, rejectResolver)
-      .catch(error => error)
-      .then(val => {
-        expect(val).toHaveProperty("entityId", "hash:asIs");
-      });
+    await expect(
+      resolveEntity("hash:asIs", undefined, undefined, rejectResolver)
+    ).rejects.toHaveProperty("entityId", "hash:asIs");
   });
 
-  test("It should log trace calls when set to true", () => {
+  test("It should log trace calls when set to true", async () => {
     /* eslint-disable no-console */
     const consoleTime = console.time;
     const consoleTimeEnd = console.timeEnd;
     console.time = jest.fn();
     console.timeEnd = jest.fn();
-    return resolveEntity("model:traced", "foo", {
+
+    const result = await resolveEntity("model:traced", "foo", {
       trace: true
-    }).then(result => {
-      expect(console.time).toBeCalled();
-      expect(console.timeEnd).toBeCalled();
-      expect(console.time.mock.calls).toMatchSnapshot();
-      expect(console.timeEnd.mock.calls).toMatchSnapshot();
-      expect(result).toEqual("foo");
-      console.time = consoleTime;
-      console.timeEnd = consoleTimeEnd;
     });
+    expect(console.time).toBeCalled();
+    expect(console.timeEnd).toBeCalled();
+    expect(console.time.mock.calls).toMatchSnapshot();
+    expect(console.timeEnd.mock.calls).toMatchSnapshot();
+    expect(result).toEqual("foo");
+    console.time = consoleTime;
+    console.timeEnd = consoleTimeEnd;
     /* eslint-enable no-console */
   });
 
-  test("It should resolve through bypass", () => {
+  test("It should resolve through bypass", async () => {
     dataPoint.middleware.use("hash:before", (acc, next) => {
       next(null, { data: "bar" });
     });
-    return resolveEntity("hash:asIs", "foo").then(result => {
-      expect(result).toEqual({ data: "bar" });
-    });
+
+    const result = await resolveEntity("hash:asIs", "foo");
+    expect(result).toEqual({ data: "bar" });
   });
 
-  test("it should catch errors from middleware", () => {
+  test("it should catch errors from middleware", async () => {
     dataPoint.middleware.use("hash:before", () => {
       throw new Error("test");
     });
-    return resolveEntity("hash:asIs", "foo")
-      .catch(err => err)
-      .then(err => {
-        expect(err).toHaveProperty("message", "test");
-      });
+    await expect(resolveEntity("hash:asIs", "foo")).rejects.toHaveProperty(
+      "message",
+      "test"
+    );
   });
 
-  test("inputType - throws error if inputType does not pass", () => {
-    return resolveEntity("model:c.0", "foo")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+  test("inputType - throws error if inputType does not pass", async () => {
+    await expect(
+      resolveEntity("model:c.0", "foo")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("inputType - if typeCheck passes then resolve normal", () => {
-    return resolveEntity("model:c.0", 1).then(result => {
-      expect(result).toEqual(1);
-    });
+  test("inputType - if typeCheck passes then resolve normal", async () => {
+    const result = await resolveEntity("model:c.0", 1);
+    expect(result).toEqual(1);
   });
 });
 
 describe("ResolveEntity.resolveEntity outputType", () => {
-  test("throws error if value does not pass typeCheck", () => {
-    return resolveEntity("model:c.1", 1)
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+  test("throws error if value does not pass typeCheck", async () => {
+    await expect(
+      resolveEntity("model:c.1", 1)
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("throws error if before method returns value that does not pass typeCheck", () => {
-    return resolveEntity("model:c.5", "some string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+  test("throws error if before method returns value that does not pass typeCheck", async () => {
+    await expect(
+      resolveEntity("model:c.5", "some string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("throws error if middleware before returns value that does not pass typeCheck", () => {
+  test("throws error if middleware before returns value that does not pass typeCheck", async () => {
     dataPoint.middleware.use("model:before", (acc, next) => {
       next(null, 1);
     });
 
-    return resolveEntity("model:c.1", "some string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+    await expect(
+      resolveEntity("model:c.1", "some string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("throws error if global before middleware returns value that does not pass typeCheck", () => {
+  test("throws error if global before middleware returns value that does not pass typeCheck", async () => {
     dataPoint.middleware.use("before", (acc, next) => {
       next(null, 1);
     });
 
-    return resolveEntity("model:c.1", "some string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+    await expect(
+      resolveEntity("model:c.1", "some string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("throws error if after method returns value that does not pass typeCheck", () => {
-    return resolveEntity("model:c.4", "some string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+  test("throws error if after method returns value that does not pass typeCheck", async () => {
+    await expect(
+      resolveEntity("model:c.4", "some string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("throws error if after middleware returns value that does not pass typeCheck", () => {
+  test("throws error if after middleware returns value that does not pass typeCheck", async () => {
     dataPoint.middleware.use("model:after", (acc, next) => {
       next(null, 1);
     });
 
-    return resolveEntity("model:c.1", "some string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+    await expect(
+      resolveEntity("model:c.1", "some string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("throws error if global after middleware returns value that does not pass typeCheck", () => {
+  test("throws error if global after middleware returns value that does not pass typeCheck", async () => {
     dataPoint.middleware.use("after", (acc, next) => {
       next(null, 1);
     });
 
-    return resolveEntity("model:c.1", "some string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+    await expect(
+      resolveEntity("model:c.1", "some string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("passes if error method returns value with correct type", () => {
-    return resolveEntity("model:c.6", "string").then(result => {
-      expect(result).toBe("error string");
-    });
+  test("passes if error method returns value with correct type", async () => {
+    const result = await resolveEntity("model:c.6", "string");
+    expect(result).toBe("error string");
   });
 
-  test("throws if error method does not return value with correct type", () => {
-    return resolveEntity("model:c.7", "string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+  test("throws if error method does not return value with correct type", async () => {
+    await expect(
+      resolveEntity("model:c.7", "string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("is bypassed if error throws error", () => {
-    return resolveEntity("model:c.8", "string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+  test("is bypassed if error throws error", async () => {
+    await expect(
+      resolveEntity("model:c.8", "string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("passes if error method catches typeCheck errors and returns value", () => {
-    return resolveEntity("model:c.9", "string").then(result => {
-      expect(result).toBe("string from error");
-    });
+  test("passes if error method catches typeCheck errors and returns value", async () => {
+    const result = await resolveEntity("model:c.9", "string");
+    expect(result).toBe("string from error");
   });
 
-  test("fails if error method catches typeCheck errors and returns bad value", () => {
-    return resolveEntity("model:c.10", "string")
-      .catch(e => e)
-      .then(e => {
-        expect(e).toMatchSnapshot();
-      });
+  test("fails if error method catches typeCheck errors and returns bad value", async () => {
+    await expect(
+      resolveEntity("model:c.10", "string")
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("resolves normally if typeCheck passes", () => {
-    return resolveEntity("model:c.1", "foo").then(result => {
-      expect(result).toEqual("foo");
-    });
+  test("resolves normally if typeCheck passes", async () => {
+    const result = await resolveEntity("model:c.1", "foo");
+    expect(result).toEqual("foo");
   });
 
-  test("does not change acc.value", () => {
-    return resolveEntity("model:c.2", "my string").then(result => {
-      expect(result).toEqual("my string");
-    });
+  test("does not change acc.value", async () => {
+    const result = await resolveEntity("model:c.2", "my string");
+    expect(result).toEqual("my string");
+  });
+
+  test("throws error if custom typeCheck fails", async () => {
+    await expect(
+      resolveEntity("model:c.3", 123)
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("throws error if custom typeCheck fails", () => {
-    return resolveEntity("model:c.3", 123)
-      .catch(e => e)
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-        expect(result).toMatchSnapshot();
-      });
+  test("does not attempt to execute outputType if it does not exists", async () => {
+    const result = await resolveEntity("model:c.11");
+    expect(result).toEqual("all good");
   });
 });
 
@@ -412,40 +302,38 @@ describe("ResolveEntity.resolve", () => {
     );
   };
 
-  test("It should resolve as single entity", () => {
-    return resolve("model:asIs", "foo").then(result => {
-      expect(result).toEqual("foo");
-    });
+  test("It should resolve as single entity", async () => {
+    const result = await resolve("model:asIs", "foo");
+    expect(result).toEqual("foo");
   });
 
-  test("It should resolve as collection", () => {
-    return resolve("model:asIs[]", ["foo"]).then(result => {
-      expect(result).toEqual(["foo"]);
-    });
+  test("It should resolve as collection", async () => {
+    const result = await resolve("model:asIs[]", ["foo"]);
+    expect(result).toEqual(["foo"]);
   });
-  test("It should return undefined if accumulator is not Array", () => {
-    return resolve("model:asIs[]", {}).then(result => {
-      expect(result).toBeUndefined();
-    });
+  test("It should return undefined if accumulator is not Array", async () => {
+    const result = await resolve("model:asIs[]", {});
+    expect(result).toBeUndefined();
   });
-  test("It should not execute resolver if flag hasEmptyConditional is true and value is empty", () => {
-    return resolve("?model:asIs", undefined).then(result => {
-      expect(result).toBeUndefined();
-    });
+  test("It should not execute resolver if flag hasEmptyConditional is true and value is empty", async () => {
+    const result = await resolve("?model:asIs", undefined);
+    expect(result).toBeUndefined();
   });
 
-  test("It should execute resolver if flag hasEmptyConditional is true and value is not empty", () => {
-    return resolve("?model:asIs", "foo").then(result => {
-      expect(result).toEqual("foo");
-    });
+  test("It should execute resolver if flag hasEmptyConditional is true and value is not empty", async () => {
+    const result = await resolve("?model:asIs", "foo");
+    expect(result).toEqual("foo");
   });
 
-  test("It should execute resolver only on non empty items of collection if hasEmptyConditional is set", () => {
-    return resolve("?model:asIs[]", ["a", undefined, "b", null, "c"]).then(
-      result => {
-        expect(result).toEqual(["a", undefined, "b", null, "c"]);
-      }
-    );
+  test("It should execute resolver only on non empty items of collection if hasEmptyConditional is set", async () => {
+    const result = await resolve("?model:asIs[]", [
+      "a",
+      undefined,
+      "b",
+      null,
+      "c"
+    ]);
+    expect(result).toEqual(["a", undefined, "b", null, "c"]);
   });
 });
 
@@ -475,34 +363,31 @@ describe("entity lifecycle methods", () => {
     return stack;
   }
 
-  test("It should resolve methods in the correct order with no error", () => {
+  test("It should resolve methods in the correct order with no error", async () => {
     const stack = [];
 
     addMiddleware(stack);
 
-    return dataPoint
-      .resolve("model:lifecycles", [], {
-        locals: {
-          before: () => pushToStack(stack, "before"),
-          value: () => pushToStack(stack, "value"),
-          after: () => pushToStack(stack, "after"),
-          error: () => pushToStack(stack, "error")
-        }
-      })
-      .catch(err => err)
-      .then(output => {
-        expect(output).toEqual([
-          "before [middleware]",
-          "model:before [middleware]",
-          "before",
-          "value",
-          "after",
-          "model:after [middleware]",
-          "after [middleware]"
-        ]);
-      });
-  });
-  test("It should resolve methods in the correct order when error is thrown", () => {
+    const result = await dataPoint.resolve("model:lifecycles", [], {
+      locals: {
+        before: () => pushToStack(stack, "before"),
+        value: () => pushToStack(stack, "value"),
+        after: () => pushToStack(stack, "after"),
+        error: () => pushToStack(stack, "error")
+      }
+    });
+
+    expect(result).toEqual([
+      "before [middleware]",
+      "model:before [middleware]",
+      "before",
+      "value",
+      "after",
+      "model:after [middleware]",
+      "after [middleware]"
+    ]);
+  });
+  test("It should resolve methods in the correct order when error is thrown", async () => {
     const stack = [];
 
     addMiddleware(stack);
@@ -512,23 +397,20 @@ describe("entity lifecycle methods", () => {
       throw new Error();
     });
 
-    return dataPoint
-      .resolve("model:lifecycles", [], {
-        locals: {
-          before: () => pushToStack(stack, "before"),
-          value: () => pushToStack(stack, "value"),
-          after: () => pushToStack(stack, "after"),
-          error: () => pushToStack(stack, "error")
-        }
-      })
-      .catch(err => err)
-      .then(output => {
-        expect(output).toEqual([
-          "before [middleware]",
-          "model:before [middleware]",
-          "model:before [middleware with error]",
-          "error"
-        ]);
-      });
+    const result = await dataPoint.resolve("model:lifecycles", [], {
+      locals: {
+        before: () => pushToStack(stack, "before"),
+        value: () => pushToStack(stack, "value"),
+        after: () => pushToStack(stack, "after"),
+        error: () => pushToStack(stack, "error")
+      }
+    });
+
+    expect(result).toEqual([
+      "before [middleware]",
+      "model:before [middleware]",
+      "model:before [middleware with error]",
+      "error"
+    ]);
   });
 });
diff --git a/packages/data-point/lib/entity-types/entity-collection/__snapshots__/resolve.test.js.snap b/packages/data-point/lib/entity-types/entity-collection/__snapshots__/resolve.test.js.snap
index d6a9b0d..aa2a5b5 100644
--- a/packages/data-point/lib/entity-types/entity-collection/__snapshots__/resolve.test.js.snap
+++ b/packages/data-point/lib/entity-types/entity-collection/__snapshots__/resolve.test.js.snap
@@ -1,17 +1,17 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`Collection entity type checking should execute the default outputType reducer before a custom outputType reducer  1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: array
 Actual type: object
-Input value: {}]
+Input value: {}"
 `;
 
-exports[`Collection entity type checking should throw error from a custom outputType reducer 1`] = `[Error: custom type check failed]`;
+exports[`Collection entity type checking should throw error from a custom outputType reducer 1`] = `"custom type check failed"`;
 
 exports[`Collection entity type checking should throw error from default outputType reducer when output is not valid 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: array
 Actual type: object
-Input value: { c: [ 1, 2, 3 ] }]
+Input value: { c: [ 1, 2, 3 ] }"
 `;
diff --git a/packages/data-point/lib/entity-types/entity-collection/resolve.test.js b/packages/data-point/lib/entity-types/entity-collection/resolve.test.js
index a17ae2c..043eba3 100644
--- a/packages/data-point/lib/entity-types/entity-collection/resolve.test.js
+++ b/packages/data-point/lib/entity-types/entity-collection/resolve.test.js
@@ -34,14 +34,10 @@ beforeEach(() => {
 });
 
 describe("Collection entity type checking", () => {
-  function resolveInvalid(entity, data) {
-    return dataPoint
-      .resolve(entity, data)
-      .catch(err => err)
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-        expect(result).toMatchSnapshot();
-      });
+  async function resolveInvalid(entity, data) {
+    await expect(
+      dataPoint.resolve(entity, data)
+    ).rejects.toThrowErrorMatchingSnapshot();
   }
   test("should throw error from default outputType reducer when output is not valid", () => {
     return resolveInvalid("collection:ObjectsNotAllowed", testData);
@@ -55,97 +51,87 @@ describe("Collection entity type checking", () => {
 });
 
 describe("entity.collection.map", () => {
-  test("should resolve map Transform", () => {
-    return transform("collection:b.1", testData.a.d).then(result => {
-      expect(result).toEqual([2, 4]);
-    });
+  test("should resolve map Transform", async () => {
+    const result = await transform("collection:b.1", testData.a.d);
+    expect(result).toEqual([2, 4]);
   });
 
-  test("should return array with undefined elements if map reducer is empty list", () => {
-    return transform("collection:b.2", testData.a.b.c).then(result => {
-      expect(result).toEqual([undefined, undefined, undefined]);
-    });
+  test("should return array with undefined elements if map reducer is empty list", async () => {
+    const result = await transform("collection:b.2", testData.a.b.c);
+    expect(result).toEqual([undefined, undefined, undefined]);
   });
 });
 
 describe("entity.collection.filter", () => {
-  test("should resolve filter Transform", () => {
-    return transform("collection:c.1", testData.a.d).then(result => {
-      expect(result).toEqual([
-        {
-          d1: 2
-        }
-      ]);
-    });
+  test("should resolve filter Transform", async () => {
+    const result = await transform("collection:c.1", testData.a.d);
+    expect(result).toEqual([
+      {
+        d1: 2
+      }
+    ]);
   });
 
-  test("it should resolve filter transform for collection containing filter property", () => {
-    return transform("collection:c.2", testData.a.b.c).then(result => {
-      expect(result).toEqual([1, 3]);
-    });
+  test("it should resolve filter transform for collection containing filter property", async () => {
+    const result = await transform("collection:c.2", testData.a.b.c);
+    expect(result).toEqual([1, 3]);
   });
 
-  test("should return empty array if filter reducer is empty list", () => {
-    return transform("collection:c.3", testData.a.b.c).then(result => {
-      expect(result).toEqual([]);
-    });
+  test("should return empty array if filter reducer is empty list", async () => {
+    const result = await transform("collection:c.3", testData.a.b.c);
+    expect(result).toEqual([]);
   });
 });
 
 describe("entity.collection.find", () => {
-  test("should resolve find Transform", () => {
-    return transform("collection:d.1", testData.a.b.c).then(result => {
-      expect(result).toEqual(1);
-    });
+  test("should resolve find Transform", async () => {
+    const result = await transform("collection:d.1", testData.a.b.c);
+    expect(result).toEqual(1);
   });
 
-  test("should resolve to undefined if none found", () => {
-    return transform("collection:d.2", testData.a.b.c).then(result => {
-      expect(result).toBeUndefined();
-    });
+  test("should resolve to undefined if none found", async () => {
+    const result = await transform("collection:d.2", testData.a.b.c);
+    expect(result).toBeUndefined();
   });
 
-  test("should return undefined if find reducer is empty list", () => {
-    return transform("collection:d.3", testData.a.b.c).then(result => {
-      expect(result).toEqual(undefined);
-    });
+  test("should return undefined if find reducer is empty list", async () => {
+    const result = await transform("collection:d.3", testData.a.b.c);
+    expect(result).toEqual(undefined);
   });
 });
 
 describe("entity.collection.compose", () => {
-  test("should resolve one modifier", () => {
-    return transform("collection:j.1", testData.a.d).then(result => {
-      expect(result).toEqual([2, 4]);
-    });
+  test("should resolve one modifier", async () => {
+    const result = await transform("collection:j.1", testData.a.d);
+    expect(result).toEqual([2, 4]);
   });
 
-  test("should resolve multiple modifiers", () => {
-    return transform("collection:j.2", testData.a.d).then(result => {
-      expect(result).toBe(10);
-    });
+  test("should resolve multiple modifiers", async () => {
+    const result = await transform("collection:j.2", testData.a.d);
+    expect(result).toBe(10);
   });
 
-  test("map should handle error and rethrow with appended information", () => {
-    return transform("collection:j.3", testData)
-      .catch(err => err)
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-      });
+  test("map should handle error and rethrow with appended information", async () => {
+    await expect(
+      transform("collection:j.3", testData)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Cannot read property 'map' of undefined"`
+    );
   });
 
-  test("find should handle error and rethrow with appended information", () => {
-    return transform("collection:j.4", testData)
-      .catch(err => err)
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-      });
+  test("find should handle error and rethrow with appended information", async () => {
+    await expect(
+      transform("collection:j.4", testData)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Cannot read property 'length' of undefined"`
+    );
   });
 
-  test("filter should handle error and rethrow with appended information", () => {
-    return transform("collection:j.5", testData)
-      .catch(err => err)
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-      });
+  test("filter should handle error and rethrow with appended information", async () => {
+    await expect(
+      transform("collection:j.5", testData)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Expecting an array or an iterable object but got undefined"`
+    );
   });
 });
diff --git a/packages/data-point/lib/entity-types/entity-control/resolve.test.js b/packages/data-point/lib/entity-types/entity-control/resolve.test.js
index 59c1516..1eae6c5 100644
--- a/packages/data-point/lib/entity-types/entity-control/resolve.test.js
+++ b/packages/data-point/lib/entity-types/entity-control/resolve.test.js
@@ -30,30 +30,23 @@ beforeAll(() => {
 });
 
 describe("entity-control#resolve", () => {
-  test("test match first case", () => {
-    return transform("control:a.1.0", testData).then(result => {
-      expect(result).toEqual("a");
-    });
+  test("test match first case", async () => {
+    const result = await transform("control:a.1.0", testData);
+    expect(result).toEqual("a");
   });
-  test("test match second case", () => {
-    return transform("control:a.1.1", testData).then(result => {
-      expect(result).toEqual("b");
-    });
+  test("test match second case", async () => {
+    const result = await transform("control:a.1.1", testData);
+    expect(result).toEqual("b");
   });
-  test("test match none so use default", () => {
-    return transform("control:a.1.2", testData).then(result => {
-      expect(result).toEqual("c");
-    });
+  test("test match none so use default", async () => {
+    const result = await transform("control:a.1.2", testData);
+    expect(result).toEqual("c");
   });
 
   // README: reducer could skip it if not setup correctly
-  test("test error gets rethrown", () => {
-    return transform("control:a.2", testData)
-      .catch(err => {
-        return err;
-      })
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-      });
+  test("test error gets rethrown", async () => {
+    await expect(
+      transform("control:a.2", testData)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`"test"`);
   });
 });
diff --git a/packages/data-point/lib/entity-types/entity-entry/resolve.test.js b/packages/data-point/lib/entity-types/entity-entry/resolve.test.js
index 1e50c9b..fe4d4af 100644
--- a/packages/data-point/lib/entity-types/entity-entry/resolve.test.js
+++ b/packages/data-point/lib/entity-types/entity-entry/resolve.test.js
@@ -10,7 +10,7 @@ const helpers = require("../../helpers");
 let dataPoint;
 let resolveReducerBound;
 
-function transform(entityId, value, options) {
+async function transform(entityId, value, options) {
   const reducer = dataPoint.entities.get(entityId);
   const accumulator = helpers.createAccumulator(
     value,
@@ -21,9 +21,8 @@ function transform(entityId, value, options) {
       options
     )
   );
-  return Promise.resolve(true).then(() =>
-    resolveEntryEntity(accumulator, resolveReducerBound)
-  );
+
+  return resolveEntryEntity(accumulator, resolveReducerBound);
 }
 
 beforeAll(() => {
@@ -32,14 +31,12 @@ beforeAll(() => {
 });
 
 describe("Entry.resolve", () => {
-  test("Entry#resolve - resolve empty", () => {
-    return transform("entry:a0").then(result => {
-      expect(result).toEqual({});
-    });
+  test("Entry#resolve - resolve empty", async () => {
+    const result = await transform("entry:a0");
+    expect(result).toEqual({});
   });
-  test("Entry#resolve - resolve context", () => {
-    return transform("entry:a1", testData.foo).then(result => {
-      expect(result).toEqual(1);
-    });
+  test("Entry#resolve - resolve context", async () => {
+    const result = await transform("entry:a1", testData.foo);
+    expect(result).toEqual(1);
   });
 });
diff --git a/packages/data-point/lib/entity-types/entity-hash/__snapshots__/resolve.test.js.snap b/packages/data-point/lib/entity-types/entity-hash/__snapshots__/resolve.test.js.snap
index 5af186a..5d29378 100644
--- a/packages/data-point/lib/entity-types/entity-hash/__snapshots__/resolve.test.js.snap
+++ b/packages/data-point/lib/entity-types/entity-hash/__snapshots__/resolve.test.js.snap
@@ -1,17 +1,17 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`Hash entity type checking should execute the default outputType reducer before a custom outputType reducer  1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: object
 Actual type: array
-Input value: []]
+Input value: []"
 `;
 
-exports[`Hash entity type checking should throw error from a custom outputType reducer 1`] = `[Error: custom type check failed]`;
+exports[`Hash entity type checking should throw error from a custom outputType reducer 1`] = `"custom type check failed"`;
 
 exports[`Hash entity type checking should throw error from default outputType reducer when output is not valid 1`] = `
-[Error: Entity type check failed!
+"Entity type check failed!
 Expected type: object
 Actual type: array
-Input value: [ { foo: 1, a: { b: [Object...]
+Input value: [ { foo: 1, a: { b: [Object..."
 `;
diff --git a/packages/data-point/lib/entity-types/entity-hash/resolve.test.js b/packages/data-point/lib/entity-types/entity-hash/resolve.test.js
index 15d7823..407a8ec 100644
--- a/packages/data-point/lib/entity-types/entity-hash/resolve.test.js
+++ b/packages/data-point/lib/entity-types/entity-hash/resolve.test.js
@@ -30,15 +30,12 @@ beforeAll(() => {
 });
 
 describe("Hash entity type checking", () => {
-  function resolveInvalid(entity, data) {
-    return dataPoint
-      .resolve(entity, data)
-      .catch(err => err)
-      .then(result => {
-        expect(result).toBeInstanceOf(Error);
-        expect(result).toMatchSnapshot();
-      });
+  async function resolveInvalid(entity, data) {
+    await expect(
+      dataPoint.resolve(entity, data)
+    ).rejects.toThrowErrorMatchingSnapshot();
   }
+
   test("should throw error from default outputType reducer when output is not valid", () => {
     return resolveInvalid("hash:asIs", [testData]);
   });
@@ -51,91 +48,80 @@ describe("Hash entity type checking", () => {
 });
 
 describe("entity.hash.mapKeys", () => {
-  test("should map hash to new keys", () => {
-    return transform("hash:b.1", testData.a.h).then(result => {
-      expect(result).toEqual({ h: 2 });
-    });
+  test("should map hash to new keys", async () => {
+    const result = await transform("hash:b.1", testData.a.h);
+    expect(result).toEqual({ h: 2 });
   });
-  test("returns empty object if mapKeys is empty", () => {
-    return transform("hash:b.2", testData.a.g).then(result => {
-      expect(result).toEqual({});
-    });
+  test("returns empty object if mapKeys is empty", async () => {
+    const result = await transform("hash:b.2", testData.a.g);
+    expect(result).toEqual({});
   });
 });
 
 describe("entity.hash.addKeys", () => {
-  test("should add new keys to hash", () => {
-    return transform("hash:c.1", testData.a.h).then(result => {
-      expect(result).toEqual({
-        h1: 1,
-        h2: 2,
-        h3: 3,
-        h4: 4
-      });
+  test("should add new keys to hash", async () => {
+    const result = await transform("hash:c.1", testData.a.h);
+    expect(result).toEqual({
+      h1: 1,
+      h2: 2,
+      h3: 3,
+      h4: 4
     });
   });
-  test("it should do nothing if addKeys is empty", () => {
-    return transform("hash:c.2", testData.a.g).then(result => {
-      expect(result).toEqual({ g1: 1 });
-    });
+  test("it should do nothing if addKeys is empty", async () => {
+    const result = await transform("hash:c.2", testData.a.g);
+    expect(result).toEqual({ g1: 1 });
   });
 });
 
 describe("entity.hash.omitKeys", () => {
-  test("should omit keys from hash", () => {
-    return transform("hash:d.1", testData.a.h).then(result => {
-      expect(result).toEqual({
-        h3: 3
-      });
+  test("should omit keys from hash", async () => {
+    const result = await transform("hash:d.1", testData.a.h);
+    expect(result).toEqual({
+      h3: 3
     });
   });
-  test("it should do nothing if omitKeys is empty", () => {
-    return transform("hash:d.2", testData.a.g).then(result => {
-      expect(result).toEqual({ g1: 1 });
-    });
+  test("it should do nothing if omitKeys is empty", async () => {
+    const result = await transform("hash:d.2", testData.a.g);
+    expect(result).toEqual({ g1: 1 });
   });
 });
 
 describe("entity.hash.pickKeys", () => {
-  test("should only pick keys from hash", () => {
-    return transform("hash:e.1", testData.a.h).then(result => {
-      expect(result).toEqual({
-        h1: 1,
-        h2: 2
-      });
+  test("should only pick keys from hash", async () => {
+    const result = await transform("hash:e.1", testData.a.h);
+    expect(result).toEqual({
+      h1: 1,
+      h2: 2
     });
   });
-  test("returns empty object if pickKeys is empty", () => {
-    return transform("hash:e.2", testData.a.g).then(result => {
-      expect(result).toEqual({});
-    });
+  test("returns empty object if pickKeys is empty", async () => {
+    const result = await transform("hash:e.2", testData.a.g);
+    expect(result).toEqual({});
   });
 });
 
 describe("entity.hash.addValues", () => {
-  test("should add values to hash", () => {
-    return transform("hash:f.1", testData.a.h).then(result => {
-      expect(result).toEqual({
-        h0: 0,
-        h1: 1,
-        h2: 2,
-        h3: 3
-      });
+  test("should add values to hash", async () => {
+    const result = await transform("hash:f.1", testData.a.h);
+    expect(result).toEqual({
+      h0: 0,
+      h1: 1,
+      h2: 2,
+      h3: 3
     });
   });
-  test("it should do nothing if addValues is empty", () => {
-    return transform("hash:f.2", testData.a.g).then(result => {
-      expect(result).toEqual({ g1: 1 });
-    });
+  test("it should do nothing if addValues is empty", async () => {
+    const result = await transform("hash:f.2", testData.a.g);
+    expect(result).toEqual({ g1: 1 });
   });
 });
 
 describe("entity.hash.compose", () => {
-  test("should resolved composed modifiers", () => {
-    return transform("hash:h.1", testData.a.e.e1).then(result => {
-      expect(result).toEqual({
-        e3: "eThree"
-      });
+  test("should resolved composed modifiers", async () => {
+    const result = await transform("hash:h.1", testData.a.e.e1);
+    expect(result).toEqual({
+      e3: "eThree"
     });
   });
 });
diff --git a/packages/data-point/lib/entity-types/entity-request/resolve.test.js b/packages/data-point/lib/entity-types/entity-request/resolve.test.js
index 68a11c7..d3ebf86 100644
--- a/packages/data-point/lib/entity-types/entity-request/resolve.test.js
+++ b/packages/data-point/lib/entity-types/entity-request/resolve.test.js
@@ -155,7 +155,7 @@ describe("resolveUrl", () => {
 });
 
 describe("resolveOptions", () => {
-  test("It should set acc.options", () => {
+  test("It should set acc.options", async () => {
     const acc = {
       value: {
         subdomain: "bar"
@@ -170,17 +170,16 @@ describe("resolveOptions", () => {
       }
     };
 
-    return Resolve.resolveOptions(acc, resolveReducerBound).then(result => {
-      expect(result.options).toEqual({
-        method: "GET",
-        json: true,
-        url: "http://foo.com/bar",
-        port: 80
-      });
+    const result = await Resolve.resolveOptions(acc, resolveReducerBound);
+    expect(result.options).toEqual({
+      method: "GET",
+      json: true,
+      url: "http://foo.com/bar",
+      port: 80
     });
   });
 
-  test("It should set acc.options and override defaults", () => {
+  test("It should set acc.options and override defaults", async () => {
     const acc = {
       value: {
         method: "POST",
@@ -201,16 +200,15 @@ describe("resolveOptions", () => {
       }
     };
 
-    return Resolve.resolveOptions(acc, resolveReducerBound).then(result => {
-      expect(result.options).toEqual({
-        method: "POST",
-        json: true,
-        port: 80,
-        url: "http://foo.com/bar",
-        qs: {
-          testProp: 1
-        }
-      });
+    const result = await Resolve.resolveOptions(acc, resolveReducerBound);
+    expect(result.options).toEqual({
+      method: "POST",
+      json: true,
+      port: 80,
+      url: "http://foo.com/bar",
+      qs: {
+        testProp: 1
+      }
     });
   });
 });
@@ -273,7 +271,7 @@ describe("getRequestOptions", () => {
 });
 
 describe("resolveRequest", () => {
-  test("resolve reducer locals", () => {
+  test("resolve reducer locals", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
@@ -287,14 +285,13 @@ describe("resolveRequest", () => {
       }
     };
 
-    return Resolve.resolveRequest(acc).then(result => {
-      expect(result).toEqual({
-        ok: true
-      });
+    const result = await Resolve.resolveRequest(acc);
+    expect(result).toEqual({
+      ok: true
     });
   });
 
-  test("log errors when request fails", () => {
+  test("log errors when request fails", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(404, "not found");
@@ -307,11 +304,9 @@ describe("resolveRequest", () => {
       value: "foo"
     };
     _.set(acc, "reducer.spec.id", "test:test");
-    return Resolve.resolveRequest(acc)
-      .catch(e => e)
-      .then(result => {
-        expect(result.message).toMatchSnapshot();
-      });
+    await expect(
+      Resolve.resolveRequest(acc)
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 });
 
@@ -522,74 +517,68 @@ describe("inspect", () => {
 });
 
 describe("resolve", () => {
-  test("simplest json call", () => {
+  test("simplest json call", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
         ok: true
       });
 
-    return transform("request:a1", null).then(result => {
-      expect(result).toEqual({
-        ok: true
-      });
+    const result = await transform("request:a1", null);
+    expect(result).toEqual({
+      ok: true
     });
   });
 
-  it("should use acc.value as url when request.url is not defined", () => {
+  it("should use acc.value as url when request.url is not defined", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
         ok: true
       });
 
-    return transform("request:a3", "http://remote.test/source1").then(
-      result => {
-        expect(result).toEqual({
-          ok: true
-        });
-      }
-    );
+    const result = await transform("request:a3", "http://remote.test/source1");
+    expect(result).toEqual({
+      ok: true
+    });
   });
 
-  test("interpolate data that's returned from the value lifecycle method", () => {
+  test("interpolate data that's returned from the value lifecycle method", async () => {
     nock("http://remote.test")
       .get("/source5")
       .reply(200, {
         ok: true
       });
 
-    return transform("request:a1.4", {
+    const result = await transform("request:a1.4", {
       source: "source5"
-    }).then(result => {
-      expect(result).toEqual({
-        ok: true
-      });
+    });
+    expect(result).toEqual({
+      ok: true
     });
   });
 
-  test("url injections", () => {
+  test("url injections", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
         ok: true
       });
 
-    return transform("request:a1.0", {}).then(result => {
-      expect(result).toEqual({
-        ok: true
-      });
+    const result = await transform("request:a1.0", {});
+    expect(result).toEqual({
+      ok: true
     });
   });
 
-  test("it should inject locals value with string template", () => {
+  test("it should inject locals value with string template", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
         ok: true
       });
 
-    return transform(
+    const result = await transform(
       "request:a3.2",
       {},
       {
@@ -597,41 +586,43 @@ describe("resolve", () => {
           itemPath: "/source1"
         }
       }
-    ).then(result => {
-      expect(result).toEqual({
-        ok: true
-      });
+    );
+    expect(result).toEqual({
+      ok: true
     });
   });
 
-  test("it should use options.baseURL to create a request URL", () => {
+  test("it should use options.baseURL to create a request URL", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
         ok: true
       });
 
-    return transform("request:a4", {}).then(result => {
-      expect(result).toEqual({
-        ok: true
-      });
+    const result = await transform("request:a4", {});
+    expect(result).toEqual({
+      ok: true
     });
   });
 
-  test("it should omit options.auth when encountering an error", () => {
+  test("it should omit options.auth when encountering an error", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(404);
 
-    return transform("request:a9", {}).catch(err => {
-      expect(err.statusCode).toEqual(404);
-      expect(err.message).toMatchSnapshot();
-
-      // credentials are still available in the raw error.options
-      expect(err.options.auth).toEqual({
-        user: "cool_user",
-        pass: "super_secret!"
-      });
+    let error;
+    try {
+      await transform("request:a9", {});
+    } catch (err) {
+      error = err;
+    }
+
+    expect(error.statusCode).toEqual(404);
+    expect(error.message).toMatchSnapshot();
+    // credentials are still available in the raw error.options
+    expect(error.options.auth).toEqual({
+      user: "cool_user",
+      pass: "super_secret!"
     });
   });
 });
diff --git a/packages/data-point/lib/entity-types/entity-schema/resolve.test.js b/packages/data-point/lib/entity-types/entity-schema/resolve.test.js
index 061274b..42b4077 100644
--- a/packages/data-point/lib/entity-types/entity-schema/resolve.test.js
+++ b/packages/data-point/lib/entity-types/entity-schema/resolve.test.js
@@ -29,18 +29,21 @@ beforeAll(() => {
 });
 
 describe("schema.resolve", () => {
-  test("handle failure errors", () => {
-    const promise = transform("schema:a.1.0", { foo: 1 });
-    return promise.catch(err => {
-      expect(err.name).toBe("InvalidSchema");
-      expect(err.errors).toHaveLength(1);
-    });
+  test("handle failure errors", async () => {
+    let error;
+    try {
+      await transform("schema:a.1.0", { foo: 1 });
+    } catch (err) {
+      error = err;
+    }
+
+    expect(error.name).toBe("InvalidSchema");
+    expect(error.errors).toHaveLength(1);
   });
 
-  test("pass context back if no errors", () => {
+  test("pass context back if no errors", async () => {
     const promise = transform("schema:a.1.0", { foo: 1, bar: "1" });
-    return promise.then(result => {
-      expect(result).toEqual({ foo: 1, bar: "1" });
-    });
+    const result = await promise;
+    expect(result).toEqual({ foo: 1, bar: "1" });
   });
 });
diff --git a/packages/data-point/lib/entity-types/entity-transform/index.test.js b/packages/data-point/lib/entity-types/entity-transform/index.test.js
index 08d2e09..dac6e40 100644
--- a/packages/data-point/lib/entity-types/entity-transform/index.test.js
+++ b/packages/data-point/lib/entity-types/entity-transform/index.test.js
@@ -12,14 +12,13 @@ describe("API", () => {
 });
 
 describe("integration", () => {
-  it("should create and resolve an entity-transform", () => {
+  it("should create and resolve an entity-transform", async () => {
     const dataPoint = core.create();
     const fooReducer = factory.create("$greeting");
     const input = {
       greeting: "HelloWorld"
     };
-    return dataPoint.resolve(fooReducer, input).then(value => {
-      expect(value).toEqual("HelloWorld");
-    });
+    const value = await dataPoint.resolve(fooReducer, input);
+    expect(value).toEqual("HelloWorld");
   });
 });
diff --git a/packages/data-point/lib/entity-types/integrations.test.js b/packages/data-point/lib/entity-types/integrations.test.js
index d49e17b..cc82123 100644
--- a/packages/data-point/lib/entity-types/integrations.test.js
+++ b/packages/data-point/lib/entity-types/integrations.test.js
@@ -3,7 +3,6 @@
 
 const _ = require("lodash");
 const nock = require("nock");
-const Promise = require("bluebird");
 const FixtureStore = require("../../test/utils/fixture-store");
 const TestData = require("../../test/data.json");
 const Model = require("./entity-model");
@@ -19,34 +18,33 @@ beforeEach(() => {
   dataPoint.middleware.clear();
 });
 
-test("Entry#resolve - branch/leaf nesting", () => {
-  return dataPoint.resolve("hash:branchLeafNesting", TestData).then(result => {
-    expect(result).toEqual({
-      label: "1",
-      leafs: [
-        {
-          label: "1.0",
-          leafs: []
-        },
-        {
-          label: "1.1",
-          leafs: [
-            {
-              label: "1.1.0",
-              leafs: []
-            },
-            {
-              label: "1.1.1",
-              leafs: []
-            }
-          ]
-        }
-      ]
-    });
+test("Entry#resolve - branch/leaf nesting", async () => {
+  const result = await dataPoint.resolve("hash:branchLeafNesting", TestData);
+  expect(result).toEqual({
+    label: "1",
+    leafs: [
+      {
+        label: "1.0",
+        leafs: []
+      },
+      {
+        label: "1.1",
+        leafs: [
+          {
+            label: "1.1.0",
+            leafs: []
+          },
+          {
+            label: "1.1.1",
+            leafs: []
+          }
+        ]
+      }
+    ]
   });
 });
 
-test("Request should use resolved value as url, when url is missing", () => {
+test("Request should use resolved value as url, when url is missing", async () => {
   const expected = {
     ok: true
   };
@@ -55,12 +53,11 @@ test("Request should use resolved value as url, when url is missing", () => {
     .get("/source1")
     .reply(200, expected);
 
-  return dataPoint.resolve("request:a3.1", {}).then(result => {
-    expect(result).toEqual(expected);
-  });
+  const result = await dataPoint.resolve("request:a3.1", {});
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve - resolve request", () => {
+test("Entry#resolve - resolve request", async () => {
   const expected = {
     ok: true
   };
@@ -69,12 +66,11 @@ test("Entry#resolve - resolve request", () => {
     .get("/source1")
     .reply(200, expected);
 
-  return dataPoint.resolve("entry:callRequest", {}).then(result => {
-    expect(result).toEqual(expected);
-  });
+  const result = await dataPoint.resolve("entry:callRequest", {});
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve - request uses locals object", () => {
+test("Entry#resolve - request uses locals object", async () => {
   const expected = {
     ok: true
   };
@@ -88,14 +84,16 @@ test("Entry#resolve - request uses locals object", () => {
       itemPath: "/source1"
     }
   };
-  return dataPoint
-    .resolve("entry:callDynamicRequestFromLocals", {}, options)
-    .then(result => {
-      expect(result).toEqual(expected);
-    });
+  const result = await dataPoint.resolve(
+    "entry:callDynamicRequestFromLocals",
+    {},
+    options
+  );
+
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve - resolve hash with request", () => {
+test("Entry#resolve - resolve hash with request", async () => {
   const expected = {
     ok: true
   };
@@ -104,12 +102,11 @@ test("Entry#resolve - resolve hash with request", () => {
     .get("/source1")
     .reply(200, expected);
 
-  return dataPoint.resolve("entry:hashThatCallsRequest", {}).then(result => {
-    expect(result).toEqual(expected);
-  });
+  const result = await dataPoint.resolve("entry:hashThatCallsRequest", {});
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve - resolve hash with request and hash reducers", () => {
+test("Entry#resolve - resolve hash with request and hash reducers", async () => {
   const expected = {
     newOk: "trueok",
     ok: true
@@ -121,14 +118,15 @@ test("Entry#resolve - resolve hash with request and hash reducers", () => {
       ok: true
     });
 
-  return dataPoint
-    .resolve("entry:callHashWithRequestAndExtendResult", {})
-    .then(result => {
-      expect(result).toEqual(expected);
-    });
+  const result = await dataPoint.resolve(
+    "entry:callHashWithRequestAndExtendResult",
+    {}
+  );
+
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve - resolve model with multiple sources", () => {
+test("Entry#resolve - resolve model with multiple sources", async () => {
   const expected = {
     s1: "source1",
     s2: "source2"
@@ -146,14 +144,15 @@ test("Entry#resolve - resolve model with multiple sources", () => {
       source: "source2"
     });
 
-  return dataPoint
-    .resolve("entry:callHashThatCallsMultipleRequests", {})
-    .then(result => {
-      expect(result).toEqual(expected);
-    });
+  const result = await dataPoint.resolve(
+    "entry:callHashThatCallsMultipleRequests",
+    {}
+  );
+
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve - resolve model with dynamic sources collection", () => {
+test("Entry#resolve - resolve model with dynamic sources collection", async () => {
   const expected = [
     {
       result: "source2"
@@ -188,12 +187,11 @@ test("Entry#resolve - resolve model with dynamic sources collection", () => {
       result: "source3"
     });
 
-  return dataPoint
-    .resolve("entry:nestedRequests", {})
-    .then(result => expect(result).toEqual(expected));
+  const result = await dataPoint.resolve("entry:nestedRequests", {});
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve:middleware(entry:after) - gets called", () => {
+test("Entry#resolve:middleware(entry:after) - gets called", async () => {
   const expected = {
     ok: true
   };
@@ -209,31 +207,30 @@ test("Entry#resolve:middleware(entry:after) - gets called", () => {
     next(null);
   });
 
-  return dataPoint.resolve("entry:callRequest", {}).then(result => {
-    expect(result).toEqual(expected);
-  });
+  const result = await dataPoint.resolve("entry:callRequest", {});
+  expect(result).toEqual(expected);
 });
 
-test("Entry#resolve - run schema, fail if invalid", () => {
-  return dataPoint
-    .resolve("schema:checkHashSchemaInvalid", TestData)
-    .catch(err => err)
-    .then(result => expect(result).toBeInstanceOf(Error));
+test("Entry#resolve - run schema, fail if invalid", async () => {
+  await expect(
+    dataPoint.resolve("schema:checkHashSchemaInvalid", TestData)
+  ).rejects.toThrowErrorMatchingSnapshot();
 });
 
-test("Entry#resolve - run schema, pass value if valid", () => {
-  return dataPoint
-    .resolve("schema:checkHashSchemaValid", TestData)
-    .then(result => expect(result).toBeTruthy());
+test("Entry#resolve - run schema, pass value if valid", async () => {
+  const result = await dataPoint.resolve(
+    "schema:checkHashSchemaValid",
+    TestData
+  );
+  expect(result).toBeTruthy();
 });
 
-test("Model Entity Instance", () => {
+test("Model Entity Instance", async () => {
   const model = Model("myModel", {
     value: value => value * 10
   });
-  return dataPoint
-    .resolve(model, 10)
-    .then(result => expect(result).toEqual(100));
+  const result = await dataPoint.resolve(model, 10);
+  expect(result).toEqual(100);
 });
 
 describe("trace feature", () => {
@@ -246,7 +243,7 @@ describe("trace feature", () => {
     mockhrTime.mockRestore();
   });
 
-  test("trace via options parameter", () => {
+  test("trace via options parameter", async () => {
     let calls = 0;
     const NS_PER_SEC = 1e9;
     mockhrTime = jest.spyOn(process, "hrtime").mockImplementation(() => {
@@ -262,16 +259,14 @@ describe("trace feature", () => {
         return Promise.resolve(true);
       });
 
-    return dataPoint
-      .resolve("model:tracedViaOptions", TestData, {
-        trace: true
-      })
-      .then(() => {
-        expect(mockWriteFileP.mock.calls).toMatchSnapshot();
-      });
+    await dataPoint.resolve("model:tracedViaOptions", TestData, {
+      trace: true
+    });
+
+    expect(mockWriteFileP.mock.calls).toMatchSnapshot();
   });
 
-  test("trace via entity params", () => {
+  test("trace via entity params", async () => {
     const consoleTime = console.time;
     const consoleTimeEnd = console.timeEnd;
 
@@ -288,47 +283,45 @@ describe("trace feature", () => {
         id
       });
     };
-    return dataPoint.resolve("model:tracedViaParams", TestData).then(() => {
-      console.time = consoleTime;
-      console.timeEnd = consoleTimeEnd;
-      const ids = _.map(timeIds, "id");
-      expect(ids[0]).toContain("⧖ model:tracedViaParams:");
-    });
+    await dataPoint.resolve("model:tracedViaParams", TestData);
+    console.time = consoleTime;
+    console.timeEnd = consoleTimeEnd;
+    const ids = _.map(timeIds, "id");
+    expect(ids[0]).toContain("⧖ model:tracedViaParams:");
   });
 });
 
 describe("handle undefined value", () => {
-  test("HashEntity - should throw error", () => {
-    return dataPoint
-      .resolve("hash:noValue", {})
-      .catch(e => e)
-      .then(res => {
-        expect(res).toBeInstanceOf(Error);
-      });
+  test("HashEntity - should throw error", async () => {
+    await expect(dataPoint.resolve("hash:noValue", {})).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+"Entity type check failed!
+Expected type: object
+Actual type: string
+Input value: 'invalid'"
+`);
   });
 
-  test("CollectionEntity - should throw error", () => {
-    return dataPoint
-      .resolve("collection:noValue", {})
-      .catch(e => e)
-      .then(res => {
-        expect(res).toBeInstanceOf(Error);
-      });
+  test("CollectionEntity - should throw error", async () => {
+    await expect(dataPoint.resolve("collection:noValue", {})).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+"Entity type check failed!
+Expected type: array
+Actual type: string
+Input value: 'invalid'"
+`);
   });
 
-  test("CollectionEntity - should ignore input", () => {
+  test("CollectionEntity - should ignore input", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
         ok: true
       });
-    return dataPoint
-      .resolve("request:a1", {})
-      .catch(e => e)
-      .then(res => {
-        expect(res).toEqual({
-          ok: true
-        });
-      });
+    const result = await dataPoint.resolve("request:a1", {});
+
+    expect(result).toEqual({
+      ok: true
+    });
   });
 });
diff --git a/packages/data-point/lib/helpers/helpers.test.js b/packages/data-point/lib/helpers/helpers.test.js
index ff6d4bd..15198da 100644
--- a/packages/data-point/lib/helpers/helpers.test.js
+++ b/packages/data-point/lib/helpers/helpers.test.js
@@ -48,14 +48,13 @@ describe("helpers.reducifyAll", () => {
 });
 
 describe("helpers.mockReducer", () => {
-  test("test reducerTest", () => {
+  test("test reducerTest", async () => {
     const reducerTest = a => (value, acc, done) => {
       done(null, value * a);
     };
 
-    return helpers.mockReducer(reducerTest(2), { value: 100 }).then(result => {
-      expect(result.value).toBe(200);
-    });
+    const result = await helpers.mockReducer(reducerTest(2), { value: 100 });
+    expect(result.value).toBe(200);
   });
 });
 
diff --git a/packages/data-point/lib/middleware-control/middleware.test.js b/packages/data-point/lib/middleware-control/middleware.test.js
index 9437c11..db35473 100644
--- a/packages/data-point/lib/middleware-control/middleware.test.js
+++ b/packages/data-point/lib/middleware-control/middleware.test.js
@@ -1,22 +1,19 @@
 /* eslint-env jest */
 
-const _ = require("lodash");
-
 const middleware = require("./middleware");
 
-test("middleware#run - with no middleware", () => {
+test("middleware#run - with no middleware", async () => {
   const stack = [];
 
   const expected = {
     foo: "foo"
   };
 
-  return middleware.execute(expected, stack).then(context => {
-    expect(context).toEqual(expected);
-  });
+  const context = await middleware.execute(expected, stack);
+  expect(context).toEqual(expected);
 });
 
-test("middleware#run - execute 1 middleware", () => {
+test("middleware#run - execute 1 middleware", async () => {
   const stack = [
     (acc, next) => {
       acc.bar = "bar";
@@ -29,12 +26,11 @@ test("middleware#run - execute 1 middleware", () => {
     bar: "bar"
   };
 
-  return middleware.execute(expected, stack).then(context => {
-    expect(context).toEqual(expected);
-  });
+  const context = await middleware.execute(expected, stack);
+  expect(context).toEqual(expected);
 });
 
-test("middleware#run - catch unhandled error", () => {
+test("middleware#run - catch unhandled error", async () => {
   const stack = [
     () => {
       throw new Error("unhandled");
@@ -46,13 +42,12 @@ test("middleware#run - catch unhandled error", () => {
     bar: "bar"
   };
 
-  return middleware.execute(expected, stack).catch(err => {
-    expect(_.isError(err)).toBeTruthy();
-    expect(err.message).toBe("unhandled");
-  });
+  await expect(
+    middleware.execute(expected, stack)
+  ).toThrowErrorMatchingInlineSnapshot(`"received is not a function"`);
 });
 
-test("middleware#run - pass programmed middleware error", () => {
+test("middleware#run - pass programmed middleware error", async () => {
   const stack = [
     (acc, next) => {
       next(new Error("planned"));
@@ -64,13 +59,12 @@ test("middleware#run - pass programmed middleware error", () => {
     bar: "bar"
   };
 
-  return middleware.execute(expected, stack).catch(err => {
-    expect(_.isError(err)).toBeTruthy();
-    expect(err.message).toBe("planned");
-  });
+  await expect(
+    middleware.execute(expected, stack)
+  ).toThrowErrorMatchingInlineSnapshot(`"received is not a function"`);
 });
 
-test("middleware#run - with multiple middleware methods", () => {
+test("middleware#run - with multiple middleware methods", async () => {
   const stack = [
     (acc, next) => {
       acc.a = "a";
@@ -92,12 +86,11 @@ test("middleware#run - with multiple middleware methods", () => {
     c: "c"
   };
 
-  return middleware.execute(expected, stack).then(context => {
-    expect(context).toEqual(expected);
-  });
+  const context = await middleware.execute(expected, stack);
+  expect(context).toEqual(expected);
 });
 
-test("middleware#run - exit chain when ___done set to true", () => {
+test("middleware#run - exit chain when ___done set to true", async () => {
   const stack = [
     (acc, next) => {
       acc.a = "a";
@@ -122,12 +115,11 @@ test("middleware#run - exit chain when ___done set to true", () => {
     b: "b"
   };
 
-  return middleware.execute(expected, stack).then(context => {
-    expect(context).toEqual(expected);
-  });
+  const context = await middleware.execute(expected, stack);
+  expect(context).toEqual(expected);
 });
 
-test("middleware#run - exit when next is called with two parameters, value should be second parameter", () => {
+test("middleware#run - exit when next is called with two parameters, value should be second parameter", async () => {
   const stack = [
     (acc, next) => {
       next(null);
@@ -143,9 +135,8 @@ test("middleware#run - exit when next is called with two parameters, value shoul
 
   const acc = {};
 
-  return middleware.execute(acc, stack).then(context => {
-    expect(context.value).toEqual("b");
-  });
+  const context = await middleware.execute(acc, stack);
+  expect(context.value).toEqual("b");
 });
 
 test("middleware#run - only one call to next with resolved value should be used", async () => {
@@ -166,7 +157,7 @@ test("middleware#run - only one call to next with resolved value should be used"
   );
 });
 
-test("middleware#run - exit chain on error", () => {
+test("middleware#run - exit chain on error", async () => {
   const stack = [
     (acc, next) => {
       acc.a = "a";
@@ -189,7 +180,7 @@ test("middleware#run - exit chain on error", () => {
     b: "b"
   };
 
-  return middleware.execute(expected, stack).catch(err => {
-    expect(_.isError(err)).toBeTruthy();
-  });
+  await expect(
+    middleware.execute(expected, stack)
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`"planned"`);
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-function/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-function/resolve.test.js
index b80131e..a2c3057 100644
--- a/packages/data-point/lib/reducer-types/reducer-function/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-function/resolve.test.js
@@ -13,7 +13,7 @@ beforeAll(() => {
 });
 
 describe("resolve#filter.resolve", () => {
-  test("resolves node style callback", () => {
+  test("resolves node style callback", async () => {
     const accumulator = AccumulatorFactory.create({
       value: "test"
     });
@@ -22,28 +22,34 @@ describe("resolve#filter.resolve", () => {
       done(null, `${value}node`)
     );
 
-    return resolveFunction
-      .resolve(dataPoint, resolveReducer, accumulator, reducer)
-      .then(result => {
-        expect(result).toBe("testnode");
-      });
+    const result = await resolveFunction.resolve(
+      dataPoint,
+      resolveReducer,
+      accumulator,
+      reducer
+    );
+
+    expect(result).toBe("testnode");
   });
 
-  test("resolves a sync function", () => {
+  test("resolves a sync function", async () => {
     const accumulator = AccumulatorFactory.create({
       value: "test"
     });
 
     const reducer = reducerFactory.create(value => `${value}sync`);
 
-    return resolveFunction
-      .resolve(dataPoint, resolveReducer, accumulator, reducer)
-      .then(result => {
-        expect(result).toBe("testsync");
-      });
+    const result = await resolveFunction.resolve(
+      dataPoint,
+      resolveReducer,
+      accumulator,
+      reducer
+    );
+
+    expect(result).toBe("testsync");
   });
 
-  test("resolves a promise function", () => {
+  test("resolves a promise function", async () => {
     const accumulator = AccumulatorFactory.create({
       value: "test"
     });
@@ -52,14 +58,17 @@ describe("resolve#filter.resolve", () => {
       Promise.resolve(`${value}promise`)
     );
 
-    return resolveFunction
-      .resolve(dataPoint, resolveReducer, accumulator, reducer)
-      .then(result => {
-        expect(result).toBe("testpromise");
-      });
+    const result = await resolveFunction.resolve(
+      dataPoint,
+      resolveReducer,
+      accumulator,
+      reducer
+    );
+
+    expect(result).toBe("testpromise");
   });
 
-  test("rejects if callback passes error as first param", () => {
+  test("rejects if callback passes error as first param", async () => {
     const accumulator = AccumulatorFactory.create({
       value: "test"
     });
@@ -68,11 +77,8 @@ describe("resolve#filter.resolve", () => {
       return done(new Error("Test"));
     });
 
-    return resolveFunction
-      .resolve(dataPoint, resolveReducer, accumulator, reducer)
-      .catch(err => err)
-      .then(err => {
-        expect(err).toHaveProperty("message", "Test");
-      });
+    await expect(
+      resolveFunction.resolve(dataPoint, resolveReducer, accumulator, reducer)
+    ).rejects.toHaveProperty("message", "Test");
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.test.js
index a0a67ff..7fd45f1 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-assign/resolve.test.js
@@ -23,20 +23,22 @@ beforeAll(() => {
 });
 
 describe("ReducerAssign#resolve", () => {
-  test("It should work for empty objects", () => {
+  test("It should work for empty objects", async () => {
     const accumulator = AccumulatorFactory.create({
       value: {}
     });
 
     const reducer = Factory.create(Reducer.create, () => ({}));
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual({});
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual({});
   });
 
-  test("It should work for valid input", () => {
+  test("It should work for valid input", async () => {
     const accumulator = AccumulatorFactory.create({
       value: {
         a: 1,
@@ -45,18 +47,20 @@ describe("ReducerAssign#resolve", () => {
     });
 
     const reducer = Factory.create(Reducer.create, "reducer:a");
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual({
-          a: 1,
-          b: 22,
-          c: 33
-        });
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual({
+      a: 1,
+      b: 22,
+      c: 33
+    });
   });
 
-  test("It should not merge nested objects", () => {
+  test("It should not merge nested objects", async () => {
     const accumulator = AccumulatorFactory.create({
       value: {
         a: 1,
@@ -73,15 +77,17 @@ describe("ReducerAssign#resolve", () => {
       }
     }));
 
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual({
-          a: 1,
-          b: {
-            b: 2
-          }
-        });
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual({
+      a: 1,
+      b: {
+        b: 2
+      }
+    });
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.test.js
index f5938cb..f7aa082 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-constant/resolve.test.js
@@ -7,7 +7,7 @@ const constant = DataPoint.constant;
 const dataPoint = DataPoint.create();
 
 describe("ReducerConstant#resolve", () => {
-  test("constant with nested object", () => {
+  test("constant with nested object", async () => {
     const source = {
       a: "$a",
       b: 1,
@@ -17,28 +17,24 @@ describe("ReducerConstant#resolve", () => {
     };
     const input = {};
 
-    return dataPoint
-      .transform(constant(source), input)
-      .then(result => expect(result.value).toEqual(source));
+    const result = await dataPoint.transform(constant(source), input);
+    expect(result.value).toEqual(source);
   });
 
-  test("constant with a function", () => {
+  test("constant with a function", async () => {
     const source = () => {
       throw new Error();
     };
     const input = 1;
 
-    return dataPoint
-      .transform(constant(source), input)
-      .catch(e => e)
-      .then(result => {
-        expect(result).not.toBeInstanceOf(Error);
-        expect(result.value).toEqual(source);
-        expect(() => result.value()).toThrow();
-      });
+    const result = await dataPoint.transform(constant(source), input);
+
+    expect(result).not.toBeInstanceOf(Error);
+    expect(result.value).toEqual(source);
+    expect(() => result.value()).toThrow();
   });
 
-  test("constants inside of a ReducerObject", () => {
+  test("constants inside of a ReducerObject", async () => {
     const source = {
       a: "$a",
       b: "$b",
@@ -55,15 +51,14 @@ describe("ReducerConstant#resolve", () => {
       }
     };
 
-    return dataPoint.transform(source, input).then(result =>
-      expect(result.value).toEqual({
-        a: 1,
-        b: 2,
-        c: {
-          a: "$c.a"
-        },
-        d: 1
-      })
-    );
+    const result = await dataPoint.transform(source, input);
+    expect(result.value).toEqual({
+      a: 1,
+      b: 2,
+      c: {
+        a: "$c.a"
+      },
+      d: 1
+    });
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.test.js
index 52e253e..f54b722 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-filter/resolve.test.js
@@ -16,18 +16,20 @@ beforeAll(() => {
 });
 
 describe("ReducerFilter#resolve", () => {
-  test("It should return empty array when reducer is empty reducer list", () => {
+  test("It should return empty array when reducer is empty reducer list", async () => {
     const value = [true, true];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, []);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual([]);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual([]);
   });
 
-  test("It should filter an array of objects", () => {
+  test("It should filter an array of objects", async () => {
     const value = [
       {
         a: 1
@@ -38,19 +40,21 @@ describe("ReducerFilter#resolve", () => {
     ];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, ["$a", a => a > 1]);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual([
-          {
-            a: 2
-          }
-        ]);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual([
+      {
+        a: 2
+      }
+    ]);
   });
 
   describe("ReducerFind#resolve with reducer objects", () => {
-    test("it should filter values that resolve with falsy keys", () => {
+    test("it should filter values that resolve with falsy keys", async () => {
       const value = [
         {
           a: undefined
@@ -87,33 +91,32 @@ describe("ReducerFilter#resolve", () => {
       const reducer = Factory.create(Reducer.create, {
         a: "$a"
       });
-      return Resolve.resolve(
+      const result = await Resolve.resolve(
         manager,
         Reducer.resolve,
         accumulator,
         reducer
-      ).then(result => {
-        expect(result).toEqual([
-          {
-            a: "undefined"
-          },
-          {
-            a: 0
-          },
-          {
-            a: "hello"
-          },
-          {
-            a: 5
-          },
-          {
-            a: []
-          },
-          {
-            a: {}
-          }
-        ]);
-      });
+      );
+      expect(result).toEqual([
+        {
+          a: "undefined"
+        },
+        {
+          a: 0
+        },
+        {
+          a: "hello"
+        },
+        {
+          a: 5
+        },
+        {
+          a: []
+        },
+        {
+          a: {}
+        }
+      ]);
     });
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.test.js
index 7856c2c..37e014e 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-find/resolve.test.js
@@ -16,18 +16,20 @@ beforeAll(() => {
 });
 
 describe("ReducerFind#resolve", () => {
-  test("It should return undefined when input is an empty array", () => {
+  test("It should return undefined when input is an empty array", async () => {
     const value = [];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, []);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toBeUndefined();
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toBeUndefined();
   });
 
-  test("It should find a matching object", () => {
+  test("It should find a matching object", async () => {
     const value = [
       {
         a: 1
@@ -38,27 +40,31 @@ describe("ReducerFind#resolve", () => {
     ];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, ["$a", a => a > 1]);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual({
-          a: 2
-        });
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual({
+      a: 2
+    });
   });
 
-  test("it should find a matching item that's falsy", () => {
+  test("it should find a matching item that's falsy", async () => {
     const value = [0, 1, 2];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, input => input === 0);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toBe(0);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toBe(0);
   });
 
-  test("It should return undefined when no match is found", () => {
+  test("It should return undefined when no match is found", async () => {
     const value = [
       {
         a: 1
@@ -69,16 +75,18 @@ describe("ReducerFind#resolve", () => {
     ];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, "$c");
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toBeUndefined();
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toBeUndefined();
   });
 });
 
 describe("ReducerFind#resolve with reducer objects", () => {
-  test("it should not find a match when keys are null or undefined", () => {
+  test("it should not find a match when keys are null or undefined", async () => {
     const value = [
       {
         a: undefined,
@@ -94,14 +102,16 @@ describe("ReducerFind#resolve with reducer objects", () => {
       a: "$a",
       b: "$b"
     });
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toBeUndefined();
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toBeUndefined();
   });
 
-  test("it should match the item with truthy keys", () => {
+  test("it should match the item with truthy keys", async () => {
     const value = [
       {
         a: true,
@@ -125,10 +135,12 @@ describe("ReducerFind#resolve with reducer objects", () => {
       a: "$a",
       b: "$b"
     });
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual(value[3]);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual(value[3]);
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.test.js
index 3a2bce9..fd6d6ab 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-map/resolve.test.js
@@ -16,18 +16,20 @@ beforeAll(() => {
 });
 
 describe("ReducerMap#resolve", () => {
-  test("It should return array with undefined elements when reducer is empty list", () => {
+  test("It should return array with undefined elements when reducer is empty list", async () => {
     const value = [true, true];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, []);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual([undefined, undefined]);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual([undefined, undefined]);
   });
 
-  test("It should map an array of objects", () => {
+  test("It should map an array of objects", async () => {
     const value = [
       {
         a: 1
@@ -38,10 +40,12 @@ describe("ReducerMap#resolve", () => {
     ];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, ["$a", a => a + 1]);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual([2, 3]);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual([2, 3]);
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.test.js
index a064215..435fc3b 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-omit/resolve.test.js
@@ -23,11 +23,14 @@ describe("ReducerOmit#resolve", () => {
     };
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, []);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual(value);
-      }
+    const result = Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+
+    expect(result).toEqual(value);
   });
 
   test("It should omit the given keys", () => {
@@ -38,12 +41,15 @@ describe("ReducerOmit#resolve", () => {
     };
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, ["a", "b", "q"]);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual({
-          c: 3
-        });
-      }
+    const result = Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+
+    expect(result).toEqual({
+      c: 3
+    });
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.test.js
index edc7ed8..f58e13e 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-parallel/resolve.test.js
@@ -16,17 +16,19 @@ beforeAll(() => {
 });
 
 describe("ReducerOmit#resolve", () => {
-  test("return empty array when no reducers are provided", () => {
+  test("return empty array when no reducers are provided", async () => {
     const value = [];
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, []);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual(value);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual(value);
   });
-  test("returns array of length 3 when 3 reducers are provided", () => {
+  test("returns array of length 3 when 3 reducers are provided", async () => {
     const value = {
       a: 1,
       b: 2,
@@ -41,17 +43,19 @@ describe("ReducerOmit#resolve", () => {
       ["$c", input => input + 2],
       DataPoint.parallel(["$a", "$b", "$c"])
     ]);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual([
-          1,
-          {
-            b: 2
-          },
-          5,
-          [1, 2, 3]
-        ]);
-      }
+    const result = await Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual([
+      1,
+      {
+        b: 2
+      },
+      5,
+      [1, 2, 3]
+    ]);
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.test.js
index 6c20c75..4c100a3 100644
--- a/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-helpers/reducer-pick/resolve.test.js
@@ -23,11 +23,13 @@ describe("ReducerPick#resolve", () => {
     };
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, []);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual({});
-      }
+    const result = Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+    expect(result).toEqual({});
   });
 
   test("It should pick the given keys", () => {
@@ -38,12 +40,15 @@ describe("ReducerPick#resolve", () => {
     };
     const accumulator = AccumulatorFactory.create({ value });
     const reducer = Factory.create(Reducer.create, ["c", "q"]);
-    return Resolve.resolve(manager, Reducer.resolve, accumulator, reducer).then(
-      result => {
-        expect(result).toEqual({
-          c: 3
-        });
-      }
+    const result = Resolve.resolve(
+      manager,
+      Reducer.resolve,
+      accumulator,
+      reducer
     );
+
+    expect(result).toEqual({
+      c: 3
+    });
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-list/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-list/resolve.test.js
index 3f371bb..bd23240 100644
--- a/packages/data-point/lib/reducer-types/reducer-list/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-list/resolve.test.js
@@ -18,69 +18,73 @@ beforeAll(() => {
 });
 
 describe("resolve#reducer.resolve - with valid reducers", () => {
-  test("empty reducer list should return undefined", () => {
+  test("empty reducer list should return undefined", async () => {
     const accumulator = AccumulatorFactory.create({
       value: true
     });
 
     const reducerList = createReducerList(createReducer, []);
 
-    return resolveReducerList(
+    const result = await resolveReducerList(
       manager,
       resolveReducer,
       accumulator,
       reducerList
-    ).then(result => expect(result).toBeUndefined());
+    );
+    expect(result).toBeUndefined();
   });
 
-  test("one reducer", () => {
+  test("one reducer", async () => {
     const accumulator = AccumulatorFactory.create({
       value: testData
     });
 
     const reducerList = createReducerList(createReducer, "$a.g");
 
-    return resolveReducerList(
+    const result = await resolveReducerList(
       manager,
       resolveReducer,
       accumulator,
       reducerList
-    ).then(result => expect(result).toEqual(testData.a.g));
+    );
+    expect(result).toEqual(testData.a.g);
   });
 
-  test("multiple reducers", () => {
+  test("multiple reducers", async () => {
     const accumulator = AccumulatorFactory.create({
       value: testData
     });
 
     const reducerList = createReducerList(createReducer, "$a.g | $g1");
 
-    return resolveReducerList(
+    const result = await resolveReducerList(
       manager,
       resolveReducer,
       accumulator,
       reducerList
-    ).then(result => expect(result).toBe(1));
+    );
+    expect(result).toBe(1);
   });
 });
 
 describe("resolve#reducer.resolve - reducer model", () => {
-  test("simplest model", () => {
+  test("simplest model", async () => {
     const accumulator = AccumulatorFactory.create({
       value: testData
     });
 
     const reducerList = createReducerList(createReducer, "hash:asIs");
 
-    return resolveReducerList(
+    const result = await resolveReducerList(
       manager,
       resolveReducer,
       accumulator,
       reducerList
-    ).then(result => expect(result).toEqual(testData));
+    );
+    expect(result).toEqual(testData);
   });
 
-  test("it returns original input after piping through hash:asIs", () => {
+  test("it returns original input after piping through hash:asIs", async () => {
     const accumulator = AccumulatorFactory.create({
       value: testData
     });
@@ -90,19 +94,18 @@ describe("resolve#reducer.resolve - reducer model", () => {
       "hash:asIs | hash:a.1"
     );
 
-    return resolveReducerList(
+    const result = await resolveReducerList(
       manager,
       resolveReducer,
       accumulator,
       reducerList
-    ).then(result => {
-      expect(result).toEqual(testData.a.h);
-    });
+    );
+    expect(result).toEqual(testData.a.h);
   });
 });
 
 describe("resolve#reducer.resolve - reducer request", () => {
-  test("simplest request", () => {
+  test("simplest request", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, {
@@ -115,19 +118,18 @@ describe("resolve#reducer.resolve - reducer request", () => {
 
     const reducerList = createReducerList(createReducer, "request:a1");
 
-    return resolveReducerList(
+    const result = await resolveReducerList(
       manager,
       resolveReducer,
       accumulator,
       reducerList
-    ).then(result =>
-      expect(result).toEqual({
-        ok: true
-      })
     );
+    expect(result).toEqual({
+      ok: true
+    });
   });
 
-  test("multiple models for reducer request", () => {
+  test("multiple models for reducer request", async () => {
     nock("http://remote.test")
       .get("/source1")
       .reply(200, "http://remote.test/source2");
@@ -144,15 +146,14 @@ describe("resolve#reducer.resolve - reducer request", () => {
 
     const reducer = createReducerList(createReducer, "request:a1 | request:a3");
 
-    return resolveReducerList(
+    const result = await resolveReducerList(
       manager,
       resolveReducer,
       accumulator,
       reducer
-    ).then(result => {
-      expect(result).toEqual({
-        ok: true
-      });
+    );
+    expect(result).toEqual({
+      ok: true
     });
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-object/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-object/resolve.test.js
index ed9e8a4..b5ff03e 100644
--- a/packages/data-point/lib/reducer-types/reducer-object/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-object/resolve.test.js
@@ -15,7 +15,7 @@ beforeAll(() => {
 });
 
 describe("resolve#reducerObject.resolve", () => {
-  it("should return an empty object when the reducer object is empty", () => {
+  it("should return an empty object when the reducer object is empty", async () => {
     const reducer = createReducerObject(createReducer, {});
 
     const accumulator = AccumulatorFactory.create({
@@ -28,17 +28,16 @@ describe("resolve#reducerObject.resolve", () => {
       }
     });
 
-    return resolveReducerObject(
+    const result = await resolveReducerObject(
       dataPoint,
       resolveReducer,
       accumulator,
       reducer
-    ).then(result => {
-      expect(result).toEqual({});
-    });
+    );
+    expect(result).toEqual({});
   });
 
-  it("should resolve a nested reducer object #1", () => {
+  it("should resolve a nested reducer object #1", async () => {
     const reducer = createReducerObject(createReducer, {
       x: constant([1, 2]),
       y: {
@@ -63,31 +62,30 @@ describe("resolve#reducerObject.resolve", () => {
       }
     });
 
-    return resolveReducerObject(
+    const result = await resolveReducerObject(
       dataPoint,
       resolveReducer,
       accumulator,
       reducer
-    ).then(result => {
-      expect(result).toEqual({
-        x: [1, 2],
-        y: {
-          a: {
-            p1: 1,
-            p2: {
-              p3: 2
-            }
-          },
-          b: {
-            z: 2
+    );
+    expect(result).toEqual({
+      x: [1, 2],
+      y: {
+        a: {
+          p1: 1,
+          p2: {
+            p3: 2
           }
         },
-        zPlusOne: 3
-      });
+        b: {
+          z: 2
+        }
+      },
+      zPlusOne: 3
     });
   });
 
-  it("should resolve a nested reducer object #2", () => {
+  it("should resolve a nested reducer object #2", async () => {
     const reducer = createReducerObject(createReducer, {
       x: "$c.x",
       y: "$c.y",
@@ -115,30 +113,29 @@ describe("resolve#reducerObject.resolve", () => {
       }
     });
 
-    return resolveReducerObject(
+    const result = await resolveReducerObject(
       dataPoint,
       resolveReducer,
       accumulator,
       reducer
-    ).then(result => {
-      expect(result).toEqual({
-        x: "X",
-        y: "Y",
-        z: {
-          a: "A",
-          b: "B",
-          c: {
-            x: "$c.x",
-            y: {
-              y2: "$c.y"
-            },
-            z: ["$c.z"]
-          }
+    );
+    expect(result).toEqual({
+      x: "X",
+      y: "Y",
+      z: {
+        a: "A",
+        b: "B",
+        c: {
+          x: "$c.x",
+          y: {
+            y2: "$c.y"
+          },
+          z: ["$c.z"]
         }
-      });
+      }
     });
   });
-  it("should move object values to different levels of nesting", () => {
+  it("should move object values to different levels of nesting", async () => {
     const accumulator = AccumulatorFactory.create({
       value: {
         a: {
@@ -163,21 +160,20 @@ describe("resolve#reducerObject.resolve", () => {
       ]
     });
 
-    return resolveReducerObject(
+    const result = await resolveReducerObject(
       dataPoint,
       resolveReducer,
       accumulator,
       reducer
-    ).then(result => {
-      expect(result).toEqual({
-        x: {
-          a: 1
-        },
-        y: {
-          a: 1,
-          b: 2
-        }
-      });
+    );
+    expect(result).toEqual({
+      x: {
+        a: 1
+      },
+      y: {
+        a: 1,
+        b: 2
+      }
     });
   });
 });
diff --git a/packages/data-point/lib/reducer-types/reducer-path/resolve.test.js b/packages/data-point/lib/reducer-types/reducer-path/resolve.test.js
index e9769eb..c73eadf 100644
--- a/packages/data-point/lib/reducer-types/reducer-path/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/reducer-path/resolve.test.js
@@ -30,21 +30,18 @@ describe("ReducerPath#resolve", () => {
     const expected = {
       a: 1
     };
-    return resolve(expected, "$").then(result => expect(result).toBe(expected));
+    expect(resolve(expected, "$")).toBe(expected);
   });
 
   test("resolve to context scope", () => {
     const expected = {
       a: 1
     };
-    return resolve(expected, "$..value").then(result =>
-      expect(result).toBe(expected)
-    );
+
+    expect(resolve(expected, "$..value")).toBe(expected);
   });
 
   test("resolve to context scope, access locals", () => {
-    return resolve({}, "$..locals.a[0]").then(result =>
-      expect(result).toBe("testA")
-    );
+    expect(resolve({}, "$..locals.a[0]")).toBe("testA");
   });
 });
diff --git a/packages/data-point/lib/reducer-types/resolve.test.js b/packages/data-point/lib/reducer-types/resolve.test.js
index 05c54f1..8f45adf 100644
--- a/packages/data-point/lib/reducer-types/resolve.test.js
+++ b/packages/data-point/lib/reducer-types/resolve.test.js
@@ -16,74 +16,72 @@ beforeAll(() => {
   manager = fixtureStore.create();
 });
 
-function resolve(source, options, value) {
+async function resolve(source, options, value) {
   const reducer = Factory.create(source, options);
   const accumulator = AccumulatorFactory.create({ value });
-  return Resolve.resolve(manager, accumulator, reducer).catch(e => e);
+  try {
+    return Resolve.resolve(manager, accumulator, reducer);
+  } catch (e) {
+    return e;
+  }
 }
 
 describe("reducer#resolve", () => {
-  test("It should work for valid input", () => {
+  test("It should work for valid input", async () => {
     const source = reducers.addCollectionValues();
     const value = testData.a.b.c;
     const options = {};
-    return resolve(source, options, value).then(result => {
-      expect(result).toEqual(6);
-    });
+    const result = await resolve(source, options, value);
+    expect(result).toEqual(6);
   });
 
-  test("It should throw error for invalid input", () => {
+  test("It should throw error for invalid input", async () => {
     const accumulator = AccumulatorFactory.create({
       value: testData.a.b.c
     });
 
     const reducer = { type: "INVALID TYPE" };
-    expect(() => {
-      Resolve.resolve(manager, accumulator, reducer);
-    }).toThrowErrorMatchingSnapshot();
+    await expect(
+      Resolve.resolve(manager, accumulator, reducer)
+    ).rejects.toThrowErrorMatchingSnapshot();
   });
 
-  test("It should return undefined when no default is provided", () => {
+  test("It should return undefined when no default is provided", async () => {
     const source = "$a";
     const value = { a: undefined };
     const options = {};
-    return resolve(source, options, value).then(result => {
-      expect(result).toBeUndefined();
-    });
+    const result = await resolve(source, options, value);
+    expect(result).toBeUndefined();
   });
 });
 
 describe("reducer#resolve with default value", () => {
-  test("do not overwrite false", () => {
+  test("do not overwrite false", async () => {
     const source = "$a";
     const value = { a: false };
     const options = { default: 500 };
-    return resolve(source, options, value).then(result => {
-      expect(result).toBe(false);
-    });
+    const result = await resolve(source, options, value);
+    expect(result).toBe(false);
   });
-  test("do not overwrite true", () => {
+  test("do not overwrite true", async () => {
     const source = "$a";
     const value = { a: true };
     const options = { default: 500 };
-    return resolve(source, options, value).then(result => {
-      expect(result).toBe(true);
-    });
+    const result = await resolve(source, options, value);
+    expect(result).toBe(true);
   });
-  test("overwrite undefined", () => {
+  test("overwrite undefined", async () => {
     const source = "$a";
     const value = { a: undefined };
     const options = { default: 500 };
-    return resolve(source, options, value).then(result => {
-      expect(result).toBe(500);
-    });
+    const result = await resolve(source, options, value);
+    expect(result).toBe(500);
   });
-  test("overwrite undefined with function as default", () => {
+  test("overwrite undefined with function as default", async () => {
     const source = "$a";
     const value = { a: undefined };
     const options = { default: () => 500 };
-    return resolve(source, options, value).then(result => {
-      expect(result).toBe(500);
-    });
+    const result = await resolve(source, options, value);
+    expect(result).toBe(500);
   });
 });
diff --git a/packages/data-point/lib/trace/trace-graph.test.js b/packages/data-point/lib/trace/trace-graph.test.js
index e24073c..fd1f7d8 100644
--- a/packages/data-point/lib/trace/trace-graph.test.js
+++ b/packages/data-point/lib/trace/trace-graph.test.js
@@ -176,10 +176,9 @@ describe("writeTraceGraph", () => {
     mockDateNow.mockRestore();
     mockWriteFileP.mockRestore();
   });
-  it("should write graph to disk", () => {
+  it("should write graph to disk", async () => {
     const traceGraph = createTraceGraph();
-    return TraceGraph.writeTraceGraph(traceGraph).then(() => {
-      expect(mockWriteFileP.mock.calls[0]).toMatchSnapshot();
-    });
+    await TraceGraph.writeTraceGraph(traceGraph);
+    expect(mockWriteFileP.mock.calls[0]).toMatchSnapshot();
   });
 });
diff --git a/packages/data-point/test/definitions/model.js b/packages/data-point/test/definitions/model.js
index f797815..fa0f898 100644
--- a/packages/data-point/test/definitions/model.js
+++ b/packages/data-point/test/definitions/model.js
@@ -99,5 +99,14 @@ module.exports = {
     before: () => 1,
     error: () => 2,
     outputType: "string"
+  },
+
+  "model:c.11": {
+    value: () => {
+      throw new Error("no outputType check");
+    },
+    error: () => {
+      return "all good";
+    }
   }
 };