@adonisjs/http-server 6.2.0-0 → 6.4.0-0

package/README.md

@@ -21,7 +21,7 @@ In order to ensure that the AdonisJS community is welcoming to all, please revie
 ## License
 AdonisJS HTTP server is open-sourced software licensed under the [MIT license](LICENSE.md).
 
-[gh-workflow-image]: https://img.shields.io/github/workflow/status/adonisjs/http-server/test?style=for-the-badge
+[gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/adonisjs/http-server/test.yml?style=for-the-badge
 [gh-workflow-url]: https://github.com/adonisjs/http-server/actions/workflows/test.yml "Github action"
 
 [typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript

package/build/index.d.ts

@@ -9,7 +9,4 @@ export { defineConfig } from './src/define_config.js';
 export { RouteResource } from './src/router/resource.js';
 export { BriskRoute } from './src/router/brisk.js';
 export { HttpContext } from './src/http_context/main.js';
-export { HttpException } from './src/exceptions/http_exception.js';
-export { AbortException } from './src/exceptions/abort_exception.js';
-export { RouteNotFoundException } from './src/exceptions/route_not_found.js';
-export { CannotLookupRouteException } from './src/exceptions/cannot_lookup_route.js';
+export * as errors from './src/exceptions/main.js';

package/build/index.js

@@ -9,7 +9,4 @@ export { defineConfig } from './src/define_config.js';
 export { RouteResource } from './src/router/resource.js';
 export { BriskRoute } from './src/router/brisk.js';
 export { HttpContext } from './src/http_context/main.js';
-export { HttpException } from './src/exceptions/http_exception.js';
-export { AbortException } from './src/exceptions/abort_exception.js';
-export { RouteNotFoundException } from './src/exceptions/route_not_found.js';
-export { CannotLookupRouteException } from './src/exceptions/cannot_lookup_route.js';
+export * as errors from './src/exceptions/main.js';

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

@@ -0,0 +1,78 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Exception } from '@poppinss/utils';
+import type { HttpContext } from '../http_context/main.js';
+export declare const E_ROUTE_NOT_FOUND: new (args: [method: string, url: string], options?: ErrorOptions | undefined) => Exception;
+export declare const E_CANNOT_LOOKUP_ROUTE: new (args: [routeIdentifier: string], options?: ErrorOptions | undefined) => Exception;
+export declare const E_HTTP_EXCEPTION: {
+    new (message?: string | undefined, options?: (ErrorOptions & {
+        code?: string | undefined;
+        status?: number | undefined;
+    }) | undefined): {
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    code: string;
+    invoke(body: any, status: number, code?: string): {
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    help?: string | undefined;
+    status?: number | undefined;
+    message?: string | undefined;
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare const E_HTTP_REQUEST_ABORTED: {
+    new (message?: string | undefined, options?: (ErrorOptions & {
+        code?: string | undefined;
+        status?: number | undefined;
+    }) | undefined): {
+        handle(error: any, ctx: HttpContext): void;
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    code: string;
+    invoke(body: any, status: number, code?: string): {
+        body: any;
+        name: string;
+        help?: string | undefined;
+        code?: string | undefined;
+        status: number;
+        toString(): string;
+        readonly [Symbol.toStringTag]: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: unknown;
+    };
+    help?: string | undefined;
+    status?: number | undefined;
+    message?: string | undefined;
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};

package/build/src/exceptions/{http_exception.js → main.js}

@@ -1,5 +1,7 @@
-import { Exception } from '@poppinss/utils';
-export class HttpException extends Exception {
+import { createError, Exception } from '@poppinss/utils';
+export const E_ROUTE_NOT_FOUND = createError('Cannot %s:%s', 'E_ROUTE_NOT_FOUND', 404);
+export const E_CANNOT_LOOKUP_ROUTE = createError('Cannot lookup route "%s"', 'E_CANNOT_LOOKUP_ROUTE', 500);
+export const E_HTTP_EXCEPTION = class HttpException extends Exception {
     body;
     static code = 'E_HTTP_EXCEPTION';
     static invoke(body, status, code = 'E_HTTP_EXCEPTION') {
@@ -17,4 +19,9 @@ export class HttpException extends Exception {
         error.body = body;
         return error;
     }
-}
+};
+export const E_HTTP_REQUEST_ABORTED = class AbortException extends E_HTTP_EXCEPTION {
+    handle(error, ctx) {
+        ctx.response.status(error.status).send(error.body);
+    }
+};

package/build/src/request.js

@@ -62,7 +62,7 @@ export class Request extends Macroable {
             throw new Error('Cannot re-set initial body. Use "request.updateBody" instead');
         }
         this.updateBody(body);
-        this.#originalRequestData = Object.freeze({ ...this.#requestData });
+        this.#originalRequestData = Object.freeze(lodash.cloneDeep(this.#requestData));
     }
     updateBody(body) {
         this.#requestBody = body;

package/build/src/response.d.ts

@@ -13,7 +13,9 @@ export declare class Response extends Macroable {
     request: IncomingMessage;
     response: ServerResponse;
     get hasLazyBody(): boolean;
-    get isStreamResponse(): boolean;
+    get hasContent(): boolean;
+    get hasStream(): boolean;
+    get content(): [any, boolean, (string | undefined)?] | undefined;
     lazyBody: Partial<{
         content: [any, boolean, string?];
         stream: [ResponseStream, ((error: NodeJS.ErrnoException) => [string, number?])?];

package/build/src/response.js

@@ -13,7 +13,7 @@ import { RuntimeException } from '@poppinss/utils';
 import contentDisposition from 'content-disposition';
 import { Redirect } from './redirect.js';
 import { CookieSerializer } from './cookies/serializer.js';
-import { AbortException } from './exceptions/abort_exception.js';
+import { E_HTTP_REQUEST_ABORTED } from './exceptions/main.js';
 const statFn = promisify(stat);
 const CACHEABLE_HTTP_METHODS = ['GET', 'HEAD'];
 export class Response extends Macroable {
@@ -28,9 +28,15 @@ export class Response extends Macroable {
     get hasLazyBody() {
         return !!(this.lazyBody.content || this.lazyBody.fileToStream || this.lazyBody.stream);
     }
-    get isStreamResponse() {
+    get hasContent() {
+        return !!this.lazyBody.content;
+    }
+    get hasStream() {
         return !!(this.lazyBody.stream || this.lazyBody.fileToStream);
     }
+    get content() {
+        return this.lazyBody.content;
+    }
     lazyBody = {};
     ctx;
     constructor(request, response, encryption, config, router, qs) {
@@ -351,7 +357,7 @@ export class Response extends Macroable {
         return handler;
     }
     abort(body, status) {
-        throw AbortException.invoke(body, status || 400);
+        throw E_HTTP_REQUEST_ABORTED.invoke(body, status || 400);
     }
     abortIf(condition, body, status) {
         if (condition) {
@@ -402,8 +408,8 @@ export class Response extends Macroable {
         if (!this.isPending) {
             return;
         }
-        if (this.lazyBody.content) {
-            this.writeBody(...this.lazyBody.content);
+        if (this.content) {
+            this.writeBody(...this.content);
             return;
         }
         if (this.lazyBody.stream) {

package/build/src/router/brisk.d.ts

@@ -11,6 +11,10 @@ export declare class BriskRoute extends Macroable {
         globalMatchers: RouteMatchers;
     });
     setHandler(handler: RouteFn): Route;
-    redirect(identifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): Route;
-    redirectToPath(url: string): Route;
+    redirect(identifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions & {
+        status: number;
+    }): Route;
+    redirectToPath(url: string, options?: {
+        status: number;
+    }): Route;
 }

package/build/src/router/brisk.js

@@ -24,12 +24,20 @@ export class BriskRoute extends Macroable {
     }
     redirect(identifier, params, options) {
         return this.setHandler(async (ctx) => {
-            return ctx.response.redirect().toRoute(identifier, params || ctx.params, options);
+            const redirector = ctx.response.redirect();
+            if (options?.status) {
+                redirector.status(options.status);
+            }
+            return redirector.toRoute(identifier, params || ctx.params, options);
         });
     }
-    redirectToPath(url) {
+    redirectToPath(url, options) {
         return this.setHandler(async (ctx) => {
-            return ctx.response.redirect().toPath(url);
+            const redirector = ctx.response.redirect();
+            if (options?.status) {
+                redirector.status(options.status);
+            }
+            return redirector.toPath(url);
         });
     }
 }

package/build/src/router/executor.js

@@ -1,13 +1,14 @@
+import { useReturnValue } from './factories/use_return_value.js';
 export function execute(route, resolver, ctx) {
     return route.middleware
         .runner()
-        .finalHandler(() => {
+        .finalHandler(async () => {
         if (typeof route.handler === 'function') {
-            return route.handler(ctx);
+            return Promise.resolve(route.handler(ctx)).then(useReturnValue(ctx));
         }
-        return route.handler.handle(resolver, ctx);
+        return route.handler.handle(resolver, ctx).then(useReturnValue(ctx));
     })
-        .run((middleware, next) => {
+        .run(async (middleware, next) => {
         if (typeof middleware === 'function') {
             return middleware(ctx, next);
         }

package/build/src/router/group.d.ts

@@ -4,6 +4,7 @@ import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js
 import { Route } from './route.js';
 import { BriskRoute } from './brisk.js';
 import { RouteResource } from './resource.js';
+import { OneOrMore } from '../types/base.js';
 export declare class RouteGroup extends Macroable {
     #private;
     routes: (Route | RouteGroup | RouteResource | BriskRoute)[];
@@ -12,6 +13,6 @@ export declare class RouteGroup extends Macroable {
     prefix(prefix: string): this;
     domain(domain: string): this;
     as(name: string): this;
-    use(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
-    middleware(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
+    use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
 }

package/build/src/router/group.js

@@ -103,7 +103,14 @@ export class RouteGroup extends Macroable {
         if (!this.#middleware.length) {
             this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route));
         }
-        this.#middleware.push(middleware);
+        if (Array.isArray(middleware)) {
+            for (let one of middleware) {
+                this.#middleware.push(one);
+            }
+        }
+        else {
+            this.#middleware.push(middleware);
+        }
         return this;
     }
     middleware(middleware) {

package/build/src/router/lookup_store/route_finder.js

@@ -1,4 +1,4 @@
-import { CannotLookupRouteException } from '../../exceptions/cannot_lookup_route.js';
+import * as errors from '../../exceptions/main.js';
 export class RouteFinder {
     #routes;
     constructor(routes) {
@@ -18,7 +18,7 @@ export class RouteFinder {
     findOrFail(routeIdentifier) {
         const route = this.find(routeIdentifier);
         if (!route) {
-            throw new CannotLookupRouteException(`Cannot lookup route "${routeIdentifier}"`);
+            throw new errors.E_CANNOT_LOOKUP_ROUTE([routeIdentifier]);
         }
         return route;
     }

package/build/src/router/lookup_store/url_builder.js

@@ -1,3 +1,4 @@
+import matchit from '@poppinss/matchit';
 import { RuntimeException } from '@poppinss/utils';
 export class UrlBuilder {
     #qsParser;
@@ -27,30 +28,30 @@ export class UrlBuilder {
         const paramsArray = Array.isArray(this.#params) ? this.#params : null;
         const paramsObject = !Array.isArray(this.#params) ? this.#params : {};
         let paramsIndex = 0;
-        const tokens = pattern.split('/');
+        const tokens = matchit.parse(pattern);
         for (const token of tokens) {
-            if (token === '*') {
+            if (token.type === 0) {
+                uriSegments.push(`${token.val}${token.end}`);
+            }
+            else if (token.type === 2) {
                 const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject['*'];
                 this.#ensureHasWildCardValues(pattern, values);
-                values.forEach((value) => uriSegments.push(value));
+                uriSegments.push(`${values.join('/')}${token.end}`);
                 break;
             }
-            else if (!token.startsWith(':')) {
-                uriSegments.push(token);
-            }
             else {
-                const paramName = token.replace(/^:/, '').replace(/\?$/, '');
+                const paramName = token.val;
                 const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
-                if (!token.endsWith('?')) {
+                if (token.type === 1) {
                     this.#ensureHasParamValue(pattern, paramName, value);
                 }
                 paramsIndex++;
                 if (value !== undefined && value !== null) {
-                    uriSegments.push(value);
+                    uriSegments.push(`${value}${token.end}`);
                 }
             }
         }
-        return uriSegments.join('/');
+        return `/${uriSegments.join('/')}`;
     }
     #suffixQueryString(url, qs) {
         if (qs) {

package/build/src/router/resource.d.ts

@@ -21,5 +21,5 @@ export declare class RouteResource extends Macroable {
     params(resources: {
         [resource: string]: string;
     }): this;
-    as(name: string): this;
+    as(name: string, normalizeName?: boolean): this;
 }

package/build/src/router/resource.js

@@ -113,8 +113,8 @@ export class RouteResource extends Macroable {
         });
         return this;
     }
-    as(name) {
-        name = string.snakeCase(name);
+    as(name, normalizeName = true) {
+        name = normalizeName ? string.snakeCase(name) : name;
         this.routes.forEach((route) => {
             route.as(route.getName().replace(this.#routesBaseName, name), false);
         });

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

@@ -1,6 +1,6 @@
 import { Macroable } from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
-import type { Constructor, LazyImport } from '../types/base.js';
+import type { Constructor, LazyImport, OneOrMore } from '../types/base.js';
 import type { MiddlewareFn, ParsedNamedMiddleware, ParsedGlobalMiddleware } from '../types/middleware.js';
 import type { GetControllerHandlers, RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteMiddleware } from '../types/route.js';
 export declare class Route<Controller extends Constructor<any> = any> extends Macroable {
@@ -14,8 +14,8 @@ export declare class Route<Controller extends Constructor<any> = any> extends Ma
     where(param: string, matcher: RouteMatcher | string | RegExp): this;
     prefix(prefix: string): this;
     domain(domain: string, overwrite?: boolean): this;
-    use(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
-    middleware(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
+    use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
     as(name: string, prepend?: boolean): this;
     isDeleted(): boolean;
     markAsDeleted(): void;

package/build/src/router/route.js

@@ -86,7 +86,7 @@ export class Route extends Macroable {
         return this;
     }
     use(middleware) {
-        this.#middleware.push([middleware]);
+        this.#middleware.push(Array.isArray(middleware) ? middleware : [middleware]);
         return this;
     }
     middleware(middleware) {

package/build/src/server/factories/final_handler.js

@@ -1,4 +1,4 @@
-import { RouteNotFoundException } from '../../exceptions/route_not_found.js';
+import * as errors from '../../exceptions/main.js';
 export function finalHandler(router, resolver, ctx) {
     return function () {
         const url = ctx.request.url();
@@ -12,6 +12,6 @@ export function finalHandler(router, resolver, ctx) {
             ctx.routeKey = route.routeKey;
             return route.route.execute(route.route, resolver, ctx);
         }
-        throw new RouteNotFoundException(`Cannot ${method}:${url}`);
+        return Promise.reject(new errors.E_ROUTE_NOT_FOUND([method, url]));
     };
 }

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

@@ -1,5 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+import { Emitter } from '@adonisjs/events';
 import type { Encryption } from '@adonisjs/encryption';
 import type { Server as HttpsServer } from 'node:https';
 import type { Application } from '@adonisjs/application';
@@ -8,17 +9,15 @@ import type { LazyImport } from '../types/base.js';
 import type { MiddlewareAsClass } from '../types/middleware.js';
 import type { ErrorHandlerAsAClass, ServerConfig } from '../types/server.js';
 import { Router } from '../router/main.js';
-import { HttpContext } from '../http_context/main.js';
 export declare class Server {
     #private;
     get usingAsyncLocalStorage(): boolean;
-    constructor(app: Application<any, any>, encryption: Encryption, config: ServerConfig);
+    constructor(app: Application<any, any>, encryption: Encryption, emitter: Emitter<any>, config: ServerConfig);
     use(middleware: LazyImport<MiddlewareAsClass>[]): this;
     errorHandler(handler: LazyImport<ErrorHandlerAsAClass>): this;
     boot(): Promise<void>;
     setNodeServer(server: HttpServer | HttpsServer): void;
     getNodeServer(): HttpServer<typeof IncomingMessage, typeof ServerResponse> | HttpsServer<typeof IncomingMessage, typeof ServerResponse> | undefined;
     getRouter(): Router;
-    onRequest(callback: (ctx: HttpContext) => void): this;
     handle(req: IncomingMessage, res: ServerResponse): Promise<any>;
 }

package/build/src/server/main.js

@@ -1,3 +1,4 @@
+import onFinished from 'on-finished';
 import Middleware from '@poppinss/middleware';
 import { moduleImporter } from '@adonisjs/fold';
 import { Qs } from '../qs.js';
@@ -8,17 +9,17 @@ import { Router } from '../router/main.js';
 import { HttpContext } from '../http_context/main.js';
 import { finalHandler } from './factories/final_handler.js';
 import { writeResponse } from './factories/write_response.js';
-import { useReturnValue } from './factories/use_return_value.js';
 import { asyncLocalStorage } from '../http_context/local_storage.js';
 import { middlewareHandler } from './factories/middleware_handler.js';
 export class Server {
-    #requestHooks = new Set();
-    #errorHandler;
-    #resolvedErrorHandler = {
+    #defaultErrorHandler = {
         handle(error, ctx) {
             ctx.response.status(error.status || 500).send(error.message || 'Internal server error');
         },
     };
+    #errorHandler;
+    #resolvedErrorHandler = this.#defaultErrorHandler;
+    #emitter;
     #app;
     #encryption;
     #config;
@@ -30,8 +31,9 @@ export class Server {
     get usingAsyncLocalStorage() {
         return asyncLocalStorage.isEnabled;
     }
-    constructor(app, encryption, config) {
+    constructor(app, encryption, emitter, config) {
         this.#app = app;
+        this.#emitter = emitter;
         this.#config = config;
         this.#encryption = encryption;
         this.#qsParser = new Qs(this.#config.qs);
@@ -56,10 +58,13 @@ export class Server {
     }
     #handleRequest(ctx, resolver) {
         return this.#serverMiddlewareStack.runner()
+            .errorHandler((error) => this.#resolvedErrorHandler.handle(error, ctx))
             .finalHandler(finalHandler(this.#router, resolver, ctx))
             .run(middlewareHandler(resolver, ctx))
-            .then(useReturnValue(ctx))
-            .catch((error) => this.#resolvedErrorHandler.handle(error, ctx))
+            .catch((error) => {
+            ctx.logger.fatal({ err: error }, 'Exception raised by error handler');
+            return this.#defaultErrorHandler.handle(error, ctx);
+        })
             .finally(writeResponse(ctx));
     }
     use(middleware) {
@@ -91,17 +96,20 @@ export class Server {
     getRouter() {
         return this.#router;
     }
-    onRequest(callback) {
-        this.#requestHooks.add(callback);
-        return this;
-    }
     handle(req, res) {
+        const hasRequestListener = this.#emitter.hasListeners('http:request_finished');
+        const startTime = hasRequestListener ? process.hrtime() : null;
         const resolver = this.#app.container.createResolver();
         const request = new Request(req, res, this.#encryption, this.#config, this.#qsParser);
         const response = new Response(req, res, this.#encryption, this.#config, this.#router, this.#qsParser);
-        const ctx = new HttpContext(request, response, this.#app.logger.child({}), resolver);
-        for (let hook of this.#requestHooks) {
-            hook(ctx);
+        const ctx = new HttpContext(request, response, this.#app.logger.child({ request_id: request.id() }), resolver);
+        if (startTime) {
+            onFinished(res, () => {
+                this.#emitter.emit('http:request_finished', {
+                    ctx: ctx,
+                    duration: process.hrtime(startTime),
+                });
+            });
         }
         if (this.usingAsyncLocalStorage) {
             return asyncLocalStorage.storage.run(ctx, () => this.#handleRequest(ctx, resolver));

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

@@ -1,4 +1,5 @@
 export type { NextFn } from '@poppinss/middleware/types';
+export type OneOrMore<T> = T | T[];
 export type Constructor<T> = new (...args: any[]) => T;
 export type LazyImport<DefaultExport> = () => Promise<{
     default: DefaultExport;

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

@@ -1,8 +1,12 @@
-import type { QSParserConfig } from './qs.js';
 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';
+export type HttpRequestFinishedPayload = {
+    ctx: HttpContext;
+    duration: [number, number];
+};
 export type ServerErrorHandler = {
     handle: (error: any, ctx: HttpContext) => any;
 };

package/build/test_factories/http_context.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from '@adonisjs/logger';
+import type { Request } from '../src/request.js';
+import type { Response } from '../src/response.js';
+import { HttpContext } from '../src/http_context/main.js';
+type FactoryParameters = {
+    request: Request;
+    response: Response;
+    logger: Logger;
+};
+export declare class HttpContextFactory {
+    #private;
+    merge(params: Partial<FactoryParameters>): this;
+    create(): HttpContext;
+}
+export {};

package/build/test_factories/http_context.js

@@ -0,0 +1,24 @@
+import { Container } from '@adonisjs/fold';
+import { LoggerFactory } from '@adonisjs/logger/test_factories/logger';
+import { RequestFactory } from './request.js';
+import { ResponseFactory } from './response.js';
+import { HttpContext } from '../src/http_context/main.js';
+export class HttpContextFactory {
+    #parameters = {};
+    #createRequest() {
+        return this.#parameters.request || new RequestFactory().create();
+    }
+    #createResponse() {
+        return this.#parameters.response || new ResponseFactory().create();
+    }
+    #createLogger() {
+        return this.#parameters.logger || new LoggerFactory().create();
+    }
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    create() {
+        return new HttpContext(this.#createRequest(), this.#createResponse(), this.#createLogger(), new Container().createResolver());
+    }
+}

package/build/test_factories/qs_parser_factory.d.ts

@@ -0,0 +1,10 @@
+import { Qs } from '../src/qs.js';
+import type { QSParserConfig } from '../src/types/qs.js';
+export declare class QsParserFactory {
+    #private;
+    merge(options: Partial<{
+        parse: Partial<QSParserConfig['parse']>;
+        stringify: Partial<QSParserConfig['stringify']>;
+    }>): this;
+    create(): Qs;
+}

package/build/test_factories/qs_parser_factory.js

@@ -0,0 +1,26 @@
+import { Qs } from '../src/qs.js';
+export class QsParserFactory {
+    #options = {
+        parse: {
+            depth: 5,
+            parameterLimit: 1000,
+            allowSparse: false,
+            arrayLimit: 20,
+            comma: true,
+        },
+        stringify: {
+            encode: true,
+            encodeValuesOnly: false,
+            arrayFormat: 'indices',
+            skipNulls: false,
+        },
+    };
+    merge(options) {
+        Object.assign(this.#options.parse, options.parse);
+        Object.assign(this.#options.stringify, options.stringify);
+        return this;
+    }
+    create() {
+        return new Qs(this.#options);
+    }
+}

package/build/test_factories/request.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Encryption } from '@adonisjs/encryption';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Request } from '../src/request.js';
+import { RequestConfig } from '../src/types/request.js';
+type FactoryParameters = {
+    url: string;
+    method: string;
+    req: IncomingMessage;
+    res: ServerResponse;
+    encryption: Encryption;
+    config: Partial<RequestConfig>;
+};
+export declare class RequestFactory {
+    #private;
+    merge(params: Partial<FactoryParameters>): this;
+    create(): Request;
+}
+export {};

package/build/test_factories/request.js

@@ -0,0 +1,42 @@
+import { Socket } from 'node:net';
+import proxyAddr from 'proxy-addr';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { EncryptionFactory } from '@adonisjs/encryption/test_factories/encryption';
+import { Request } from '../src/request.js';
+import { QsParserFactory } from './qs_parser_factory.js';
+export class RequestFactory {
+    #parameters = {};
+    #getConfig() {
+        return {
+            allowMethodSpoofing: false,
+            trustProxy: proxyAddr.compile('loopback'),
+            subdomainOffset: 2,
+            generateRequestId: true,
+            ...this.#parameters.config,
+        };
+    }
+    #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;
+    }
+    #createResponse(req) {
+        return this.#parameters.res || new ServerResponse(req);
+    }
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    create() {
+        const req = this.#createRequest();
+        return new Request(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), new QsParserFactory().create());
+    }
+}

package/build/test_factories/response.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Encryption } from '@adonisjs/encryption';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Response } from '../src/response.js';
+import { Router } from '../src/router/main.js';
+import { ResponseConfig } from '../src/types/response.js';
+type FactoryParameters = {
+    req: IncomingMessage;
+    res: ServerResponse;
+    encryption: Encryption;
+    config: Partial<ResponseConfig>;
+    router: Router;
+};
+export declare class ResponseFactory {
+    #private;
+    merge(params: Partial<FactoryParameters>): this;
+    create(): Response;
+}
+export {};

package/build/test_factories/response.js

@@ -0,0 +1,43 @@
+import { Socket } from 'node:net';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { EncryptionFactory } from '@adonisjs/encryption/test_factories/encryption';
+import { RouterFactory } from './router.js';
+import { Response } from '../src/response.js';
+import { QsParserFactory } from './qs_parser_factory.js';
+export class ResponseFactory {
+    #parameters = {};
+    #getConfig() {
+        return {
+            etag: false,
+            jsonpCallbackName: 'callback',
+            cookie: {
+                maxAge: 90,
+                path: '/',
+                httpOnly: true,
+                sameSite: false,
+                secure: false,
+            },
+            ...this.#parameters.config,
+        };
+    }
+    #createRequest() {
+        return this.#parameters.req || new IncomingMessage(new Socket());
+    }
+    #createRouter() {
+        return this.#parameters.router || new RouterFactory().create();
+    }
+    #createResponse(req) {
+        return this.#parameters.res || new ServerResponse(req);
+    }
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    create() {
+        const req = this.#createRequest();
+        return new Response(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), this.#createRouter(), new QsParserFactory().create());
+    }
+}

package/build/test_factories/router.d.ts

@@ -0,0 +1,13 @@
+import type { Encryption } from '@adonisjs/encryption';
+import type { Application } from '@adonisjs/application';
+import { Router } from '../src/router/main.js';
+type FactoryParameters = {
+    app: Application<any, any>;
+    encryption: Encryption;
+};
+export declare class RouterFactory {
+    #private;
+    merge(params: Partial<FactoryParameters>): this;
+    create(): Router;
+}
+export {};

package/build/test_factories/router.js

@@ -0,0 +1,20 @@
+import { AppFactory } from '@adonisjs/application/test_factories/app';
+import { EncryptionFactory } from '@adonisjs/encryption/test_factories/encryption';
+import { Router } from '../src/router/main.js';
+import { QsParserFactory } from './qs_parser_factory.js';
+export class RouterFactory {
+    #parameters = {};
+    #getApp() {
+        return this.#parameters.app || new AppFactory().create(new URL('./app/', import.meta.url));
+    }
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    create() {
+        return new Router(this.#getApp(), this.#createEncryption(), new QsParserFactory().create());
+    }
+}

package/build/test_factories/server_factory.d.ts

@@ -0,0 +1,17 @@
+import { Emitter } from '@adonisjs/events';
+import type { Encryption } from '@adonisjs/encryption';
+import type { Application } from '@adonisjs/application';
+import { Server } from '../src/server/main.js';
+import type { ServerConfig } from '../src/types/server.js';
+type FactoryParameters = {
+    app: Application<any, any>;
+    encryption: Encryption;
+    emitter: Emitter<any>;
+    config: Partial<ServerConfig>;
+};
+export declare class ServerFactory {
+    #private;
+    merge(params: Partial<FactoryParameters>): this;
+    create(): Server;
+}
+export {};

package/build/test_factories/server_factory.js

@@ -0,0 +1,27 @@
+import { Emitter } from '@adonisjs/events';
+import { AppFactory } from '@adonisjs/application/test_factories/app';
+import { EncryptionFactory } from '@adonisjs/encryption/test_factories/encryption';
+import { Server } from '../src/server/main.js';
+import { defineConfig } from '../src/define_config.js';
+export class ServerFactory {
+    #parameters = {};
+    #getEmitter() {
+        return this.#parameters.emitter || new Emitter(this.#getApp());
+    }
+    #getConfig() {
+        return defineConfig(this.#parameters.config || {});
+    }
+    #getApp() {
+        return this.#parameters.app || new AppFactory().create(new URL('./app/', import.meta.url));
+    }
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    create() {
+        return new Server(this.#getApp(), this.#createEncryption(), this.#getEmitter(), this.#getConfig());
+    }
+}

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@adonisjs/http-server",
-  "version": "6.2.0-0",
+  "version": "6.4.0-0",
   "description": "AdonisJS HTTP server with support packed with Routing and Cookies",
   "main": "build/index.js",
   "type": "module",
   "files": [
     "build/src",
+    "build/test_factories",
     "build/index.d.ts",
     "build/index.js"
   ],
   "exports": {
     ".": "./build/index.js",
-    "./types": "./build/src/types/main.js"
+    "./types": "./build/src/types/main.js",
+    "./test_factories/*": "./build/test_factories/*.js"
   },
   "scripts": {
     "pretest": "npm run lint",
@@ -37,13 +39,14 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^6.4.0-0",
-    "@adonisjs/config": "^4.1.2-0",
-    "@adonisjs/encryption": "^5.0.2-0",
-    "@adonisjs/fold": "^9.8.0-0",
-    "@adonisjs/logger": "^5.1.0-0",
-    "@commitlint/cli": "^17.3.0",
-    "@commitlint/config-conventional": "^17.3.0",
+    "@adonisjs/application": "^6.6.0-0",
+    "@adonisjs/config": "^4.1.3-0",
+    "@adonisjs/encryption": "^5.1.0-0",
+    "@adonisjs/events": "^8.4.0-0",
+    "@adonisjs/fold": "^9.9.0-0",
+    "@adonisjs/logger": "^5.2.0-0",
+    "@commitlint/cli": "^17.4.1",
+    "@commitlint/config-conventional": "^17.4.0",
     "@fastify/middie": "^8.1.0",
     "@japa/api-client": "^1.4.2",
     "@japa/assert": "^1.3.6",
@@ -51,7 +54,7 @@
     "@japa/run-failed-tests": "^1.1.0",
     "@japa/runner": "^2.2.2",
     "@japa/spec-reporter": "^1.3.2",
-    "@swc/core": "^1.3.22",
+    "@swc/core": "^1.3.26",
     "@types/accepts": "^1.3.5",
     "@types/content-disposition": "^0.5.5",
     "@types/cookie": "^0.5.1",
@@ -59,7 +62,7 @@
     "@types/encodeurl": "^1.0.0",
     "@types/etag": "^1.8.1",
     "@types/fresh": "^0.5.0",
-    "@types/fs-extra": "^9.0.13",
+    "@types/fs-extra": "^11.0.1",
     "@types/http-status-codes": "^1.2.0",
     "@types/mime-types": "^2.1.1",
     "@types/on-finished": "^2.3.1",
@@ -73,16 +76,16 @@
     "c8": "^7.12.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.28.0",
-    "eslint-config-prettier": "^8.5.0",
+    "eslint": "^8.31.0",
+    "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-adonis": "^3.0.3",
     "eslint-plugin-prettier": "^4.2.1",
-    "fastify": "^4.10.2",
+    "fastify": "^4.11.0",
     "fs-extra": "^11.1.0",
     "github-label-sync": "^2.2.0",
     "http-status-codes": "^2.2.0",
-    "husky": "^8.0.2",
-    "np": "^7.6.2",
+    "husky": "^8.0.3",
+    "np": "^7.6.3",
     "pem": "^1.14.6",
     "prettier": "^2.8.1",
     "reflect-metadata": "^0.1.13",
@@ -93,8 +96,8 @@
   "dependencies": {
     "@poppinss/macroable": "^1.0.0-0",
     "@poppinss/matchit": "^3.1.2",
-    "@poppinss/middleware": "^3.0.0",
-    "@poppinss/utils": "^6.1.0-0",
+    "@poppinss/middleware": "^3.1.0",
+    "@poppinss/utils": "^6.3.1-0",
     "@sindresorhus/is": "^5.3.0",
     "accepts": "^1.3.8",
     "content-disposition": "^0.5.4",
@@ -113,9 +116,10 @@
     "vary": "^1.1.2"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^6.4.0-0",
-    "@adonisjs/encryption": "^5.0.2-0",
-    "@adonisjs/fold": "^9.8.0-0"
+    "@adonisjs/application": "^6.6.0-0",
+    "@adonisjs/encryption": "^5.1.0-0",
+    "@adonisjs/events": "^8.4.0-0",
+    "@adonisjs/fold": "^9.9.0-0"
   },
   "repository": {
     "type": "git",

package/build/src/exceptions/abort_exception.d.ts

@@ -1,5 +0,0 @@
-import { HttpException } from './http_exception.js';
-import type { HttpContext } from '../http_context/main.js';
-export declare class AbortException extends HttpException {
-    handle(error: HttpException, ctx: HttpContext): void;
-}

package/build/src/exceptions/abort_exception.js

@@ -1,6 +0,0 @@
-import { HttpException } from './http_exception.js';
-export class AbortException extends HttpException {
-    handle(error, ctx) {
-        ctx.response.status(error.status).send(error.body);
-    }
-}

package/build/src/exceptions/cannot_lookup_route.d.ts

@@ -1,5 +0,0 @@
-import { Exception } from '@poppinss/utils';
-export declare class CannotLookupRouteException extends Exception {
-    static status: number;
-    static code: string;
-}

package/build/src/exceptions/cannot_lookup_route.js

@@ -1,5 +0,0 @@
-import { Exception } from '@poppinss/utils';
-export class CannotLookupRouteException extends Exception {
-    static status = 500;
-    static code = 'E_CANNOT_LOOKUP_ROUTE';
-}

package/build/src/exceptions/http_exception.d.ts

@@ -1,6 +0,0 @@
-import { Exception } from '@poppinss/utils';
-export declare class HttpException extends Exception {
-    body: any;
-    static code: string;
-    static invoke(body: any, status: number, code?: string): HttpException;
-}

package/build/src/exceptions/route_not_found.d.ts

@@ -1,5 +0,0 @@
-import { HttpException } from './http_exception.js';
-export declare class RouteNotFoundException extends HttpException {
-    static status: number;
-    static code: string;
-}

package/build/src/exceptions/route_not_found.js

@@ -1,5 +0,0 @@
-import { HttpException } from './http_exception.js';
-export class RouteNotFoundException extends HttpException {
-    static status = 404;
-    static code = 'E_ROUTE_NOT_FOUND';
-}