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

package/build/factories/request.d.ts

@@ -1,6 +1,6 @@
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { Request } from '../src/request.ts';
+import { HttpRequest } from '../src/request.ts';
 import { type RequestConfig } from '../src/types/request.ts';
 type FactoryParameters = {
     url: string;
@@ -14,7 +14,7 @@ type FactoryParameters = {
  * Request factory is used to generate request class instances for
  * testing
  */
-export declare class RequestFactory {
+export declare class HttpRequestFactory {
     #private;
     /**
      * Merge factory params
@@ -24,6 +24,6 @@ export declare class RequestFactory {
     /**
      * Create request
      */
-    create(): Request;
+    create(): HttpRequest;
 }
 export {};

package/build/factories/response.d.ts

@@ -1,6 +1,6 @@
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { Response } from '../src/response.ts';
+import { HttpResponse } from '../src/response.ts';
 import { type Router } from '../src/router/main.ts';
 import { type ResponseConfig } from '../src/types/response.ts';
 type FactoryParameters = {
@@ -14,7 +14,7 @@ type FactoryParameters = {
  * Response factory is used to generate response class instances for
  * testing
  */
-export declare class ResponseFactory {
+export declare class HttpResponseFactory {
     #private;
     /**
      * Merge factory params
@@ -24,6 +24,6 @@ export declare class ResponseFactory {
     /**
      * Create response class instance
      */
-    create(): Response;
+    create(): HttpResponse;
 }
 export {};

package/build/factories/router.d.ts

@@ -1,4 +1,4 @@
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import type { Application } from '@adonisjs/application';
 import { Router } from '../src/router/main.ts';
 type FactoryParameters = {

package/build/factories/server_factory.d.ts

@@ -1,6 +1,6 @@
 import { Logger } from '@adonisjs/logger';
 import { Emitter } from '@adonisjs/events';
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import type { Application } from '@adonisjs/application';
 import { Server } from '../src/server/main.ts';
 import type { ServerConfig } from '../src/types/server.ts';

package/build/factories/url_builder_factory.d.ts

@@ -1,4 +1,4 @@
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import type { Router } from '../src/router/main.ts';
 import { type LookupList } from '../src/types/url_builder.ts';
 type FactoryParameters = {
@@ -19,8 +19,8 @@ export declare class URLBuilderFactory<Routes extends LookupList> {
      * Create URL builder helpers
      */
     create(): {
-        urlFor: import("../src/types/url_builder.ts").UrlFor<Routes>;
-        signedUrlFor: import("../src/types/url_builder.ts").UrlFor<Routes, import("../src/types/url_builder.ts").SignedURLOptions>;
+        urlFor: import("../src/client/types.ts").UrlFor<Routes>;
+        signedUrlFor: import("../src/client/types.ts").UrlFor<Routes, import("../src/types/url_builder.ts").SignedURLOptions>;
     };
 }
 export {};

package/build/helpers-XD4_pfkD.js

@@ -0,0 +1,108 @@
+//#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)) {
+			route = findRoute(domainsRoutes, routeIdentifier, routeDomain, method, disableLegacyLookup);
+			if (route) break;
+		}
+		return route;
+	}
+	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) => {
+		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;
+}
+/**
+* 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`);
+			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;
+		/**
+		* 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 };