# Easy API boilerplate

Quick and dirty API boilerplate, using:
  * Redis 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[],
  redisOpts{}, 
  restifyOpts{}
})
```

The included example uses docker and docker-compose, so the db host is set to
"redis" 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 redis 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.


## Routes

Routes are defined as simple factories, passed a db wrapper, yup and log instance as
an object (`{db, 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);
```