# Easy API boilerplate

Quick and dirty API boilerplate, using:
  * CouchDB for the DB 
  * Yup for validation
  * Restify for the web server/routing
  * Winston for logging
  * ESLint for linting

There are many limitations to this configuration, it is intended as a
debugging/prototyping tool.

There are fairly few npm modules, not a lot of code, and most things are
simply factories with dependencies passed in.


## Usage

Import `start` from `easy-api.js`, call like so:
```
start({
  routes[], 
  host, 
  port,
  middlewares[],
  couchDbOpts{}, 
  restifyOpts{}
})
```

The included example uses docker and docker-compose, so the db host is set to
"couchdb" and the restify server listens on `0.0.0.0:8080`. You'll need to rename
`.env.example` to `.env` and change the password.


## Storage

Objects are stored in couchdb by calculating the sha256 hash, hex digest from a
"path" array for convenience (e.g. `["users", req.params.userName, "stats",
"visits"]`).

There is no hardening or security intention behind this - it's simply a fast
hash to use as an ID.


## CouchDB options

* protocol: protocol to access couchdb, e.g. http
* host: couchdb host, e.g. couchdb.mydomain.com
* port: couchdb port, e.g. 5984
* dbs: array of DB names to connect to (created if they don't exist), e.g. ['visits']
* username: couchdb username, e.g. admin
* password: couchbase password, e.g. password123


## Routes

Routes are defined as simple factories, passed an array of wrapped dbs, yup and log instance as
an object (`{dbs, yup, log}`) and expected to return:
  * verb: HTTP verb, e.g. `get`
  * path: restify path string, e.g. `/api/hello/:name`
  * handlers: array of restify handler functions for route
  * schema (optional): yup schema to validate against


## Validation

If a route passes a schema, the request will be validated against it before any
other handlers are called.

  * get requests validate against `req.params`
  * post requests validate against `req.body`

When validation fails, a HTTP 400 is returned and the remaining handlers are not
processed.


## Middlewares

Middlewares are defined as factories, returning a restify-compatible middleware.
They are passed the server instance and restify, like so:
```
const middlewareToBeApplied = middlewareFactory({server, restify});
server.use(middlewareToBeApplied);
```