@adonisjs/http-server 8.0.0-next.8 → 8.0.0

package/build/helpers-C_2HouOe.js

@@ -0,0 +1,52 @@
+function findRoute(domainsRoutes, routeIdentifier, domain, method, disableLegacyLookup) {
+	if (!domain) {
+		let route = null;
+		for (const routeDomain of Object.keys(domainsRoutes)) {
+			route = findRoute(domainsRoutes, routeIdentifier, routeDomain, method, disableLegacyLookup);
+			if (route) break;
+		}
+		return route;
+	}
+	const routes = domainsRoutes[domain];
+	if (!routes) return null;
+	const lookupByPattern = !disableLegacyLookup;
+	const lookupByController = !disableLegacyLookup;
+	return routes.find((route) => {
+		if (method && !route.methods.includes(method)) return false;
+		if (route.name === routeIdentifier || lookupByPattern && route.pattern === routeIdentifier) return true;
+		if (lookupByController && route.handler && typeof route.handler === "object") return "reference" in route.handler && route.handler.reference === routeIdentifier;
+		return false;
+	}) || null;
+}
+function createURL(pattern, tokens, searchParamsStringifier, params, options) {
+	const uriSegments = [];
+	const paramsArray = Array.isArray(params) ? params : null;
+	const paramsObject = !Array.isArray(params) ? params ?? {} : {};
+	let paramsIndex = 0;
+	for (const token of tokens) {
+		if (token.type === 0) {
+			uriSegments.push(token.val === "/" ? "" : `${token.val}${token.end}`);
+			continue;
+		}
+		if (token.type === 2) {
+			const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject["*"];
+			if (!Array.isArray(values) || !values.length) throw new Error(`Cannot make URL for "${pattern}". Invalid value provided for the wildcard param`);
+			uriSegments.push(`${values.join("/")}${token.end}`);
+			break;
+		}
+		const paramName = token.val;
+		const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
+		const isDefined = value !== void 0 && value !== null;
+		if (token.type === 1 && !isDefined) throw new Error(`Cannot make URL for "${pattern}". Missing value for the "${paramName}" param`);
+		if (isDefined) uriSegments.push(`${value}${token.end}`);
+		paramsIndex++;
+	}
+	let URI = `/${uriSegments.join("/")}`;
+	if (options?.prefixUrl) URI = `${options?.prefixUrl.replace(/\/$/, "")}${URI}`;
+	if (options?.qs) {
+		const queryString = searchParamsStringifier(options?.qs);
+		URI = queryString ? `${URI}?${queryString}` : URI;
+	}
+	return URI;
+}
+export { findRoute as n, createURL as t };

package/build/index.d.ts

@@ -1,10 +1,11 @@
+export { Qs } from './src/qs.ts';
 export * as errors from './src/errors.ts';
-export { Request } from './src/request.ts';
-export { Response } from './src/response.ts';
 export { Redirect } from './src/redirect.ts';
 export { Server } from './src/server/main.ts';
 export { Router } from './src/router/main.ts';
 export { Route } from './src/router/route.ts';
+export { HttpRequest } from './src/request.ts';
+export { HttpResponse } from './src/response.ts';
 export { BriskRoute } from './src/router/brisk.ts';
 export { RouteGroup } from './src/router/group.ts';
 export { defineConfig } from './src/define_config.ts';

package/build/index.js

@@ -1,373 +1,158 @@
-import {
-  BriskRoute,
-  CookieClient,
-  CookieParser,
-  CookieSerializer,
-  E_CANNOT_LOOKUP_ROUTE,
-  E_HTTP_EXCEPTION,
-  E_HTTP_REQUEST_ABORTED,
-  E_ROUTE_NOT_FOUND,
-  HttpContext,
-  Redirect,
-  Request,
-  Response,
-  ResponseStatus,
-  Route,
-  RouteGroup,
-  RouteResource,
-  Router,
-  Server,
-  canWriteResponseBody,
-  defineConfig,
-  errors_exports,
-  parseRange,
-  tracing_channels_exports
-} from "./chunk-W6WKITGF.js";
-import "./chunk-NQNHMINZ.js";
-
-// src/exception_handler.ts
-import is from "@sindresorhus/is";
+import { a as RouteGroup, c as Route, m as canWriteResponseBody, o as RouteResource, p as tracing_channels_exports, s as BriskRoute, t as parseRange } from "./utils-BjSHKI3s.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-D-kQXU0e.js";
+import "./helpers-C_2HouOe.js";
+import "./types-AUwURgIL.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,
-  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);
+			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);
+			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/helpers.d.ts

@@ -0,0 +1,37 @@
+import { type ClientRouteMatchItTokens, type ClientRouteJSON, type URLOptions } from './types.ts';
+/**
+ * Finds a route by its identifier across domains.
+ *
+ * Searches for routes by name, pattern, or controller reference. When no domain
+ * is specified, searches across all domains. Supports legacy lookup strategies
+ * for backwards compatibility.
+ *
+ * @param domainsRoutes - Object mapping domain names to route arrays
+ * @param routeIdentifier - Route name, pattern, or controller reference to find
+ * @param domain - Optional domain to limit search scope
+ * @param method - Optional HTTP method to filter routes
+ * @param disableLegacyLookup - Whether to disable pattern and controller lookup
+ *
+ * @example
+ * ```ts
+ * const route = findRoute(routes, 'users.show', 'api', 'GET')
+ * const route2 = findRoute(routes, '/users/:id', undefined, 'GET')
+ * ```
+ */
+export declare function findRoute<Route extends ClientRouteJSON>(domainsRoutes: {
+    [domain: string]: Route[];
+}, routeIdentifier: string, domain?: string, method?: string, disableLegacyLookup?: boolean): null | Route;
+/**
+ * Makes URL for a given route pattern using its parsed tokens. The
+ * tokens could be generated using the "parseRoute" method.
+ *
+ * @param pattern - The route pattern
+ * @param tokens - Array of parsed route tokens
+ * @param searchParamsStringifier - Function to stringify query parameters
+ * @param params - Route parameters as array or object
+ * @param options - URL options
+ * @returns {string} The generated URL
+ */
+export declare function createURL(pattern: string, tokens: Pick<ClientRouteMatchItTokens, 'val' | 'type' | 'end'>[], searchParamsStringifier: (qs: Record<string, any>) => string, params?: any[] | {
+    [param: string]: any;
+}, options?: URLOptions): string;