@adonisjs/http-server 8.1.0 → 8.1.2

package/build/factories/main.js

@@ -1,7 +1,8 @@
-import "../chunk-B2GA45YG.js";
-import { _ as Qs, c as HttpRequest, i as HttpResponse, n as Server, r as HttpContext, s as Router, t as defineConfig } from "../define_config-t7GL92UR.js";
-import { s as parseRoute } from "../helpers-aa47NQc6.js";
-import { t as createURL } from "../helpers-XD4_pfkD.js";
+import "../utils-BjSHKI3s.js";
+import { _ as Qs, c as HttpRequest, i as HttpResponse, n as Server, r as HttpContext, s as Router, t as defineConfig } from "../define_config-BRmlbWlB.js";
+import { t as createURL } from "../helpers-C_2HouOe.js";
+import { parseRoute } from "../src/helpers.js";
+import "../types-AUwURgIL.js";
 import { Container } from "@adonisjs/fold";
 import { Socket } from "node:net";
 import proxyAddr from "proxy-addr";
@@ -13,15 +14,7 @@ import { IncomingMessage, ServerResponse } from "node:http";
 import { Logger } from "@adonisjs/logger";
 import { Emitter } from "@adonisjs/events";
 import { LoggerFactory } from "@adonisjs/logger/factories";
-//#region factories/qs_parser_factory.ts
-/**
-* QS Parser factory is used to generate the query string
-* parser for testing
-*/
 var QsParserFactory = class {
-	/**
-	* Default configuration options for the QS parser
-	*/
 	#options = {
 		parse: {
 			depth: 5,
@@ -37,75 +30,33 @@ var QsParserFactory = class {
 			skipNulls: false
 		}
 	};
-	/**
-	* Merge QS parser factory options
-	* @param options - Partial options to merge with existing configuration
-	*/
 	merge(options) {
 		Object.assign(this.#options.parse, options.parse);
 		Object.assign(this.#options.stringify, options.stringify);
 		return this;
 	}
-	/**
-	* Create instance of the QS parser class
-	*/
 	create() {
 		return new Qs(this.#options);
 	}
 };
-//#endregion
-//#region factories/router.ts
-/**
-* Router factory is used to generate router class instances for
-* testing
-*/
 var RouterFactory = class {
-	/**
-	* Factory parameters for creating router instances
-	*/
 	#parameters = {};
-	/**
-	* Returns an instance of the application class
-	*/
 	#getApp() {
 		return this.#parameters.app || new AppFactory().create(new URL("./app/", import.meta.url));
 	}
-	/**
-	* Returns an instance of the encryptor to encrypt
-	* signed URLs
-	*/
 	#createEncryption() {
 		return this.#parameters.encryption || new EncryptionFactory().create();
 	}
-	/**
-	* Merge factory params
-	* @param params - Partial factory parameters to merge
-	*/
 	merge(params) {
 		Object.assign(this.#parameters, params);
 		return this;
 	}
-	/**
-	* Create router instance
-	*/
 	create() {
 		return new Router(this.#getApp(), this.#createEncryption(), new QsParserFactory().create());
 	}
 };
-//#endregion
-//#region factories/request.ts
-/**
-* Request factory is used to generate request class instances for
-* testing
-*/
 var HttpRequestFactory = class {
-	/**
-	* Factory parameters for creating request instances
-	*/
 	#parameters = {};
-	/**
-	* Returns the config for the request class
-	*/
 	#getConfig() {
 		return {
 			allowMethodSpoofing: false,
@@ -118,59 +69,29 @@ var HttpRequestFactory = class {
 			...this.#parameters.config
 		};
 	}
-	/**
-	* Returns the HTTP req object
-	*/
 	#createRequest() {
 		const req = this.#parameters.req || new IncomingMessage(new Socket());
 		if (this.#parameters.url) req.url = this.#parameters.url;
 		if (this.#parameters.method) req.method = this.#parameters.method;
 		return req;
 	}
-	/**
-	* Returns the HTTP res object
-	* @param req - The incoming message request object
-	*/
 	#createResponse(req) {
 		return this.#parameters.res || new ServerResponse(req);
 	}
-	/**
-	* Returns an instance of the encryptor to encrypt
-	* signed URLs
-	*/
 	#createEncryption() {
 		return this.#parameters.encryption || new EncryptionFactory().create();
 	}
-	/**
-	* Merge factory params
-	* @param params - Partial factory parameters to merge
-	*/
 	merge(params) {
 		Object.assign(this.#parameters, params);
 		return this;
 	}
-	/**
-	* Create request
-	*/
 	create() {
 		const req = this.#createRequest();
 		return new HttpRequest(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), new QsParserFactory().create());
 	}
 };
-//#endregion
-//#region factories/response.ts
-/**
-* Response factory is used to generate response class instances for
-* testing
-*/
 var HttpResponseFactory = class {
-	/**
-	* Factory parameters for creating response instances
-	*/
 	#parameters = {};
-	/**
-	* Returns the config for the request class
-	*/
 	#getConfig() {
 		return {
 			etag: false,
@@ -186,119 +107,54 @@ var HttpResponseFactory = class {
 			...this.#parameters.config
 		};
 	}
-	/**
-	* Returns the HTTP req object
-	*/
 	#createRequest() {
 		return this.#parameters.req || new IncomingMessage(new Socket());
 	}
-	/**
-	* Returns an instance of the router
-	*/
 	#createRouter() {
 		return this.#parameters.router || new RouterFactory().create();
 	}
-	/**
-	* Returns the HTTP res object
-	* @param req - The incoming message request object
-	*/
 	#createResponse(req) {
 		return this.#parameters.res || new ServerResponse(req);
 	}
