henhouse v2.0.46

Henhouse

A Microservices Framework for REST APIs

Installation

Install using npm:

npm install henhouse

API Reference

henhouse

import module

const Henhouse = require('henhouse')

constructor

const myService = new Henhouse({
  servicePath: 'my-service' // null by default 
})

listen

listen at a specified port

myService.listen(3000)

close

listen at a specified port

myService.close()

get | put | post | patch | delete

• Match URL patterns to callback functions

myService
  .get('/foo', async (ctx, next) => {
    ctx.body = 'foo';
  })
  .post('/foo', async (ctx, next) => {
    ctx.body = `Body: ${ JSON.stringify(ctx.request.body) }`;
  })
  .get('/bar/:id', async (ctx, next) => {
    ctx.body = 'bar: ' + this.params.id;
  })
  .listen(3000)

• Match model name to callback functions

myService
  .get('foo', async (ctx, next, model, id) => {
    ctx.body = await model.query(ctx.$queryOptions, id)
  })
  .post('foo', async (ctx, next, model) => {
    ctx.body = await model.create(ctx.$requestBody)
  })
  .patch('foo', async (ctx, next, model, id) => {
    await model.update(ctx.$requestBody, id)
    ctx.body = 'ok'
  })
  .delete('foo', async (ctx, next, model, id) => {
    await model.remove(id)
    ctx.body = 'ok'
  })
  .listen(3000)

url query options

• specify attributes white list

http://localhost:3000/foos?fields=a,b

• if "foo" got a associations named "bar"

http://localhost:3000/foos?fields=a,b,bar.c,bar.d

• put some query conditions

http://localhost:3000/foos?a=1&b=*bar

if model "foo" got a db engine behind, it may query like:

 select * from foo
 where foo.a=1 and foo.b like '%bar'

• it can also support nested object in query

http://localhost:3000/foos?a=1&bar.b=2,3,4

it may run a sql like:

 select * from foo
 inner join bar on bar.id = foo.bar_id
  and bar.b in (2,3,4)
 where foo.a=1

• order

http://localhost:3000/foos?order=name,-beginDate

it's may run a sql like:

 select * from foo
 order by name, begin_date desc

static

serving static files

const { resolve } = require('path');

const myService = new Henhouse();
myService
  .getStatic({ root: path.resolve(__dirname, 'static-root') })
  .getStatic('/foo', { root: path.resolve(__dirname, 'static-foo') })
  .getStatic('/bar') // __dirname/bar
  .listen(3000)

HttpException

const HttpException = Henhosue.HttpException
new henhouse.HttpException(status, message, stackEnumerable)

create a new http exception

throw new HttpException(400, 'oops...');