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

package/build/src/helpers.d.ts

@@ -1,8 +1,11 @@
-import { type Encryption } from '@adonisjs/encryption';
+import { type Encryption } from '@boringnode/encryption';
+import { type Qs } from './qs.ts';
+import { createURL } from './client/helpers.ts';
 import { type CookieOptions } from './types/response.ts';
-import { type SignedURLOptions, type URLOptions } from './types/url_builder.ts';
+import { type SignedURLOptions } from './types/url_builder.ts';
 import type { RouteMatchers, RouteJSON, MatchItRouteToken } from './types/route.ts';
 import { type MiddlewareFn, type RouteHandlerInfo, type MiddlewareHandlerInfo, type ParsedGlobalMiddleware, type ParsedNamedMiddleware } from './types/middleware.ts';
+export { createURL };
 /**
  * This function is similar to the intrinsic function encodeURI. However, it will not encode:
  *  - The \, ^, or | characters
@@ -42,20 +45,6 @@ export { default as mime } from 'mime-types';
  * @returns {MatchItRouteToken[]} Array of parsed route tokens
  */
 export declare function parseRoute(pattern: string, matchers?: RouteMatchers): MatchItRouteToken[];
-/**
- * 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<MatchItRouteToken, 'val' | 'type' | 'end'>[], searchParamsStringifier: (qs: Record<string, any>) => string, params?: any[] | {
-    [param: string]: any;
-}, options?: URLOptions): string;
 /**
  * Makes signed URL for a given route pattern using its parsed tokens. The
  * tokens could be generated using the "parseRoute" method.
@@ -106,3 +95,21 @@ export declare function middlewareInfo(middleware: MiddlewareFn | ParsedGlobalMi
  * @returns {Promise<RouteHandlerInfo>} Promise resolving to route handler information
  */
 export declare function routeInfo(route: RouteJSON): Promise<RouteHandlerInfo>;
+/**
+ * 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'
+ * ```
+ */
+export declare function appendQueryString(uri: string, queryString: Record<string, any>, qsParser: Qs): string;

package/build/src/helpers.js

@@ -1,22 +1,76 @@
-import {
-  createSignedURL,
-  createURL,
-  default as default2,
-  default2 as default3,
-  matchRoute,
-  middlewareInfo,
-  parseRoute,
-  routeInfo,
-  serializeCookie
-} from "../chunk-NQNHMINZ.js";
-export {
-  createSignedURL,
-  createURL,
-  default2 as encodeUrl,
-  matchRoute,
-  middlewareInfo,
-  default3 as mime,
-  parseRoute,
-  routeInfo,
-  serializeCookie
-};
+import { n as safeDecodeURI } from "../utils-BjSHKI3s.js";
+import { t as createURL } from "../helpers-C_2HouOe.js";
+import { serialize } from "cookie-es";
+import matchit from "@poppinss/matchit";
+import string from "@poppinss/utils/string";
+import { parseBindingReference } from "@adonisjs/fold";
+import encodeUrl from "encodeurl";
+import mime from "mime-types";
+function parseRoute(pattern, matchers) {
+	return matchit.parse(pattern, matchers);
+}
+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
+		}
+	});
+}
+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);
+}
+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
+	});
+}
+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])
+	};
+}
+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
+	};
+}
+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;
+}
+export { appendQueryString, createSignedURL, createURL, encodeUrl, matchRoute, middlewareInfo, mime, parseRoute, routeInfo, serializeCookie };

package/build/src/http_context/main.d.ts

@@ -1,36 +1,86 @@
 import Macroable from '@poppinss/macroable';
 import type { Logger } from '@adonisjs/logger';
 import { type ContainerResolver } from '@adonisjs/fold';
