Catnapify is a pretty, decorated wrapper around restify. Using brand new, ES6 decorators, It allows developpers to move logic such as data validation, logging and sourcing datas. It is typescript ready and promise based. It also support hooks and header validation.
Install with the usual
npm install catnapify --save
Then, create a server and a simple route:
import { Server, catnapify } from 'catnapify';
constructor(){ super() }
class MyServer extends Server {
@catnapify('get', '/ping')
ping(request: Request) {
return 'pong'
}
}
let serv = new MyServer;
serv.listen()
That's it! No need to register the route. You can add middleware using the same API as in restify (using use()), and pass a customer restify instance to Server constructor. Notice that you can link a server to a Controller instance using .link(). The example above works because Server is itself inheritating from the Controller class.
The decorated function must accept a Request object. This object is a wrapper around the usual req, res, done triplet, and is used to store custom data as well.
It must return either a Response (which would follow a pattern {code: XXX, answer: {}}) or a simple object (in this case, the HTTP code 200 would be used). The function can also
throw a Response, which would be correctly interpreted by the catnapify instance. The Response can or cannot be wrapped in a Promise (which allow for asynchrone threatement such as grabbing data from MongoDB)
A weakness of restify is that it force the coder to check incoming and outgoing variable on everyroute. Catnapify prevent that by providing the give() and need() decorator.
Both of them accept a variable name, an array of variable name, or a variable name and a validator, like in this exemple:
interface Doggo {
race: string;
name: string;
good_doggo: boolean;
}
function isGoodDoggo(doggo: any) : boolean {
return doggo.good_doggo;
}
class TestController extends Controller {
constructor(){ super() }
@catnapify('post', '/post')
@give('doggo', isGoodDoggo)
post(request: Request) {
return Promise.resolve({code: 200, give: {
doggo: {
race: 'Pit bull',
name: 'Headeater',
good_doggo: false
}}})
}
}
If the route is not called with the right request parameters, catnapify will answer a 400 BAD REQUEST HTTP response.
Logger link to a bunzyan instance to log inbound and outbound stream. It can be linked with a loggerConfig instance to set in which stream the 'input', 'output', 'error' and 'internal' error will be showed.
let loggerConfig = {
logger: loggerMock,
input: 'notice',
output: 'trace'
}
class TestController extends Controller {
constructor(){ super() }
@catnapify('post', '/post')
@logger(loggerConfig)
post(request: Request) {
return Promise.resolve({code: 200, response: 'ok'})
}
}
Catnapify also add a support for Hooks. It can execute function before or after the decorated function, and in case of an error.
@catnapify('post', '/post')
@before(function(request: TestRequest){
request.foo = 'bar'
return request;
})
post(request: TestRequest) {
expect(request.foo).to.be.equal('bar')
return Promise.resolve({code: 200, give: 'ok'})
}