@adonisjs/http-server 8.0.0-next.12 → 8.0.0-next.13

package/build/index.js

@@ -1,378 +1,160 @@
-import {
-  CookieClient,
-  CookieParser,
-  CookieSerializer,
-  E_CANNOT_LOOKUP_ROUTE,
-  E_HTTP_EXCEPTION,
-  E_HTTP_REQUEST_ABORTED,
-  E_ROUTE_NOT_FOUND,
-  HttpContext,
-  Qs,
-  Redirect,
-  Request,
-  Response,
-  ResponseStatus,
-  Router,
-  Server,
-  defineConfig,
-  errors_exports
-} from "./chunk-L2UOVWDK.js";
-import {
-  BriskRoute,
-  Route,
-  RouteGroup,
-  RouteResource,
-  canWriteResponseBody,
-  parseRange,
-  tracing_channels_exports
-} from "./chunk-QDK57QGB.js";
-import "./chunk-77CSRFCU.js";
-import "./chunk-2QM3D5BN.js";
-
-// src/exception_handler.ts
-import is from "@sindresorhus/is";
+import { C as canWriteResponseBody, S as tracing_channels_exports, _ as Route, g as BriskRoute, h as RouteResource, m as RouteGroup, u as parseRange } from "./helpers-Dt-25M21.js";
+import { _ as Qs, a as CookieSerializer, c as HttpRequest, d as Redirect, f as E_CANNOT_LOOKUP_ROUTE, g as errors_exports, h as E_ROUTE_NOT_FOUND, i as HttpResponse, l as CookieParser, m as E_HTTP_REQUEST_ABORTED, n as Server, o as ResponseStatus, p as E_HTTP_EXCEPTION, r as HttpContext, s as Router, t as defineConfig, u as CookieClient } from "./define_config-DpDqx7A4.js";
+import "./helpers-C_2HouOe.js";
+import "./url_builder-piNQy-CF.js";
 import Macroable from "@poppinss/macroable";
