@appolo/agent
v8.0.11
Published
Fast and simple http server framework
Downloads
755
Readme
Appolo Agent
Fast and simple http server build with typescript and appolo-route
Installation:
npm install @appolo/agent --save
Usage:
import {Agent} from '@appolo/agent'
await new Agent()
.get("/test/:id/", (req: IRequest, res: IResponse) => {
res.json({query: req.query, params: req.params})
}).listen(3000);
Agent
Options
port
- port number to agent will listen default8080
errorStack
- boolean print error stack on error defaultfalse
errorMessage
- boolean print error message defaulttrue
maxRouteCache
- max number of cached routes paths with lru cache default1000
,useRouteCache
- boolean use route path cache defaulttrue
decodeUrlParams
- boolean usedecodeURIComponent
on path params defaultfalse
qsParser
- module to use to parse querystring valuesqs
|querystring default
qs`viewEngine
- like express view wngineviewFolder
- view folder to search view paths default ``viewCache
- boolean cache viewviewExt
- views file ext defaulthtml
await new Agent({port:3000})
.get("/test/:id/", (req: IRequest, res: IResponse) => {
res.json({query: req.query, params: req.params})
}).listen();
get server(): http.Server | https.Server
get node http server
get router(): Router
get router instance
listen(port: number, cb?: Function): Promise<Agent>
bind the agent to port call callback if provided return the agent instance
close(): Promise<void>
close the agent connection to http server and clean everything
Routing
Static route
let app = new Agent()
.get("/test/test2", (req,res)=>res.send("working"));
.post("/test/test2", (req,res)=>res.send("working post"));
Parametric route
let router = new Agent()
.get("/test/:userId/:userName", (req,res)=>res.send("working"));
Wildcard route
let router = new Agent()
.get("/*", (req,res)=>res.send("working"));
Regex route
same syntax as path-to-regexp
let app = new Agent()
.get("/test/:file(^\\d+).png", (req,res)=>res.send("working"));
get(path: string, ...handler: any[]): Agent
register new Route handler using Http.Get Method
post(path: string, ...handler: any[]): Agent
register new Route handler using Http.Post Method
put(path: string, ...handler: any[]): Agent
register new Route handler using Http.Put Method
patch(path: string, ...handler: any[]): Agent
register new Route handler using Http.Put Method
patch(path: string, ...handler: any[]): Agent
register new Route handler using Http.Patch Method
delete(path: string, ...handler: any[]): Agent
register new Route handler using Http.Delete Method
head(path: string, ...handler: any[]): Agent
register new Route handler using Http.Delete Method
add(method:Http.Methods, path: string, ...handler: any[]): Router
register new Route handler. multi methods supported
let agent = new Agent()
.add("POST","/test/:param", someMiddleware(),(req,res)=>res.send("working"));
Middlewares
the agent supports any express middleware or cusotom middalwares
import favicon = require('static-favicon');
import bodyParser = require("body-parser");
import {IRequest,IResponse,NextFn} from 'appolo-agent';
let agent = new Agent()
.use(bodyParser.json());
.use(function (req:IRequest, res: IResponse, next: NextFn) {
res.setHeader("Access-Control-Allow-Origin", "*");
next();
})
.use(favicon());}
.get("/test/:param", someMiddleware(),(req,res)=>res.send("working"));
IRequest
the request object inherits from http.incomingmessage
req.query
query params object
req.body
body parser params object
req.params
route params object
req.hostname
host name of the request
req.path
path name of the request
req.secure
boolean true is the request is https
req.protocol
protocol of the request http
or https
req.app
instance of the agent
req.get(name:string)
req.header(name:string)
Returns the specified HTTP request header
req.get('content-type'); // => "text/plain"
req.is(type:string)
Returns the matching content type if the incoming request’s “Content-Type” HTTP header field matches the MIME type specified by the type parameter. If the request has no body, returns null. Returns false otherwise.
req.is('html'); // => 'html'
req.is('text/html'); // => 'text/html'
IResponse
the response object inherits from http.ServerResponse
res.status(code: number): IResponse
set response status code
res.status(200).json({name:"value"});
res.contentType(type: string): IResponse
set response content type
res.header(key: string, value: string): IResponse
res.set(key: string, value: string): IResponse
set response header
`res.cache(seconds: number): IResponse
set Cache-Control
header in seconds
res.gzip(): IResponse
compress the response with gzip and set Content-Encoding
header to gzip
res.redirect(path: string): void
redirect the request to new path
res.cookie(key: string, value: any, options?: cookie.CookieSerializeOptions): IResponse
sets cookie name to value. The value parameter may be a string or object converted to JSON.
res.cookie('name', 'test', { domain: '.example.com', path: '/admin', secure: true });
res.cookie('someName', '{someVal:1}', { expires: new Date(Date.now() + 900000), httpOnly: true });
res.clearCookie(key: string, options?: cookie.CookieSerializeOptions): IResponse
clears the cookie specified by name.
res.cookie('name', 'tobi', { path: '/admin' });
res.clearCookie('name', { path: '/admin' });
json(obj: object)
sends a JSON response.
res.json({name:"value"});
jsonp(obj: object)
Sends a JSON response with JSONP support. This method is identical to res.json(), except that it opts-in to JSONP callback support
res.jsonp({name:"value"});
`render(path: string | string[], params?: any): Promise``
render(params?: any): Promise<void>
render view html by path and params
res.render('index');
res.render('/path/to/view');
res.render('index',{some:"data"});
send(data?: string | Buffer| object)
res.send(new Buffer('some buffer'));
res.send({ some: 'data' });
res.send('<p>some html</p>');
res.status(404).send('not found');
res.status(500).send({ error: 'some error' });
License
MIT