-import type { Request } from '../request.ts';
-import type { Response } from '../response.ts';
+import type { HttpRequest } from '../request.ts';
+import type { HttpResponse } from '../response.ts';
 import type { RouteJSON } from '../types/route.ts';
 /**
- * Http context encapsulates properties for a given HTTP request. The
- * context class can be extended using macros and getters.
+ * HTTP context encapsulates all properties and services for a given HTTP request.
+ *
+ * The HttpContext class serves as the central hub for request-specific data and services.
+ * It provides access to the request, response, route information, container resolver,
+ * and logger instances. The context can be extended using macros and getters for
+ * application-specific functionality.
+ *
+ * @example
+ * ```ts
+ * export default class UsersController {
+ *   async show({ request, response, params }: HttpContext) {
+ *     const user = await User.find(params.id)
+ *     return response.json(user)
+ *   }
+ * }
+ * ```
  */
 export declare class HttpContext extends Macroable {
-    request: Request;
-    response: Response;
+    request: HttpRequest;
+    response: HttpResponse;
     logger: Logger;
     containerResolver: ContainerResolver<any>;
     /**
-     * Find if async localstorage is enabled for HTTP requests
-     * or not
+     * Indicates whether async local storage is enabled for HTTP requests.
+     *
+     * When enabled, the HTTP context is automatically available within the
+     * scope of request processing through static methods like get() and getOrFail().
      */
     static get usingAsyncLocalStorage(): boolean;
     /**
-     * Get access to the HTTP context. Available only when
-     * "usingAsyncLocalStorage" is true
+     * Get access to the current HTTP context from async local storage.
+     *
+     * This method is only available when async local storage is enabled.
+     * Returns null if called outside of an HTTP request context.
+     *
+     * @example
+     * ```ts
+     * const ctx = HttpContext.get()
+     * if (ctx) {
+     *   console.log(ctx.request.url())
+     * }
+     * ```
      */
     static get(): HttpContext | null;
     /**
-     * Get the HttpContext instance or raise an exception if not
-     * available
+     * Get the HttpContext instance or raise an exception if not available.
+     *
+     * This method is useful when you need guaranteed access to the HTTP context
+     * and want to fail fast if it's not available.
+     *
+     * @throws RuntimeException when async local storage is disabled or context is unavailable
+     *
+     * @example
+     * ```ts
+     * const ctx = HttpContext.getOrFail()
+     * const userId = ctx.request.input('user_id')
+     * ```
      */
     static getOrFail(): HttpContext;
     /**
-     * Run a method that doesn't have access to HTTP context from
-     * the async local storage.
+     * Run a method outside of the HTTP context scope.
+     *
+     * This method allows you to execute code that should not have access to
+     * the current HTTP context from async local storage. Useful for background
+     * tasks or operations that should be context-independent.
+     *
+     * @param callback - Function to execute outside the context
+     * @param args - Arguments to pass to the callback
+     *
+     * @example
+     * ```ts
+     * HttpContext.runOutsideContext(() => {
+     *   // This code cannot access HttpContext.get()
+     *   performBackgroundTask()
+     * })
+     * ```
      */
     static runOutsideContext<T>(callback: (...args: any[]) => T, ...args: any[]): T;
     /**
@@ -53,12 +103,12 @@ export declare class HttpContext extends Macroable {
     /**
      * Creates a new HttpContext instance
      *
-     * @param {Request} request - The HTTP request instance
-     * @param {Response} response - The HTTP response instance
+     * @param {HttpRequest} request - The HTTP request instance
+     * @param {HttpResponse} response - The HTTP response instance
      * @param {Logger} logger - The logger instance
      * @param {ContainerResolver<any>} containerResolver - The IoC container resolver
      */
-    constructor(request: Request, response: Response, logger: Logger, containerResolver: ContainerResolver<any>);
+    constructor(request: HttpRequest, response: HttpResponse, logger: Logger, containerResolver: ContainerResolver<any>);
     /**
      * A helper to see top level properties on the context object
      */

package/build/src/qs.d.ts

@@ -1,7 +1,21 @@
 import { type QSParserConfig } from './types/qs.ts';
 /**
- * Query string parser used to parse and stringify query
- * strings.
+ * Query string parser that provides methods to parse and stringify query strings.
+ *
+ * This class wraps the popular 'qs' package with configurable options for parsing
+ * and stringifying query parameters. It allows customization of array handling,
+ * depth limits, and encoding behavior.
+ *
+ * @example
+ * ```ts
+ * const qs = new Qs({
+ *   parse: { depth: 5, arrayLimit: 20 },
+ *   stringify: { encode: false, skipNulls: true }
+ * })
+ *
+ * const parsed = qs.parse('users[0][name]=john&users[0][age]=25')
+ * const stringified = qs.stringify({ users: [{ name: 'john', age: 25 }] })
+ * ```
  */
 export declare class Qs {
     #private;
@@ -15,7 +29,7 @@ export declare class Qs {
      * @param value - Query string to parse (e.g., "foo=bar&baz=qux")
      * @returns Parsed object representation of the query string
      */
-    parse: (value: string) => import("qs").ParsedQs;
+    parse: (value: string) => import("@poppinss/qs").ParsedQs;
     /**
      * Converts a JavaScript object into a query string using the configured options
      * @param value - Object to convert to query string

package/build/src/redirect.d.ts

@@ -1,10 +1,29 @@
 import type { IncomingMessage } from 'node:http';
 import type { Qs } from './qs.ts';
-import type { Response } from './response.ts';
 import type { Router } from './router/main.ts';
+import type { HttpResponse } from './response.ts';
 import type { RoutesList, LookupList, URLOptions, GetRoutesForMethod, RouteBuilderArguments } from './types/url_builder.ts';
 /**
- * Exposes the API to construct redirect routes
+ * Provides a fluent API for constructing HTTP redirect responses.
+ *
+ * The Redirect class allows you to build redirects with custom status codes,
+ * query string forwarding, and route-based URL generation. It supports both
+ * direct URL redirects and route-based redirects using registered route names.
+ *
+ * @example
+ * ```ts
+ * // Basic redirect
+ * return response.redirect('https://example.com')
+ *
+ * // Redirect to a route
+ * return response.redirect().toRoute('users.show', { id: 1 })
+ *
+ * // Redirect with status code and query string
+ * return response.redirect()
+ *   .status(301)
+ *   .withQs({ utm_source: 'newsletter' })
+ *   .toPath('/dashboard')
+ * ```
  */
 export declare class Redirect {
     #private;
@@ -15,7 +34,7 @@ export declare class Redirect {
      * @param router - AdonisJS router instance
      * @param qs - Query string parser instance
      */
-    constructor(request: IncomingMessage, response: Response, router: Router, qs: Qs);
+    constructor(request: IncomingMessage, response: HttpResponse, router: Router, qs: Qs);
     /**
      * Sets a custom HTTP status code for the redirect response
      * @param statusCode - HTTP status code to use (e.g., 301, 302, 307)

package/build/src/request.d.ts

@@ -1,5 +1,5 @@
 import Macroable from '@poppinss/macroable';
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import { type ServerResponse, type IncomingMessage, type IncomingHttpHeaders } from 'node:http';
 import type { Qs } from './qs.ts';
 import { type RequestConfig } from './types/request.ts';
@@ -13,7 +13,7 @@ import type { HttpContext } from './http_context/main.ts';
  * You can access the original [IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)
  * using `request.request` property.
  */
-export declare class Request extends Macroable {
+export declare class HttpRequest extends Macroable {
     #private;
     /** Native Node.js incoming message instance */
     request: IncomingMessage;
@@ -48,9 +48,16 @@ export declare class Request extends Macroable {
     /** Native Node.js server response instance */
     response: ServerResponse, encryption: Encryption, config: RequestConfig, qsParser: Qs);
     /**
-     * Returns the request id from the `x-request-id` header. The
-     * header is untouched, if it already exists.
-     * @returns The request ID or undefined if not found/generated
+     * Returns the request ID from the `x-request-id` header.
+     *
+     * If the header doesn't exist and request ID generation is enabled,
+     * a new UUID will be generated and added to the request headers.
+     *
+     * @example
+     * ```ts
+     * const requestId = request.id()
+     * console.log(requestId) // '550e8400-e29b-41d4-a716-446655440000'
+     * ```
      */
     id(): string | undefined;
     /**

package/build/src/response.d.ts

@@ -1,5 +1,5 @@
 import Macroable from '@poppinss/macroable';
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import { type ServerResponse, type IncomingMessage } from 'node:http';
 import type { Qs } from './qs.ts';
 import { Redirect } from './redirect.ts';
@@ -19,7 +19,7 @@ import type { CastableHeader, CookieOptions, ResponseConfig, ResponseStream } fr
  * response.download('/path/to/file.pdf')
  * ```
  */
-export declare class Response extends Macroable {
+export declare class HttpResponse extends Macroable {
     #private;
     request: IncomingMessage;
     response: ServerResponse;
@@ -46,7 +46,7 @@ export declare class Response extends Macroable {
     /**
      * The readable stream instance configured for the response
      */
-    get outgoingStream(): import("stream").Readable | undefined;
+    get outgoingStream(): ResponseStream | undefined;
     /**
      * Configuration for file streaming including path and etag generation flag
      */
@@ -159,14 +159,14 @@ export declare class Response extends Macroable {
      * @param key - Header name
      * @returns The header value
      */
-    getHeader(key: string): import("http").OutgoingHttpHeader | undefined;
+    getHeader(key: string): import("node:http").OutgoingHttpHeader | undefined;
     /**
      * Gets all response headers as an object
      *
      * @returns Object containing all headers
      */
     getHeaders(): {
-        [x: string]: import("http").OutgoingHttpHeader | undefined;
+        [x: string]: import("node:http").OutgoingHttpHeader | undefined;
         accept?: string | string[] | undefined;
         "accept-charset"?: string | string[] | undefined;
         "accept-encoding"?: string | string[] | undefined;

package/build/src/response_status.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Standard HTTP response status codes organized as a constant object.
+ *
+ * This object provides named constants for all standard HTTP status codes,
+ * making code more readable and less error-prone when setting response statuses.
+ * The naming follows PascalCase convention for consistency with TypeScript conventions.
+ *
+ * @example
+ * ```ts
+ * response.status(ResponseStatus.NotFound)
+ * response.status(ResponseStatus.InternalServerError)
+ * response.status(ResponseStatus.Created)
+ * ```
+ */
 export declare const ResponseStatus: {
     readonly Continue: 100;
     readonly SwitchingProtocols: 101;

package/build/src/router/main.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 type { Constructor, LazyImport } from '@poppinss/utils/types';
 import type { Qs } from '../qs.ts';
@@ -249,7 +249,11 @@ export declare class Router {
      * @param indentation - Indentation level for generated types
      * @returns Generated TypeScript types as string
      */
-    generateTypes(indentation?: number): string;
+    generateTypes(indentation?: number): {
+        imports: never[];
+        types: string[];
+        routes: string;
+    };
     /**
      * Find route for a given URL, method and optionally domain
      * @param uri - The URI to match