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

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

@@ -1,6 +1,6 @@
 import type { Logger } from '@adonisjs/logger';
 import type { LazyImport } from '@poppinss/utils/types';
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import type { Server as HttpsServer } from 'node:https';
 import type { Application } from '@adonisjs/application';
 import type { EmitterLike } from '@adonisjs/events/types';
@@ -8,9 +8,9 @@ import { type ContainerResolver } from '@adonisjs/fold';
 import type { ServerResponse, IncomingMessage, Server as HttpServer } from 'node:http';
 import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.ts';
 import type { ServerConfig, HttpServerEvents, ErrorHandlerAsAClass, TestingMiddlewarePipeline } from '../types/server.ts';
-import { Request } from '../request.ts';
-import { Response } from '../response.ts';
+import { HttpRequest } from '../request.ts';
 import { Router } from '../router/main.ts';
+import { HttpResponse } from '../response.ts';
 import { HttpContext } from '../http_context/main.ts';
 /**
  * The Server class provides the core HTTP server implementation for AdonisJS.
@@ -105,7 +105,7 @@ export declare class Server {
      * @param res - Node.js ServerResponse
      * @returns New Request instance
      */
-    createRequest(req: IncomingMessage, res: ServerResponse): Request;
+    createRequest(req: IncomingMessage, res: ServerResponse): HttpRequest;
     /**
      * Creates a Response instance from Node.js request/response objects
      *
@@ -113,7 +113,7 @@ export declare class Server {
      * @param res - Node.js ServerResponse
      * @returns New Response instance
      */
-    createResponse(req: IncomingMessage, res: ServerResponse): Response;
+    createResponse(req: IncomingMessage, res: ServerResponse): HttpResponse;
     /**
      * Creates an HttpContext instance with request-specific logger
      *
@@ -122,7 +122,7 @@ export declare class Server {
      * @param resolver - Container resolver for dependency injection
      * @returns New HttpContext instance
      */
