fuse-http v1.0.12
FuseHTTP
FuseHTTP is a lightweight HTTP server implementation based on express with simplicity in mind.
import { Route } from 'fuse-http';
@Route("/")
export class MainRoute {
public async get(req) {
return "hello world";
}
}
Key features
- Simple setup
- Decorator based
- Automatic dependency injections by name
- Custom error handling
npm install fuse-http --save
Getting started
You would need fuse.js configuration to bundle and start your project. So let's create fuse.js
first
fuse.js
const { FuseBox } = require("fuse-box");
const fuse = FuseBox.init({
homeDir: "src",
target: "server@esnext",
output: "dist/$name.js"
});
fuse.bundle("app")
.instructions(">[index.ts]")
.watch().completed(proc => proc.start())
fuse.run();
Now let's create our application entry point
index.ts
import { Server } from "fuse-http";
// just import the route module here
import './routes/MainRoute';
// start the server
Server.start({ port: 3001 });
Sample route: routes/MainRoute
import { Route } from 'fuse-http';
@Route("/")
export class MainRoute {
public get(req) {
return "hello world";
}
}
Routing
import { Route } from 'fuse-http';
@Route("/")
export class MainRoute {
public async get(req) {
return "hello world";
}
public async post() {
return {};
}
public async anyOtherHTTPMethod() {
return "any other";
}
}
HTTPMethod name must be found in the Route class, once matched it will be executed (with dependency injections).
You can return any kind of object, it will be serialised to JSON if possible. (strings for example will be printed as is)
Dependency injections
The framework comes with default dependency injections to make your life easier.
Name | Object |
---|---|
req | Express.req |
res | Express.res |
next | Express.next |
THe order should not matter, the only thing what matter is naming. For example the following example should work just fine.
@Route("/")
export class MainRoute {
public async get(next: express.NextFunction) {
return "hello world";
}
}
Creating your first injection
The following module must be imported in your entry point.
import { Injector } from "fuse-http";
@Injector("foo")
class Foo {
private inject(req : express.Request) {
return this;
}
public helloWorld(){
return { hello : "world" }
}
}
Now as we registered the injector, we can now use it.
@Route("/")
export class MainRoute {
public async get(foo: Foo) {
return foo.helloWorld() // will render { hello : "world" }
}
}
Here FuseBox magically resolved the first parameter, evaluated inject
method.
inject
method is resolved accordingly, respecting other injections recursively. So you can inject req
res
or next
injections too.
Decorators
Define your decorator by providing a class with init function to a wrapper MethodDecorator
import { MethodDecorator } from "fuse-http";
export const Permissions = MethodDecorator<string>(class {
init(req) {
if (!req.query.foobar){
throw { message : "Foobar must be there" }
}
}
})
init
will be constucted with all your injections including req
and res
from express
Usage in route
@Route("/")
class TestRoute {
@Permissions("sdf")
public async get() {
return {ok : true};
}
}
Error handlers
A handler must have test
method, where we test if that particular exception should be processed. For example, here is BaseHandler
@ErrorHandler()
export class ErrorBaseHandler {
public express : ExpressData;
public test(e){
const res = this.express.res;
if ( e instanceof ErrorNotFound){
res.status(404).send({code : 404, message : e.message})
}
}
}