Class DinoRouter

src/modules/router/dino.router.ts:32–208

// Register middlewares on the router level
// so that the middlewares are available for all routes at router level
export class DinoRouter implements IDinoRouter {
    private router: Router;
    private diContainer: IDIContainer;
    private enableTaskContext: boolean;

    constructor(config: IRouterConfig) {
        this.diContainer = config.diContainer;
        // Gets the new instance of express.router
        this.router = config.routerCb();
        this.enableTaskContext = config.enableTaskContext;
    }

    // made public for unit test and not available on interface contract
    resolve<T>(middleware: Function, dino: IDinoProperties): T {
        let o = this.diContainer.resolve<T>(middleware);

        return this.enableTaskContext ?
            ObjectUtility.replaceObjectReferences(o, dino.context, IUserIdentity) : o;
    }

    // made public for unit test and not available on interface contract
    registerMiddleware(middleware: IMiddlewareProvider): void {
        let provider = DinoParser.parseMiddlewareProvider(middleware);

        if (DinoUtility.isSyncMiddleWare(provider.useClass)) {
            this.router.use((req, res, next) => {
                let mware = this.resolve<Middleware>(
                    provider.useClass, res.locals.dino);
                mware.invoke(req, res, next, provider.data);
            });
        } else if (DinoUtility.isAsyncMiddleWare(provider.useClass)) {
            this.router.use(async (req, res, next) => {
                let mware = this.resolve<MiddlewareAsync>(
                    provider.useClass, res.locals.dino);
                try {
                    await mware.invoke(req, res, next, provider.data);
                } catch (err) {
                    next(err);
                }
            });
        }
    }

    // made public for unit test and not available on interface contract
    registerBeginActionFilter(filter: IMiddlewareProvider): void {
        let provider = DinoParser.parseMiddlewareProvider(filter);

        if (DinoUtility.isSyncActionFilter(provider.useClass)) {
            this.router.use((req, res, next) => {
                let mware = this.resolve<ActionFilter>(
                    provider.useClass, res.locals.dino);
                mware.beforeExecution(req, res, next, provider.data);
            });
        } else if (DinoUtility.isAsyncActionFilter(provider.useClass)) {
            this.router.use(async (req, res, next) => {
                let mware = this.resolve<ActionFilterAsync>(
                    provider.useClass, res.locals.dino);
                try {