refactor: handle of performance improvements

Author: thetutlage

npm-audit.html

@@ -55,7 +55,7 @@ <h5 class="card-title">
                 <div class="card">
                     <div class="card-body">
                         <h5 class="card-title">
-                            July 22nd 2020, 7:05:03 am
+                            July 22nd 2020, 9:46:15 am
                         </h5>
                         <p class="card-text">Last updated</p>
                     </div>

src/Server/PreCompiler/index.ts

@@ -13,9 +13,9 @@ import haye from 'haye'
 import { Middleware } from 'co-compose'
 import { Exception } from '@poppinss/utils'
 import { RouteNode } from '@ioc:Adonis/Core/Route'
-import { MiddlewareStoreContract } from '@ioc:Adonis/Core/Middleware'
 import { IocContract, IocResolverContract } from '@adonisjs/fold'
 import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import { MiddlewareStoreContract, ResolvedMiddlewareHandler } from '@ioc:Adonis/Core/Middleware'
 
 import { useReturnValue } from '../../helpers'
 
@@ -31,53 +31,51 @@ export class PreCompiler {
 	/**
 	 * This function is used by reference to execute the route handler
 	 */
-	private finalRouteHandler = async function finalRouteHandler(ctx: HttpContextContract) {
-		let data: any = {}
-
-		let requestProfiler = ctx.profiler
+	private runRouteHandler = async (ctx: HttpContextContract) => {
+		const routeHandler = ctx.route!.meta.resolvedHandler!
 
 		/*
 		 * Passing a child to the route handler, so that all internal
 		 * actions can have their own child row
 		 */
-		ctx.profiler = ctx.profiler.create('http:route:handler', data)
-
-		const routeHandler = ctx.route!.meta.resolvedHandler!
 		let returnValue: any
 
 		try {
 			if (routeHandler.type === 'function') {
 				returnValue = await routeHandler.handler(ctx)
 			} else {
-				data.controller = routeHandler.namespace
-				data.method = routeHandler.method
 				returnValue = await this.resolver.call(routeHandler, ctx.route!.meta.namespace, [ctx])
 			}
 
 			if (useReturnValue(returnValue, ctx)) {
 				ctx.response.send(returnValue)
 			}
-
-			ctx.profiler.end()
-			ctx.profiler = requestProfiler
 		} catch (error) {
-			ctx.profiler.end()
-			ctx.profiler = requestProfiler
 			throw error
 		}
-	}.bind(this)
+	}
+
+	/**
+	 * Method to execute middleware using the middleware store
+	 */
+	private executeMiddleware = (
+		middleware: ResolvedMiddlewareHandler,
+		params: [HttpContextContract, () => Promise<void>]
+	) => {
+		return this.middlewareStore.invokeMiddleware(middleware, params)
+	}
 
 	/**
 	 * This function is used by reference to execute the route middleware + route handler
 	 */
-	private routeMiddlewareHandler = async function routeMiddlewareHandler(ctx: HttpContextContract) {
-		await new Middleware()
+	private runRouteMiddleware = (ctx: HttpContextContract) => {
+		return new Middleware()
 			.register(ctx.route!.meta.resolvedMiddleware!)
 			.runner()
-			.executor(this.middlewareStore.invokeMiddleware.bind(this.middlewareStore))
-			.finalHandler(this.finalRouteHandler, [ctx])
+			.executor(this.executeMiddleware)
+			.finalHandler(this.runRouteHandler, [ctx])
 			.run([ctx])
-	}.bind(this)
+	}
 
 	/**
 	 * The resolver used to resolve the controllers from IoC container
@@ -138,9 +136,9 @@ export class PreCompiler {
 	 */
 	private setFinalHandler(route: RouteNode) {
 		if (route.meta.resolvedMiddleware && route.meta.resolvedMiddleware.length) {
-			route.meta.finalHandler = this.routeMiddlewareHandler
+			route.meta.finalHandler = this.runRouteMiddleware
 		} else {
-			route.meta.finalHandler = this.finalRouteHandler
+			route.meta.finalHandler = this.runRouteHandler
 		}
 	}
 

src/Server/RequestHandler/index.ts

@@ -9,29 +9,30 @@
 
 /// <reference path="../../../adonis-typings/index.ts" />
 
-import { Exception } from '@poppinss/utils'
 import { Middleware } from 'co-compose'
-import { MiddlewareStoreContract } from '@ioc:Adonis/Core/Middleware'
-import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import { Exception } from '@poppinss/utils'
 import { RouterContract } from '@ioc:Adonis/Core/Route'
+import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import { MiddlewareStoreContract, ResolvedMiddlewareHandler } from '@ioc:Adonis/Core/Middleware'
 
 /**
  * Handles the request by invoking it's middleware chain, along with the
  * route finalHandler
  */
 export class RequestHandler {
 	private globalMiddleware: Middleware
+	private handleRequest: (ctx: HttpContextContract) => Promise<void>
+
 	constructor(private middlewareStore: MiddlewareStoreContract, private router: RouterContract) {}
 
 	/**
-	 * Executes the middleware chain, followed by the route handler.
+	 * Function to invoke global middleware
 	 */
-	private async invokeHandler(ctx: HttpContextContract) {
-		await this.globalMiddleware
-			.runner()
-			.executor(this.middlewareStore.invokeMiddleware.bind(this.middlewareStore))
-			.finalHandler(ctx.route!.meta.finalHandler, [ctx])
-			.run([ctx])
+	private executeMiddleware = (
+		middleware: ResolvedMiddlewareHandler,
+		params: [HttpContextContract, () => Promise<void>]
+	) => {
+		return this.middlewareStore.invokeMiddleware(middleware, params)
 	}
 
 	/**
@@ -71,18 +72,27 @@ export class RequestHandler {
 	 */
 	public async handle(ctx: HttpContextContract) {
 		this.findRoute(ctx)
-		await this.invokeHandler(ctx)
+		return this.handleRequest(ctx)
 	}
 
 	/**
 	 * Computing certain methods to optimize for runtime performance
 	 */
 	public commit() {
 		const middleware = this.middlewareStore.get()
-		if (middleware.length) {
-			this.globalMiddleware = new Middleware().register(middleware)
-		} else {
-			this.invokeHandler = async (ctx) => ctx.route!.meta.finalHandler(ctx)
+
+		if (!middleware.length) {
+			this.handleRequest = (ctx) => ctx.route!.meta.finalHandler(ctx)
+			return
+		}
+
+		this.globalMiddleware = new Middleware().register(middleware)
+		this.handleRequest = (ctx) => {
+			return this.globalMiddleware
+				.runner()
+				.executor(this.executeMiddleware)
+				.finalHandler(ctx.route!.meta.finalHandler, [ctx])
+				.run([ctx])
 		}
 	}
 }

src/Server/index.ts

@@ -93,10 +93,11 @@ export class Server implements ServerContract {
 		 * Start with before hooks upfront. If they raise error
 		 * then execute error handler.
 		 */
-		const shortcircuit = await this.hooks.executeBefore(ctx)
-		if (!shortcircuit) {
-			return this.requestHandler.handle(ctx)
-		}
+		return this.hooks.executeBefore(ctx).then((shortcircuit) => {
+			if (!shortcircuit) {
+				return this.requestHandler.handle(ctx)
+			}
+		})
 	}
 
 	/**