+import is from "@sindresorhus/is";
 var ExceptionHandler = class extends Macroable {
-  /**
-   * Cached expanded status pages mapping individual status codes to their renderers
-   * Computed from the statusPages property when first accessed
-   */
-  #expandedStatusPages;
-  /**
-   * Controls whether to include debug information in error responses
-   * When enabled, errors include complete stack traces and detailed debugging info
-   * Defaults to true in non-production environments
-   */
-  debug = process.env.NODE_ENV !== "production";
-  /**
-   * Controls whether to render custom status pages for unhandled errors
-   * When enabled, errors with matching status codes use configured status page renderers
-   * Defaults to true in production environments
-   */
-  renderStatusPages = process.env.NODE_ENV === "production";
-  /**
-   * Mapping of HTTP status code ranges to their corresponding page renderers
-   * Supports ranges like '400-499' or individual codes like '404'
-   */
-  statusPages = {};
-  /**
-   * Controls whether errors should be reported to logging systems
-   * When disabled, errors are handled but not logged or reported
-   */
-  reportErrors = true;
-  /**
-   * Array of exception class constructors to exclude from error reporting
-   * These exceptions are handled but not logged or reported to external systems
-   */
-  ignoreExceptions = [
-    E_HTTP_EXCEPTION,
-    E_ROUTE_NOT_FOUND,
-    E_CANNOT_LOOKUP_ROUTE,
-    E_HTTP_REQUEST_ABORTED
-  ];
-  /**
-   * Array of HTTP status codes to exclude from error reporting
-   * Errors with these status codes are handled but not logged
-   */
-  ignoreStatuses = [400, 422, 401];
-  /**
-   * Array of custom error codes to exclude from error reporting
-   * Errors with these codes are handled but not logged
-   */
-  ignoreCodes = [];
-  /**
-   * Expands status page ranges into individual status code mappings
-   * Creates a cached lookup table for faster status page resolution
-   * @returns Mapping of status codes to renderers
-   */
-  #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;
-  }
-  /**
-   * Normalizes any thrown value into a standardized HttpError object
-   * Ensures the error has required properties like message and status
-   * @param error - Any thrown value (Error, string, object, etc.)
-   * @returns {HttpError} Normalized error object with status and message
-   */
-  #toHttpError(error) {
-    const httpError = is.object(error) ? error : new Error(String(error));
-    if (!httpError.message) {
-      httpError.message = "Internal server error";
-    }
-    if (!httpError.status) {
-      httpError.status = 500;
-    }
-    return httpError;
-  }
-  /**
-   * Provides additional context information for error reporting
-   * Includes request ID when available for correlation across logs
-   * @param ctx - HTTP context containing request information
-   * @returns Additional context data for error reporting
-   */
-  context(ctx) {
-    const requestId = ctx.request.id();
-    return requestId ? {
-      "x-request-id": requestId
-    } : {};
-  }
-  /**
-   * Determines the appropriate log level based on HTTP status code
-   * 5xx errors are logged as 'error', 4xx as 'warn', others as 'info'
-   * @param error - HTTP error object with status code
-   * @returns {Level} Appropriate logging level for the error
-   */
-  getErrorLogLevel(error) {
-    if (error.status >= 500) {
-      return "error";
-    }
-    if (error.status >= 400) {
-      return "warn";
-    }
-    return "info";
-  }
-  /**
-   * Determines whether debug information should be included in error responses
-   * Override this method to implement context-specific debug control
-   * @param _ - HTTP context (unused in base implementation)
-   * @returns {boolean} True if debugging should be enabled
-   */
-  isDebuggingEnabled(_) {
-    return this.debug;
-  }
-  /**
-   * Determines whether an error should be reported to logging systems
-   * Checks against ignore lists for exceptions, status codes, and error codes
-   * @param error - HTTP error to evaluate for reporting
-   * @returns {boolean} True if the error should be reported
-   */
-  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;
-  }
-  /**
-   * Renders an error as a JSON response
-   * In debug mode, includes full stack trace using Youch
-   * @param error - HTTP error to render
-   * @param ctx - HTTP context for the request
-   */
-  async renderErrorAsJSON(error, ctx) {
-    if (this.isDebuggingEnabled(ctx)) {
-      const { Youch } = await import("youch");
-      const json = await new Youch().toJSON(error);
-      ctx.response.status(error.status).send(json);
-      return;
-    }
-    ctx.response.status(error.status).send({ message: error.message });
-  }
-  /**
-   * Renders an error as a JSON API compliant response
-   * Follows JSON API specification for error objects
-   * @param error - HTTP error to render
-   * @param ctx - HTTP context for the request
-   */
-  async renderErrorAsJSONAPI(error, ctx) {
-    if (this.isDebuggingEnabled(ctx)) {
-      const { Youch } = await import("youch");
-      const json = await new Youch().toJSON(error);
-      ctx.response.status(error.status).send(json);
-      return;
-    }
-    ctx.response.status(error.status).send({
-      errors: [
-        {
-          title: error.message,
-          code: error.code,
-          status: error.status
-        }
-      ]
-    });
-  }
-  /**
-   * Renders an error as an HTML response
-   * Uses status pages if configured, otherwise shows debug info or simple message
-   * @param error - HTTP error to render
-   * @param ctx - HTTP context for the request
-   */
-  async renderErrorAsHTML(error, ctx) {
-    const statusPages = this.#expandStatusPages();
-    if (this.renderStatusPages && statusPages[error.status]) {
-      const statusPageResponse = await statusPages[error.status](error, ctx);
-      if (canWriteResponseBody(statusPageResponse, ctx)) {
-        return ctx.response.safeStatus(error.status).send(statusPageResponse);
-      }
-      return statusPageResponse;
-    }
-    if (this.isDebuggingEnabled(ctx)) {
-      const { Youch } = await import("youch");
-      const html = await new Youch().toHTML(error, {
-        request: ctx.request.request,
-        cspNonce: "nonce" in ctx.response ? ctx.response.nonce : void 0
-      });
-      ctx.response.status(error.status).send(html);
-      return;
-    }
-    ctx.response.status(error.status).send(`<p> ${error.message} </p>`);
-  }
-  /**
-   * Renders validation error messages as a JSON response
-   * Returns errors in a simple format with field-specific messages
-   * @param error - Validation error containing messages array
-   * @param ctx - HTTP context for the request
-   */
-  async renderValidationErrorAsJSON(error, ctx) {
-    ctx.response.status(error.status).send({
-      errors: error.messages
-    });
-  }
-  /**
-   * Renders validation error messages as JSON API compliant response
-   * Transforms validation messages to JSON API error object format
-   * @param error - Validation error containing messages array
-   * @param ctx - HTTP context for the request
-   */
-  async renderValidationErrorAsJSONAPI(error, ctx) {
-    ctx.response.status(error.status).send({
-      errors: error.messages.map((message) => {
-        return {
-          title: message.message,
-          code: message.rule,
-          source: {
-            pointer: message.field
-          },
-          meta: message.meta
-        };
-      })
-    });
-  }
-  /**
-   * Renders validation error messages as an HTML response
-   * Creates simple HTML list of field errors separated by line breaks
-   * @param error - Validation error containing messages array
-   * @param ctx - HTTP context for the request
-   */
-  async renderValidationErrorAsHTML(error, ctx) {
-    ctx.response.status(error.status).type("html").send(
-      error.messages.map((message) => {
-        return `${message.field} - ${message.message}`;
-      }).join("<br />")
-    );
-  }
-  /**
-   * Renders an error to the appropriate response format based on content negotiation
-   * Supports HTML, JSON API, and JSON formats based on Accept headers
-   * @param error - HTTP error to render
-   * @param ctx - HTTP context for the request
-   */
-  renderError(error, ctx) {
-    switch (ctx.request.accepts(["html", "application/vnd.api+json", "json"])) {
-      case "application/vnd.api+json":
-        return this.renderErrorAsJSONAPI(error, ctx);
-      case "json":
-        return this.renderErrorAsJSON(error, ctx);
-      case "html":
-      default:
-        return this.renderErrorAsHTML(error, ctx);
-    }
-  }
-  /**
-   * Renders validation errors to the appropriate response format based on content negotiation
-   * Supports HTML, JSON API, and JSON formats for validation error messages
-   * @param error - Validation error to render
-   * @param ctx - HTTP context for the request
-   */
-  renderValidationError(error, ctx) {
-    switch (ctx.request.accepts(["html", "application/vnd.api+json", "json"])) {
-      case "application/vnd.api+json":
-        return this.renderValidationErrorAsJSONAPI(error, ctx);
-      case "json":
-        return this.renderValidationErrorAsJSON(error, ctx);
-      case "html":
-      default:
-        return this.renderValidationErrorAsHTML(error, ctx);
-    }
-  }
-  /**
-   * Reports an error to logging systems if reporting is enabled
-   * Allows errors to self-report via their own report method if available
-   * @param error - Any error object to report
-   * @param ctx - HTTP context for additional reporting context
-   */
-  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);
-    ctx.logger.log(
-      level,
-      {
-        ...level === "error" || level === "fatal" ? { err: httpError } : {},
-        ...this.context(ctx)
-      },
-      httpError.message
-    );
-  }
-  /**
-   * Handles errors during HTTP request processing
-   * Delegates to error's own handle method if available, otherwise renders response
-   * @param error - Any error object to handle
-   * @param ctx - HTTP context for error handling
-   */
-  async handle(error, ctx) {
-    const httpError = this.#toHttpError(error);
-    if (typeof httpError.handle === "function") {
-      return httpError.handle(httpError, ctx);
-    }
-    if (httpError.code === "E_VALIDATION_ERROR" && "messages" in httpError) {
-      return this.renderValidationError(httpError, ctx);
-    }
-    return this.renderError(httpError, ctx);
-  }
-};
-export {
-  BriskRoute,
-  CookieClient,
-  CookieParser,
-  CookieSerializer,
-  ExceptionHandler,
-  HttpContext,
-  Qs,
-  Redirect,
-  Request,
-  Response,
-  ResponseStatus,
-  Route,
-  RouteGroup,
-  RouteResource,
-  Router,
-  Server,
-  defineConfig,
-  errors_exports as errors,
-  tracing_channels_exports as tracingChannels
+	#expandedStatusPages;
+	debug = process.env.NODE_ENV !== "production";
+	renderStatusPages = process.env.NODE_ENV === "production";
+	statusPages = {};
+	reportErrors = true;
+	ignoreExceptions = [
+		E_HTTP_EXCEPTION,
+		E_ROUTE_NOT_FOUND,
+		E_CANNOT_LOOKUP_ROUTE,
+		E_HTTP_REQUEST_ABORTED
+	];
+	ignoreStatuses = [
+		400,
+		422,
+		401
+	];
+	ignoreCodes = [];
+	#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));
+		if (!httpError.message) httpError.message = "Internal server error";
+		if (!httpError.status) httpError.status = 500;
+		return httpError;
+	}
+	context(ctx) {
+		const requestId = ctx.request.id();
+		return requestId ? { "x-request-id": requestId } : {};
+	}
+	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 renderErrorAsJSON(error, ctx) {
+		if (this.isDebuggingEnabled(ctx)) {
+			const { Youch } = await import("youch");
+			const json = await new Youch().toJSON(error);
+			ctx.response.status(error.status).send(json);
+			return;
+		}
+		ctx.response.status(error.status).send({ message: error.message });
+	}
+	async renderErrorAsJSONAPI(error, ctx) {
+		if (this.isDebuggingEnabled(ctx)) {
+			const { Youch } = await import("youch");
+			const json = await new Youch().toJSON(error);
+			ctx.response.status(error.status).send(json);
+			return;
+		}
+		ctx.response.status(error.status).send({ errors: [{
+			title: error.message,
+			code: error.code,
+			status: error.status
+		}] });
+	}
+	async renderErrorAsHTML(error, ctx) {
+		const statusPages = this.#expandStatusPages();
+		if (this.renderStatusPages && statusPages[error.status]) {
+			const statusPageResponse = await statusPages[error.status](error, ctx);
+			if (canWriteResponseBody(statusPageResponse, ctx)) return ctx.response.safeStatus(error.status).send(statusPageResponse);
+			return statusPageResponse;
+		}
+		if (this.isDebuggingEnabled(ctx)) {
+			const { Youch } = await import("youch");
+			const html = await new Youch().toHTML(error, {
+				request: ctx.request.request,
+				cspNonce: "nonce" in ctx.response ? ctx.response.nonce : void 0
+			});
+			ctx.response.status(error.status).send(html);
+			return;
+		}
+		ctx.response.status(error.status).send(`<p> ${error.message} </p>`);
+	}
+	async renderValidationErrorAsJSON(error, ctx) {
+		ctx.response.status(error.status).send({ errors: error.messages });
+	}
+	async renderValidationErrorAsJSONAPI(error, ctx) {
+		ctx.response.status(error.status).send({ errors: error.messages.map((message) => {
+			return {
+				title: message.message,
+				code: message.rule,
+				source: { pointer: message.field },
+				meta: message.meta
+			};
+		}) });
+	}
+	async renderValidationErrorAsHTML(error, ctx) {
+		ctx.response.status(error.status).type("html").send(error.messages.map((message) => {
+			return `${message.field} - ${message.message}`;
+		}).join("<br />"));
+	}
+	renderError(error, ctx) {
+		switch (ctx.request.accepts([
+			"html",
+			"application/vnd.api+json",
+			"json"
+		])) {
+			case "application/vnd.api+json": return this.renderErrorAsJSONAPI(error, ctx);
+			case "json": return this.renderErrorAsJSON(error, ctx);
+			case "html":
+			default: return this.renderErrorAsHTML(error, ctx);
+		}
+	}
+	renderValidationError(error, ctx) {
+		switch (ctx.request.accepts([
+			"html",
+			"application/vnd.api+json",
+			"json"
+		])) {
+			case "application/vnd.api+json": return this.renderValidationErrorAsJSONAPI(error, ctx);
+			case "json": return this.renderValidationErrorAsJSON(error, ctx);
+			case "html":
+			default: return this.renderValidationErrorAsHTML(error, ctx);
+		}
+	}
+	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);
+		ctx.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);
+		if (httpError.code === "E_VALIDATION_ERROR" && "messages" in httpError) return this.renderValidationError(httpError, ctx);
+		return this.renderError(httpError, ctx);
+	}
 };
