easy-api-boilerplate

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);