routup 3.0.0-alpha.3 → 3.1.0

package/dist/index.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var http = require('@ebec/http');
 var smob = require('smob');
 var buffer = require('buffer');
 var uncrypto = require('uncrypto');
@@ -8,17 +7,18 @@ var proxyAddr = require('proxy-addr');
 var mimeExplorer = require('mime-explorer');
 var Negotiator = require('negotiator');
 var readableStream = require('readable-stream');
+var http = require('@ebec/http');
 var pathToRegexp = require('path-to-regexp');
 
 exports.MethodName = void 0;
 (function(MethodName) {
-    MethodName["GET"] = "get";
-    MethodName["POST"] = "post";
-    MethodName["PUT"] = "put";
-    MethodName["PATCH"] = "patch";
-    MethodName["DELETE"] = "delete";
-    MethodName["OPTIONS"] = "options";
-    MethodName["HEAD"] = "head";
+    MethodName["GET"] = "GET";
+    MethodName["POST"] = "POST";
+    MethodName["PUT"] = "PUT";
+    MethodName["PATCH"] = "PATCH";
+    MethodName["DELETE"] = "DELETE";
+    MethodName["OPTIONS"] = "OPTIONS";
+    MethodName["HEAD"] = "HEAD";
 })(exports.MethodName || (exports.MethodName = {}));
 exports.HeaderName = void 0;
 (function(HeaderName) {
@@ -53,32 +53,6 @@ exports.HeaderName = void 0;
     HeaderName["X_FORWARDED_PROTO"] = "x-forwarded-proto";
 })(exports.HeaderName || (exports.HeaderName = {}));
 