+export { BriskRoute, CookieClient, CookieParser, CookieSerializer, ExceptionHandler, HttpContext, HttpRequest, HttpResponse, Qs, Redirect, ResponseStatus, Route, RouteGroup, RouteResource, Router, Server, defineConfig, errors_exports as errors, tracing_channels_exports as tracingChannels };

package/build/src/client/url_builder.js

@@ -1,12 +1,3 @@
-import {
-  createUrlBuilder
-} from "../../chunk-77CSRFCU.js";
-import {
-  createURL,
-  findRoute
-} from "../../chunk-2QM3D5BN.js";
-export {
-  createURL,
-  createUrlBuilder,
-  findRoute
-};
+import { n as findRoute, t as createURL } from "../../helpers-C_2HouOe.js";
+import { t as createUrlBuilder } from "../../url_builder-piNQy-CF.js";
+export { createURL, createUrlBuilder, findRoute };

package/build/src/exception_handler.d.ts

@@ -66,6 +66,13 @@ export declare class ExceptionHandler extends Macroable {
      * Errors with these codes are handled but not logged
      */
     protected ignoreCodes: string[];
+    /**
+     * Normalizes any thrown value into a standardized HttpError object
+     * Ensures the error has required properties like message and status
+     * @param error - Any thrown value (Error, string, object, etc.)
+     * @returns {HttpError} Normalized error object with status and message
+     */
+    protected toHttpError(error: unknown): HttpError;
     /**
      * Provides additional context information for error reporting
      * Includes request ID when available for correlation across logs

package/build/src/helpers.js

@@ -1,26 +1,3 @@
-import {
-  appendQueryString,
-  createSignedURL,
-  default as default2,
-  default2 as default3,
-  matchRoute,
-  middlewareInfo,
-  parseRoute,
-  routeInfo,
-  serializeCookie
-} from "../chunk-QDK57QGB.js";
-import {
-  createURL
-} from "../chunk-2QM3D5BN.js";
-export {
-  appendQueryString,
-  createSignedURL,
-  createURL,
-  default2 as encodeUrl,
-  matchRoute,
-  middlewareInfo,
-  default3 as mime,
-  parseRoute,
-  routeInfo,
-  serializeCookie
-};
+import { a as middlewareInfo, c as routeInfo, i as matchRoute, l as serializeCookie, n as createSignedURL, o as mime, r as encodeUrl, s as parseRoute, t as appendQueryString } from "../helpers-Dt-25M21.js";
+import { t as createURL } from "../helpers-C_2HouOe.js";
+export { appendQueryString, createSignedURL, createURL, encodeUrl, matchRoute, middlewareInfo, mime, parseRoute, routeInfo, serializeCookie };

package/build/src/http_context/main.d.ts

@@ -1,8 +1,8 @@
 import Macroable from '@poppinss/macroable';
 import type { Logger } from '@adonisjs/logger';
 import { type ContainerResolver } from '@adonisjs/fold';
-import type { Request } from '../request.ts';
-import type { Response } from '../response.ts';
+import type { HttpRequest } from '../request.ts';
+import type { HttpResponse } from '../response.ts';
 import type { RouteJSON } from '../types/route.ts';
 /**
  * HTTP context encapsulates all properties and services for a given HTTP request.
@@ -23,8 +23,8 @@ import type { RouteJSON } from '../types/route.ts';
  * ```
  */
 export declare class HttpContext extends Macroable {
-    request: Request;
-    response: Response;
+    request: HttpRequest;
+    response: HttpResponse;
     logger: Logger;
     containerResolver: ContainerResolver<any>;
     /**
@@ -103,12 +103,12 @@ export declare class HttpContext extends Macroable {
     /**
      * Creates a new HttpContext instance
      *
-     * @param {Request} request - The HTTP request instance
-     * @param {Response} response - The HTTP response instance
+     * @param {HttpRequest} request - The HTTP request instance
+     * @param {HttpResponse} response - The HTTP response instance
      * @param {Logger} logger - The logger instance
      * @param {ContainerResolver<any>} containerResolver - The IoC container resolver
      */
-    constructor(request: Request, response: Response, logger: Logger, containerResolver: ContainerResolver<any>);
+    constructor(request: HttpRequest, response: HttpResponse, logger: Logger, containerResolver: ContainerResolver<any>);
     /**
      * A helper to see top level properties on the context object
      */

package/build/src/redirect.d.ts

@@ -1,7 +1,7 @@
 import type { IncomingMessage } from 'node:http';
 import type { Qs } from './qs.ts';
-import type { Response } from './response.ts';
 import type { Router } from './router/main.ts';
+import type { HttpResponse } from './response.ts';
 import type { RoutesList, LookupList, URLOptions, GetRoutesForMethod, RouteBuilderArguments } from './types/url_builder.ts';
 /**
  * Provides a fluent API for constructing HTTP redirect responses.
@@ -34,7 +34,7 @@ export declare class Redirect {
      * @param router - AdonisJS router instance
      * @param qs - Query string parser instance
      */
-    constructor(request: IncomingMessage, response: Response, router: Router, qs: Qs);
+    constructor(request: IncomingMessage, response: HttpResponse, router: Router, qs: Qs);
     /**
      * Sets a custom HTTP status code for the redirect response
      * @param statusCode - HTTP status code to use (e.g., 301, 302, 307)

package/build/src/request.d.ts

@@ -13,7 +13,7 @@ import type { HttpContext } from './http_context/main.ts';
  * You can access the original [IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)
  * using `request.request` property.
  */
-export declare class Request extends Macroable {
+export declare class HttpRequest extends Macroable {
     #private;
     /** Native Node.js incoming message instance */
     request: IncomingMessage;