@adonisjs/http-server 8.0.0 → 8.1.0

package/build/factories/main.js

@@ -1,8 +1,7 @@
-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-D-kQXU0e.js";
-import { t as createURL } from "../helpers-C_2HouOe.js";
-import { parseRoute } from "../src/helpers.js";
-import "../types-AUwURgIL.js";
+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 { Container } from "@adonisjs/fold";
 import { Socket } from "node:net";
 import proxyAddr from "proxy-addr";
@@ -14,7 +13,15 @@ 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,
@@ -30,33 +37,75 @@ 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,
@@ -69,29 +118,59 @@ 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,
@@ -107,54 +186,119 @@ 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;
@@ -164,18 +308,32 @@ 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-C_2HouOe.js → helpers-XD4_pfkD.js}

@@ -1,4 +1,28 @@
+//#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)) {
@@ -9,6 +33,10 @@ 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) => {
@@ -18,16 +46,34 @@ 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`);
@@ -37,16 +83,26 @@ 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 };