-class ErrorProxy extends http.HTTPError {
-}
-
-function isError(input) {
-    return input instanceof ErrorProxy;
-}
-
-/**
- * Create an error proxy by
- * - an existing error (accessible via cause property)
- * - options
- * - message
- *
- * @param input
- */ function createError(input) {
-    if (isError(input)) {
-        return input;
-    }
-    if (typeof input === 'string') {
-        return new ErrorProxy(input);
-    }
-    return new ErrorProxy({
-        cause: input
-    }, input);
-}
-
 function isRequestCacheable(req, modifiedTime) {
     const modifiedSince = req.headers[exports.HeaderName.IF_MODIFIED_SINCE];
     if (!modifiedSince) {
@@ -209,33 +183,6 @@ function setRequestHeader(req, name, value) {
     return cookiesStrings;
 }
 
-function transformHeaderToTuples(key, value) {
-    const output = [];
-    if (Array.isArray(value)) {
-        for(let j = 0; j < value.length; j++){
-            output.push([
-                key,
-                value[j]
-            ]);
-        }
-    } else if (value !== undefined) {
-        output.push([
-            key,
-            String(value)
-        ]);
-    }
-    return output;
-}
-function transformHeadersToTuples(input) {
-    const output = [];
-    const keys = Object.keys(input);
-    for(let i = 0; i < keys.length; i++){
-        const key = keys[i].toLowerCase();
-        output.push(...transformHeaderToTuples(key, input[key]));
-    }
-    return output;
-}
-
 function isObject(item) {
     return !!item && typeof item === 'object' && !Array.isArray(item);
 }
@@ -348,6 +295,15 @@ function getCharsetForMimeType(type) {
     return undefined;
 }
 
+function toMethodName(input, alt) {
+    if (input) {
+        return input.toUpperCase();
+    }
+    return alt;
+}
+
+const nextPlaceholder = (_err)=>{};
+
 /**
  * Based on https://github.com/unjs/pathe v1.1.1 (055f50a6f1131f4e5c56cf259dd8816168fba329)
  */ function normalizeWindowsPath(input = '') {
@@ -751,6 +707,35 @@ function createRequest(context) {
     return readable;
 }
 
+class RoutupError extends http.HTTPError {
+}
+
+function isError(input) {
+    return input instanceof RoutupError;
+}
+
+/**
+ * Create an internal error object by
+ * - an existing error (accessible via cause property)
+ * - options
+ * - message
+ *
+ * @param input
+ */ function createError(input) {
+    if (isError(input)) {
+        return input;
+    }
+    if (typeof input === 'string') {
+        return new RoutupError(input);
+    }
+    if (!isObject(input)) {
+        return new RoutupError();
+    }
+    return new RoutupError({
+        cause: input
+    }, input);
+}
+
 function setResponseCacheHeaders(res, options) {
     options = options || {};
     const cacheControls = [
@@ -906,7 +891,7 @@ async function send(res, chunk) {
         const etagFn = findRouterOption('etag', useRequestRouterPath(res.req));
         const chunkHash = await etagFn(chunk, encoding, len);
         if (isResponseGone(res)) {
-            return Promise.resolve();
+            return;
         }
         if (typeof chunkHash === 'string') {
             res.setHeader(exports.HeaderName.ETag, chunkHash);
@@ -927,23 +912,22 @@ async function send(res, chunk) {
         res.removeHeader(exports.HeaderName.TRANSFER_ENCODING);
     }
     if (isResponseGone(res)) {
-        return Promise.resolve();
+        return;
     }
-    if (res.req.method === 'HEAD') {
+    if (res.req.method === 'HEAD' || res.req.method === 'head') {
         // skip body for HEAD
         res.end();
-        return Promise.resolve();
+        return;
     }
     if (typeof chunk === 'undefined' || chunk === null) {
         res.end();
-        return Promise.resolve();
+        return;
     }
     if (typeof encoding !== 'undefined') {
         res.end(chunk, encoding);
-        return Promise.resolve();
+        return;
     }
     res.end(chunk);
-    return Promise.resolve();
 }
 
 function sendAccepted(res, chunk) {
@@ -1089,7 +1073,7 @@ function sendRedirect(res, location, statusCode = 302) {
     return send(res, html);
 }
 
-function sendWebResponse(res, webResponse) {
+async function sendWebResponse(res, webResponse) {
     if (webResponse.redirected) {
         res.setHeader(exports.HeaderName.LOCATION, webResponse.url);
     }
@@ -1107,15 +1091,16 @@ function sendWebResponse(res, webResponse) {
         }
     });
     if (webResponse.body) {
-        return sendStream(res, webResponse.body);
+        await sendStream(res, webResponse.body);
+        return Promise.resolve();
     }
     res.end();
     return Promise.resolve();
 }
 
-function sendWebBlob(res, blob) {
+async function sendWebBlob(res, blob) {
     setResponseHeaderContentType(res, blob.type);
-    return sendStream(res, blob.stream());
+    await sendStream(res, blob.stream());
 }
 
 function createResponse(request) {
@@ -1263,84 +1248,130 @@ function createResponse(request) {
     return writable;
 }
 
-function buildDispatcherMeta(input) {
-    return {
-        mountPath: input.mountPath || '/',
-        params: input.params || {},
-        path: input.path || '/',
-        routerPath: []
-    };
-}
-function cloneDispatcherMeta(input) {
-    return {
-        path: input.path,
-        mountPath: input.mountPath,
-        error: input.error,
-        routerPath: [
-            ...input.routerPath
-        ],
-        params: cloneDispatcherMetaParams(input.params)
-    };
-}
-function cloneDispatcherMetaParams(input) {
-    if (typeof input === 'undefined') {
-        return {};
+async function sendData(event, chunk) {
+    if (chunk instanceof Error) {
+        return Promise.reject(createError(chunk));
     }
-    const keys = Object.keys(input);
-    if (keys.length === 0) {
-        return {};
+    if (isStream(chunk)) {
+        await sendStream(event.response, chunk);
+        return Promise.resolve();
     }
-    const output = {};
-    for(let i = 0; i < keys.length; i++){
-        output[keys[i]] = input[keys[i]];
+    if (isWebBlob(chunk)) {
+        await sendWebBlob(event.response, chunk);
+        return Promise.resolve();
     }
-    return output;
-}
-function mergeDispatcherMetaParams(t1, t2) {
-    if (!t1 && !t2) {
-        return {};
+    if (isWebResponse(chunk)) {
+        await sendWebResponse(event.response, chunk);
+        return Promise.resolve();
     }
-    if (!t1 || !t2) {
-        return t1 || t2;
+    return send(event.response, chunk);
+}
+function dispatch(event, target) {
+    setRequestParams(event.request, event.params);
+    setRequestMountPath(event.request, event.mountPath);
+    setRequestRouterPath(event.request, event.routerPath);
+    return new Promise((resolve, reject)=>{
+        let handled = false;
+        const unsubscribe = ()=>{
+            event.response.off('close', done);
+            event.response.off('error', done);
+        };
+        const shutdown = (dispatched, err)=>{
+            if (handled) {
+                return;
+            }
+            handled = true;
+            unsubscribe();
+            if (err) {
+                reject(createError(err));
+            } else {
+                resolve(dispatched);
+            }
+        };
+        const done = (err)=>shutdown(true, err);
+        const next = (err)=>shutdown(false, err);
+        event.response.once('close', done);
+        event.response.once('error', done);
+        const handle = async (data)=>{
+            if (typeof data === 'undefined' || handled) {
+                return false;
+            }
+            handled = true;
+            unsubscribe();
+            if (!event.dispatched) {
+                await sendData(event, data);
+            }
+            return true;
+        };
+        try {
+            const output = target(next);
+            if (isPromise(output)) {
+                output.then((r)=>handle(r)).then((resolved)=>{
+                    if (resolved) {
+                        resolve(true);
+                    }
+                }).catch((e)=>reject(createError(e)));
+                return;
+            }
+            Promise.resolve().then(()=>handle(output)).then((resolved)=>{
+                if (resolved) {
+                    resolve(true);
+                }
+            }).catch((e)=>reject(createError(e)));
+        } catch (error) {
+            next(error);
+        }
+    });
+}
+
+function isDispatcherErrorEvent(event) {
+    return typeof event.error !== 'undefined';
+}
+
+class DispatchEvent {
+    get dispatched() {
+        return this._dispatched || this.response.writableEnded || this.response.headersSent;
     }
-    const keys = Object.keys(t2);
-    if (keys.length === 0) {
-        return t1;
+    set dispatched(value) {
+        this._dispatched = value;
     }
-    for(let i = 0; i < keys.length; i++){
-        t1[keys[i]] = t2[keys[i]];
+    constructor(context){
+        this.request = context.request;
+        this.response = context.response;
+        this.method = context.method || exports.MethodName.GET;
+        this.methodsAllowed = [];
+        this.mountPath = '/';
+        this.params = {};
+        this.path = context.path || '/';
+        this.routerPath = [];
+        this.next = nextPlaceholder;
     }
-    return t1;
 }
 
-async function dispatchNodeRequest(router, req, res) {
-    try {
-        const dispatched = await router.dispatch({
-            req,
-            res
-        }, buildDispatcherMeta({
-            path: useRequestPath(req)
-        }));
-        if (dispatched) {
-            return;
-        }
-        if (!isResponseGone(res)) {
-            res.statusCode = 404;
-            res.end();
-        }
-    } catch (e) {
-        if (!isResponseGone(res)) {
-            if (isError(e)) {
-                res.statusCode = e.statusCode;
-                if (e.statusMessage) {
-                    res.statusMessage = e.statusMessage;
-                }
-            } else {
-                res.statusCode = 500;
-            }
-            res.end();
+class DispatchErrorEvent extends DispatchEvent {
+}
+
+async function dispatchNodeRequest(router, request, response) {
+    const event = new DispatchEvent({
+        request,
+        response,
+        path: useRequestPath(request),
+        method: toMethodName(request.method, exports.MethodName.GET)
+    });
+    await router.dispatch(event);
+    if (event.dispatched) {
+        return;
+    }
+    if (event.error) {
+        event.response.statusCode = event.error.statusCode;
+        if (event.error.statusMessage) {
+            event.response.statusMessage = event.error.statusMessage;
         }
+        event.response.end();
+        return;
     }
+    event.response.statusCode = 404;
+    event.response.end();
 }
 function createNodeDispatcher(router) {
     return (req, res)=>{
@@ -1349,10 +1380,38 @@ function createNodeDispatcher(router) {
     };
 }
 
-async function dispatchRawRequest(router, request, options = {}) {
+function transformHeaderToTuples(key, value) {
+    const output = [];
+    if (Array.isArray(value)) {
+        for(let j = 0; j < value.length; j++){
+            output.push([
+                key,
+                value[j]
+            ]);
+        }
+    } else if (value !== undefined) {
+        output.push([
+            key,
+            String(value)
+        ]);
+    }
+    return output;
+}
+function transformHeadersToTuples(input) {
+    const output = [];
+    const keys = Object.keys(input);
+    for(let i = 0; i < keys.length; i++){
+        const key = keys[i].toLowerCase();
+        output.push(...transformHeaderToTuples(key, input[key]));
+    }
+    return output;
+}
+
+async function dispatchRawRequest(router, request) {
+    const method = toMethodName(request.method, exports.MethodName.GET);
     const req = createRequest({
         url: request.path,
-        method: request.method,
+        method,
         body: request.body,
         headers: request.headers
     });
@@ -1377,52 +1436,45 @@ async function dispatchRawRequest(router, request, options = {}) {
             headers: getHeaders(),
             body: res.body
         });
-    try {
-        const dispatched = await router.dispatch({
-            req,
-            res
-        }, buildDispatcherMeta({
-            path: useRequestPath(req)
-        }));
-        if (dispatched) {
-            return createRawResponse();
-        }
-        return createRawResponse({
-            status: 404
-        });
-    } catch (e) {
-        if (options.throwOnError) {
-            throw e;
-        }
-        if (isError(e)) {
-            return createRawResponse({
-                status: e.statusCode,
-                statusMessage: e.statusMessage
-            });
-        }
+    const event = new DispatchEvent({
+        request: req,
+        response: res,
+        path: request.path,
+        method
+    });
+    await router.dispatch(event);
+    if (event.dispatched) {
+        return createRawResponse();
+    }
+    if (event.error) {
         return createRawResponse({
-            status: 500
+            status: event.error.statusCode,
+            statusMessage: event.error.statusMessage
         });
     }
+    return createRawResponse({
+        status: 404
+    });
 }
 function createRawDispatcher(router) {
     return async (request)=>dispatchRawRequest(router, request);
 }
 
-async function dispatchWebRequest(router, request, options = {}) {
+async function dispatchWebRequest(router, request) {
     const url = new URL(request.url);
     const headers = {};
     request.headers.forEach((value, key)=>{
         headers[key] = value;
     });
+    const method = toMethodName(request.method, exports.MethodName.GET);
     const res = await dispatchRawRequest(router, {
-        method: request.method,
+        method,
         path: url.pathname + url.search,
         headers,
         body: request.body
-    }, options);
+    });
     let body;
-    if (request.method === exports.MethodName.HEAD || res.status === 304 || res.status === 101 || res.status === 204 || res.status === 205) {
+    if (method === exports.MethodName.HEAD || res.status === 304 || res.status === 101 || res.status === 204 || res.status === 205) {
         body = null;
     } else {
         body = res.body;
@@ -1442,35 +1494,98 @@ exports.HandlerType = void 0;
     HandlerType["CORE"] = "core";
     HandlerType["ERROR"] = "error";
 })(exports.HandlerType || (exports.HandlerType = {}));
-
-function coreHandler(input) {
-    if (typeof input === 'function') {
-        return {
-            type: exports.HandlerType.CORE,
-            fn: input
+const HandlerSymbol = Symbol.for('Handler');
+
+var HookName;
+(function(HookName) {
+    HookName["ERROR"] = "error";
+    HookName["DISPATCH_START"] = "dispatchStart";
+    HookName["DISPATCH_END"] = "dispatchEnd";
+    HookName["CHILD_MATCH"] = "childMatch";
+    HookName["CHILD_DISPATCH_BEFORE"] = "childDispatchBefore";
+    HookName["CHILD_DISPATCH_AFTER"] = "childDispatchAfter";
+})(HookName || (HookName = {}));
+
+class HookManager {
+    // --------------------------------------------------
+    addListener(name, fn) {
+        this.items[name] = this.items[name] || [];
+        this.items[name].push(fn);
+        return ()=>{
+            this.removeListener(name, fn);
         };
     }
-    return {
-        type: exports.HandlerType.CORE,
-        ...input
-    };
-}
-
-function errorHandler(input) {
-    if (typeof input === 'function') {
-        return {
-            type: exports.HandlerType.ERROR,
-            fn: input
-        };
+    removeListener(name, fn) {
+        if (!this.items[name]) {
+            return;
+        }
+        if (typeof fn === 'undefined') {
+            delete this.items[name];
+            return;
+        }
+        if (typeof fn === 'function') {
+            const index = this.items[name].indexOf(fn);
+            if (index !== -1) {
+                this.items[name].splice(index, 1);
+            }
+        }
+        if (this.items[name].length === 0) {
+            delete this.items[name];
+        }
+    }
+    // --------------------------------------------------
+    /**
+     * @throws RoutupError
+     *
+     * @param name
+     * @param event
+     */ async trigger(name, event) {
+        if (!this.items[name] || this.items[name].length === 0) {
+            return;
+        }
+        try {
+            for(let i = 0; i < this.items[name].length; i++){
+                const hook = this.items[name][i];
+                event.dispatched = await dispatch(event, (next)=>Promise.resolve().then(()=>{
+                        event.next = next;
+                        return this.triggerListener(name, event, hook);
+                    }).catch((err)=>next(err)));
+                event.next = nextPlaceholder;
+                if (event.dispatched) {
+                    if (event.error) {
+                        event.error = undefined;
+                    }
+                    return;
+                }
+            }
+        } catch (e) {
+            event.error = e;
+            if (!this.isErrorListenerHook(name)) {
+                await this.trigger(HookName.ERROR, event);
+                if (event.dispatched) {
+                    if (event.error) {
+                        event.error = undefined;
+                    }
+                }
+            }
+        }
+    }
+    triggerListener(name, event, listener) {
+        if (this.isErrorListenerHook(name)) {
+            if (isDispatcherErrorEvent(event)) {
+                return listener(event);
+            }
+            return undefined;
+        }
+        return listener(event);
+    }
+    isErrorListenerHook(input) {
+        return input === HookName.ERROR;
+    }
+    // --------------------------------------------------
+    constructor(){
+        this.items = {};
     }
-    return {
-        type: exports.HandlerType.ERROR,
-        ...input
-    };
-}
-
-function isHandler(input) {
-    return isObject(input) && typeof input.fn === 'function' && typeof input.type === 'string';
 }
 
 function decodeParam(val) {
@@ -1528,93 +1643,59 @@ function isPath(input) {
     return typeof input === 'string' || input instanceof RegExp;
 }
 
-const LayerSymbol = Symbol.for('Layer');
-
-class Layer {
+class Handler {
     // --------------------------------------------------
     get type() {
-        return this.handler.type;
+        return this.config.type;
     }
     get path() {
-        return this.handler.path;
+        return this.config.path;
     }
     get method() {
-        return this.handler.method ? this.handler.method.toLowerCase() : undefined;
+        if (this._method || !this.config.method) {
+            return this._method;
+        }
+        this._method = toMethodName(this.config.method);
+        return this._method;
     }
     // --------------------------------------------------
-    dispatch(event, meta) {
+    async dispatch(event) {
         if (this.pathMatcher) {
-            const pathMatch = this.pathMatcher.exec(meta.path);
+            const pathMatch = this.pathMatcher.exec(event.path);
             if (pathMatch) {
-                meta.params = mergeDispatcherMetaParams(meta.params, pathMatch.params);
+                event.params = {
+                    ...event.params,
+                    ...pathMatch.params
+                };
             }
         }
-        setRequestParams(event.req, meta.params);
-        setRequestMountPath(event.req, meta.mountPath);
-        setRequestRouterPath(event.req, meta.routerPath);
-        return new Promise((resolve, reject)=>{
-            let handled = false;
-            const unsubscribe = ()=>{
-                event.res.off('close', onFinished);
-                event.res.off('error', onFinished);
-            };
-            const shutdown = (dispatched, err)=>{
-                if (handled) {
-                    return;
-                }
-                handled = true;
-                unsubscribe();
-                if (err) {
-                    reject(createError(err));
-                } else {
-                    resolve(dispatched);
-                }
-            };
-            const onFinished = (err)=>shutdown(true, err);
-            const onNext = (err)=>shutdown(false, err);
-            event.res.once('close', onFinished);
-            event.res.once('error', onFinished);
-            const handle = (data)=>{
-                if (typeof data === 'undefined' || handled) {
-                    return Promise.resolve();
-                }
-                handled = true;
-                unsubscribe();
-                return this.sendOutput(event.res, data).then(()=>resolve(true)).catch((e)=>reject(createError(e)));
-            };
-            try {
-                let output;
-                if (this.handler.type === exports.HandlerType.ERROR) {
-                    if (meta.error) {
-                        output = this.handler.fn(meta.error, event.req, event.res, onNext);
+        await this.hookManager.trigger(HookName.CHILD_DISPATCH_BEFORE, event);
+        if (event.dispatched) {
+            return Promise.resolve();
+        }
+        try {
+            event.dispatched = await dispatch(event, (done)=>{
+                if (this.config.type === exports.HandlerType.ERROR) {
+                    if (event.error) {
+                        return this.config.fn(event.error, event.request, event.response, done);
                     }
                 } else {
-                    output = this.handler.fn(event.req, event.res, onNext);
+                    return this.config.fn(event.request, event.response, done);
                 }
-                if (isPromise(output)) {
-                    output.then((r)=>handle(r)).catch((e)=>reject(createError(e)));
-                    return;
+                return undefined;
+            });
+        } catch (e) {
+            if (isError(e)) {
+                event.error = e;
+                await this.hookManager.trigger(HookName.ERROR, event);
+                if (event.dispatched) {
+                    event.error = undefined;
+                } else {
+                    throw e;
                 }
-                Promise.resolve().then(()=>handle(output)).catch((e)=>reject(createError(e)));
-            } catch (error) {
-                onNext(error);
             }
-        });
-    }
-    sendOutput(res, input) {
-        if (input instanceof Error) {
-            return Promise.reject(createError(input));
-        }
-        if (isStream(input)) {
-            return sendStream(res, input);
         }
-        if (isWebBlob(input)) {
-            return sendWebBlob(res, input);
-        }
-        if (isWebResponse(input)) {
-            return sendWebResponse(res, input);
-        }
-        return send(res, input);
+        return this.hookManager.trigger(HookName.CHILD_DISPATCH_AFTER, event);
     }
     // --------------------------------------------------
     matchPath(path) {
@@ -1623,30 +1704,81 @@ class Layer {
         }
         return this.pathMatcher.test(path);
     }
+    setPath(path) {
+        if (typeof path === 'string') {
+            path = withLeadingSlash(path);
+        }
+        this.config.path = path;
+        if (typeof path === 'undefined') {
+            this.pathMatcher = undefined;
+            return;
+        }
+        this.pathMatcher = new PathMatcher(path, {
+            end: !!this.config.method
+        });
+    }
+    // --------------------------------------------------
     matchMethod(method) {
-        if (!this.method) {
-            return true;
+        return !this.method || method === this.method || method === exports.MethodName.HEAD && this.method === exports.MethodName.GET;
+    }
+    setMethod(input) {
+        const method = toMethodName(input);
+        this.config.method = method;
+        this._method = method;
+    }
+    // --------------------------------------------------
+    mountHooks() {
+        if (this.config.onBefore) {
+            this.hookManager.addListener(HookName.CHILD_DISPATCH_BEFORE, this.config.onBefore);
         }
-        const name = method.toLowerCase();
-        if (name === this.method) {
-            return true;
+        if (this.config.onAfter) {
+            this.hookManager.addListener(HookName.CHILD_DISPATCH_AFTER, this.config.onAfter);
+        }
+        if (this.config.onError) {
+            this.hookManager.addListener(HookName.ERROR, this.config.onError);
         }
-        return name === exports.MethodName.HEAD && this.method === exports.MethodName.GET;
     }
     // --------------------------------------------------
     constructor(handler){
-        this['@instanceof'] = LayerSymbol;
-        this.handler = handler;
-        if (handler.path) {
-            this.pathMatcher = new PathMatcher(handler.path, {
-                end: !!handler.method
-            });
-        }
+        this['@instanceof'] = HandlerSymbol;
+        this.config = handler;
+        this.hookManager = new HookManager();
+        this.mountHooks();
+        this.setPath(handler.path);
+    }
+}
+
+function coreHandler(input) {
+    if (typeof input === 'function') {
+        return new Handler({
+            type: exports.HandlerType.CORE,
+            fn: input
+        });
+    }
+    return new Handler({
+        type: exports.HandlerType.CORE,
+        ...input
+    });
+}
+
+function errorHandler(input) {
+    if (typeof input === 'function') {
+        return new Handler({
+            type: exports.HandlerType.ERROR,
+            fn: input
+        });
     }
+    return new Handler({
+        type: exports.HandlerType.ERROR,
+        ...input
+    });
 }
 
-function isLayerInstance(input) {
-    return isInstance(input, LayerSymbol);
+function isHandlerConfig(input) {
+    return isObject(input) && typeof input.fn === 'function' && typeof input.type === 'string';
+}
+function isHandler(input) {
+    return isInstance(input, HandlerSymbol);
 }
 
 function isPlugin(input) {
@@ -1656,10 +1788,7 @@ function isPlugin(input) {
     if (typeof input.name !== 'undefined' && typeof input.name !== 'string') {
         return false;
     }
-    if (typeof input.install !== 'function' || input.install.length !== 1) {
-        return false;
-    }
-    return typeof input.version === 'undefined' || typeof input.version === 'string';
+    return typeof input.install === 'function' && input.install.length === 1;
 }
 
 function transformRouterOptions(input) {
@@ -1673,6 +1802,15 @@ function transformRouterOptions(input) {
 }
 
 const RouterSymbol = Symbol.for('Router');
+var RouterPipelineStep;
+(function(RouterPipelineStep) {
+    RouterPipelineStep[RouterPipelineStep["START"] = 0] = "START";
+    RouterPipelineStep[RouterPipelineStep["LOOKUP"] = 1] = "LOOKUP";
+    RouterPipelineStep[RouterPipelineStep["CHILD_BEFORE"] = 2] = "CHILD_BEFORE";
+    RouterPipelineStep[RouterPipelineStep["CHILD_DISPATCH"] = 3] = "CHILD_DISPATCH";
+    RouterPipelineStep[RouterPipelineStep["CHILD_AFTER"] = 4] = "CHILD_AFTER";
+    RouterPipelineStep[RouterPipelineStep["FINISH"] = 5] = "FINISH";
+})(RouterPipelineStep || (RouterPipelineStep = {}));
 
 let nextId = 0;
 function generateRouterID() {
@@ -1684,220 +1822,252 @@ function isRouterInstance(input) {
 
 class Router {
     // --------------------------------------------------
+    matchPath(path) {
+        if (this.pathMatcher) {
+            return this.pathMatcher.test(path);
+        }
+        return true;
+    }
     setPath(value) {
-        if (value === '/' || !isPath(value)) {
+        if (value === '/' || typeof value === 'undefined') {
+            this.pathMatcher = undefined;
             return;
         }
-        let path;
         if (typeof value === 'string') {
-            path = withLeadingSlash(withoutTrailingSlash(`${value}`));
+            this.pathMatcher = new PathMatcher(withLeadingSlash(withoutTrailingSlash(`${value}`)), {
+                end: false
+            });
         } else {
-            path = value;
+            this.pathMatcher = new PathMatcher(value, {
+                end: false
+            });
         }
-        this.pathMatcher = new PathMatcher(path, {
-            end: false
-        });
     }
     // --------------------------------------------------
-    matchPath(path) {
-        if (this.pathMatcher) {
-            return this.pathMatcher.test(path);
+    async executePipelineStep(context) {
+        switch(context.step){
+            case RouterPipelineStep.START:
+                {
+                    return this.executePipelineStepStart(context);
+                }
+            case RouterPipelineStep.LOOKUP:
+                {
+                    return this.executePipelineStepLookup(context);
+                }
+            case RouterPipelineStep.CHILD_BEFORE:
+                {
+                    return this.executePipelineStepChildBefore(context);
+                }
+            case RouterPipelineStep.CHILD_DISPATCH:
+                {
+                    return this.executePipelineStepChildDispatch(context);
+                }
+            case RouterPipelineStep.CHILD_AFTER:
+                {
+                    return this.executePipelineStepChildAfter(context);
+                }
+            case RouterPipelineStep.FINISH:
+            default:
+                {
+                    return this.executePipelineStepFinish(context);
+                }
         }
-        return true;
     }
-    // --------------------------------------------------
-    async dispatch(event, meta) {
-        const allowedMethods = [];
-        if (this.pathMatcher) {
-            const output = this.pathMatcher.exec(meta.path);
-            if (typeof output !== 'undefined') {
-                meta.mountPath = cleanDoubleSlashes(`${meta.mountPath}/${output.path}`);
-                if (meta.path === output.path) {
-                    meta.path = '/';
-                } else {
-                    meta.path = withLeadingSlash(meta.path.substring(output.path.length));
-                }
-                meta.params = {
-                    ...meta.params,
-                    ...output.params
-                };
+    async executePipelineStepStart(context) {
+        return this.hookManager.trigger(HookName.DISPATCH_START, context.event).then(()=>{
+            if (context.event.dispatched) {
+                context.step = RouterPipelineStep.FINISH;
+            } else {
+                context.step++;
             }
-        }
-        meta.routerPath.push(this.id);
-        let err;
-        let item;
-        let itemMeta;
-        let match = false;
-        for(let i = 0; i < this.stack.length; i++){
-            item = this.stack[i];
-            if (isLayerInstance(item)) {
-                if (item.type !== exports.HandlerType.ERROR && err) {
-                    continue;
+            return this.executePipelineStep(context);
+        });
+    }
+    async executePipelineStepLookup(context) {
+        if (context.event.dispatched || context.stackIndex >= this.stack.length) {
+            context.step = RouterPipelineStep.FINISH;
+            return this.executePipelineStep(context);
+        }
+        let match;
+        const item = this.stack[context.stackIndex];
+        if (isHandler(item)) {
+            if (context.event.error && item.type === exports.HandlerType.CORE || !context.event.error && item.type === exports.HandlerType.ERROR) {
+                context.stackIndex++;
+                return this.executePipelineStepLookup(context);
+            }
+            match = item.matchPath(context.event.path);
+            if (match) {
+                if (item.method) {
+                    context.event.methodsAllowed.push(item.method);
                 }
-                match = item.matchPath(meta.path);
-                if (match && event.req.method) {
-                    if (!item.matchMethod(event.req.method)) {
-                        match = false;
-                    }
-                    if (item.method) {
-                        allowedMethods.push(item.method);
+                if (item.matchMethod(context.event.method)) {
+                    await this.hookManager.trigger(HookName.CHILD_MATCH, context.event);
+                    if (context.event.dispatched) {
+                        context.step = RouterPipelineStep.FINISH;
+                    } else {
+                        context.step++;
                     }
+                    return this.executePipelineStep(context);
                 }
-            } else if (isRouterInstance(item)) {
-                match = item.matchPath(meta.path);
             }
-            if (!match) {
-                continue;
+            context.stackIndex++;
+            return this.executePipelineStepLookup(context);
+        }
+        match = item.matchPath(context.event.path);
+        if (match) {
+            await this.hookManager.trigger(HookName.CHILD_MATCH, context.event);
+            if (context.event.dispatched) {
+                context.step = RouterPipelineStep.FINISH;
+            } else {
+                context.step++;
             }
-            itemMeta = cloneDispatcherMeta(meta);
-            if (err) {
-                itemMeta.error = err;
+            return this.executePipelineStep(context);
+        }
+        context.stackIndex++;
+        return this.executePipelineStepLookup(context);
+    }
+    async executePipelineStepChildBefore(context) {
+        return this.hookManager.trigger(HookName.CHILD_DISPATCH_BEFORE, context.event).then(()=>{
+            if (context.event.dispatched) {
+                context.step = RouterPipelineStep.FINISH;
+            } else {
+                context.step++;
             }
-            try {
-                const dispatched = await item.dispatch(event, itemMeta);
-                if (dispatched) {
-                    return true;
-                }
-            } catch (e) {
-                if (isError(e)) {
-                    err = e;
-                }
+            return this.executePipelineStep(context);
+        });
+    }
+    async executePipelineStepChildAfter(context) {
+        return this.hookManager.trigger(HookName.CHILD_DISPATCH_AFTER, context.event).then(()=>{
+            if (context.event.dispatched) {
+                context.step = RouterPipelineStep.FINISH;
+            } else {
+                context.step = RouterPipelineStep.LOOKUP;
             }
+            return this.executePipelineStep(context);
+        });
+    }
+    async executePipelineStepChildDispatch(context) {
+        if (context.event.dispatched || typeof this.stack[context.stackIndex] === 'undefined') {
+            context.step = RouterPipelineStep.FINISH;
+            return this.executePipelineStep(context);
         }
-        if (err) {
-            throw err;
+        try {
+            await this.stack[context.stackIndex].dispatch(context.event);
+        } catch (e) {
+            context.event.error = e;
+            await this.hookManager.trigger(HookName.ERROR, context.event);
         }
-        if (event.req.method && event.req.method.toLowerCase() === exports.MethodName.OPTIONS) {
-            if (allowedMethods.indexOf(exports.MethodName.GET) !== -1) {
-                allowedMethods.push(exports.MethodName.HEAD);
-            }
-            smob.distinctArray(allowedMethods);
-            const options = allowedMethods.map((key)=>key.toUpperCase()).join(',');
-            if (!isResponseGone(event.res)) {
-                event.res.setHeader(exports.HeaderName.ALLOW, options);
-                await send(event.res, options);
+        context.stackIndex++;
+        context.step++;
+        return this.executePipelineStep(context);
+    }
+    async executePipelineStepFinish(context) {
+        if (context.event.error || context.event.dispatched) {
+            return this.hookManager.trigger(HookName.DISPATCH_END, context.event);
+        }
+        if (!context.event.dispatched && context.event.routerPath.length === 1 && context.event.method && context.event.method === exports.MethodName.OPTIONS) {
+            if (context.event.methodsAllowed.indexOf(exports.MethodName.GET) !== -1) {
+                context.event.methodsAllowed.push(exports.MethodName.HEAD);
             }
-            return true;
+            smob.distinctArray(context.event.methodsAllowed);
+            const options = context.event.methodsAllowed.map((key)=>key.toUpperCase()).join(',');
+            context.event.response.setHeader(exports.HeaderName.ALLOW, options);
+            await send(context.event.response, options);
+            context.event.dispatched = true;
         }
-        return false;
+        return this.hookManager.trigger(HookName.DISPATCH_END, context.event);
     }
-    delete(path, handler) {
-        if (isPath(path)) {
-            this.use({
-                ...handler,
-                method: exports.MethodName.DELETE,
-                path
-            });
-            return this;
+    // --------------------------------------------------
+    async dispatch(event) {
+        if (this.pathMatcher) {
+            const output = this.pathMatcher.exec(event.path);
+            if (typeof output !== 'undefined') {
+                event.mountPath = cleanDoubleSlashes(`${event.mountPath}/${output.path}`);
+                if (event.path === output.path) {
+                    event.path = '/';
+                } else {
+                    event.path = withLeadingSlash(event.path.substring(output.path.length));
+                }
+                event.params = {
+                    ...event.params,
+                    ...output.params
+                };
+            }
         }
-        this.use({
-            ...path,
-            method: exports.MethodName.DELETE
+        const context = {
+            step: RouterPipelineStep.START,
+            event,
+            stackIndex: 0
+        };
+        event.routerPath.push(this.id);
+        return this.executePipelineStepStart(context).then(()=>{
+            context.event.routerPath.pop();
         });
+    }
+    delete(...input) {
+        this.useForMethod(exports.MethodName.DELETE, ...input);
         return this;
     }
-    get(path, handler) {
-        if (isPath(path)) {
-            this.use({
-                ...handler,
-                method: exports.MethodName.GET,
-                path
-            });
-            return this;
-        }
-        this.use({
-            ...path,
-            method: exports.MethodName.GET
-        });
+    get(...input) {
+        this.useForMethod(exports.MethodName.GET, ...input);
         return this;
     }
-    post(path, handler) {
-        if (isPath(path)) {
-            this.use({
-                ...handler,
-                method: exports.MethodName.POST,
-                path
-            });
-            return this;
-        }
-        this.use({
-            ...path,
-            method: exports.MethodName.POST
-        });
+    post(...input) {
+        this.useForMethod(exports.MethodName.POST, ...input);
         return this;
     }
-    put(path, handler) {
-        if (isPath(path)) {
-            this.use({
-                ...handler,
-                method: exports.MethodName.PUT,
-                path
-            });
-            return this;
-        }
-        this.use({
-            ...path,
-            method: exports.MethodName.PUT
-        });
+    put(...input) {
+        this.useForMethod(exports.MethodName.PUT, ...input);
         return this;
     }
-    patch(path, handler) {
-        if (isPath(path)) {
-            this.use({
-                ...handler,
-                method: exports.MethodName.PATCH,
-                path
-            });
-            return this;
-        }
-        this.use({
-            ...path,
-            method: exports.MethodName.PATCH
-        });
+    patch(...input) {
+        this.useForMethod(exports.MethodName.PATCH, ...input);
         return this;
     }
-    head(path, handler) {
-        if (isPath(path)) {
-            this.use({
-                ...handler,
-                method: exports.MethodName.HEAD,
-                path
-            });
-            return this;
-        }
-        this.use({
-            ...path,
-            method: exports.MethodName.HEAD
-        });
+    head(...input) {
+        this.useForMethod(exports.MethodName.HEAD, ...input);
         return this;
     }
-    options(path, handler) {
-        if (isPath(path)) {
-            this.use({
-                ...handler,
-                method: exports.MethodName.OPTIONS,
-                path
-            });
-            return this;
-        }
-        this.use({
-            ...path,
-            method: exports.MethodName.OPTIONS
-        });
+    options(...input) {
+        this.useForMethod(exports.MethodName.OPTIONS, ...input);
         return this;
     }
-    use(...input) {
-        const modifyPath = (input)=>{
-            if (typeof input === 'string') {
-                return withLeadingSlash(input);
+    // --------------------------------------------------
+    useForMethod(method, ...input) {
+        let path;
+        for(let i = 0; i < input.length; i++){
+            const element = input[i];
+            if (isPath(element)) {
+                path = element;
+                continue;
             }
-            return input;
-        };
+            if (isHandlerConfig(element)) {
+                if (path) {
+                    element.path = path;
+                }
+                element.method = method;
+                this.use(element);
+                continue;
+            }
+            if (isHandler(element)) {
+                if (path) {
+                    element.setPath(path);
+                }
+                element.setMethod(method);
+                this.use(element);
+            }
+        }
+    }
+    use(...input) {
         let path;
         for(let i = 0; i < input.length; i++){
             const item = input[i];
             if (isPath(item)) {
-                path = modifyPath(item);
+                if (typeof item === 'string') {
+                    path = withLeadingSlash(item);
+                } else {
+                    path = item;
+                }
                 continue;
             }
             if (isRouterInstance(item)) {
@@ -1907,9 +2077,15 @@ class Router {
                 this.stack.push(item);
                 continue;
             }
+            if (isHandlerConfig(item)) {
+                item.path = path || item.path;
+                this.stack.push(new Handler(item));
+                continue;
+            }
             if (isHandler(item)) {
-                item.path = path || modifyPath(item.path);
-                this.stack.push(new Layer(item));
+                item.setPath(path || item.path);
+                this.stack.push(item);
+                continue;
             }
             if (isPlugin(item)) {
                 if (path) {
@@ -1926,15 +2102,26 @@ class Router {
     // --------------------------------------------------
     install(plugin, context = {}) {
         const name = context.name || plugin.name;
+        const router = new Router({
+            name
+        });
+        plugin.install(router);
         if (context.path) {
-            const router = new Router({
-                name
-            });
-            plugin.install(router);
             this.use(context.path, router);
+        } else {
+            this.use(router);
+        }
+        return this;
+    }
+    on(name, fn) {
+        return this.hookManager.addListener(name, fn);
+    }
+    off(name, fn) {
+        if (typeof fn === 'undefined') {
+            this.hookManager.removeListener(name);
             return this;
         }
-        plugin.install(this);
+        this.hookManager.removeListener(name, fn);
         return this;
     }
     // --------------------------------------------------
@@ -1947,20 +2134,21 @@ class Router {
      */ this.stack = [];
         this.id = generateRouterID();
         this.name = options.name;
+        this.hookManager = new HookManager();
         this.setPath(options.path);
         setRouterOptions(this.id, transformRouterOptions(options));
     }
 }
 
-exports.ErrorProxy = ErrorProxy;
-exports.Layer = Layer;
+exports.DispatchErrorEvent = DispatchErrorEvent;
+exports.DispatchEvent = DispatchEvent;
+exports.Handler = Handler;
+exports.HandlerSymbol = HandlerSymbol;
 exports.PathMatcher = PathMatcher;
 exports.Router = Router;
+exports.RoutupError = RoutupError;
 exports.appendResponseHeader = appendResponseHeader;
 exports.appendResponseHeaderDirective = appendResponseHeaderDirective;
-exports.buildDispatcherMeta = buildDispatcherMeta;
-exports.cloneDispatcherMeta = cloneDispatcherMeta;
-exports.cloneDispatcherMetaParams = cloneDispatcherMetaParams;
 exports.coreHandler = coreHandler;
 exports.createError = createError;
 exports.createNodeDispatcher = createNodeDispatcher;
@@ -1968,6 +2156,7 @@ exports.createRawDispatcher = createRawDispatcher;
 exports.createRequest = createRequest;
 exports.createResponse = createResponse;
 exports.createWebDispatcher = createWebDispatcher;
+exports.dispatch = dispatch;
 exports.dispatchNodeRequest = dispatchNodeRequest;
 exports.dispatchRawRequest = dispatchRawRequest;
 exports.dispatchWebRequest = dispatchWebRequest;
@@ -1984,16 +2173,15 @@ exports.getRequestHeader = getRequestHeader;
 exports.getRequestHostName = getRequestHostName;
 exports.getRequestIP = getRequestIP;
 exports.getRequestProtocol = getRequestProtocol;
+exports.isDispatcherErrorEvent = isDispatcherErrorEvent;
 exports.isError = isError;
 exports.isHandler = isHandler;
-exports.isLayerInstance = isLayerInstance;
+exports.isHandlerConfig = isHandlerConfig;
 exports.isPath = isPath;
 exports.isPlugin = isPlugin;
 exports.isRequestCacheable = isRequestCacheable;
 exports.isResponseGone = isResponseGone;
-exports.isRouterInstance = isRouterInstance;
 exports.matchRequestContentType = matchRequestContentType;
-exports.mergeDispatcherMetaParams = mergeDispatcherMetaParams;
 exports.send = send;
 exports.sendAccepted = sendAccepted;
 exports.sendCreated = sendCreated;
@@ -2013,6 +2201,8 @@ exports.setResponseCacheHeaders = setResponseCacheHeaders;
 exports.setResponseContentTypeByFileName = setResponseContentTypeByFileName;
 exports.setResponseHeaderAttachment = setResponseHeaderAttachment;
 exports.setResponseHeaderContentType = setResponseHeaderContentType;
+exports.transformHeaderToTuples = transformHeaderToTuples;
+exports.transformHeadersToTuples = transformHeadersToTuples;
 exports.unsetRequestEnv = unsetRequestEnv;
 exports.useRequestEnv = useRequestEnv;
 exports.useRequestMountPath = useRequestMountPath;