-    createHttpContext(request: Request, response: Response, resolver: ContainerResolver<any>): HttpContext;
+    createHttpContext(request: HttpRequest, response: HttpResponse, resolver: ContainerResolver<any>): HttpContext;
     /**
      * Gets the list of registered global middleware
      *

package/build/src/types/main.js

@@ -0,0 +1 @@
+export {};

package/build/src/types/response.d.ts

@@ -30,6 +30,11 @@ export type CastableHeader = string | number | boolean | string[] | number[] | b
  * Configuration options for HTTP response handling and processing
  */
 export type ResponseConfig = {
+    /**
+     * Define a custom serializer to serialize the response body
+     * to a JSON string
+     */
+    serializeJSON(payload: unknown): string | undefined;
     /**
      * Whether or not to generate etags for responses. Etags can be
      * enabled/disabled when sending response as well.
@@ -51,4 +56,4 @@ export type ResponseConfig = {
 /**
  * A readable stream that can be piped to the response stream method
  */
-export type ResponseStream = Readable;
+export type ResponseStream = Readable | ReadableStream<any>;

package/build/src/types/route.d.ts

@@ -4,6 +4,7 @@ import type { Constructor, LazyImport } from '@poppinss/utils/types';
 import type { ServerErrorHandler } from './server.ts';
 import type { HttpContext } from '../http_context/main.ts';
 import type { MiddlewareFn, ParsedGlobalMiddleware } from './middleware.ts';
+import { type ClientRouteJSON, type ClientRouteMatchItTokens } from '../client/types.ts';
 /**
  * Configuration for matching and casting route parameters
  */
@@ -16,16 +17,7 @@ export type RouteMatcher = {
 /**
  * Route token structure used internally by the matchit routing library
  */
-export type MatchItRouteToken = RouteMatcher & {
-    /** Original token string */
-    old: string;
-    /** Token type identifier (0=static, 1=param, 2=wildcard, 3=optional) */
-    type: 0 | 1 | 2 | 3;
-    /** Token value */
-    val: string;
-    /** Token end delimiter */
-    end: string;
-};
+export type MatchItRouteToken = RouteMatcher & ClientRouteMatchItTokens;
 /**
  * Extracts method names from a controller class that accept HttpContext as first parameter
  */
@@ -120,20 +112,12 @@ export type RouteMatchers = {
 /**
  * Complete route definition with all metadata, handlers, and execution context
  */
-export type RouteJSON = {
+export type RouteJSON = Pick<ClientRouteJSON, 'name' | 'methods' | 'domain' | 'pattern'> & {
     /**
      * The execute function to execute the route middleware
      * and the handler
      */
     execute: (route: RouteJSON, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']) => any;
-    /**
-     * A unique name for the route
-     */
-    name?: string;
-    /**
-     * Route URI pattern
-     */
-    pattern: string;
     /**
      * Route handler
      */
@@ -150,14 +134,6 @@ export type RouteJSON = {
      * Tokens to be used to construct the route URL
      */
     tokens: MatchItRouteToken[];
-    /**
-     * HTTP methods, the route responds to.
-     */
-    methods: string[];
-    /**
-     * The domain for which the route is registered.
-     */
-    domain: string;
     /**
      * Matchers for route params.
      */

package/build/src/types/url_builder.d.ts

@@ -1,16 +1,5 @@
-/**
- * Types shared with the client. These should never import other types
- */
-import { type Prettify } from '@poppinss/utils/types';
-/**
- * Configuration options for URL generation helpers
- */
-export type URLOptions = {
-    /** Query string parameters to append to the URL */
-    qs?: Record<string, any>;
-    /** URL prefix to prepend to the generated URL */
-    prefixUrl?: string;
-};
+import { type UrlFor, type LookupList, type URLOptions, type LookupListRoute, type RouteBuilderArguments } from '../client/types.ts';
+export { URLOptions, LookupListRoute, RouteBuilderArguments, LookupList, UrlFor };
 /**
  * Configuration options for signed URL generation helpers
  */
@@ -20,133 +9,6 @@ export type SignedURLOptions = URLOptions & {
     /** Purpose identifier for the signed URL */
     purpose?: string;
 };
-/**
- * Utility type that constructs function arguments for route URL builders based on route parameters
- */
-export type RouteBuilderArguments<Identifier, Route, Options extends any = URLOptions> = Route extends LookupListRoute ? Prettify<Route['params'] extends undefined ? [identifier: Identifier, params?: undefined, options?: Options] : [undefined] extends [Route['params']] ? [
-    identifier: Identifier,
-    params?: Route['params'] | Route['paramsTuple'],
-    options?: Options
-] : [
-    identifier: Identifier,
-    params: Route['params'] | Route['paramsTuple'],
-    options?: Options
-]> : never;
-/**
- * LookupList type is used by the URLBuilder to provide
- * type-safety when creating URLs.
- *
- * There is no runtime property that matches this type. Its
- * purely for type-inference.
- */
-/**
- * Route definition structure for type-safe URL building
- */
-export type LookupListRoute = {
-    /** Parameters as a tuple for positional arguments */
-    paramsTuple?: [...any[]];
-    /** Parameters as a named object */
-    params?: {
-        [name: string]: any;
-    };
-};
-/**
- * Complete route lookup structure organized by HTTP methods and route identifiers
- */
-export type LookupList = {
-    /** HTTP method to route mapping */
-    [method: string]: {
-        /** Route identifier to route definition mapping */
-        [identifier: string]: LookupListRoute;
-    };
-};
-/**
- * The urlFor helper is used to make URLs for pre-existing known routes. You can
- * make a URL using the route name, route pattern, or the route controller
- * reference (depends upon enabled lookupStrategies)
- *
- * ```ts
- * urlFor('users.show', [1]) // /users/1
- *
- * // Lookup inside a specific domain
- * urlFor('blog.adonisjs.com@posts.show', [1]) // /posts/1
- * ```
- */
-export type UrlFor<Routes extends LookupList, Options extends any = URLOptions> = (<Identifier extends keyof Routes['ALL'] & string>(...[identifier, params, options]: RouteBuilderArguments<Identifier, Routes['ALL'][Identifier], Options>) => string) & {
-    /**
-     * Make URL for a GET route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.get('users.show', [1]) // { method: 'get', url: '/users/1' }
-     * urlFor.get('users.store', [1]) // Error: Route not found GET@users/store
-     * ```
-     */
-    get<RouteIdentifier extends keyof Routes['GET'] & string>(...[identifier, params, options]: RouteBuilderArguments<RouteIdentifier, Routes['GET'][RouteIdentifier], Options>): {
-        method: 'get';
-        url: string;
-    };
-    /**
-     * Make URL for a POST route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.post('users.store') // { method: 'post', url: '/users' }
-     * urlFor.post('users.show', [1]) // Error: Route not found POST@users.show
-     * ```
-     */
-    post<RouteIdentifier extends keyof Routes['POST'] & string>(...[identifier, params, options]: RouteBuilderArguments<RouteIdentifier, Routes['POST'][RouteIdentifier], Options>): {
-        method: 'post';
-        url: string;
-    };
-    /**
-     * Make URL for a PUT route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.put('users.update', [1]) // { method: 'put', url: '/users/1' }
-     * urlFor.put('users.show', [1]) // Error: Route not found PUT@users.show
-     * ```
-     */
-    put<RouteIdentifier extends keyof Routes['PUT'] & string>(...[identifier, params, options]: RouteBuilderArguments<RouteIdentifier, Routes['PUT'][RouteIdentifier], Options>): {
-        method: 'put';
-        url: string;
-    };
-    /**
-     * Make URL for a PATCH route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.put('users.update', [1]) // { method: 'patch', url: '/users/1' }
-     * urlFor.put('users.show', [1]) // Error: Route not found PATCH@users.show
-     * ```
-     */
-    patch<RouteIdentifier extends keyof Routes['PATCH'] & string>(...[identifier, params, options]: RouteBuilderArguments<RouteIdentifier, Routes['PATCH'][RouteIdentifier], Options>): {
-        method: 'patch';
-        url: string;
-    };
-    /**
-     * Make URL for a DELETE route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.delete('users.destroy', [1]) // { method: 'delete', url: '/users/1' }
-     * urlFor.delete('users.show', [1]) // Error: Route not found DELETE@users.show
-     * ```
-     */
-    delete<RouteIdentifier extends keyof Routes['DELETE'] & string>(...[identifier, params, options]: RouteBuilderArguments<RouteIdentifier, Routes['DELETE'][RouteIdentifier], Options>): {
-        method: 'delete';
-        url: string;
-    };
-    /**
-     * Make URL for a custom route method. An error will be raised if the route doesn't
-     * exist for the same method.
-     */
-    method<Method extends keyof Routes & string, RouteIdentifier extends keyof Routes[Method] & string>(method: Method, ...[identifier, params, options]: RouteBuilderArguments<RouteIdentifier, Routes[Method][RouteIdentifier], Options>): {
-        method: Method;
-        url: string;
-    };
-};
 /**
  * Utility type to extract routes for a specific HTTP method from the routes collection
  */

package/build/src/utils.d.ts

@@ -4,23 +4,88 @@ import { BriskRoute } from './router/brisk.ts';
 import type { RouteJSON } from './types/route.ts';
 import { RouteResource } from './router/resource.ts';
 /**
- * Makes input string consistent by having only the starting
- * slash
+ * 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('/') // '/'
+ * ```
  */
 export declare function dropSlash(input: string): string;
 /**
- * Returns a flat list of routes from the route groups and resources
+ * 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
+ * ])
+ * ```
  */
 export declare function toRoutesJSON(routes: (RouteGroup | Route | RouteResource | BriskRoute)[]): RouteJSON[];
 /**
- * Helper to know if the remote address should
- * be trusted.
+ * 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'))
+ * ```
  */
 export declare function trustProxy(remoteAddress: string, proxyFn: (addr: string, distance: number) => boolean): boolean;
 /**
- * Parses a range expression to an object filled with the range
+ * 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' }
+ * ```
  */
 export declare function parseRange<T>(range: string, value: T): Record<number, T>;
+/**
+ * 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 }
+ * ```
+ */
 export declare function safeDecodeURI(path: string, useSemicolonDelimiter: boolean): {
     pathname: string;
     query: string;

package/build/types-AUwURgIL.js

@@ -0,0 +1 @@
+export {};