v0.1.0 | Base Implementation

- includes readme, unit test, ci config

Author: json2d

.npmignore

@@ -0,0 +1,3 @@
+test
+.nyc_output
+travis.yml

README.md

@@ -0,0 +1,80 @@
+# 😪 await-on
+![npm](https://img.shields.io/npm/v/await-on.svg)
+![node](https://img.shields.io/node/v/await-on.svg)
+![npm](https://img.shields.io/npm/l/await-on.svg)
+![npm](https://img.shields.io/npm/dt/await-on.svg)
+![Travis](https://img.shields.io/travis/bitstrider/await-on.svg)
+
+
+really simple error handling with await/async
+
+inspired by [`await-to-js`](https://github.com/scopsy/await-to-js) whose creator [Dima Grossman](http://blog.grossman.io/how-to-write-async-await-without-try-catch-blocks-in-javascript/) originally blogged about using destructuring array assignment
+
+## Overview
+This package basically provides 3 syntactical paths to choose from:
+```javascript
+const {on, handler} = require('await-on');
+
+const fetchData = () => new Promise(/*...*/);
+
+const [err, data] = await on(fetchData());
+const [err, data] = await handler(fetchData)(); //decorator
+const [err, data] = await fetchData().handle(); //prototype extension
+```
+
+The goal is to avoid the built-in approach using the `try`/`catch` block pattern:
+
+```javascript
+try{
+	const data = await fetchData();
+	res.send(data);
+}catch(err) {
+	res.send(err);
+}
+```
+
+## Quick Usage
+
+using `on` with the function `fetchData` which returns a Promise that resolve to some result `data`:
+```javascript
+const {on} = require('await-on');
+const fetchData = () => new Promise(/*...*/);
+
+async function foo(req,res) {
+	const [err, data] = await on(fetchData());
+	if(err) res.send(err);
+	else res.send(data);
+}
+```
+
+Using the decorator pattern with `handler` yields some cleaner high level code:
+
+```javascript
+const {handler} = require('await-on');
+let fetchData = () => new Promise(/*...*/);
+fetchData = handler(fetchData);
+
+async function foo(req,res) {
+	const [err, data] = await fetchData();
+	!err ? res.send(data) : res.send(err);
+}
+```
+
+Finally, using the prototype extension `handle` on Promise types is also clean and is arguably even more readable because it also uses the chaining pattern already standard when working with Promises 🌟 :
+
+```javascript
+require('await-on');
+
+async function foo(req,res) {
+	const [err, data] = await fetchData().handle();
+	!err ? res.send(data) : res.send(err);
+}
+```
+
+## Type fuzziness
+Non-promises will passthrough same as the behavior of the native `await`
+
+```javascript
+const [err,answer] = await on(42); //not a promise but ok no big deal
+console.log(answer) //> 42
+```

lib/await-on.js

@@ -0,0 +1,32 @@
+"use strict";
+
+/**
+ * Handler which takes a promise and returns array signature with `[err, data]`.
+ * @param  {Promise} promise    Promise to handle
+ * @return {Array}              Array with signature `[err, data]`
+ */
+function on(promise) {
+  if(promise instanceof Promise) {
+    return promise.then(data => {
+      return [null, data];
+    })
+    .catch(err => [err]);
+
+  }else{
+    return [null,promise]
+  }
+}
+
+/**
+ * Decorator which takes a promise bearing function and returns that function wrapped with `on`.
+ * @param  {Function} wrapped    Function to be decorated
+ * @return {Function}            Function decorated
+ */
+const handler = (wrapped) => () => on(wrapped())
+
+//Promise type extension
+global.Promise.prototype.handle = function() {
+  return on(this)
+}
+
+module.exports = {handler,on}