-	/**
-	* Returns an instance of the encryptor to encrypt
-	* signed URLs
-	*/
 	#createEncryption() {
 		return this.#parameters.encryption || new EncryptionFactory().create();
 	}
-	/**
-	* Merge factory params
-	* @param params - Partial factory parameters to merge
-	*/
 	merge(params) {
 		Object.assign(this.#parameters, params);
 		return this;
 	}
-	/**
-	* Create response class instance
-	*/
 	create() {
 		const req = this.#createRequest();
 		return new HttpResponse(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), this.#createRouter(), new QsParserFactory().create());
 	}
 };
-//#endregion
-//#region factories/server_factory.ts
-/**
-* Server factory is used to generate server class instances for
-* testing
-*/
 var ServerFactory = class {
-	/**
-	* Factory parameters for creating server instances
-	*/
 	#parameters = {};
-	/**
-	* Returns the emitter instance
-	*/
 	#getEmitter() {
 		return this.#parameters.emitter || new Emitter(this.#getApp());
 	}
-	/**
-	* Returns the logger instance
-	*/
 	#getLogger() {
 		return this.#parameters.logger || new Logger({ enabled: false });
 	}
-	/**
-	* Returns the config for the server class
-	*/
 	#getConfig() {
 		return defineConfig(this.#parameters.config || {});
 	}
-	/**
-	* Returns an instance of the application class
-	*/
 	#getApp() {
 		return this.#parameters.app || new AppFactory().create(new URL("./app/", import.meta.url));
 	}
-	/**
-	* Returns an instance of the encryptor to encrypt
-	* signed URLs
-	*/
 	#createEncryption() {
 		return this.#parameters.encryption || new EncryptionFactory().create();
 	}
-	/**
-	* Merge factory params
-	* @param params - Partial factory parameters to merge
-	*/
 	merge(params) {
 		Object.assign(this.#parameters, params);
 		return this;
 	}
-	/**
-	* Create server instance
-	*/
 	create() {
 		return new Server(this.#getApp(), this.#createEncryption(), this.#getEmitter(), this.#getLogger(), this.#getConfig());
 	}
 };
-//#endregion
-//#region factories/http_context.ts
-/**
-* HttpContext factory is used to generate Http context class instances for
-* testing
-*/
 var HttpContextFactory = class {
-	/**
-	* Factory parameters for creating HTTP context instances
-	*/
 	#parameters = {};
-	/**
-	* Returns the request class instance
-	*/
 	#createRequest() {
 		if (this.#parameters.request) return this.#parameters.request;
 		let { url, method, route } = this.#parameters;
@@ -308,32 +164,18 @@ var HttpContextFactory = class {
 			method
 		}).create();
 	}
-	/**
-	* Returns the response class instance
-	*/
 	#createResponse() {
 		return this.#parameters.response || new HttpResponseFactory().create();
 	}
-	/**
-	* Returns an instance of the logger class
-	*/
 	#createLogger() {
 		return this.#parameters.logger || new LoggerFactory().create();
 	}
-	/**
-	* Merge factory params
-	* @param params - Partial factory parameters to merge
-	*/
 	merge(params) {
 		Object.assign(this.#parameters, params);
 		return this;
 	}
-	/**
-	* Create HTTP context instance
-	*/
 	create() {
 		return new HttpContext(this.#createRequest(), this.#createResponse(), this.#createLogger(), new Container().createResolver());
 	}
 };
-//#endregion
 export { HttpContextFactory, QsParserFactory, HttpRequestFactory as RequestFactory, HttpResponseFactory as ResponseFactory, RouterFactory, ServerFactory };

package/build/{helpers-XD4_pfkD.js → helpers-C_2HouOe.js}

@@ -1,28 +1,4 @@
-//#region src/client/helpers.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')
-* ```
-*/
 function findRoute(domainsRoutes, routeIdentifier, domain, method, disableLegacyLookup) {
-	/**
-	* Search for route in all the domains when no domain name is
-	* mentioned.
-	*/
 	if (!domain) {
 		let route = null;
 		for (const routeDomain of Object.keys(domainsRoutes)) {
@@ -33,10 +9,6 @@ function findRoute(domainsRoutes, routeIdentifier, domain, method, disableLegacy
 	}
 	const routes = domainsRoutes[domain];
 	if (!routes) return null;
-	/**
-	* Pattern and controller are supported for legacy reasons. However
-	* the URL builder only works with names
-	*/
 	const lookupByPattern = !disableLegacyLookup;
 	const lookupByController = !disableLegacyLookup;
 	return routes.find((route) => {
@@ -46,34 +18,16 @@ function findRoute(domainsRoutes, routeIdentifier, domain, method, disableLegacy
 		return false;
 	}) || null;
 }
-/**
-* 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
-*/
 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) {
-		/**
-		* Static param
-		*/
 		if (token.type === 0) {
 			uriSegments.push(token.val === "/" ? "" : `${token.val}${token.end}`);
 			continue;
 		}
-		/**
-		* Wildcard param. It will always be the last param, hence we will provide
-		* it all the remaining values
-		*/
 		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`);
@@ -83,26 +37,16 @@ function createURL(pattern, tokens, searchParamsStringifier, params, options) {
 		const paramName = token.val;
 		const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
 		const isDefined = value !== void 0 && value !== null;
-		/**
-		* Required param
-		*/
 		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("/")}`;
-	/**
-	* Prefix base URL
-	*/
 	if (options?.prefixUrl) URI = `${options?.prefixUrl.replace(/\/$/, "")}${URI}`;
-	/**
-	* Append query string
-	*/
 	if (options?.qs) {
 		const queryString = searchParamsStringifier(options?.qs);
 		URI = queryString ? `${URI}?${queryString}` : URI;
 	}
 	return URI;
 }
-//#endregion
 export { findRoute as n, createURL as t };