@adonisjs/http-server 6.8.2-9 → 7.0.0-0

package/build/index.d.ts

@@ -1,14 +1,272 @@
-export { Request } from './src/request.js';
-export { Response } from './src/response.js';
-export { Redirect } from './src/redirect.js';
-export { Server } from './src/server/main.js';
-export { Router } from './src/router/main.js';
-export { Route } from './src/router/route.js';
-export * as errors from './src/exceptions.js';
-export { BriskRoute } from './src/router/brisk.js';
-export { RouteGroup } from './src/router/group.js';
-export { defineConfig } from './src/define_config.js';
-export { CookieClient } from './src/cookies/client.js';
-export { HttpContext } from './src/http_context/main.js';
-export { RouteResource } from './src/router/resource.js';
-export { ExceptionHandler } from './src/exception_handler.js';
+import { H as HttpContext, S as ServerConfig, c as StatusPageRange, d as StatusPageRenderer, e as HttpError } from './main-e5b46c83.js';
+export { B as BriskRoute, f as Redirect, a as Request, b as Response, g as Route, h as RouteGroup, i as RouteResource, R as Router } from './main-e5b46c83.js';
+export { S as Server } from './main-29eaaee4.js';
+import { Exception } from '@poppinss/utils';
+import { Encryption } from '@adonisjs/encryption';
+import Macroable from '@poppinss/macroable';
+import { Level } from '@adonisjs/logger/types';
+import '@adonisjs/fold';
+import '@adonisjs/logger';
+import 'node:url';
+import 'node:http';
+import 'qs';
+import 'http';
+import 'stream';
+import '@poppinss/middleware';
+import '@poppinss/middleware/types';
+import 'node:stream';
+import '@adonisjs/application';
+import '@adonisjs/events';
+import 'node:https';
+
+declare const E_ROUTE_NOT_FOUND: new (args: [method: string, url: string], options?: ErrorOptions | undefined) => Exception;
+declare const E_CANNOT_LOOKUP_ROUTE: new (args: [routeIdentifier: string], options?: ErrorOptions | undefined) => Exception;
+declare const E_HTTP_EXCEPTION: {
+    new (message?: string | undefined, options?: (ErrorOptions & {
+        code?: string | undefined;
+        status?: number | undefined;
+    }) | undefined): {
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    code: string;
+    /**
+     * This method returns an instance of the exception class
+     */
+    invoke(body: any, status: number, code?: string): {
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    help?: string | undefined;
+    status?: number | undefined;
+    message?: string | undefined;
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+declare const E_HTTP_REQUEST_ABORTED: {
+    new (message?: string | undefined, options?: (ErrorOptions & {
+        code?: string | undefined;
+        status?: number | undefined;
+    }) | undefined): {
+        handle(error: any, ctx: HttpContext): void;
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    code: string;
+    /**
+     * This method returns an instance of the exception class
+     */
+    invoke(body: any, status: number, code?: string): {
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    help?: string | undefined;
+    status?: number | undefined;
+    message?: string | undefined;
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+
+declare const exceptions_E_CANNOT_LOOKUP_ROUTE: typeof E_CANNOT_LOOKUP_ROUTE;
+declare const exceptions_E_HTTP_EXCEPTION: typeof E_HTTP_EXCEPTION;
+declare const exceptions_E_HTTP_REQUEST_ABORTED: typeof E_HTTP_REQUEST_ABORTED;
+declare const exceptions_E_ROUTE_NOT_FOUND: typeof E_ROUTE_NOT_FOUND;
+declare namespace exceptions {
+  export {
+    exceptions_E_CANNOT_LOOKUP_ROUTE as E_CANNOT_LOOKUP_ROUTE,
+    exceptions_E_HTTP_EXCEPTION as E_HTTP_EXCEPTION,
+    exceptions_E_HTTP_REQUEST_ABORTED as E_HTTP_REQUEST_ABORTED,
+    exceptions_E_ROUTE_NOT_FOUND as E_ROUTE_NOT_FOUND,
+  };
+}
+
+type UserDefinedServerConfig = Partial<Omit<ServerConfig, 'trustProxy'> & {
+    trustProxy: ((address: string, distance: number) => boolean) | boolean | string;
+}>;
+/**
+ * Define configuration for the HTTP server
+ */
+declare function defineConfig(config: UserDefinedServerConfig): ServerConfig;
+
+/**
+ * Cookie client exposes the API to parse/set AdonisJS cookies
+ * as a client.
+ */
+declare class CookieClient {
+    #private;
+    constructor(encryption: Encryption);
+    /**
+     * Encrypt a key value pair to be sent in the cookie header
+     */
+    encrypt(key: string, value: any): string | null;
+    /**
+     * Sign a key value pair to be sent in the cookie header
+     */
+    sign(key: string, value: any): string | null;
+    /**
+     * Encode a key value pair to be sent in the cookie header
+     */
+    encode(_: string, value: any): string | null;
+    /**
+     * Unsign a signed cookie value
+     */
+    unsign(key: string, value: string): any;
+    /**
+     * Decrypt an encrypted cookie value
+     */
+    decrypt(key: string, value: string): any;
+    /**
+     * Decode an encoded cookie value
+     */
+    decode(_: string, value: string): any;
+    /**
+     * Parse response cookie
+     */
+    parse(key: string, value: any): any;
+}
+
+/**
+ * The base HTTP exception handler one can inherit from to handle
+ * HTTP exceptions.
+ *
+ * The HTTP exception handler has support for
+ *
+ * - Ability to render exceptions by calling the render method on the exception.
+ * - Rendering status pages
+ * - Pretty printing errors during development
+ * - Transforming errors to JSON or HTML using content negotiation
+ * - Reporting errors
+ */
+declare class ExceptionHandler extends Macroable {
+    #private;
+    /**
+     * Whether or not to render debug info. When set to true, the errors
+     * will have the complete error stack.
+     */
+    protected debug: boolean;
+    /**
+     * Whether or not to render status pages. When set to true, the unhandled
+     * errors with matching status codes will be rendered using a status
+     * page.
+     */
+    protected renderStatusPages: boolean;
+    /**
+     * A collection of error status code range and the view to render.
+     */
+    protected statusPages: Record<StatusPageRange, StatusPageRenderer>;
+    /**
+     * Enable/disable errors reporting
+     */
+    protected reportErrors: boolean;
+    /**
+     * An array of exception classes to ignore when
+     * reporting an error
+     */
+    protected ignoreExceptions: any[];
+    /**
+     * An array of HTTP status codes to ignore when reporting
+     * an error
+     */
+    protected ignoreStatuses: number[];
+    /**
+     * An array of error codes to ignore when reporting
+     * an error
+     */
+    protected ignoreCodes: string[];
+    /**
+     * Error reporting context
+     */
+    protected context(ctx: HttpContext): any;
+    /**
+     * Returns the log level for an error based upon the error
+     * status code.
+     */
+    protected getErrorLogLevel(error: HttpError): Level;
+    /**
+     * A boolean to control if errors should be rendered with
+     * all the available debugging info.
+     */
+    protected isDebuggingEnabled(_: HttpContext): boolean;
+    /**
+     * Returns a boolean by checking if an error should be reported.
+     */
+    protected shouldReport(error: HttpError): boolean;
+    /**
+     * Renders an error to JSON response
+     */
+    renderErrorAsJSON(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Renders an error to JSON API response
+     */
+    renderErrorAsJSONAPI(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Renders an error to HTML response
+     */
+    renderErrorAsHTML(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Renders the validation error message to a JSON
+     * response
+     */
+    renderValidationErrorAsJSON(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Renders the validation error message as per JSON API
+     * spec
+     */
+    renderValidationErrorAsJSONAPI(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Renders the validation error as an HTML string
+     */
+    renderValidationErrorAsHTML(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Renders the error to response
+     */
+    renderError(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Renders the validation error to response
+     */
+    renderValidationError(error: HttpError, ctx: HttpContext): Promise<void>;
+    /**
+     * Reports an error during an HTTP request
+     */
+    report(error: unknown, ctx: HttpContext): Promise<void>;
+    /**
+     * Handles the error during the HTTP request.
+     */
+    handle(error: unknown, ctx: HttpContext): Promise<any>;
+}
+
+export { CookieClient, ExceptionHandler, HttpContext, defineConfig, exceptions as errors };

package/build/index.js

@@ -1,22 +1,308 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export { Request } from './src/request.js';
-export { Response } from './src/response.js';
-export { Redirect } from './src/redirect.js';
-export { Server } from './src/server/main.js';
-export { Router } from './src/router/main.js';
-export { Route } from './src/router/route.js';
-export * as errors from './src/exceptions.js';
-export { BriskRoute } from './src/router/brisk.js';
-export { RouteGroup } from './src/router/group.js';
-export { defineConfig } from './src/define_config.js';
-export { CookieClient } from './src/cookies/client.js';
-export { HttpContext } from './src/http_context/main.js';
-export { RouteResource } from './src/router/resource.js';
-export { ExceptionHandler } from './src/exception_handler.js';
+import {
+  BriskRoute,
+  CookieClient,
+  E_CANNOT_LOOKUP_ROUTE,
+  E_HTTP_EXCEPTION,
+  E_HTTP_REQUEST_ABORTED,
+  E_ROUTE_NOT_FOUND,
+  HttpContext,
+  Redirect,
+  Request,
+  Response,
+  Route,
+  RouteGroup,
+  RouteResource,
+  Router,
+  Server,
+  defineConfig,
+  exceptions_exports,
+  parseRange
+} from "./chunk-XX72ATFY.js";
+
+// src/exception_handler.ts
+import is from "@sindresorhus/is";
+import Macroable from "@poppinss/macroable";
+var ExceptionHandler = class extends Macroable {
+  /**
+   * Computed from the status pages property
+   */
+  #expandedStatusPages;
+  /**
+   * Whether or not to render debug info. When set to true, the errors
+   * will have the complete error stack.
+   */
+  debug = process.env.NODE_ENV !== "production";
+  /**
+   * Whether or not to render status pages. When set to true, the unhandled
+   * errors with matching status codes will be rendered using a status
+   * page.
+   */
+  renderStatusPages = process.env.NODE_ENV === "production";
+  /**
+   * A collection of error status code range and the view to render.
+   */
+  statusPages = {};
+  /**
+   * Enable/disable errors reporting
+   */
+  reportErrors = true;
+  /**
+   * An array of exception classes to ignore when
+   * reporting an error
+   */
+  ignoreExceptions = [
+    E_HTTP_EXCEPTION,
+    E_ROUTE_NOT_FOUND,
+    E_CANNOT_LOOKUP_ROUTE,
+    E_HTTP_REQUEST_ABORTED
+  ];
+  /**
+   * An array of HTTP status codes to ignore when reporting
+   * an error
+   */
+  ignoreStatuses = [400, 422, 401];
+  /**
+   * An array of error codes to ignore when reporting
+   * an error
+   */
+  ignoreCodes = [];
+  /**
+   * Expands status pages
+   */
+  #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;
+  }
+  /**
+   * Forcefully tweaking the type of the error object to
+   * have known properties.
+   */
+  #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;
+  }
+  /**
+   * Error reporting context
+   */
+  context(ctx) {
+    const requestId = ctx.request.id();
+    return requestId ? {
+      "x-request-id": requestId
+    } : {};
+  }
+  /**
+   * Returns the log level for an error based upon the error
+   * status code.
+   */
+  getErrorLogLevel(error) {
+    if (error.status >= 500) {
+      return "error";
+    }
+    if (error.status >= 400) {
+      return "warn";
+    }
+    return "info";
+  }
+  /**
+   * A boolean to control if errors should be rendered with
+   * all the available debugging info.
+   */
+  isDebuggingEnabled(_) {
+    return this.debug;
+  }
+  /**
+   * Returns a boolean by checking if an 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 to JSON response
+   */
+  async renderErrorAsJSON(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 });
+  }
+  /**
+   * Renders an error to JSON API response
+   */
+  async renderErrorAsJSONAPI(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
+        }
+      ]
+    });
+  }
+  /**
+   * Renders an error to HTML response
+   */
+  async renderErrorAsHTML(error, ctx) {
+    if (this.isDebuggingEnabled(ctx)) {
+      const { default: Youch } = await import("youch");
+      const html = await new Youch(error, ctx.request.request).toHTML({
+        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 the validation error message to a JSON
+   * response
+   */
+  async renderValidationErrorAsJSON(error, ctx) {
+    ctx.response.status(error.status).send({
+      errors: error.messages
+    });
+  }
+  /**
+   * Renders the validation error message as per JSON API
+   * spec
+   */
+  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 the validation error as an HTML string
+   */
+  async renderValidationErrorAsHTML(error, ctx) {
+    ctx.response.status(error.status).type("html").send(
+      error.messages.map((message) => {
+        return `${message.field} - ${message.message}`;
+      }).join("<br />")
+    );
+  }
+  /**
+   * Renders the error to response
+   */
+  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 the validation error to response
+   */
+  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 during an HTTP request
+   */
+  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 the error during the HTTP request.
+   */
+  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);
+    }
+    const statusPages = this.#expandStatusPages();
+    if (this.renderStatusPages && statusPages[httpError.status]) {
+      return statusPages[httpError.status](httpError, ctx);
+    }
+    return this.renderError(httpError, ctx);
+  }
+};
+export {
+  BriskRoute,
+  CookieClient,
+  ExceptionHandler,
+  HttpContext,
+  Redirect,
+  Request,
+  Response,
+  Route,
+  RouteGroup,
+  RouteResource,
+  Router,
+  Server,
+  defineConfig,
+  exceptions_exports as errors
+};

package/build/{src/server/main.d.ts → main-29eaaee4.d.ts}

@@ -1,24 +1,17 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+import { Logger } from '@adonisjs/logger';
 import { Emitter } from '@adonisjs/events';
-import type { Logger } from '@adonisjs/logger';
-import type { Encryption } from '@adonisjs/encryption';
-import type { Server as HttpsServer } from 'node:https';
-import type { Application } from '@adonisjs/application';
+import { Encryption } from '@adonisjs/encryption';
+import { Server as Server$2 } from 'node:https';
+import { Application } from '@adonisjs/application';
 import { ContainerResolver } from '@adonisjs/fold';
-import type { ServerResponse, IncomingMessage, Server as HttpServer } from 'node:http';
-import type { LazyImport } from '../types/base.js';
-import type { MiddlewareAsClass } from '../types/middleware.js';
-import type { ServerConfig, ErrorHandlerAsAClass, TestingMiddlewarePipeline } from '../types/server.js';
-import { Request } from '../request.js';
-import { Response } from '../response.js';
-import { Router } from '../router/main.js';
-import { HttpContext } from '../http_context/main.js';
+import { Server as Server$1, IncomingMessage, ServerResponse } from 'node:http';
+import { S as ServerConfig, M as MiddlewareAsClass, T as TestingMiddlewarePipeline, L as LazyImport, E as ErrorHandlerAsAClass, R as Router, a as Request, b as Response, H as HttpContext } from './main-e5b46c83.js';
+
 /**
  * The HTTP server implementation to handle incoming requests and respond using the
  * registered routes.
  */
-export declare class Server {
+declare class Server {
     #private;
     /**
      * Know if async local storage is enabled or not.
@@ -50,12 +43,12 @@ export declare class Server {
     /**
      * Set the HTTP server instance used to listen for requests.
      */
-    setNodeServer(server: HttpServer | HttpsServer): void;
+    setNodeServer(server: Server$1 | Server$2): void;
     /**
      * Returns reference to the underlying HTTP server
      * in use
      */
-    getNodeServer(): HttpServer<typeof IncomingMessage, typeof ServerResponse> | HttpsServer<typeof IncomingMessage, typeof ServerResponse> | undefined;
+    getNodeServer(): Server$1<typeof IncomingMessage, typeof ServerResponse> | Server$2<typeof IncomingMessage, typeof ServerResponse> | undefined;
     /**
      * Returns reference to the router instance used
      * by the server.
@@ -78,3 +71,5 @@ export declare class Server {
      */
     handle(req: IncomingMessage, res: ServerResponse): Promise<any>;
 }
+
+export { Server as S };