@adonisjs/http-server 6.4.3-0 → 6.5.0-0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # The MIT License
 
-Copyright 2022 Harminder Virk, contributors
+Copyright (c) 2023 AdonisJS Framework
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/build/factories/main.d.ts

@@ -0,0 +1,6 @@
+export { HttpContextFactory } from './http_context.js';
+export { QsParserFactory } from './qs_parser_factory.js';
+export { RequestFactory } from './request.js';
+export { ResponseFactory } from './response.js';
+export { RouterFactory } from './router.js';
+export { ServerFactory } from './server_factory.js';

package/build/factories/main.js

@@ -0,0 +1,6 @@
+export { HttpContextFactory } from './http_context.js';
+export { QsParserFactory } from './qs_parser_factory.js';
+export { RequestFactory } from './request.js';
+export { ResponseFactory } from './response.js';
+export { RouterFactory } from './router.js';
+export { ServerFactory } from './server_factory.js';

package/build/{test_factories → factories}/request.js

@@ -11,7 +11,7 @@ export class RequestFactory {
             allowMethodSpoofing: false,
             trustProxy: proxyAddr.compile('loopback'),
             subdomainOffset: 2,
-            generateRequestId: true,
+            generateRequestId: false,
             ...this.#parameters.config,
         };
     }

package/build/index.d.ts

@@ -9,4 +9,5 @@ export { defineConfig } from './src/define_config.js';
 export { RouteResource } from './src/router/resource.js';
 export { BriskRoute } from './src/router/brisk.js';
 export { HttpContext } from './src/http_context/main.js';
-export * as errors from './src/exceptions/main.js';
+export * as errors from './src/exceptions.js';
+export { HttpExceptionHandler } from './src/exception_handler.js';

package/build/index.js

@@ -9,4 +9,5 @@ export { defineConfig } from './src/define_config.js';
 export { RouteResource } from './src/router/resource.js';
 export { BriskRoute } from './src/router/brisk.js';
 export { HttpContext } from './src/http_context/main.js';
-export * as errors from './src/exceptions/main.js';
+export * as errors from './src/exceptions.js';
+export { HttpExceptionHandler } from './src/exception_handler.js';

package/build/src/exception_handler.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from '@adonisjs/logger';
+import type { Level } from '@adonisjs/logger/types';
+import type { HttpContext } from './http_context/main.js';
+import type { HttpError, StatusPageRange, StatusPageRenderer } from './types/server.js';
+export declare class HttpExceptionHandler {
+    #private;
+    protected logger: Logger;
+    protected debug: boolean;
+    protected renderStatusPages: boolean;
+    protected statusPages: Record<StatusPageRange, StatusPageRenderer>;
+    protected renderers: {
+        html: (error: HttpError, ctx: HttpContext) => Promise<void>;
+        json: (error: HttpError, ctx: HttpContext) => Promise<void>;
+        json_api: (error: HttpError, ctx: HttpContext) => Promise<void>;
+    };
+    protected reportErrors: boolean;
+    protected ignoreExceptions: any[];
+    protected ignoreStatuses: number[];
+    protected ignoreCodes: string[];
+    constructor(logger: Logger);
+    protected context(ctx: HttpContext): any;
+    protected getResponseFormat(ctx: HttpContext): 'html' | 'json' | 'json_api';
+    protected getErrorLogLevel(error: HttpError): Level;
+    protected isDebuggingEnabled(_: HttpContext): boolean;
+    protected shouldReport(error: HttpError): boolean;
+    report(error: unknown, ctx: HttpContext): Promise<void>;
+    handle(error: unknown, ctx: HttpContext): Promise<any>;
+}

package/build/src/exception_handler.js

