@adonisjs/http-server 7.7.0 → 8.0.0-next.1

package/build/src/server/factories/middleware_handler.d.ts

@@ -1,8 +1,8 @@
-import type { NextFn } from '@poppinss/middleware/types';
 import type { ContainerResolver } from '@adonisjs/fold';
-import type { HttpContext } from '../../http_context/main.js';
-import { ParsedGlobalMiddleware } from '../../types/middleware.js';
+import type { NextFn } from '@poppinss/middleware/types';
+import type { HttpContext } from '../../http_context/main.ts';
+import { type ParsedGlobalMiddleware } from '../../types/middleware.ts';
 /**
  * The middleware handler invokes the middleware functions.
  */
-export declare function middlewareHandler(resolver: ContainerResolver<any>, ctx: HttpContext): (fn: ParsedGlobalMiddleware, next: NextFn) => any;
+export declare function middlewareHandler(resolver: ContainerResolver<any>, ctx: HttpContext): (fn: ParsedGlobalMiddleware, next: NextFn) => Promise<any>;

package/build/src/server/factories/route_finder.d.ts

@@ -0,0 +1,10 @@
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { Router } from '../../router/main.ts';
+import type { HttpContext } from '../../http_context/main.ts';
+import type { ServerErrorHandler } from '../../types/server.ts';
+/**
+ * The route finder is executed after the server middleware stack.
+ * It looks for a matching route and executes the route middleware
+ * stack.
+ */
+export declare function routeFinder(router: Router, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']): () => any;

package/build/src/server/factories/write_response.d.ts

@@ -1,4 +1,4 @@
-import type { HttpContext } from '../../http_context/main.js';
+import type { HttpContext } from '../../http_context/main.ts';
 /**
  * Writes the response to the socket. The "finish" method can
  * raise error when unable to serialize the response.

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

@@ -1,17 +1,17 @@
 import type { Logger } from '@adonisjs/logger';
+import type { LazyImport } from '@poppinss/utils/types';
 import type { Encryption } from '@adonisjs/encryption';
 import type { Server as HttpsServer } from 'node:https';
 import type { Application } from '@adonisjs/application';
 import type { EmitterLike } from '@adonisjs/events/types';
-import { ContainerResolver } from '@adonisjs/fold';
+import { type ContainerResolver } from '@adonisjs/fold';
 import type { ServerResponse, IncomingMessage, Server as HttpServer } from 'node:http';
-import type { LazyImport } from '../types/base.js';
-import type { MiddlewareAsClass } from '../types/middleware.js';
-import type { ServerConfig, HttpServerEvents, ErrorHandlerAsAClass, TestingMiddlewarePipeline } from '../types/server.js';
-import { Request } from '../request.js';
-import { Response } from '../response.js';
-import { Router } from '../router/main.js';
-import { HttpContext } from '../http_context/main.js';
+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 { Router } from '../router/main.ts';
+import { HttpContext } from '../http_context/main.ts';
 /**
  * The HTTP server implementation to handle incoming requests and respond using the
  * registered routes.
@@ -75,6 +75,10 @@ export declare class Server {
      * Creates an instance of the [[HttpContext]] class
      */
     createHttpContext(request: Request, response: Response, resolver: ContainerResolver<any>): HttpContext;
+    /**
+     * Returns a list of server middleware stack
+     */
+    getMiddlewareList(): ParsedGlobalMiddleware[];
     /**
      * Handle request
      */

package/build/src/tracing_channels.d.ts

@@ -0,0 +1,23 @@
+import diagnostics_channel from 'node:diagnostics_channel';
+import type { MiddlewareTracingData } from './types/tracing_channels.ts';
+/**
+ * Traces every HTTP request handled by the {@link Server} class.
+ */
+export declare const httpRequest: diagnostics_channel.TracingChannel<"adonisjs:http.request", import("./http_context/main.ts").HttpContext>;
+/**
+ * Traces middleware executed during the HTTP request
+ */
+export declare const httpMiddleware: diagnostics_channel.TracingChannel<"adonisjs:http.middleware", MiddlewareTracingData>;
+/**
+ * Traces the exception handler that converts errors into HTTP responses
+ */
+export declare const httpExceptionHandler: diagnostics_channel.TracingChannel<"adonisjs:http.exception.handler", object>;
+/**
+ * Traces route handler executed during the HTTP request
+ */
+export declare const httpRouteHandler: diagnostics_channel.TracingChannel<"adonisjs:http.route.handler", import("./types/route.ts").RouteJSON>;
+/**
+ * Traces non-stream and non-file download responses written by the AdonisJS
+ * response class
+ */
+export declare const httpResponseSerializer: diagnostics_channel.TracingChannel<"adonisjs:http.response.serializer", object>;

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

@@ -1,7 +1,7 @@
-export * from './base.js';
-export * from './middleware.js';
-export * from './qs.js';
-export * from './request.js';
-export * from './response.js';
-export * from './route.js';
-export * from './server.js';
+export * from './qs.ts';
+export * from './route.ts';
+export * from './server.ts';
+export * from './request.ts';
+export * from './response.ts';
+export * from './url_builder.ts';
+export * from './middleware.ts';

package/build/src/types/main.js

@@ -1 +0,0 @@
-//# sourceMappingURL=main.js.map

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

@@ -1,6 +1,7 @@
 import type { ContainerResolver } from '@adonisjs/fold';
-import type { Constructor, NextFn } from './base.js';
-import type { HttpContext } from '../http_context/main.js';
+import type { NextFn } from '@poppinss/middleware/types';
+import type { Constructor, LazyImport } from '@poppinss/utils/types';
+import type { HttpContext } from '../http_context/main.ts';
 /**
  * Middleware represented as a class
  */
@@ -24,6 +25,7 @@ export type MiddlewareFn = (ctx: HttpContext, next: NextFn) => any;
  */
 export type ParsedGlobalMiddleware = {
     name?: string;
+    reference: LazyImport<MiddlewareAsClass> | MiddlewareAsClass;
     handle: (resolver: ContainerResolver<any>, ...args: [ctx: HttpContext, next: NextFn, params?: any]) => any;
 };
 /**
@@ -31,7 +33,38 @@ export type ParsedGlobalMiddleware = {
  */
 export type ParsedNamedMiddleware = {
     name: string;
+    reference: LazyImport<MiddlewareAsClass> | MiddlewareAsClass;
     handle: ParsedGlobalMiddleware['handle'];
     args: any;
 };
+/**
+ * Info node representing a middleware handler
+ */
+export type MiddlewareHandlerInfo = {
+    type: 'closure';
+    name: string;
+} | {
+    type: 'named';
+    name: string;
+    args: any | undefined;
+    method: string;
+    moduleNameOrPath: string;
+} | {
+    type: 'global';
+    name?: string | undefined;
+    method: string;
+    moduleNameOrPath: string;
+};
+/**
+ * Info node representing route handler
+ */
+export type RouteHandlerInfo = {
+    type: 'closure';
+    name: string;
+    args?: string;
+} | {
+    type: 'controller';
+    method: string;
+    moduleNameOrPath: string;
+};
 export {};

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

@@ -17,6 +17,10 @@ export type RequestConfig = {
      * Defaults to false
      */
     generateRequestId: boolean;
+    /**
+     * A custom method to generate a unique request id. Defaults to uuid v4.
+     */
+    createRequestId(): string;
     /**
      * Method spoofing allows changing the request method using the query string.
      * For example: Making a POST request on URL /users/1?_method=PATCH will

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

@@ -1,4 +1,4 @@
-import { Readable } from 'node:stream';
+import { type Readable } from 'node:stream';
 /**
  * Cookie options can that can be set on the response
  */

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

@@ -1,16 +1,16 @@
 import type Middleware from '@poppinss/middleware';
 import type { ContainerResolver } from '@adonisjs/fold';
-import type { Constructor, LazyImport } from './base.js';
-import type { HttpContext } from '../http_context/main.js';
-import type { MiddlewareFn, ParsedGlobalMiddleware } from './middleware.js';
-import { ServerErrorHandler } from './server.js';
+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';
 /**
- * Returns a union of methods from a controller that accepts
- * the context as the first argument.
+ * Shape of a route param matcher
  */
-export type GetControllerHandlers<Controller extends Constructor<any>> = {
-    [K in keyof InstanceType<Controller>]: InstanceType<Controller>[K] extends (ctx: HttpContext, ...args: any[]) => any ? K : never;
-}[keyof InstanceType<Controller>];
+export type RouteMatcher = {
+    match?: RegExp;
+    cast?: (value: string) => any;
+};
 /**
  * Route token stored by matchit library
  */
@@ -20,6 +20,13 @@ export type MatchItRouteToken = RouteMatcher & {
     val: string;
     end: string;
 };
+/**
+ * Returns a union of methods from a controller that accepts
+ * the context as the first argument.
+ */
+export type GetControllerHandlers<Controller extends Constructor<any>> = {
+    [K in keyof InstanceType<Controller>]: InstanceType<Controller>[K] extends (ctx: HttpContext, ...args: any[]) => any ? K : never;
+}[keyof InstanceType<Controller>];
 /**
  * Route handler defined as a function
  */
@@ -38,36 +45,6 @@ export type StoreRouteMiddleware = MiddlewareFn | ({
     name?: string;
     args?: any[];
 } & ParsedGlobalMiddleware);
-/**
- * Route node persisted within the routes store
- */
-export type StoreRouteNode = {
-    /**
-     * The execute function to execute the route middleware
-     * and the handler
-     */
-    execute: (route: StoreRouteNode, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']) => any;
-    /**
-     * A unique name for the route
-     */
-    name?: string;
-    /**
-     * Route URI pattern
-     */
-    pattern: string;
-    /**
-     * Route handler
-     */
-    handler: StoreRouteHandler;
-    /**
-     * Route middleware
-     */
-    middleware: Middleware<StoreRouteMiddleware>;
-    /**
-     * Additional metadata associated with the route
-     */
-    meta: Record<string, any>;
-};
 /**
  * An object of routes for a given HTTP method
  */
@@ -77,7 +54,7 @@ export type StoreMethodNode = {
         [pattern: string]: string;
     };
     routes: {
-        [pattern: string]: StoreRouteNode;
+        [pattern: string]: RouteJSON;
     };
 };
 /**
@@ -100,7 +77,7 @@ export type StoreRoutesTree = {
  * Shape of the matched route for a pattern, method and domain.
  */
 export type MatchedRoute = {
-    route: StoreRouteNode;
+    route: RouteJSON;
     /**
      * A unique key for the looked up route
      */
@@ -114,13 +91,6 @@ export type MatchedRoute = {
      */
     subdomains: Record<string, any>;
 };
-/**
- * Shape of a route param matcher
- */
-export type RouteMatcher = {
-    match?: RegExp;
-    cast?: (value: string) => any;
-};
 /**
  * A collection of route matchers
  */
@@ -130,7 +100,36 @@ export type RouteMatchers = {
 /**
  * Representation of a route as JSON
  */
-export type RouteJSON = StoreRouteNode & {
+export type RouteJSON = {
+    /**
+     * 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
+     */
+    handler: StoreRouteHandler;
+    /**
+     * Route middleware
+     */
+    middleware: Middleware<StoreRouteMiddleware>;
+    /**
+     * Additional metadata associated with the route
+     */
+    meta: Record<string, any>;
+    /**
+     * Tokens to be used to construct the route URL
+     */
+    tokens: MatchItRouteToken[];
     /**
      * HTTP methods, the route responds to.
      */
@@ -150,6 +149,7 @@ export type RouteJSON = StoreRouteNode & {
 export type ResourceActionNames = 'create' | 'index' | 'store' | 'show' | 'edit' | 'update' | 'destroy';
 /**
  * Options accepted by makeUrl method
+ * @deprecated
  */
 export type MakeUrlOptions = {
     qs?: Record<string, any>;
@@ -159,6 +159,7 @@ export type MakeUrlOptions = {
 };
 /**
  * Options accepted by makeSignedUrl method
+ * @deprecated
  */
 export type MakeSignedUrlOptions = MakeUrlOptions & {
     expiresIn?: string | number;

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

@@ -1,9 +1,9 @@
+import type { Constructor } from '@poppinss/utils/types';
 import type { ErrorHandler, FinalHandler } from '@poppinss/middleware/types';
-import type { Constructor } from './base.js';
-import type { QSParserConfig } from './qs.js';
-import type { RequestConfig } from './request.js';
-import type { ResponseConfig } from './response.js';
-import type { HttpContext } from '../http_context/main.js';
+import type { QSParserConfig } from './qs.ts';
+import type { RequestConfig } from './request.ts';
+import type { ResponseConfig } from './response.ts';
+import type { HttpContext } from '../http_context/main.ts';
 /**
  * Normalized HTTP error used by the exception
  * handler.

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

@@ -0,0 +1,6 @@
+import type { RouteJSON } from './route.ts';
+import type { HttpContext } from '../http_context/main.ts';
+import type { MiddlewareFn, ParsedGlobalMiddleware, ParsedNamedMiddleware } from './middleware.ts';
+export type HTTPRequestTracingData = HttpContext;
+export type MiddlewareTracingData = ParsedGlobalMiddleware | ParsedNamedMiddleware | MiddlewareFn;
+export type RouteHandlerTracingData = RouteJSON;

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

@@ -0,0 +1,147 @@
+/**
+ * Types shared with the client. These should never import other types
+ */
+import { type Prettify } from '@poppinss/utils/types';
+/**
+ * Options accepted by "urlFor" helper
+ */
+export type URLOptions = {
+    qs?: Record<string, any>;
+    prefixUrl?: string;
+};
+/**
+ * Options accepted by "signedUrlFor" helper
+ */
+export type SignedURLOptions = URLOptions & {
+    expiresIn?: string | number;
+    purpose?: string;
+};
+/**
+ * Returns params for a route identifier
+ */
+export type RouteBuilderArguments<Routes, Method extends keyof Routes, Identifier extends keyof Routes[Method], Options extends any = URLOptions> = Routes extends LookupList ? Prettify<undefined extends Routes[Method][Identifier]['params'] ? [identifier: Identifier, params?: undefined, options?: Options] : [undefined] extends [Routes[Method][Identifier]['params']] ? [
+    identifier: Identifier,
+    params?: Routes[Method][Identifier]['params'] | Routes[Method][Identifier]['paramsTuple'],
+    options?: Options
+] : [
+    identifier: Identifier,
+    params: Routes[Method][Identifier]['params'] | Routes[Method][Identifier]['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.
+ */
+export type LookupList = {
+    [method: string]: {
+        [identifier: string]: {
+            paramsTuple?: [...any[]];
+            params?: {
+                [name: string]: any;
+            };
+        };
+    };
+};
+/**
+ * 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<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<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<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<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<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<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<Routes, Method, RouteIdentifier, Options>): {
+        method: Method;
+        url: string;
+    };
+};
+/**
+ * To be generated by the router and used by the URL builder
+ * and the LookupStore
+ */
+export interface RoutesList {
+}
+/**
+ * Helper to get routes for a given method from the RoutesList. The
+ * RoutesList is extended in the userland code.
+ */
+export type GetRoutesForMethod<Method> = {
+    [K in keyof RoutesList]: Method extends K ? RoutesList[Method] : never;
+};

package/build/src/utils.d.ts

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