@wooksjs/event-http 0.4.26 → 0.4.28

package/dist/index.cjs

@@ -2,9 +2,9 @@
 
 var eventCore = require('@wooksjs/event-core');
 var url = require('url');
-var stream = require('stream');
-var wooks = require('wooks');
 var http = require('http');
+var wooks = require('wooks');
+var stream = require('stream');
 
 function createHttpContext(data, options) {
     return eventCore.createEventContext({
@@ -19,40 +19,99 @@ function useHttpContext() {
     return eventCore.useEventContext('HTTP');
 }
 
+function escapeRegex(s) {
+    return s.replace(/[$()*+./?[\\\]^{|}-]/g, '\\$&');
+}
+function safeDecode(f, v) {
+    try {
+        return f(v);
+    }
+    catch (error) {
+        return v;
+    }
+}
+function safeDecodeURIComponent(uri) {
+    if (!uri.includes('%')) {
+        return uri;
+    }
+    return safeDecode(decodeURIComponent, uri);
+}
+
+function convertTime(time, unit = 'ms') {
+    if (typeof time === 'number') {
+        return time / units[unit];
+    }
+    const rg = /(\d+)(\w+)/g;
+    let t = 0;
+    let r;
+    while ((r = rg.exec(time))) {
+        t += Number(r[1]) * (units[r[2]] || 0);
+    }
+    return t / units[unit];
+}
+const units = {
+    ms: 1,
+    s: 1000,
+    m: 1000 * 60,
+    h: 1000 * 60 * 60,
+    d: 1000 * 60 * 60 * 24,
+    w: 1000 * 60 * 60 * 24 * 7,
+    M: 1000 * 60 * 60 * 24 * 30,
+    Y: 1000 * 60 * 60 * 24 * 365,
+};
+
+function renderCookie(key, data) {
+    let attrs = '';
+    for (const [a, v] of Object.entries(data.attrs)) {
+        const func = cookieAttrFunc[a];
+        if (typeof func === 'function') {
+            const val = func(v);
+            attrs += val ? `; ${val}` : '';
+        }
+        else {
+            throw new TypeError(`Unknown Set-Cookie attribute ${a}`);
+        }
+    }
+    return `${key}=${encodeURIComponent(data.value)}${attrs}`;
+}
+const cookieAttrFunc = {
+    expires: (v) => `Expires=${typeof v === 'string' || typeof v === 'number' ? new Date(v).toUTCString() : v.toUTCString()}`,
+    maxAge: (v) => `Max-Age=${convertTime(v, 's').toString()}`,
+    domain: (v) => `Domain=${v}`,
+    path: (v) => `Path=${v}`,
+    secure: (v) => (v ? 'Secure' : ''),
+    httpOnly: (v) => (v ? 'HttpOnly' : ''),
+    sameSite: (v) => v ? `SameSite=${typeof v === 'string' ? v : 'Strict'}` : '',
+};
+
 const xForwardedFor = 'x-forwarded-for';
 function useRequest() {
     const { store } = useHttpContext();
     const { init } = store('request');
     const event = store('event');
-    const { req } = event.value;
-    const rawBody = () => init('rawBody', () => {
-        return new Promise((resolve, reject) => {
-            let body = Buffer.from('');
-            req.on('data', function (chunk) {
-                body = Buffer.concat([body, chunk]);
-            });
-            req.on('error', function (err) {
-                reject(err);
-            });
-            req.on('end', function () {
-                resolve(body);
-            });
+    const req = event.get('req');
+    const rawBody = () => init('rawBody', () => new Promise((resolve, reject) => {
+        let body = Buffer.from('');
+        req.on('data', chunk => {
+            body = Buffer.concat([body, chunk]);
         });
-    });
+        req.on('error', err => {
+            reject(err);
+        });
+        req.on('end', () => {
+            resolve(body);
+        });
+    }));
     const reqId = eventCore.useEventId().getId;
     const forwardedIp = () => init('forwardedIp', () => {
-        if (typeof req.headers[xForwardedFor] === 'string' &&
-            req.headers[xForwardedFor]) {
-            return req.headers[xForwardedFor]
-                .split(',')
-                .shift()
-                ?.trim();
+        if (typeof req.headers[xForwardedFor] === 'string' && req.headers[xForwardedFor]) {
+            return req.headers[xForwardedFor].split(',').shift()?.trim();
         }
         else {
             return '';
         }
     });
-    const remoteIp = () => init('remoteIp', () => req.socket?.remoteAddress || req.connection?.remoteAddress || '');
+    const remoteIp = () => init('remoteIp', () => req.socket.remoteAddress || req.connection.remoteAddress || '');
     function getIp(options) {
         if (options?.trustProxy) {
             return forwardedIp() || getIp();
@@ -61,16 +120,10 @@ function useRequest() {
             return remoteIp();
         }
     }
-    const getIpList = () => init('ipList', () => {
-        return {
-            remoteIp: req.socket?.remoteAddress ||
-                req.connection?.remoteAddress ||
-                '',
-            forwarded: (req.headers[xForwardedFor] || '')
-                .split(',')
-                .map((s) => s.trim()),
-        };
-    });
+    const getIpList = () => init('ipList', () => ({
+        remoteIp: req.socket.remoteAddress || req.connection.remoteAddress || '',
+        forwarded: (req.headers[xForwardedFor] || '').split(',').map(s => s.trim()),
+    }));
     return {
         rawRequest: req,
         url: req.url,
@@ -113,13 +166,73 @@ function useSetHeader(name) {
     return hook(name);
 }
 
+function useCookies() {
+    const { store } = useHttpContext();
+    const { cookie } = useHeaders();
+    const { init } = store('cookies');
+    const getCookie = (name) => init(name, () => {
+        if (cookie) {
+            const result = new RegExp(`(?:^|; )${escapeRegex(name)}=(.*?)(?:;?$|; )`, 'i').exec(cookie);
+            return result?.[1] ? safeDecodeURIComponent(result[1]) : null;
+        }
+        else {
+            return null;
+        }
+    });
+    return {
+        rawCookies: cookie,
+        getCookie,
+    };
+}
+function useSetCookies() {
+    const { store } = useHttpContext();
+    const cookiesStore = store('setCookies');
+    function setCookie(name, value, attrs) {
+        cookiesStore.set(name, {
+            value,
+            attrs: attrs || {},
+        });
+    }
+    function cookies() {
+        return cookiesStore
+            .entries()
+            .filter(a => !!a[1])
+            .map(([key, value]) => renderCookie(key, value));
+    }
+    return {
+        setCookie,
+        getCookie: cookiesStore.get,
+        removeCookie: cookiesStore.del,
+        clearCookies: cookiesStore.clear,
+        cookies,
+    };
+}
+function useSetCookie(name) {
+    const { setCookie, getCookie } = useSetCookies();
+    const valueHook = eventCore.attachHook({
+        name,
+        type: 'cookie',
+    }, {
+        get: () => getCookie(name)?.value,
+        set: (value) => {
+            setCookie(name, value, getCookie(name)?.attrs);
+        },
+    });
+    return eventCore.attachHook(valueHook, {
+        get: () => getCookie(name)?.attrs,
+        set: (attrs) => {
+            setCookie(name, getCookie(name)?.value || '', attrs);
+        },
+    }, 'attrs');
+}
+
 function useAccept() {
     const { store } = useHttpContext();
     const { accept } = useHeaders();
     const accepts = (mime) => {
         const { set, get, has } = store('accept');
         if (!has(mime)) {
-            return set(mime, !!(accept && (accept === '*/*' || accept.indexOf(mime) >= 0)));
+            return set(mime, !!(accept && (accept === '*/*' || accept.includes(mime))));
         }
         return get(mime);
     };
@@ -171,62 +284,39 @@ function useAuthorization() {
     };
 }
 
-function convertTime(time, unit = 'ms') {
-    if (typeof time === 'number')
-        return time / units[unit];
-    const rg = /(\d+)(\w+)/g;
-    let t = 0;
-    let r;
-    while ((r = rg.exec(time))) {
-        t += Number(r[1]) * (units[r[2]] || 0);
-    }
-    return t / units[unit];
-}
-const units = {
-    ms: 1,
-    s: 1000,
-    m: 1000 * 60,
-    h: 1000 * 60 * 60,
-    d: 1000 * 60 * 60 * 24,
-    w: 1000 * 60 * 60 * 24 * 7,
-    M: 1000 * 60 * 60 * 24 * 30,
-    Y: 1000 * 60 * 60 * 24 * 365,
-};
-
 function renderCacheControl(data) {
     let attrs = '';
     for (const [a, v] of Object.entries(data)) {
-        if (typeof v === 'undefined')
+        if (v === undefined) {
             continue;
+        }
         const func = cacheControlFunc[a];
         if (typeof func === 'function') {
             const val = func(v);
             if (val) {
-                attrs += attrs ? ', ' + val : val;
+                attrs += attrs ? `, ${val}` : val;
             }
         }
         else {
-            throw new Error('Unknown Cache-Control attribute ' + a);
+            throw new TypeError(`Unknown Cache-Control attribute ${a}`);
         }
     }
     return attrs;
 }
 const cacheControlFunc = {
-    mustRevalidate: (v) => v ? 'must-revalidate' : '',
+    mustRevalidate: (v) => (v ? 'must-revalidate' : ''),
     noCache: (v) => v ? (typeof v === 'string' ? `no-cache="${v}"` : 'no-cache') : '',
     noStore: (v) => (v ? 'no-store' : ''),
     noTransform: (v) => (v ? 'no-transform' : ''),
     public: (v) => (v ? 'public' : ''),
     private: (v) => v ? (typeof v === 'string' ? `private="${v}"` : 'private') : '',
-    proxyRevalidate: (v) => v ? 'proxy-revalidate' : '',
-    maxAge: (v) => 'max-age=' + convertTime(v, 's').toString(),
-    sMaxage: (v) => 's-maxage=' + convertTime(v, 's').toString(),
+    proxyRevalidate: (v) => (v ? 'proxy-revalidate' : ''),
+    maxAge: (v) => `max-age=${convertTime(v, 's').toString()}`,
+    sMaxage: (v) => `s-maxage=${convertTime(v, 's').toString()}`,
 };
 
 const renderAge = (v) => convertTime(v, 's').toString();
-const renderExpires = (v) => typeof v === 'string' || typeof v === 'number'
-    ? new Date(v).toUTCString()
-    : v.toUTCString();
+const renderExpires = (v) => typeof v === 'string' || typeof v === 'number' ? new Date(v).toUTCString() : v.toUTCString();
 const renderPragmaNoCache = (v) => (v ? 'no-cache' : '');
 function useSetCacheControl() {
     const { setHeader } = useSetHeaders();
@@ -253,15 +343,16 @@ function useSetCacheControl() {
 function useResponse() {
     const { store } = useHttpContext();
     const event = store('event');
-    const { res } = event.value;
+    const res = event.get('res');
     const responded = store('response').hook('responded');
     const statusCode = store('status').hook('code');
     function status(code) {
         return (statusCode.value = code ? code : statusCode.value);
     }
     const rawResponse = (options) => {
-        if (!options || !options.passthrough)
+        if (!options || !options.passthrough) {
             responded.value = true;
+        }
         return res;
     };
     return {
@@ -278,108 +369,6 @@ function useStatus() {
     return store('status').hook('code');
 }
 
-function renderCookie(key, data) {
-    let attrs = '';
-    for (const [a, v] of Object.entries(data.attrs)) {
-        const func = cookieAttrFunc[a];
-        if (typeof func === 'function') {
-            const val = func(v);
-            attrs += val ? '; ' + val : '';
-        }
-        else {
-            throw new Error('Unknown Set-Cookie attribute ' + a);
-        }
-    }
-    return `${key}=${encodeURIComponent(data.value)}${attrs}`;
-}
-const cookieAttrFunc = {
-    expires: (v) => 'Expires=' +
-        (typeof v === 'string' || typeof v === 'number'
-            ? new Date(v).toUTCString()
-            : v.toUTCString()),
-    maxAge: (v) => 'Max-Age=' + convertTime(v, 's').toString(),
-    domain: (v) => 'Domain=' + v,
-    path: (v) => 'Path=' + v,
-    secure: (v) => (v ? 'Secure' : ''),
-    httpOnly: (v) => (v ? 'HttpOnly' : ''),
-    sameSite: (v) => v ? 'SameSite=' + (typeof v === 'string' ? v : 'Strict') : '',
-};
-
-function escapeRegex(s) {
-    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-function safeDecode(f, v) {
-    try {
-        return f(v);
-    }
-    catch (e) {
-        return v;
-    }
-}
-function safeDecodeURIComponent(uri) {
-    if (uri.indexOf('%') < 0)
-        return uri;
-    return safeDecode(decodeURIComponent, uri);
-}
-
-function useCookies() {
-    const { store } = useHttpContext();
-    const { cookie } = useHeaders();
-    const { init } = store('cookies');
-    const getCookie = (name) => init(name, () => {
-        if (cookie) {
-            const result = new RegExp(`(?:^|; )${escapeRegex(name)}=(.*?)(?:;?$|; )`, 'i').exec(cookie);
-            return result && result[1]
-                ? safeDecodeURIComponent(result[1])
-                : null;
-        }
-        else {
-            return null;
-        }
-    });
-    return {
-        rawCookies: cookie,
-        getCookie,
-    };
-}
-function useSetCookies() {
-    const { store } = useHttpContext();
-    const cookiesStore = store('setCookies');
-    function setCookie(name, value, attrs) {
-        cookiesStore.set(name, {
-            value,
-            attrs: attrs || {},
-        });
-    }
-    function cookies() {
-        return cookiesStore
-            .entries()
-            .filter((a) => !!a[1])
-            .map(([key, value]) => renderCookie(key, value));
-    }
-    return {
-        setCookie,
-        getCookie: cookiesStore.get,
-        removeCookie: cookiesStore.del,
-        clearCookies: cookiesStore.clear,
-        cookies,
-    };
-}
-function useSetCookie(name) {
-    const { setCookie, getCookie } = useSetCookies();
-    const valueHook = eventCore.attachHook({
-        name,
-        type: 'cookie',
-    }, {
-        get: () => getCookie(name)?.value,
-        set: (value) => setCookie(name, value, getCookie(name)?.attrs),
-    });
-    return eventCore.attachHook(valueHook, {
-        get: () => getCookie(name)?.attrs,
-        set: (attrs) => setCookie(name, getCookie(name)?.value || '', attrs),
-    }, 'attrs');
-}
-
 class WooksURLSearchParams extends url.URLSearchParams {
     toJson() {
         const json = {};
@@ -420,89 +409,91 @@ class BaseHttpResponseRenderer {
         if (typeof response.body === 'string' ||
             typeof response.body === 'boolean' ||
             typeof response.body === 'number') {
-            if (!response.getContentType())
+            if (!response.getContentType()) {
                 response.setContentType('text/plain');
+            }
             return response.body.toString();
         }
-        if (typeof response.body === 'undefined') {
+        if (response.body === undefined) {
             return '';
         }
         if (response.body instanceof Uint8Array) {
             return response.body;
         }
         if (typeof response.body === 'object') {
-            if (!response.getContentType())
+            if (!response.getContentType()) {
                 response.setContentType('application/json');
+            }
             return JSON.stringify(response.body);
         }
-        throw new Error('Unsupported body format "' + typeof response.body + '"');
+        throw new Error(`Unsupported body format "${typeof response.body}"`);
     }
 }
 
 const httpStatusCodes = {
-    [100]: 'Continue',
-    [101]: 'Switching protocols',
-    [102]: 'Processing',
-    [103]: 'Early Hints',
-    [200]: 'OK',
-    [201]: 'Created',
-    [202]: 'Accepted',
-    [203]: 'Non-Authoritative Information',
-    [204]: 'No Content',
-    [205]: 'Reset Content',
-    [206]: 'Partial Content',
-    [207]: 'Multi-Status',
-    [208]: 'Already Reported',
-    [226]: 'IM Used',
-    [300]: 'Multiple Choices',
-    [301]: 'Moved Permanently',
-    [302]: 'Found (Previously "Moved Temporarily")',
-    [303]: 'See Other',
-    [304]: 'Not Modified',
-    [305]: 'Use Proxy',
-    [306]: 'Switch Proxy',
-    [307]: 'Temporary Redirect',
-    [308]: 'Permanent Redirect',
-    [400]: 'Bad Request',
-    [401]: 'Unauthorized',
-    [402]: 'Payment Required',
-    [403]: 'Forbidden',
-    [404]: 'Not Found',
-    [405]: 'Method Not Allowed',
-    [406]: 'Not Acceptable',
-    [407]: 'Proxy Authentication Required',
-    [408]: 'Request Timeout',
-    [409]: 'Conflict',
-    [410]: 'Gone',
-    [411]: 'Length Required',
-    [412]: 'Precondition Failed',
-    [413]: 'Payload Too Large',
-    [414]: 'URI Too Long',
-    [415]: 'Unsupported Media Type',
-    [416]: 'Range Not Satisfiable',
-    [417]: 'Expectation Failed',
-    [418]: 'I\'m a Teapot',
-    [421]: 'Misdirected Request',
-    [422]: 'Unprocessable Entity',
-    [423]: 'Locked',
-    [424]: 'Failed Dependency',
-    [425]: 'Too Early',
-    [426]: 'Upgrade Required',
-    [428]: 'Precondition Required',
-    [429]: 'Too Many Requests',
-    [431]: 'Request Header Fields Too Large',
-    [451]: 'Unavailable For Legal Reasons',
-    [500]: 'Internal Server Error',
-    [501]: 'Not Implemented',
-    [502]: 'Bad Gateway',
-    [503]: 'Service Unavailable',
-    [504]: 'Gateway Timeout',
-    [505]: 'HTTP Version Not Supported',
-    [506]: 'Variant Also Negotiates',
-    [507]: 'Insufficient Storage',
-    [508]: 'Loop Detected',
-    [510]: 'Not Extended',
-    [511]: 'Network Authentication Required',
+    100: 'Continue',
+    101: 'Switching protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found (Previously "Moved Temporarily")',
+    303: 'See Other',
+    304: 'Not Modified',
+    305: 'Use Proxy',
+    306: 'Switch Proxy',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Payload Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a Teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required',
 };
 exports.EHttpStatusCode = void 0;
 (function (EHttpStatusCode) {
@@ -571,6 +562,109 @@ exports.EHttpStatusCode = void 0;
     EHttpStatusCode[EHttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
 })(exports.EHttpStatusCode || (exports.EHttpStatusCode = {}));
 
+const preStyles = 'font-family: monospace;' +
+    'width: 100%;' +
+    'max-width: 900px;' +
+    'padding: 10px;' +
+    'margin: 20px auto;' +
+    'border-radius: 8px;' +
+    'background-color: #494949;' +
+    'box-shadow: 0px 0px 3px 2px rgb(255 255 255 / 20%);';
+class HttpErrorRenderer extends BaseHttpResponseRenderer {
+    renderHtml(response) {
+        const data = response.body || {};
+        response.setContentType('text/html');
+        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
+        return ('<html style="background-color: #333; color: #bbb;">' +
+            `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` +
+            `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` +
+            `<center><h4>${data.message}</h1></center><hr color="#666">` +
+            `<center style="color: #666;"> Wooks v${"0.4.28"} </center>` +
+            `${keys.length > 0
+                ? `<pre style="${preStyles}">${JSON.stringify({
+                    ...data,
+                    statusCode: undefined,
+                    message: undefined,
+                    error: undefined,
+                }, null, '  ')}</pre>`
+                : ''}` +
+            '</body></html>');
+    }
+    renderText(response) {
+        const data = response.body || {};
+        response.setContentType('text/plain');
+        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
+        return (`${data.statusCode} ${httpStatusCodes[data.statusCode]}\n${data.message}` +
+            `\n\n${keys.length > 0
+                ? `${JSON.stringify({
+                    ...data,
+                    statusCode: undefined,
+                    message: undefined,
+                    error: undefined,
+                }, null, '  ')}`
+                : ''}`);
+    }
+    renderJson(response) {
+        const data = response.body || {};
+        response.setContentType('application/json');
+        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
+        return (`{"statusCode":${escapeQuotes(data.statusCode)},` +
+            `"error":"${escapeQuotes(data.error)}",` +
+            `"message":"${escapeQuotes(data.message)}"` +
+            `${keys.length > 0
+                ? `,${keys.map(k => `"${escapeQuotes(k)}":${JSON.stringify(data[k])}`).join(',')}`
+                : ''}}`);
+    }
+    render(response) {
+        const { acceptsJson, acceptsText, acceptsHtml } = useAccept();
+        response.status = response.body?.statusCode || 500;
+        if (acceptsJson()) {
+            return this.renderJson(response);
+        }
+        else if (acceptsHtml()) {
+            return this.renderHtml(response);
+        }
+        else if (acceptsText()) {
+            return this.renderText(response);
+        }
+        else {
+            return this.renderJson(response);
+        }
+    }
+}
+function escapeQuotes(s) {
+    return (typeof s === 'number' ? s : s || '').toString().replace(/"/g, '\\"');
+}
+
+class HttpError extends Error {
+    constructor(code = 500, _body = '') {
+        super(typeof _body === 'string' ? _body : _body.message);
+        this.code = code;
+        this._body = _body;
+        this.name = 'HttpError';
+    }
+    get body() {
+        return typeof this._body === 'string'
+            ? {
+                statusCode: this.code,
+                message: this.message,
+                error: httpStatusCodes[this.code],
+            }
+            : {
+                ...this._body,
+                statusCode: this.code,
+                message: this.message,
+                error: httpStatusCodes[this.code],
+            };
+    }
+    attachRenderer(renderer) {
+        this.renderer = renderer;
+    }
+    getRenderer() {
+        return this.renderer;
+    }
+}
+
 const defaultStatus = {
     GET: exports.EHttpStatusCode.OK,
     POST: exports.EHttpStatusCode.Created,
@@ -651,7 +745,7 @@ class BaseHttpResponse {
             ...this._headers,
         };
         const setCookie = [...newCookies, ...cookies()];
-        if (setCookie && setCookie.length) {
+        if (setCookie.length > 0) {
             this._headers['set-cookie'] = setCookie;
         }
         return this;
@@ -677,7 +771,7 @@ class BaseHttpResponse {
     async respond() {
         const { rawResponse, hasResponded } = useResponse();
         const { method, rawRequest } = useRequest();
-        const logger = eventCore.useEventLogger('http-response');
+        const logger = eventCore.useEventLogger('http-response') || console;
         if (hasResponded()) {
             this.panic('The response was already sent.', logger);
         }
@@ -698,7 +792,7 @@ class BaseHttpResponse {
             }
             else {
                 return new Promise((resolve, reject) => {
-                    stream.on('error', (e) => {
+                    stream.on('error', e => {
                         stream.destroy();
                         res.end();
                         reject(e);
@@ -711,8 +805,7 @@ class BaseHttpResponse {
                 });
             }
         }
-        else if (globalThis.Response &&
-            this.body instanceof Response) {
+        else if (globalThis.Response && this.body instanceof Response) {
             this.mergeFetchStatus(this.body.status);
             if (method === 'HEAD') {
                 res.end();
@@ -735,10 +828,12 @@ class BaseHttpResponse {
         else {
             const renderedBody = this.renderer.render(this);
             this.mergeStatus(renderedBody);
-            res.writeHead(this.status, {
+            res
+                .writeHead(this.status, {
                 'content-length': Buffer.byteLength(renderedBody),
                 ...this._headers,
-            }).end(method !== 'HEAD' ? renderedBody : '');
+            })
+                .end(method === 'HEAD' ? '' : renderedBody);
         }
     }
 }
@@ -749,124 +844,18 @@ async function respondWithFetch(fetchBody, res) {
                 res.write(chunk);
             }
         }
-        catch (e) {
+        catch (error) {
         }
     }
     res.end();
 }
 
-const preStyles = 'font-family: monospace;' +
-    'width: 100%;' +
-    'max-width: 900px;' +
-    'padding: 10px;' +
-    'margin: 20px auto;' +
-    'border-radius: 8px;' +
-    'background-color: #494949;' +
-    'box-shadow: 0px 0px 3px 2px rgb(255 255 255 / 20%);';
-class HttpErrorRenderer extends BaseHttpResponseRenderer {
-    renderHtml(response) {
-        const data = response.body || {};
-        response.setContentType('text/html');
-        const keys = Object.keys(data).filter((key) => !['statusCode', 'error', 'message'].includes(key));
-        return ('<html style="background-color: #333; color: #bbb;">' +
-            `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` +
-            `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` +
-            `<center><h4>${data.message}</h1></center><hr color="#666">` +
-            `<center style="color: #666;"> Wooks v${"0.4.26"} </center>` +
-            `${keys.length
-                ? `<pre style="${preStyles}">${JSON.stringify({
-                    ...data,
-                    statusCode: undefined,
-                    message: undefined,
-                    error: undefined,
-                }, null, '  ')}</pre>`
-                : ''}` +
-            '</body></html>');
-    }
-    renderText(response) {
-        const data = response.body || {};
-        response.setContentType('text/plain');
-        const keys = Object.keys(data).filter((key) => !['statusCode', 'error', 'message'].includes(key));
-        return (`${data.statusCode} ${httpStatusCodes[data.statusCode]}\n${data.message}` +
-            `\n\n${keys.length
-                ? `${JSON.stringify({
-                    ...data,
-                    statusCode: undefined,
-                    message: undefined,
-                    error: undefined,
-                }, null, '  ')}`
-                : ''}`);
-    }
-    renderJson(response) {
-        const data = response.body || {};
-        response.setContentType('application/json');
-        const keys = Object.keys(data).filter((key) => !['statusCode', 'error', 'message'].includes(key));
-        return (`{"statusCode":${escapeQuotes(data.statusCode)},` +
-            `"error":"${escapeQuotes(data.error)}",` +
-            `"message":"${escapeQuotes(data.message)}"` +
-            `${keys.length
-                ? ',' +
-                    keys
-                        .map((k) => `"${escapeQuotes(k)}":${JSON.stringify(data[k])}`)
-                        .join(',')
-                : ''}}`);
-    }
-    render(response) {
-        const { acceptsJson, acceptsText, acceptsHtml } = useAccept();
-        response.status = response.body?.statusCode || 500;
-        if (acceptsJson()) {
-            return this.renderJson(response);
-        }
-        else if (acceptsHtml()) {
-            return this.renderHtml(response);
-        }
-        else if (acceptsText()) {
-            return this.renderText(response);
-        }
-        else {
-            return this.renderJson(response);
-        }
-    }
-}
-function escapeQuotes(s) {
-    return (typeof s === 'number' ? s : s || '')
-        .toString()
-        .replace(/[\""]/g, '\\"');
-}
-
-class HttpError extends Error {
-    constructor(code = 500, _body = '') {
-        super(typeof _body === 'string' ? _body : _body.message);
-        this.code = code;
-        this._body = _body;
-    }
-    get body() {
-        return typeof this._body === 'string'
-            ? {
-                statusCode: this.code,
-                message: this.message,
-                error: httpStatusCodes[this.code],
-            }
-            : {
-                ...this._body,
-                statusCode: this.code,
-                message: this.message,
-                error: httpStatusCodes[this.code],
-            };
-    }
-    attachRenderer(renderer) {
-        this.renderer = renderer;
-    }
-    getRenderer() {
-        return this.renderer;
-    }
-}
-
 function createWooksResponder(renderer = new BaseHttpResponseRenderer(), errorRenderer = new HttpErrorRenderer()) {
     function createResponse(data) {
         const { hasResponded } = useResponse();
-        if (hasResponded())
+        if (hasResponded()) {
             return null;
+        }
         if (data instanceof Error) {
             const r = new BaseHttpResponse(errorRenderer);
             let httpError;
@@ -923,20 +912,22 @@ class WooksHttp extends wooks.WooksAdapterBase {
     options(path, handler) {
         return this.on('OPTIONS', path, handler);
     }
-    async listen(...args) {
+    async listen(port, hostname, backlog, listeningListener) {
         const server = (this.server = http.createServer(this.getServerCb()));
         return new Promise((resolve, reject) => {
             server.once('listening', resolve);
             server.once('error', reject);
-            server.listen(...args);
+            server.listen(port, hostname, backlog, listeningListener);
         });
     }
     close(server) {
         const srv = server || this.server;
         return new Promise((resolve, reject) => {
-            srv?.close((err) => {
-                if (err)
-                    return reject(err);
+            srv?.close(err => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
                 resolve(srv);
             });
         });
@@ -948,7 +939,7 @@ class WooksHttp extends wooks.WooksAdapterBase {
         this.server = server;
     }
     respond(data) {
-        void this.responder.respond(data)?.catch((e) => {
+        void this.responder.respond(data)?.catch(e => {
             this.logger.error('Uncought response exception', e);
         });
     }
@@ -960,10 +951,10 @@ class WooksHttp extends wooks.WooksAdapterBase {
                 try {
                     await this.processHandlers(handlers || [this.opts?.onNotFound]);
                 }
-                catch (e) {
-                    this.logger.error('Internal error, please report', e);
+                catch (error) {
+                    this.logger.error('Internal error, please report', error);
                     restoreCtx();
-                    this.respond(e);
+                    this.respond(error);
                     clearCtx();
                 }
             }
@@ -988,11 +979,11 @@ class WooksHttp extends wooks.WooksAdapterBase {
                 clearCtx();
                 break;
             }
-            catch (e) {
-                this.logger.error(`Uncought route handler exception: ${store('event').get('req').url || ''}`, e);
+            catch (error) {
+                this.logger.error(`Uncought route handler exception: ${store('event').get('req')?.url || ''}`, error);
                 if (isLastHandler) {
                     restoreCtx();
-                    this.respond(e);
+                    this.respond(error);
                     clearCtx();
                 }
             }