@@ -0,0 +1,148 @@
+import is from '@sindresorhus/is';
+import { parseRange } from './helpers.js';
+import * as errors from './exceptions.js';
+export class HttpExceptionHandler {
+    logger;
+    debug = process.env.NODE_ENV !== 'production';
+    renderStatusPages = process.env.NODE_ENV === 'production';
+    statusPages = {};
+    #expandedStatusPages;
+    renderers = {
+        html: async (error, ctx) => {
+            if (this.isDebuggingEnabled(ctx)) {
+                const { default: Youch } = await import('youch');
+                const html = await new Youch(error, ctx.request.request).toHTML();
+                ctx.response.status(error.status).send(html);
+                return;
+            }
+            ctx.response.status(error.status).send(`<p> ${error.message} </p>`);
+        },
+        json: async (error, ctx) => {
+            if (this.isDebuggingEnabled(ctx)) {
+                const { default: Youch } = await import('youch');
+                const json = await new Youch(error, ctx.request.request).toJSON();
+                ctx.response.status(error.status).send(json.error);
+                return;
+            }
+            ctx.response.status(error.status).send({ message: error.message });
+        },
+        json_api: async (error, ctx) => {
+            if (this.isDebuggingEnabled(ctx)) {
+                const { default: Youch } = await import('youch');
+                const json = await new Youch(error, ctx.request.request).toJSON();
+                ctx.response.status(error.status).send(json.error);
+                return;
+            }
+            ctx.response.status(error.status).send({
+                errors: [
+                    {
+                        title: error.message,
+                        code: error.code,
+                        status: error.status,
+                    },
+                ],
+            });
+        },
+    };
+    reportErrors = true;
+    ignoreExceptions = [
+        errors.E_HTTP_EXCEPTION,
+        errors.E_ROUTE_NOT_FOUND,
+        errors.E_CANNOT_LOOKUP_ROUTE,
+        errors.E_HTTP_REQUEST_ABORTED,
+    ];
+    ignoreStatuses = [400, 422, 401];
+    ignoreCodes = [];
+    constructor(logger) {
+        this.logger = logger;
+    }
+    #expandStatusPages() {
+        if (!this.#expandedStatusPages) {
+            this.#expandedStatusPages = Object.keys(this.statusPages).reduce((result, range) => {
+                const renderer = this.statusPages[range];
+                result = Object.assign(result, parseRange(range, renderer));
+                return result;
+            }, {});
+        }
+        return this.#expandedStatusPages;
+    }
+    #toHttpError(error) {
+        const httpError = is.object(error) ? error : new Error(String(error));
+        httpError.message = httpError.message || 'Internal server error';
+        httpError.status = httpError.status || 500;
+        return httpError;
+    }
+    context(ctx) {
+        const requestId = ctx.request.id();
+        return requestId
+            ? {
+                'x-request-id': requestId,
+            }
+            : {};
+    }
+    getResponseFormat(ctx) {
+        switch (ctx.request.accepts(['html', 'application/vnd.api+json', 'json'])) {
+            case 'application/vnd.api+json':
+                return 'json_api';
+            case 'json':
+                return 'json';
+            case 'html':
+            default:
+                return 'html';
+        }
+    }
+    getErrorLogLevel(error) {
+        if (error.status >= 500) {
+            return 'error';
+        }
+        if (error.status >= 400) {
+            return 'warn';
+        }
+        return 'info';
+    }
+    isDebuggingEnabled(_) {
+        return this.debug;
+    }
+    shouldReport(error) {
+        if (this.reportErrors === false) {
+            return false;
+        }
+        if (this.ignoreStatuses.includes(error.status)) {
+            return false;
+        }
+        if (error.code && this.ignoreCodes.includes(error.code)) {
+            return false;
+        }
+        if (this.ignoreExceptions.find((exception) => error instanceof exception)) {
+            return false;
+        }
+        return true;
+    }
+    async report(error, ctx) {
+        const httpError = this.#toHttpError(error);
+        if (!this.shouldReport(httpError)) {
+            return;
+        }
+        if (typeof httpError.report === 'function') {
+            httpError.report(httpError, ctx);
+            return;
+        }
+        const level = this.getErrorLogLevel(httpError);
+        this.logger.log(level, {
+            ...(level === 'error' || level === 'fatal' ? { err: httpError } : {}),
+            ...this.context(ctx),
+        }, httpError.message);
+    }
+    async handle(error, ctx) {
+        const httpError = this.#toHttpError(error);
+        if (typeof httpError.handle === 'function') {
+            return httpError.handle(httpError, ctx);
+        }
+        const statusPages = this.#expandStatusPages();
+        if (this.renderStatusPages && statusPages[httpError.status]) {
+            return statusPages[httpError.status](httpError, ctx);
+        }
+        const responseFormat = this.getResponseFormat(ctx);
+        return this.renderers[responseFormat](httpError, ctx);
+    }
+}

