Super light-weight package with decorators, middleware support, interceptors and dependency injections

Koa-with-decorators supports basic injections. Controller can inject services/providers. Providers can have their own providers and so on... Your controller can have a constructor like in example below.

constructor(private readonly userService: UserService) { }

Type of provider must be specified with Class. You can't use interface here.

Example:

import Koa = require('koa');
import KoaRouter = require('koa-router');
import {Router as KoaRoutes, Middleware, Controller, Method, Interceptor, CustomInterceptor} from 'koa-with-decorators';

const PORT = process.env.PORT || 3000;
const root = new KoaRouter();
const app = new Koa();
const routes = new KoaRoutes();
 
 
class UserService {
    public users = ['First', 'Second', 'Third'];
}


class CInterceptor implements CustomInterceptor {
    constructor(private readonly userService: UserService) {}
    
    before(ctx: Koa.Context, next:Function) {
        /* Example of interceptor can be cache logic
        const cache = checkIfInCache();
        if(cache) 
            return ctx.body = cache;
        return next();
        */
        next(); // Before acts like middleware but runs after middleware decorator 
    }

    after(ctx: Koa.Context) { //Doesn't act like middleware, acts like method that runs after controller method. !You don't need to run next in your controller method!
        /*
            cache(something);
        */
        console.log(this.userService.users);
    }

    /* Note:
        You could also use this approach.
        Don't forget to use old js functions instead of arrow functions to get access to this
        This method is more complex but is better if you don't need any provider.
    
    intercept() {
        return {
            before: function(this: any, ctx: Koa.Context, next:Function) {
                console.log(this.userService.users);
                console.log('Ran before');
                next()
            },
            after: (ctx: Koa.Context) => {
                console.log('Ran after');
            }
        }
    }
    */
}
 
@Controller('users')
class UsersRoutes {
    constructor(private readonly userService: UserService) {}
 
    //If you don't care about providers and you don't need them in your middlewares
     //If you don't care about providers and you don't need them in your middlewares
     @Middleware([
        (ctx: Koa.Context, next:any) => {next()}, 
        (ctx: Koa.Context, next:any) => {next()}
    ])
    @Interceptor(CInterceptor)
    @Method('GET', '/usersB')
    getUsers(ctx: Koa.Context) {
        ctx.body = this.userService.users;
    }
    //If you want to have this context (to access providers for example) in your middlewares you can do this
    @Interceptor(CInterceptor)
    @Method('GET', '/usersA', true)
    _getUsers(){
        return [ //You have access to this
            (ctx: Koa.Context, next:any) => {console.log('I got users '+this.userService.users); next();},
            (ctx: Koa.Context, next:any) => {console.log('Second middleware'); next()},
            (ctx: Koa.Context) => { ctx.body = this.userService.users}
        ]
    }
}
 
root.use('/api', routes.registerRoutes(UsersRoutes, true).routes());
 
app.use(root.routes());
app.use(root.allowedMethods());
 
app.listen(PORT, () => console.log('Listening to port '+PORT));