@adonisjs/http-server 8.0.0-next.9 → 8.1.0

package/build/helpers-aa47NQc6.js

@@ -0,0 +1,1426 @@
+import { n as __exportAll } from "./chunk-B2GA45YG.js";
+import { t as createURL } from "./helpers-XD4_pfkD.js";
+import { InvalidArgumentsException, RuntimeException } from "@poppinss/utils/exception";
+import { debuglog } from "node:util";
+import { serialize } from "cookie-es";
+import matchit from "@poppinss/matchit";
+import string from "@poppinss/utils/string";
+import { moduleCaller, moduleImporter, parseBindingReference } from "@adonisjs/fold";
+import Cache from "tmp-cache";
+import Macroable from "@poppinss/macroable";
+import is from "@sindresorhus/is";
+import Middleware from "@poppinss/middleware";
+import diagnostics_channel from "node:diagnostics_channel";
+import StringBuilder from "@poppinss/utils/string_builder";
+import encodeUrl from "encodeurl";
+import mime from "mime-types";
+//#region src/debug.ts
+/**
+* Debug logger instance for the AdonisJS HTTP server package.
+*
+* This debug logger can be enabled by setting the NODE_DEBUG environment variable
+* to include 'adonisjs:http'. When enabled, it will output detailed debugging
+* information about HTTP server operations including route matching, middleware
+* execution, and response generation.
+*
+* @example
+* ```bash
+* NODE_DEBUG=adonisjs:http node ace serve
+* ```
+*/
+var debug_default = debuglog("adonisjs:http");
+//#endregion
+//#region src/router/factories/use_return_value.ts
+/**
+* Check if the value can be used to write the response body. Returns
+* false when the response body has already been set
+* @param value - The value to check
+* @param ctx - The HTTP context instance
+* @returns True if value can be used for response body
+*/
+function canWriteResponseBody(value, ctx) {
+	return value !== void 0 && !ctx.response.hasLazyBody && value !== ctx.response;
+}
+/**
+* A factory function that uses the return value of the request
+* pipeline as the response
+* @param ctx - The HTTP context instance
+* @returns Function that handles return values
+*/
+function useReturnValue(ctx) {
+	return function(value) {
+		if (canWriteResponseBody(value, ctx)) ctx.response.send(value);
+	};
+}
+//#endregion
+//#region src/tracing_channels.ts
+var tracing_channels_exports = /* @__PURE__ */ __exportAll({
+	httpExceptionHandler: () => httpExceptionHandler,
+	httpMiddleware: () => httpMiddleware,
+	httpRequest: () => httpRequest,
+	httpResponseSerializer: () => httpResponseSerializer,
+	httpRouteHandler: () => httpRouteHandler
+});
+/**
+* Traces every HTTP request handled by the {@link Server} class.
+*/
+const httpRequest = diagnostics_channel.tracingChannel("adonisjs.http.request");
+/**
+* Traces middleware executed during the HTTP request
+*/
+const httpMiddleware = diagnostics_channel.tracingChannel("adonisjs.http.middleware");
+/**
+* Traces the exception handler that converts errors into HTTP responses
+*/
+const httpExceptionHandler = diagnostics_channel.tracingChannel("adonisjs.http.exception.handler");
+/**
+* Traces route handler executed during the HTTP request
+*/
+const httpRouteHandler = diagnostics_channel.tracingChannel("adonisjs.http.route.handler");
+/**
+* Traces non-stream and non-file download responses written by the AdonisJS
+* response class
+*/
+const httpResponseSerializer = diagnostics_channel.tracingChannel("adonisjs.http.response.serializer");
+//#endregion
+//#region src/router/executor.ts
+/**
+* Executor to execute the route middleware pipeline the route
+* handler
+* @param route - The route JSON object containing route information
+* @param resolver - Container resolver for dependency injection
+* @param ctx - The HTTP context instance
+* @param errorResponder - Error handler function for handling errors
+*/
+function execute(route, resolver, ctx, errorResponder) {
+	return route.middleware.runner().errorHandler((error) => errorResponder(error, ctx)).finalHandler(() => {
+		if (typeof route.handler === "function") return httpRouteHandler.tracePromise(($ctx) => Promise.resolve(route.handler($ctx)), httpRouteHandler.hasSubscribers ? { route } : void 0, void 0, ctx).then(useReturnValue(ctx));
+		return httpRouteHandler.tracePromise(route.handler.handle, httpRouteHandler.hasSubscribers ? { route } : void 0, void 0, resolver, ctx).then(useReturnValue(ctx));
+	}).run(async (middleware, next) => {
+		if (typeof middleware === "function") return httpMiddleware.tracePromise(middleware, httpMiddleware.hasSubscribers ? { middleware } : void 0, void 0, ctx, next);
+		return httpMiddleware.tracePromise(middleware.handle, httpMiddleware.hasSubscribers ? { middleware } : void 0, void 0, resolver, ctx, next, middleware.args);
+	});
+}
+//#endregion
+//#region src/router/route.ts
+/**
+* The Route class provides a fluent API for constructing and configuring HTTP routes.
+*
+* Routes define how HTTP requests are handled by mapping URL patterns and HTTP methods
+* to controller actions or inline handlers. This class supports middleware application,
+* parameter validation, naming, and various other route-specific configurations.
+*
+* @example
+* ```ts
+* const route = new Route(app, middleware, {
+*   pattern: '/users/:id',
+*   methods: ['GET'],
+*   handler: 'UsersController.show'
+* })
+*
+* route
+*   .where('id', /^[0-9]+$/)
+*   .middleware(['auth'])
+*   .as('users.show')
+* ```
+*/
+var Route = class extends Macroable {
+	/**
+	* The URL pattern for this route. May contain dynamic parameters
+	* prefixed with a colon (e.g., '/users/:id').
+	*/
+	#pattern;
+	/**
+	* Array of HTTP methods this route responds to (e.g., ['GET', 'POST']).
+	*/
+	#methods;
+	/**
+	* A unique identifier for the route, used for URL generation and
+	* route referencing.
+	*/
+	#name;
+	/**
+	* Flag indicating whether the route should be excluded from registration
+	* in the route store. This must be set before calling Router.commit().
+	*/
+	#isDeleted = false;
+	/**
+	* The handler function or controller method that processes requests
+	* matching this route.
+	*/
+	#handler;
+	/**
+	* Route parameter matchers inherited from the global router configuration.
+	* These are applied to all routes unless overridden locally.
+	*/
+	#globalMatchers;
+	/**
+	* Reference to the AdonisJS application instance, used for module
+	* resolution and dependency injection.
+	*/
+	#app;
+	/**
+	* Global middleware registered on the router that applies to this route.
+	*/
+	#routerMiddleware;
+	/**
+	* The domain this route belongs to. Defaults to 'root' when no specific
+	* domain is configured.
+	*/
+	#routeDomain = "root";
+	/**
+	* Route-specific parameter matchers that validate dynamic segments.
+	* Populated via the where() method and takes precedence over global matchers.
+	*/
+	#matchers = {};
+	/**
+	* Stack of URL prefixes applied to this route, typically inherited from
+	* route groups. Prefixes are applied in reverse order during pattern computation.
+	*/
+	#prefixes = [];
+	/**
+	* Multi-dimensional array of middleware, where each nested array represents
+	* a layer in the middleware stack. This structure maintains the order of
+	* middleware application from groups and direct assignments.
+	*/
+	#middleware = [];
+	/**
+	* Creates a new Route instance
+	* @param app - The AdonisJS application instance
+	* @param routerMiddleware - Array of global middleware registered on the router
+	* @param options - Configuration options for the route
+	*/
+	constructor(app, routerMiddleware, options) {
+		super();
+		this.#app = app;
+		this.#routerMiddleware = routerMiddleware;
+		this.#pattern = options.pattern;
+		this.#methods = options.methods;
+		this.#globalMatchers = options.globalMatchers;
+		const { handler, routeName } = this.#resolveRouteHandle(options.handler);
+		this.#handler = handler;
+		this.#name = routeName;
+	}
+	/**
+	* Resolves the route handler from various input formats into a normalized
+	* StoreRouteHandler object. Supports string references, inline functions,
+	* class constructors, and lazy imports.
+	*
+	* @param handler - The handler in one of the supported formats:
+	*   - String: 'Controller.method' or 'Controller' (defaults to 'handle')
+	*   - Function: Inline route handler function
+	*   - Tuple: [Controller class or lazy import, optional method name]
+	*/
+	#resolveRouteHandle(handler) {
+		/**
+		* Convert magic string to handle method call
+		*/
+		if (typeof handler === "string") {
+			const parts = handler.split(".");
+			const method = parts.length === 1 ? "handle" : parts.pop();
+			const moduleRefId = parts.join(".");
+			const controllerName = new StringBuilder(moduleRefId.split("/").pop()).removeSuffix("controller").snakeCase();
+			return {
+				handler: {
+					method,
+					reference: handler,
+					importExpression: moduleRefId,
+					...moduleImporter(() => this.#app.import(moduleRefId), method).toHandleMethod(),
+					name: handler
+				},
+				routeName: method === "handle" ? controllerName.toString() : `${controllerName}.${string.snakeCase(method)}`
+			};
+		}
+		/**
+		* Using a lazily imported controller
+		*/
+		if (Array.isArray(handler)) {
+			const controller = handler[0];
+			const method = handler[1] ?? "handle";
+			/**
+			* The first item of the tuple is a class constructor
+			*/
+			if (is.class(controller)) {
+				const controllerName = new StringBuilder(controller.name).removeSuffix("controller").snakeCase();
+				return {
+					handler: {
+						method,
+						reference: handler,
+						importExpression: null,
+						...moduleCaller(controller, method).toHandleMethod()
+					},
+					routeName: method === "handle" ? controllerName.toString() : `${controllerName}.${string.snakeCase(method)}`
+				};
+			}
+			const controllerName = controller.name ? new StringBuilder(controller.name).removeSuffix("controller").snakeCase() : void 0;
+			/**
+			* The first item of the tuple is a function that lazily
+			* loads the controller
+			*/
+			return {
+				handler: {
+					method,
+					reference: handler,
+					importExpression: String(controller),
+					...moduleImporter(controller, method).toHandleMethod()
+				},
+				routeName: controllerName ? method === "handle" ? controllerName.toString() : `${controllerName}.${string.snakeCase(method)}` : void 0
+			};
+		}
+		return { handler };
+	}
+	/**
+	* Merges global and route-specific parameter matchers into a single object.
+	* Local matchers take precedence over global matchers when conflicts occur.
+	*/
+	#getMatchers() {
+		return {
+			...this.#globalMatchers,
+			...this.#matchers
+		};
+	}
+	/**
+	* Computes the final route pattern by applying all prefixes from route groups.
+	* Prefixes are applied in reverse order (innermost group first) and normalized
+	* to remove leading/trailing slashes.
+	*/
+	#computePattern() {
+		const pattern = dropSlash(this.#pattern);
+		const prefix = this.#prefixes.slice().reverse().map((one) => dropSlash(one)).join("");
+		return prefix ? `${prefix}${pattern === "/" ? "" : pattern}` : pattern;
+	}
+	/**
+	* Returns the route's handler configuration object.
+	*/
+	getHandler() {
+		return this.#handler;
+	}
+	/**
+	* Defines a validation matcher for a route parameter. Route-level matchers
+	* take precedence over group-level matchers to ensure routes can override
+	* group constraints.
+	*
+	* @param param - The name of the route parameter to validate
+	* @param matcher - The validation pattern as a string, RegExp, or RouteMatcher object
+	*
+	* @example
+	* ```ts
+	* // Validate that 'id' is numeric
+	* route.where('id', /^[0-9]+$/)
+	*
+	* // Using a string pattern
+	* route.where('slug', '[a-z0-9-]+')
+	*
+	* // Route matcher takes precedence over group matcher
+	* Route.group(() => {
+	*   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
+	* }).where('id', /[^a-z$]/)
+	* // The route's /^[0-9]$/ wins over the group's matcher
+	* ```
+	*/
+	where(param, matcher) {
+		if (this.#matchers[param]) return this;
+		if (typeof matcher === "string") this.#matchers[param] = { match: new RegExp(matcher) };
+		else if (is.regExp(matcher)) this.#matchers[param] = { match: matcher };
+		else this.#matchers[param] = matcher;
+		return this;
+	}
+	/**
+	* Adds a URL prefix to the route pattern. Multiple calls stack prefixes
+	* which are applied in reverse order during pattern computation.
+	*
+	* @param prefix - The URL prefix to prepend to the route pattern
+	*
+	* @example
+	* ```ts
+	* route.prefix('/api').prefix('/v1')
+	* // Results in pattern: /v1/api/users (for original pattern /users)
+	* ```
+	*/
+	prefix(prefix) {
+		this.#prefixes.push(prefix);
+		return this;
+	}
+	/**
+	* Assigns a custom domain to the route. By default, routes belong to the
+	* 'root' domain. Once set, the domain is not overwritten unless the
+	* overwrite flag is true.
+	*
+	* @param domain - The domain identifier for this route
+	* @param overwrite - Whether to overwrite an existing non-root domain
+	*
+	* @example
+	* ```ts
+	* route.domain('api.example.com')
+	*
+	* // Overwrite existing domain
+	* route.domain('new.example.com', true)
+	* ```
+	*/
+	domain(domain, overwrite = false) {
+		if (this.#routeDomain === "root" || overwrite) this.#routeDomain = domain;
+		return this;
+	}
+	/**
+	* Registers one or more middleware to execute before the route handler.
+	* Middleware can be inline functions or named middleware references registered
+	* with the router's middleware store.
+	*
+	* @param middleware - Single middleware or array of middleware to apply
+	*
+	* @example
+	* ```ts
+	* // Single middleware
+	* route.use(async (ctx, next) => {
+	*   console.log('Before handler')
+	*   await next()
+	* })
+	*
+	* // Multiple middleware
+	* route.use(['auth', 'admin'])
+	* ```
+	*/
+	use(middleware) {
+		this.#middleware.push(Array.isArray(middleware) ? middleware : [middleware]);
+		return this;
+	}
+	/**
+	* Alias for the {@link Route.use} method.
+	*
+	* @param middleware - Single middleware or array of middleware to apply
+	*/
+	middleware(middleware) {
+		return this.use(middleware);
+	}
+	/**
+	* Assigns a unique name to the route for use in URL generation and route
+	* referencing. Assigning a new name replaces any existing name unless
+	* prepend is true.
+	*
+	* @param name - The route name to assign
+	* @param prepend - If true, prepends the name to the existing name with a dot separator
+	*
+	* @example
+	* ```ts
+	* // Set route name
+	* route.as('users.show')
+	*
+	* // Prepend to existing name (typically used by route groups)
+	* route.as('admin', true) // Results in 'admin.users.show'
+	* ```
+	*/
+	as(name, prepend = false) {
+		if (prepend) {
+			if (!this.#name) throw new RuntimeException(`Routes inside a group must have names before calling "router.group.as"`);
+			this.#name = `${name}.${this.#name}`;
+			return this;
+		}
+		this.#name = name;
+		return this;
+	}
+	/**
+	* Checks whether the route has been marked for deletion. Deleted routes
+	* are excluded from the route store during registration.
+	*/
+	isDeleted() {
+		return this.#isDeleted;
+	}
+	/**
+	* Marks the route for deletion. Deleted routes will not be registered
+	* with the route store when Router.commit() is called.
+	*
+	* @example
+	* ```ts
+	* const route = Route.get('/admin', 'handler')
+	* route.markAsDeleted()
+	* // This route will not be registered
+	* ```
+	*/
+	markAsDeleted() {
+		this.#isDeleted = true;
+	}
+	/**
+	* Returns the unique name assigned to the route, if any.
+	*/
+	getName() {
+		return this.#name;
+	}
+	/**
+	* Returns the route's URL pattern with dynamic parameters.
+	*/
+	getPattern() {
+		return this.#pattern;
+	}
+	/**
+	* Updates the route's URL pattern.
+	*
+	* @param pattern - The new URL pattern to assign to the route
+	*
+	* @example
+	* ```ts
+	* route.setPattern('/users/:id/posts/:postId')
+	* ```
+	*/
+	setPattern(pattern) {
+		this.#pattern = pattern;
+		return this;
+	}
+	/**
+	* Returns the multi-dimensional middleware stack registered on this route.
+	* The returned value is shared by reference, not a copy.
+	*/
+	getMiddleware() {
+		return this.#middleware;
+	}
+	/**
+	* Constructs a frozen Middleware instance for storage. This combines global
+	* router middleware with route-specific middleware in the correct execution order.
+	* The middleware is frozen to prevent modifications after route registration.
+	*/
+	#getMiddlewareForStore() {
+		const middleware = new Middleware();
+		this.#routerMiddleware.forEach((one) => {
+			debug_default("adding global middleware to route %s, %O", this.#pattern, one);
+			middleware.add(one);
+		});
+		this.#middleware.flat().forEach((one) => {
+			debug_default("adding named middleware to route %s, %O", this.#pattern, one);
+			middleware.add(one);
+		});
+		middleware.freeze();
+		return middleware;
+	}
+	/**
+	* Serializes the route into a JSON representation suitable for storage and
+	* execution. This includes the computed pattern with prefixes, merged matchers,
+	* parsed route tokens, and frozen middleware stack.
+	*
+	* @example
+	* ```ts
+	* const json = route.toJSON()
+	* console.log(json.pattern) // '/api/users/:id'
+	* console.log(json.methods) // ['GET']
+	* console.log(json.name) // 'users.show'
+	* ```
+	*/
+	toJSON() {
+		const pattern = this.#computePattern();
+		const matchers = this.#getMatchers();
+		return {
+			domain: this.#routeDomain,
+			pattern,
+			matchers,
+			tokens: parseRoute(pattern, matchers),
+			meta: {},
+			name: this.#name,
+			handler: this.#handler,
+			methods: this.#methods,
+			middleware: this.#getMiddlewareForStore(),
+			execute
+		};
+	}
+};
+//#endregion
+//#region src/router/brisk.ts
+/**
+* Brisk routes exposes the API to configure the route handler by chaining
+* one of the pre-defined methods.
+*
+* For example: Instead of defining the redirect logic as a callback, one can
+* chain the `.redirect` method.
+*
+* Brisk routes are always registered under the `GET` HTTP method.
+*/
+var BriskRoute = class extends Macroable {
+	/**
+	* Route pattern
+	*/
+	#pattern;
+	/**
+	* Matchers inherited from the router
+	*/
+	#globalMatchers;
+	/**
+	* Reference to the AdonisJS application
+	*/
+	#app;
+	/**
+	* Middleware registered on the router
+	*/
+	#routerMiddleware;
+	/**
+	* Reference to route instance. Set after `setHandler` is called
+	*/
+	route = null;
+	/**
+	* Creates a new BriskRoute instance
+	* @param app - The AdonisJS application instance
+	* @param routerMiddleware - Array of global middleware registered on the router
+	* @param options - Configuration options for the brisk route
+	*/
+	constructor(app, routerMiddleware, options) {
+		super();
+		this.#app = app;
+		this.#routerMiddleware = routerMiddleware;
+		this.#pattern = options.pattern;
+		this.#globalMatchers = options.globalMatchers;
+	}
+	/**
+	* Set handler for the brisk route
+	* @param handler - The route handler function
+	* @returns The created route instance
+	*/
+	setHandler(handler) {
+		this.route = new Route(this.#app, this.#routerMiddleware, {
+			pattern: this.#pattern,
+			globalMatchers: this.#globalMatchers,
+			methods: ["GET", "HEAD"],
+			handler
+		});
+		return this.route;
+	}
+	/**
+	* Redirects to a given route. Params from the original request will
+	* be used when no custom params are defined.
+	* @param args - Route identifier, parameters, and options for building the redirect URL
+	* @returns The created route instance
+	*/
+	redirect(...args) {
+		const [identifier, params, options] = args;
+		function redirectsToRoute(ctx) {
+			const redirector = ctx.response.redirect();
+			if (options?.status) redirector.status(options.status);
+			return redirector.toRoute(identifier, params || ctx.params, options);
+		}
+		Object.defineProperty(redirectsToRoute, "listArgs", {
+			value: identifier,
+			writable: false
+		});
+		return this.setHandler(redirectsToRoute);
+	}
+	/**
+	* Redirect request to a fixed URL
+	* @param url - The URL to redirect to
+	* @param options - Optional redirect options including HTTP status code
+	* @returns The created route instance
+	*/
+	redirectToPath(url, options) {
+		function redirectsToPath(ctx) {
+			const redirector = ctx.response.redirect();
+			if (options?.status) redirector.status(options.status);
+			return redirector.toPath(url);
+		}
+		Object.defineProperty(redirectsToPath, "listArgs", {
+			value: url,
+			writable: false
+		});
+		return this.setHandler(redirectsToPath);
+	}
+};
+//#endregion
+//#region src/router/resource.ts
+/**
+* Route resource exposes the API to register multiple routes for a resource.
+*/
+var RouteResource = class extends Macroable {
+	/**
+	* Resource identifier. Nested resources are separated
+	* with a dot notation
+	*/
+	#resource;
+	/**
+	* The controller to handle resource routing requests
+	*/
+	#controller;
+	/**
+	* Is it a shallow resource? Shallow resources URLs do not have parent
+	* resource name and id once they can be identified with the id.
+	*/
+	#shallow = false;
+	/**
+	* Matchers inherited from the router
+	*/
+	#globalMatchers;
+	/**
+	* Reference to the AdonisJS application
+	*/
+	#app;
+	/**
+	* Middleware registered on the router
+	*/
+	#routerMiddleware;
+	/**
+	* Parameter names for the resources. Defaults to `id` for
+	* a singular resource and `resource_id` for nested
+	* resources.
+	*/
+	#params = {};
+	/**
+	* Base name for the routes. We suffix action names
+	* on top of the base name
+	*/
+	#routesBaseName;
+	/**
+	* A collection of routes instances that belongs to this resource
+	*/
+	routes = [];
+	/**
+	* Creates a new RouteResource instance
+	* @param app - The AdonisJS application instance
+	* @param routerMiddleware - Array of global middleware registered on the router
+	* @param options - Configuration options for the route resource
+	*/
+	constructor(app, routerMiddleware, options) {
+		super();
+		this.#validateResourceName(options.resource);
+		this.#app = app;
+		this.#shallow = options.shallow;
+		this.#routerMiddleware = routerMiddleware;
+		this.#controller = options.controller;
+		this.#globalMatchers = options.globalMatchers;
+		this.#resource = this.#normalizeResourceName(options.resource);
+		this.#routesBaseName = this.#getRoutesBaseName();
+		this.#buildRoutes();
+	}
+	/**
+	* Normalizes the resource name to dropping leading and trailing
+	* slashes.
+	*/
+	#normalizeResourceName(resource) {
+		return resource.replace(/^\//, "").replace(/\/$/, "");
+	}
+	/**
+	* Ensure resource name is not an empty string
+	*/
+	#validateResourceName(resource) {
+		if (!resource || resource === "/") throw new RuntimeException(`Invalid resource name "${resource}"`);
+	}
+	/**
+	* Converting segments of a resource to snake case to
+	* make the route name.
+	*/
+	#getRoutesBaseName() {
+		return this.#resource.split(".").map((token) => string.snakeCase(token)).join(".");
+	}
+	/**
+	* Create a new route for the given pattern, methods and controller action
+	*/
+	#createRoute(pattern, methods, action) {
+		const route = new Route(this.#app, this.#routerMiddleware, {
+			pattern,
+			methods,
+			handler: typeof this.#controller === "string" ? `${this.#controller}.${action}` : [this.#controller, action],
+			globalMatchers: this.#globalMatchers
+		});
+		route.as(`${this.#routesBaseName}.${action}`);
+		this.routes.push(route);
+	}
+	/**
+	* Returns the `resource_id` name for a given resource. The
+	* resource name is converted to singular form and
+	* transformed to snake case.
+	*
+	* photos becomes photo_id
+	* users becomes user_id
+	*/
+	#getResourceId(resource) {
+		return `${string.snakeCase(string.singular(resource))}_id`;
+	}
+	/**
+	* Build routes for the given resource
+	*/
+	#buildRoutes() {
+		const resources = this.#resource.split(".");
+		const mainResource = resources.pop();
+		this.#params[mainResource] = ":id";
+		const baseURI = `${resources.map((resource) => {
+			const paramName = `:${this.#getResourceId(resource)}`;
+			this.#params[resource] = paramName;
+			return `${resource}/${paramName}`;
+		}).join("/")}/${mainResource}`;
+		this.#createRoute(baseURI, ["GET", "HEAD"], "index");
+		this.#createRoute(`${baseURI}/create`, ["GET", "HEAD"], "create");
+		this.#createRoute(baseURI, ["POST"], "store");
+		this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["GET", "HEAD"], "show");
+		this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id/edit`, ["GET", "HEAD"], "edit");
+		this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["PUT", "PATCH"], "update");
+		this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["DELETE"], "destroy");
+	}
+	/**
+	* Filter the routes based on their partial names
+	*/
+	#filter(names, inverse) {
+		const actions = Array.isArray(names) ? names : [names];
+		return this.routes.filter((route) => {
+			const match = actions.find((name) => route.getName().endsWith(name));
+			return inverse ? !match : match;
+		});
+	}
+	/**
+	* Register only given routes and remove others
+	* @param names - Array of action names to keep
+	* @returns Current RouteResource instance with filtered actions
+	*/
+	only(names) {
+		this.#filter(names, true).forEach((route) => route.markAsDeleted());
+		return this;
+	}
+	/**
+	* Register all routes, except the one's defined
+	* @param names - Array of action names to exclude
+	* @returns Current RouteResource instance with filtered actions
+	*/
+	except(names) {
+		this.#filter(names, false).forEach((route) => route.markAsDeleted());
+		return this;
+	}
+	/**
+	* Register api only routes. The `create` and `edit` routes, which
+	* are meant to show forms will not be registered
+	* @returns Current RouteResource instance without create and edit actions
+	*/
+	apiOnly() {
+		return this.except(["create", "edit"]);
+	}
+	/**
+	* Define matcher for params inside the resource
+	* @param key - The parameter name to match
+	* @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
+	* @returns Current RouteResource instance for method chaining
+	*/
+	where(key, matcher) {
+		this.routes.forEach((route) => {
+			route.where(key, matcher);
+		});
+		return this;
+	}
+	tap(actions, callback) {
+		if (typeof actions === "function") {
+			this.routes.forEach((route) => {
+				if (!route.isDeleted()) actions(route);
+			});
+			return this;
+		}
+		this.#filter(actions, false).forEach((route) => {
+			if (!route.isDeleted()) callback(route);
+		});
+		return this;
+	}
+	/**
+	* Set the param name for a given resource
+	* @param resources - Object mapping resource names to parameter names
+	* @returns Current RouteResource instance for method chaining
+	*/
+	params(resources) {
+		Object.keys(resources).forEach((resource) => {
+			const param = resources[resource];
+			const existingParam = this.#params[resource];
+			this.#params[resource] = `:${param}`;
+			this.routes.forEach((route) => {
+				route.setPattern(route.getPattern().replace(`${resource}/${existingParam}`, `${resource}/:${param}`));
+			});
+		});
+		return this;
+	}
+	/**
+	* Define one or more middleware on the routes created by
+	* the resource.
+	*
+	* Calling this method multiple times will append middleware
+	* to existing list.
+	* @param actions - Action name(s) or '*' for all actions
+	* @param middleware - Middleware function(s) to apply
+	* @returns Current RouteResource instance for method chaining
+	*/
+	use(actions, middleware) {
+		if (actions === "*") this.tap((route) => route.use(middleware));
+		else this.tap(actions, (route) => route.use(middleware));
+		return this;
+	}
+	/**
+	* Alias for {@link RouteResource.use}
+	* @param actions - Action name(s) or '*' for all actions
+	* @param middleware - Middleware function(s) to apply
+	* @returns Current RouteResource instance for method chaining
+	*/
+	middleware(actions, middleware) {
+		return this.use(actions, middleware);
+	}
+	/**
+	* Prepend name to all the routes
+	* @param name - The name to prepend to all route names
+	* @param normalizeName - Whether to normalize the name to snake_case
+	* @returns Current RouteResource instance for method chaining
+	*/
+	as(name, normalizeName = true) {
+		name = normalizeName ? string.snakeCase(name) : name;
+		this.routes.forEach((route) => {
+			route.as(route.getName().replace(this.#routesBaseName, name), false);
+		});
+		this.#routesBaseName = name;
+		return this;
+	}
+};
+//#endregion
+//#region src/router/group.ts
+/**
+* Group class exposes the API to take action on a group of routes.
+* The group routes must be pre-defined using the constructor.
+*/
+var RouteGroup = class RouteGroup extends Macroable {
+	/**
+	* Array of middleware registered on the group.
+	*/
+	#middleware = [];
+	/**
+	* Creates a new RouteGroup instance
+	* @param routes - Array of routes that belong to this group
+	*/
+	constructor(routes) {
+		super();
+		this.routes = routes;
+	}
+	/**
+	* Shares midldeware stack with the routes. The method is invoked recursively
+	* to only register middleware with the route class and not with the
+	* resource or the child group
+	*/
+	#shareMiddlewareStackWithRoutes(route) {
+		if (route instanceof RouteGroup) {
+			route.routes.forEach((child) => this.#shareMiddlewareStackWithRoutes(child));
+			return;
+		}
+		if (route instanceof RouteResource) {
+			route.routes.forEach((child) => child.getMiddleware().unshift(this.#middleware));
+			return;
+		}
+		if (route instanceof BriskRoute) {
+			route.route.getMiddleware().unshift(this.#middleware);
+			return;
+		}
+		route.getMiddleware().unshift(this.#middleware);
+	}
+	/**
+	* Updates the route name. The method is invoked recursively to only update
+	* the name with the route class and not with the resource or the child
+	* group.
+	*/
+	#updateRouteName(route, name) {
+		if (route instanceof RouteGroup) {
+			route.routes.forEach((child) => this.#updateRouteName(child, name));
+			return;
+		}
+		if (route instanceof RouteResource) {
+			route.routes.forEach((child) => child.as(name, true));
+			return;
+		}
+		if (route instanceof BriskRoute) {
+			route.route.as(name, true);
+			return;
+		}
+		route.as(name, true);
+	}
+	/**
+	* Sets prefix on the route. The method is invoked recursively to only set
+	* the prefix with the route class and not with the resource or the
+	* child group.
+	*/
+	#setRoutePrefix(route, prefix) {
+		if (route instanceof RouteGroup) {
+			route.routes.forEach((child) => this.#setRoutePrefix(child, prefix));
+			return;
+		}
+		if (route instanceof RouteResource) {
+			route.routes.forEach((child) => child.prefix(prefix));
+			return;
+		}
+		if (route instanceof BriskRoute) {
+			route.route.prefix(prefix);
+			return;
+		}
+		route.prefix(prefix);
+	}
+	/**
+	* Updates domain on the route. The method is invoked recursively to only update
+	* the domain with the route class and not with the resource or the child
+	* group.
+	*/
+	#updateRouteDomain(route, domain) {
+		if (route instanceof RouteGroup) {
+			route.routes.forEach((child) => this.#updateRouteDomain(child, domain));
+			return;
+		}
+		if (route instanceof RouteResource) {
+			route.routes.forEach((child) => child.domain(domain));
+			return;
+		}
+		if (route instanceof BriskRoute) {
+			route.route.domain(domain, false);
+			return;
+		}
+		route.domain(domain, false);
+	}
+	/**
+	* Updates matchers on the route. The method is invoked recursively to only update
+	* the matchers with the route class and not with the resource or the child
+	* group.
+	*/
+	#updateRouteMatchers(route, param, matcher) {
+		if (route instanceof RouteGroup) {
+			route.routes.forEach((child) => this.#updateRouteMatchers(child, param, matcher));
+			return;
+		}
+		if (route instanceof RouteResource) {
+			route.routes.forEach((child) => child.where(param, matcher));
+			return;
+		}
+		if (route instanceof BriskRoute) {
+			route.route.where(param, matcher);
+			return;
+		}
+		route.where(param, matcher);
+	}
+	/**
+	* Define route param matcher
+	*
+	* ```ts
+	* Route.group(() => {
+	* }).where('id', /^[0-9]+/)
+	* ```
+	* @param param - The parameter name to match
+	* @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
+	* @returns Current RouteGroup instance for method chaining
+	*/
+	where(param, matcher) {
+		this.routes.forEach((route) => this.#updateRouteMatchers(route, param, matcher));
+		return this;
+	}
+	/**
+	* Define prefix all the routes in the group.
+	*
+	* ```ts
+	* Route.group(() => {
+	* }).prefix('v1')
+	* ```
+	* @param prefix - The prefix to add to all routes in the group
+	* @returns Current RouteGroup instance for method chaining
+	*/
+	prefix(prefix) {
+		this.routes.forEach((route) => this.#setRoutePrefix(route, prefix));
+		return this;
+	}
+	/**
+	* Define domain for all the routes.
+	*
+	* ```ts
+	* Route.group(() => {
+	* }).domain(':name.adonisjs.com')
+	* ```
+	* @param domain - The domain pattern for all routes in the group
+	* @returns Current RouteGroup instance for method chaining
+	*/
+	domain(domain) {
+		this.routes.forEach((route) => this.#updateRouteDomain(route, domain));
+		return this;
+	}
+	/**
+	* Prepend name to the routes name.
+	*
+	* ```ts
+	* Route.group(() => {
+	* }).as('version1')
+	* ```
+	* @param name - The name to prepend to all route names in the group
+	* @returns Current RouteGroup instance for method chaining
+	*/
+	as(name) {
+		this.routes.forEach((route) => this.#updateRouteName(route, name));
+		return this;
+	}
+	/**
+	* Prepend an array of middleware to all routes middleware.
+	*
+	* ```ts
+	* Route.group(() => {
+	* }).use(middleware.auth())
+	* ```
+	* @param middleware - Middleware function(s) to apply to all routes in the group
+	* @returns Current RouteGroup instance for method chaining
+	*/
+	use(middleware) {
+		/**
+		* Register middleware with children. We share the group middleware
+		* array by reference, therefore have to register it only for the
+		* first time.
+		*/
+		if (!this.#middleware.length) this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route));
+		if (Array.isArray(middleware)) for (let one of middleware) this.#middleware.push(one);
+		else this.#middleware.push(middleware);
+		return this;
+	}
+	/**
+	* Alias for {@link RouteGroup.use}
+	* @param middleware - Middleware function(s) to apply to all routes in the group
+	* @returns Current RouteGroup instance for method chaining
+	*/
+	middleware(middleware) {
+		return this.use(middleware);
+	}
+};
+//#endregion
+//#region src/utils.ts
+const proxyCache = new Cache({ max: 200 });
+/**
+* Makes input string consistent by having only the starting slash.
+*
+* Removes trailing slashes and ensures the path starts with a forward slash,
+* except for the root path '/' which remains unchanged.
+*
+* @param input - The input path string to normalize
+*
+* @example
+* ```ts
+* dropSlash('/users/') // '/users'
+* dropSlash('users') // '/users'
+* dropSlash('/') // '/'
+* ```
+*/
+function dropSlash(input) {
+	if (input === "/") return "/";
+	return `/${input.replace(/^\//, "").replace(/\/$/, "")}`;
+}
+/**
+* Returns a flat list of routes from route groups, resources, and brisk routes.
+*
+* This function recursively processes route collections, extracting individual routes
+* from groups and resources while filtering out any deleted routes.
+*
+* @param routes - Array containing route groups, individual routes, resources, and brisk routes
+*
+* @example
+* ```ts
+* const flatRoutes = toRoutesJSON([
+*   routeGroup,
+*   singleRoute,
+*   resourceRoutes
+* ])
+* ```
+*/
+function toRoutesJSON(routes) {
+	return routes.reduce((list, route) => {
+		if (route instanceof RouteGroup) {
+			list = list.concat(toRoutesJSON(route.routes));
+			return list;
+		}
+		if (route instanceof RouteResource) {
+			list = list.concat(toRoutesJSON(route.routes));
+			return list;
+		}
+		if (route instanceof BriskRoute) {
+			if (route.route && !route.route.isDeleted()) list.push(route.route.toJSON());
+			return list;
+		}
+		if (!route.isDeleted()) list.push(route.toJSON());
+		return list;
+	}, []);
+}
+/**
+* Helper to determine if a remote address should be trusted.
+*
+* Uses caching to avoid repeated expensive proxy function calls for the same
+* remote address. The cache improves performance when the same addresses are
+* checked multiple times.
+*
+* @param remoteAddress - The remote IP address to check
+* @param proxyFn - Function that determines if an address should be trusted
+*
+* @example
+* ```ts
+* const isTrusted = trustProxy('192.168.1.1', proxyAddr.compile('loopback'))
+* ```
+*/
+function trustProxy(remoteAddress, proxyFn) {
+	if (proxyCache.has(remoteAddress)) return proxyCache.get(remoteAddress);
+	const result = proxyFn(remoteAddress, 0);
+	proxyCache.set(remoteAddress, result);
+	return result;
+}
+/**
+* Parses a range expression (e.g., '200..299') into an object with numeric keys.
+*
+* Supports both single values and ranges. For ranges, all numbers between
+* the start and end (inclusive) are mapped to the provided value.
+*
+* @param range - Range expression as a string (e.g., '200', '200..299')
+* @param value - Value to assign to each number in the range
+*
+* @example
+* ```ts
+* parseRange('200', 'success') // { 200: 'success' }
+* parseRange('200..202', 'success') // { 200: 'success', 201: 'success', 202: 'success' }
+* ```
+*/
+function parseRange(range, value) {
+	const parts = range.split("..");
+	const min = Number(parts[0]);
+	const max = Number(parts[1]);
+	/**
+	* The ending status code does not exists
+	*/
+	if (parts.length === 1 && !Number.isNaN(min)) return { [min]: value };
+	/**
+	* The starting status code is not a number
+	*/
+	if (Number.isNaN(min) || Number.isNaN(max)) return {};
+	/**
+	* Min and max are same
+	*/
+	if (min === max) return { [min]: value };
+	/**
+	* Max cannot be smaller than min
+	*/
+	if (max < min) throw new InvalidArgumentsException(`Invalid range "${range}"`);
+	/**
+	* Loop over the range and create a collection
+	* of status codes
+	*/
+	return [...Array(max - min + 1).keys()].reduce((result, step) => {
+		result[min + step] = value;
+		return result;
+	}, {});
+}
+/**
+* Decodes specific percent-encoded characters in URI components.
+*
+* This function handles decoding of specific character codes that are commonly
+* percent-encoded in URIs, such as %, #, $, &, +, etc.
+*
+* @param highCharCode - The high character code of the hex pair
+* @param lowCharCode - The low character code of the hex pair
+*/
+function decodeComponentChar(highCharCode, lowCharCode) {
+	if (highCharCode === 50) {
+		if (lowCharCode === 53) return "%";
+		if (lowCharCode === 51) return "#";
+		if (lowCharCode === 52) return "$";
+		if (lowCharCode === 54) return "&";
+		if (lowCharCode === 66) return "+";
+		if (lowCharCode === 98) return "+";
+		if (lowCharCode === 67) return ",";
+		if (lowCharCode === 99) return ",";
+		if (lowCharCode === 70) return "/";
+		if (lowCharCode === 102) return "/";
+		return null;
+	}
+	if (highCharCode === 51) {
+		if (lowCharCode === 65) return ":";
+		if (lowCharCode === 97) return ":";
+		if (lowCharCode === 66) return ";";
+		if (lowCharCode === 98) return ";";
+		if (lowCharCode === 68) return "=";
+		if (lowCharCode === 100) return "=";
+		if (lowCharCode === 70) return "?";
+		if (lowCharCode === 102) return "?";
+		return null;
+	}
+	if (highCharCode === 52 && lowCharCode === 48) return "@";
+	return null;
+}
+/**
+* Safely decodes a URI path while handling special characters and query strings.
+*
+* This function carefully parses and decodes URI components, handling edge cases
+* like double-encoded characters and non-standard query string delimiters.
+* It separates the pathname from query parameters and determines whether
+* route parameters should be decoded.
+*
+* @param path - The URI path to decode
+* @param useSemicolonDelimiter - Whether to treat semicolons as query string delimiters
+*
+* @example
+* ```ts
+* const result = safeDecodeURI('/users/123?name=john', false)
+* // Returns: { pathname: '/users/123', query: 'name=john', shouldDecodeParam: false }
+* ```
+*/
+function safeDecodeURI(path, useSemicolonDelimiter) {
+	let shouldDecode = false;
+	let shouldDecodeParam = false;
+	let querystring = "";
+	for (let i = 1; i < path.length; i++) {
+		const charCode = path.charCodeAt(i);
+		if (charCode === 37) {
+			const highCharCode = path.charCodeAt(i + 1);
+			const lowCharCode = path.charCodeAt(i + 2);
+			if (decodeComponentChar(highCharCode, lowCharCode) === null) shouldDecode = true;
+			else {
+				shouldDecodeParam = true;
+				if (highCharCode === 50 && lowCharCode === 53) {
+					shouldDecode = true;
+					path = path.slice(0, i + 1) + "25" + path.slice(i + 1);
+					i += 2;
+				}
+				i += 2;
+			}
+		} else if (charCode === 63 || charCode === 35 || charCode === 59 && useSemicolonDelimiter) {
+			querystring = path.slice(i + 1);
+			path = path.slice(0, i);
+			break;
+		}
+	}
+	return {
+		pathname: shouldDecode ? decodeURI(path) : path,
+		query: querystring,
+		shouldDecodeParam
+	};
+}
+//#endregion
+//#region src/helpers.ts
+/**
+* Parse a route pattern into an array of tokens. These tokes can be used
+* to match routes, or print them with semantic information.
+*
+* Token types
+*
+* - 0: (static) segment
+* - 1: (parameter) segment
+* - 2: (wildcard) segment
+* - 3: (optional parameter) segment
+*
+* Value (val) refers to the segment value
+*
+* end refers to be the suffix or the segment (if any)
+*
+* @param pattern - The route pattern to parse
+* @param matchers - Optional route matchers
+* @returns {MatchItRouteToken[]} Array of parsed route tokens
+*/
+function parseRoute(pattern, matchers) {
+	return matchit.parse(pattern, matchers);
+}
+/**
+* Makes signed URL for a given route pattern using its parsed tokens. The
+* tokens could be generated using the "parseRoute" method.
+*
+* @param identifier - Route identifier
+* @param tokens - Array of parsed route tokens
+* @param searchParamsStringifier - Function to stringify query parameters
+* @param encryption - Encryption instance for signing
+* @param params - Route parameters as array or object
+* @param options - Signed URL options
+* @returns {string} The generated signed URL
+*/
+function createSignedURL(identifier, tokens, searchParamsStringifier, encryption, params, options) {
+	const signature = encryption.getMessageVerifier().sign(createURL(identifier, tokens, searchParamsStringifier, params, {
+		...options,
+		prefixUrl: void 0
+	}), options?.expiresIn, options?.purpose);
+	return createURL(identifier, tokens, searchParamsStringifier, params, {
+		...options,
+		qs: {
+			...options?.qs,
+			signature
+		}
+	});
+}
+/**
+* Match a given URI with an array of patterns and extract the params
+* from the URL. Null value is returned in case of no match
+*
+* @param url - The URL to match
+* @param patterns - Array of route patterns to match against
+* @returns {null | Record<string, string>} Extracted parameters or null if no match
+*/
+function matchRoute(url, patterns) {
+	const tokensBucket = patterns.map((pattern) => parseRoute(pattern));
+	const match = matchit.match(url, tokensBucket);
+	if (!match.length) return null;
+	return matchit.exec(url, match);
+}
+/**
+* Serialize the value of a cookie to a string you can send via
+* set-cookie response header.
+*
+* @param key - Cookie name
+* @param value - Cookie value
+* @param options - Cookie options
+* @returns {string} Serialized cookie string
+*/
+function serializeCookie(key, value, options) {
+	let expires;
+	let maxAge;
+	if (options) {
+		expires = typeof options.expires === "function" ? options.expires() : options.expires;
+		maxAge = options.maxAge ? string.seconds.parse(options.maxAge) : void 0;
+	}
+	return serialize(key, value, {
+		...options,
+		maxAge,
+		expires
+	});
+}
+/**
+* Returns the info about a middleware handler. In case of lazy imports, the method
+* will return the import path
+*
+* @param middleware - The middleware function or parsed middleware
+* @returns {Promise<MiddlewareHandlerInfo>} Promise resolving to middleware handler information
+*/
+async function middlewareInfo(middleware) {
+	if (typeof middleware === "function") return {
+		type: "closure",
+		name: middleware.name || "closure"
+	};
+	if ("args" in middleware) return {
+		type: "named",
+		name: middleware.name,
+		args: middleware.args,
+		...await parseBindingReference([middleware.reference])
+	};
+	return {
+		type: "global",
+		name: middleware.name,
+		...await parseBindingReference([middleware.reference])
+	};
+}
+/**
+* Returns the info about a route handler. In case of lazy imports, the method
+* will return the import path.
+*
+* @param route - The route JSON object
+* @returns {Promise<RouteHandlerInfo>} Promise resolving to route handler information
+*/
+async function routeInfo(route) {
+	return "reference" in route.handler ? {
+		type: "controller",
+		...await parseBindingReference(route.handler.reference)
+	} : {
+		type: "closure",
+		name: route.handler.name || "closure",
+		args: "listArgs" in route.handler ? String(route.handler.listArgs) : void 0
+	};
+}
+/**
+* Appends query string parameters to a URI. Existing query parameters
+* in the URI are merged with the new ones.
+*
+* @param uri - The base URI to append query string to
+* @param queryString - Object containing query parameters to append
+* @param qsParser - Query string parser instance for stringify/parse operations
+*
+* @example
+* ```ts
+* const result = appendQueryString('/users', { page: 1, limit: 10 }, qsParser)
+* // Returns: '/users?page=1&limit=10'
+*
+* const result2 = appendQueryString('/users?sort=name', { page: 1 }, qsParser)
+* // Returns: '/users?sort=name&page=1'
+* ```
+*/
+function appendQueryString(uri, queryString, qsParser) {
+	const { query, pathname } = safeDecodeURI(uri, false);
+	const mergedQueryString = qsParser.stringify(Object.assign(qsParser.parse(query), queryString));
+	return mergedQueryString ? `${pathname}?${mergedQueryString}` : pathname;
+}
+//#endregion
+export { canWriteResponseBody as C, tracing_channels_exports as S, Route as _, middlewareInfo as a, httpRequest as b, routeInfo as c, safeDecodeURI as d, toRoutesJSON as f, BriskRoute as g, RouteResource as h, matchRoute as i, serializeCookie as l, RouteGroup as m, createSignedURL as n, mime as o, trustProxy as p, encodeUrl as r, parseRoute as s, appendQueryString as t, parseRange as u, httpExceptionHandler as v, debug_default as w, httpResponseSerializer as x, httpMiddleware as y };