package/build/src/{exceptions/main.d.ts → exceptions.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Exception } from '@poppinss/utils';
-import type { HttpContext } from '../http_context/main.js';
+import type { HttpContext } from './http_context/main.js';
 export declare const E_ROUTE_NOT_FOUND: new (args: [method: string, url: string], options?: ErrorOptions | undefined) => Exception;
 export declare const E_CANNOT_LOOKUP_ROUTE: new (args: [routeIdentifier: string], options?: ErrorOptions | undefined) => Exception;
 export declare const E_HTTP_EXCEPTION: {

package/build/src/helpers.d.ts

@@ -6,3 +6,4 @@ import { RouteResource } from './router/resource.js';
 export declare function dropSlash(input: string): string;
 export declare function toRoutesJSON(routes: (RouteGroup | Route | RouteResource | BriskRoute)[]): RouteJSON[];
 export declare function trustProxy(remoteAddress: string, proxyFn: (addr: string, distance: number) => boolean): boolean;
+export declare function parseRange<T>(range: string, value: T): Record<number, T>;

package/build/src/helpers.js

@@ -1,4 +1,5 @@
 import Cache from 'tmp-cache';
+import { InvalidArgumentsException } from '@poppinss/utils';
 import { BriskRoute } from './router/brisk.js';
 import { RouteGroup } from './router/group.js';
 import { RouteResource } from './router/resource.js';
@@ -39,3 +40,23 @@ export function trustProxy(remoteAddress, proxyFn) {
     proxyCache.set(remoteAddress, result);
     return result;
 }
+export function parseRange(range, value) {
+    const parts = range.split('..');
+    const min = Number(parts[0]);
+    const max = Number(parts[1]);
+    if (Number.isNaN(min) || Number.isNaN(max)) {
+        return {};
+    }
+    if (min === max) {
+        return {
+            [min]: value,
+        };
+    }
+    if (max < min) {
+        throw new InvalidArgumentsException(`Invalid range "${range}"`);
+    }
+    return [...Array(max - min + 1).keys()].reduce((result, step) => {
+        result[min + step] = value;
+        return result;
+    }, {});
+}

package/build/src/response.js

@@ -13,7 +13,7 @@ import { RuntimeException } from '@poppinss/utils';
 import contentDisposition from 'content-disposition';
 import { Redirect } from './redirect.js';
 import { CookieSerializer } from './cookies/serializer.js';
-import { E_HTTP_REQUEST_ABORTED } from './exceptions/main.js';
+import { E_HTTP_REQUEST_ABORTED } from './exceptions.js';
 const statFn = promisify(stat);
 const CACHEABLE_HTTP_METHODS = ['GET', 'HEAD'];
 export class Response extends Macroable {

package/build/src/router/lookup_store/route_finder.js

@@ -1,4 +1,4 @@
-import * as errors from '../../exceptions/main.js';
+import * as errors from '../../exceptions.js';
 export class RouteFinder {
     #routes;
     constructor(routes) {

package/build/src/server/factories/final_handler.js

@@ -1,4 +1,4 @@
-import * as errors from '../../exceptions/main.js';
+import * as errors from '../../exceptions.js';
 export function finalHandler(router, resolver, ctx) {
     return function () {
         const url = ctx.request.url();

package/build/src/server/main.js

@@ -13,6 +13,7 @@ import { asyncLocalStorage } from '../http_context/local_storage.js';
 import { middlewareHandler } from './factories/middleware_handler.js';
 export class Server {
     #defaultErrorHandler = {
+        report() { },
         handle(error, ctx) {
             ctx.response.status(error.status || 500).send(error.message || 'Internal server error');
         },
@@ -60,7 +61,10 @@ export class Server {
     }
     #handleRequest(ctx, resolver) {
         return this.#serverMiddlewareStack.runner()
-            .errorHandler((error) => this.#resolvedErrorHandler.handle(error, ctx))
+            .errorHandler((error) => {
+            this.#resolvedErrorHandler.report(error, ctx);
+            return this.#resolvedErrorHandler.handle(error, ctx);
+        })
             .finalHandler(finalHandler(this.#router, resolver, ctx))
             .run(middlewareHandler(resolver, ctx))
             .catch((error) => {

package/build/src/types/server.d.ts

@@ -3,11 +3,25 @@ import type { QSParserConfig } from './qs.js';
 import type { RequestConfig } from './request.js';
 import type { ResponseConfig } from './response.js';
 import type { HttpContext } from '../http_context/main.js';
+export type HttpError = {
+    message: string;
+    status: number;
+    code?: string;
+    stack?: string;
+    cause?: any;
+    messages?: any;
+    errors?: any;
+    handle?: (...args: any[]) => any;
+    report?: (...args: any[]) => any;
+};
+export type StatusPageRange = `${number}..${number}`;
+export type StatusPageRenderer = (error: HttpError, ctx: HttpContext) => any | Promise<any>;
 export type HttpRequestFinishedPayload = {
     ctx: HttpContext;
     duration: [number, number];
 };
 export type ServerErrorHandler = {
+    report: (error: any, ctx: HttpContext) => any;
     handle: (error: any, ctx: HttpContext) => any;
 };
 export type ErrorHandlerAsAClass = Constructor<ServerErrorHandler>;

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@adonisjs/http-server",
-  "version": "6.4.3-0",
+  "version": "6.5.0-0",
   "description": "AdonisJS HTTP server with support packed with Routing and Cookies",
   "main": "build/index.js",
   "type": "module",
   "files": [
     "build/src",
-    "build/test_factories",
+    "build/factories",
     "build/index.d.ts",
     "build/index.js"
   ],
   "exports": {
     ".": "./build/index.js",
     "./types": "./build/src/types/main.js",
-    "./test_factories/*": "./build/test_factories/*.js"
+    "./factories": "./build/factories/main.js"
   },
   "scripts": {
     "pretest": "npm run lint",
@@ -44,7 +44,7 @@
     "@adonisjs/encryption": "^5.1.0-0",
     "@adonisjs/events": "^8.4.3-0",
     "@adonisjs/fold": "^9.9.0-0",
-    "@adonisjs/logger": "^5.2.0-0",
+    "@adonisjs/logger": "^5.3.0-0",
     "@commitlint/cli": "^17.4.2",
     "@commitlint/config-conventional": "^17.4.2",
     "@fastify/middie": "^8.1.0",
@@ -113,14 +113,15 @@
     "qs": "^6.11.0",
     "tmp-cache": "^1.1.0",
     "type-is": "^1.6.18",
-    "vary": "^1.1.2"
+    "vary": "^1.1.2",
+    "youch": "^3.2.2"
   },
   "peerDependencies": {
     "@adonisjs/application": "^6.8.0-0",
     "@adonisjs/encryption": "^5.1.0-0",
     "@adonisjs/events": "^8.4.3-0",
     "@adonisjs/fold": "^9.9.0-0",
-    "@adonisjs/logger": "^5.2.0-0"
+    "@adonisjs/logger": "^5.3.0-0"
   },
   "repository": {
     "type": "git",
@@ -183,7 +184,7 @@
     ],
     "exclude": [
       "tests/**",
-      "test_factories/**",
+      "factories/**",
       ".yalc/**"
     ]
   }