@adonisjs/http-server 6.0.1-0 → 6.1.0-0

package/build/index.d.ts

@@ -13,4 +13,3 @@ 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 { defineMiddleware, defineNamedMiddleware } from './src/define_middleware.js';

package/build/index.js

@@ -13,4 +13,3 @@ 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 { defineMiddleware, defineNamedMiddleware } from './src/define_middleware.js';

package/build/src/define_middleware.d.ts

@@ -1,4 +1,6 @@
-import type { LazyImport } from './types/base.js';
-import type { MiddlewareAsClass } from './types/middleware.js';
-export declare function defineMiddleware(list: LazyImport<MiddlewareAsClass>[]): LazyImport<MiddlewareAsClass>[];
-export declare function defineNamedMiddleware<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): NamedMiddleware;
+import type { LazyImport, UnWrapLazyImport } from './types/base.js';
+import type { GetMiddlewareArgs, MiddlewareAsClass, ParsedGlobalMiddleware } from './types/middleware.js';
+export declare function defineNamedMiddleware<NamedMiddleware extends Record<string | number | symbol, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): { [K in keyof NamedMiddleware]: <Args extends GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[K]>>>(...args: Args) => {
+    name: K;
+    args: Args[0];
+} & ParsedGlobalMiddleware; };

package/build/src/define_middleware.js

@@ -1,6 +1,17 @@
-export function defineMiddleware(list) {
-    return list;
+import { moduleImporter } from '@adonisjs/fold';
+function middlewareReferenceBuilder(name, middleware) {
+    const handler = moduleImporter(middleware, 'handle').toHandleMethod();
+    return function (...args) {
+        return {
+            name,
+            args: args[0],
+            ...handler,
+        };
+    };
 }
 export function defineNamedMiddleware(collection) {
-    return collection;
+    return Object.keys(collection).reduce((result, key) => {
+        result[key] = middlewareReferenceBuilder(key, collection[key]);
+        return result;
+    }, {});
 }

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

@@ -1,5 +1,6 @@
 import type { Logger } from '@adonisjs/logger';
 import { Macroable } from '@poppinss/macroable';
+import { ContainerResolver } from '@adonisjs/fold';
 import type { Request } from '../request.js';
 import type { Response } from '../response.js';
 import type { StoreRouteNode } from '../types/route.js';
@@ -7,6 +8,7 @@ export declare class HttpContext extends Macroable {
     request: Request;
     response: Response;
     logger: Logger;
+    containerResolver: ContainerResolver<any>;
     static get usingAsyncLocalStorage(): boolean;
     static get(): HttpContext | null;
     static getOrFail(): HttpContext;
@@ -15,6 +17,6 @@ export declare class HttpContext extends Macroable {
     routeKey?: string;
     params: Record<string, any>;
     subdomains: Record<string, any>;
-    constructor(request: Request, response: Response, logger: Logger);
+    constructor(request: Request, response: Response, logger: Logger, containerResolver: ContainerResolver<any>);
     inspect(): string;
 }

package/build/src/http_context/main.js

@@ -6,6 +6,7 @@ export class HttpContext extends Macroable {
     request;
     response;
     logger;
+    containerResolver;
     static get usingAsyncLocalStorage() {
         return asyncLocalStorage.isEnabled;
     }
@@ -35,11 +36,12 @@ export class HttpContext extends Macroable {
     routeKey;
     params = {};
     subdomains = {};
-    constructor(request, response, logger) {
+    constructor(request, response, logger, containerResolver) {
         super();
         this.request = request;
         this.response = response;
         this.logger = logger;
+        this.containerResolver = containerResolver;
         this.request.ctx = this;
         this.response.ctx = this;
     }

package/build/src/request.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import { Macroable } from '@poppinss/macroable';
-import type { Encryption } from '@adonisjs/encryption';
 import { UrlWithStringQuery } from 'node:url';
+import type { Encryption } from '@adonisjs/encryption';
 import { ServerResponse, IncomingMessage, IncomingHttpHeaders } from 'node:http';
 import type { Qs } from './qs.js';
 import { RequestConfig } from './types/request.js';

package/build/src/request.js

@@ -4,8 +4,8 @@ import typeIs from 'type-is';
 import accepts from 'accepts';
 import { isIP } from 'node:net';
 import proxyaddr from 'proxy-addr';
-import { safeEqual } from '@poppinss/utils';
 import lodash from '@poppinss/utils/lodash';
+import { safeEqual } from '@poppinss/utils';
 import { Macroable } from '@poppinss/macroable';
 import { parse } from 'node:url';
 import { trustProxy } from './helpers.js';

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

@@ -1,14 +1,12 @@
 import { Macroable } from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
 import { Route } from './route.js';
-import type { LazyImport } from '../types/base.js';
-import type { MiddlewareStore } from '../middleware/store.js';
-import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { ParsedGlobalMiddleware } from '../types/middleware.js';
 import type { MakeUrlOptions, RouteFn, RouteMatchers } from '../types/route.js';
-export declare class BriskRoute<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+export declare class BriskRoute extends Macroable {
     #private;
-    route: null | Route<NamedMiddleware>;
-    constructor(app: Application<any, any, any>, middlewareStore: MiddlewareStore<NamedMiddleware>, options: {
+    route: null | Route;
+    constructor(app: Application<any, any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
         pattern: string;
         globalMatchers: RouteMatchers;
     });

package/build/src/router/brisk.js

@@ -4,17 +4,17 @@ export class BriskRoute extends Macroable {
     #pattern;
     #globalMatchers;
     #app;
-    #middlewareStore;
+    #routerMiddleware;
     route = null;
-    constructor(app, middlewareStore, options) {
+    constructor(app, routerMiddleware, options) {
         super();
         this.#app = app;
-        this.#middlewareStore = middlewareStore;
+        this.#routerMiddleware = routerMiddleware;
         this.#pattern = options.pattern;
         this.#globalMatchers = options.globalMatchers;
     }
     setHandler(handler) {
-        this.route = new Route(this.#app, this.#middlewareStore, {
+        this.route = new Route(this.#app, this.#routerMiddleware, {
             pattern: this.#pattern,
             globalMatchers: this.#globalMatchers,
             methods: ['GET', 'HEAD'],

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

@@ -1,19 +1,17 @@
 import { Macroable } from '@poppinss/macroable';
-import type { MiddlewareStore } from '../middleware/store.js';
-import type { LazyImport, UnWrapLazyImport } from '../types/base.js';
 import type { RouteMatcher } from '../types/route.js';
-import type { GetMiddlewareArgs, MiddlewareAsClass, MiddlewareFn } from '../types/middleware.js';
+import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js';
 import { Route } from './route.js';
 import { BriskRoute } from './brisk.js';
 import { RouteResource } from './resource.js';
-export declare class RouteGroup<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+export declare class RouteGroup extends Macroable {
     #private;
     routes: (Route | RouteGroup | RouteResource | BriskRoute)[];
-    constructor(routes: (Route | RouteGroup | RouteResource | BriskRoute)[], middlewareStore: MiddlewareStore<NamedMiddleware>);
+    constructor(routes: (Route | RouteGroup | RouteResource | BriskRoute)[]);
     where(param: string, matcher: RouteMatcher | string | RegExp): this;
     prefix(prefix: string): this;
     domain(domain: string): this;
     as(name: string): this;
-    middleware<Name extends keyof NamedMiddleware>(middleware: Name, ...args: GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[Name]>>): this;
-    middleware(middleware: MiddlewareFn): this;
+    use(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
+    middleware(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
 }

package/build/src/router/group.js

@@ -4,11 +4,9 @@ import { RouteResource } from './resource.js';
 export class RouteGroup extends Macroable {
     routes;
     #middleware = [];
-    #middlewareStore;
-    constructor(routes, middlewareStore) {
+    constructor(routes) {
         super();
         this.routes = routes;
-        this.#middlewareStore = middlewareStore;
     }
     #shareMiddlewareStackWithRoutes(route) {
         if (route instanceof RouteGroup) {
@@ -101,17 +99,14 @@ export class RouteGroup extends Macroable {
         this.routes.forEach((route) => this.#updateRouteName(route, name));
         return this;
     }
-    middleware(middleware, args) {
+    use(middleware) {
         if (!this.#middleware.length) {
             this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route));
         }
-        if (typeof middleware === 'string') {
-            this.#middleware.push(this.#middlewareStore.get(middleware, args));
-            return this;
-        }
-        if (typeof middleware === 'function') {
-            this.#middleware.push(middleware);
-        }
+        this.#middleware.push(middleware);
         return this;
     }
+    middleware(middleware) {
+        return this.use(middleware);
+    }
 }

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

@@ -5,29 +5,33 @@ import { Route } from './route.js';
 import { RouteGroup } from './group.js';
 import { BriskRoute } from './brisk.js';
 import { RouteResource } from './resource.js';
+import type { LazyImport } from '../types/base.js';
 import { LookupStore } from './lookup_store/main.js';
 import { RouteMatchers as Matchers } from './matchers.js';
-import type { LazyImport } from '../types/base.js';
-import { MiddlewareStore } from '../middleware/store.js';
-import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js';
 import type { RouteFn, MatchedRoute, RouteMatcher, MakeUrlOptions, MakeSignedUrlOptions } from '../types/route.js';
-export declare class Router<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends LookupStore {
+export declare class Router extends LookupStore {
     #private;
-    routes: (Route<NamedMiddleware> | RouteResource<NamedMiddleware> | RouteGroup<NamedMiddleware> | BriskRoute<NamedMiddleware>)[];
+    routes: (Route | RouteResource | RouteGroup | BriskRoute)[];
     usingDomains: boolean;
     matchers: Matchers;
-    constructor(app: Application<any, any, any>, encryption: Encryption, middlewareStore: MiddlewareStore<NamedMiddleware>, qsParser: Qs);
-    route(pattern: string, methods: string[], handler: string | RouteFn): Route<NamedMiddleware>;
-    any(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
-    get(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
-    post(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
-    put(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
-    patch(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
-    delete(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
-    group(callback: () => void): RouteGroup<NamedMiddleware>;
-    resource(resource: string, controller: string): RouteResource<NamedMiddleware>;
-    shallowResource(resource: string, controller: string): RouteResource<NamedMiddleware>;
-    on(pattern: string): BriskRoute<NamedMiddleware>;
+    constructor(app: Application<any, any>, encryption: Encryption, qsParser: Qs);
+    use(middleware: LazyImport<MiddlewareAsClass>[]): this;
+    named<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): { [K in keyof NamedMiddleware]: <Args extends import("../types/middleware.js").GetMiddlewareArgs<import("../types/base.js").UnWrapLazyImport<NamedMiddleware[K]>>>(...args: Args) => {
+        name: K;
+        args: Args[0];
+    } & ParsedGlobalMiddleware; };
+    route(pattern: string, methods: string[], handler: string | RouteFn): Route;
+    any(pattern: string, handler: string | RouteFn): Route;
+    get(pattern: string, handler: string | RouteFn): Route;
+    post(pattern: string, handler: string | RouteFn): Route;
+    put(pattern: string, handler: string | RouteFn): Route;
+    patch(pattern: string, handler: string | RouteFn): Route;
+    delete(pattern: string, handler: string | RouteFn): Route;
+    group(callback: () => void): RouteGroup;
+    resource(resource: string, controller: string): RouteResource;
+    shallowResource(resource: string, controller: string): RouteResource;
+    on(pattern: string): BriskRoute;
     where(param: string, matcher: RouteMatcher | string | RegExp): this;
     commit(): void;
     match(url: string, method: string, hostname?: string | null): null | MatchedRoute;

package/build/src/router/main.js

@@ -1,4 +1,5 @@
 import is from '@sindresorhus/is';
+import { moduleImporter } from '@adonisjs/fold';
 import { RuntimeException } from '@poppinss/utils';
 import { Route } from './route.js';
 import { RouteGroup } from './group.js';
@@ -8,19 +9,19 @@ import { toRoutesJSON } from '../helpers.js';
 import { RouteResource } from './resource.js';
 import { LookupStore } from './lookup_store/main.js';
 import { RouteMatchers as Matchers } from './matchers.js';
+import { defineNamedMiddleware } from '../define_middleware.js';
 export class Router extends LookupStore {
     #app;
     #store = new RoutesStore();
     #globalMatchers = {};
-    #middlewareStore;
+    #middleware = [];
     #openedGroups = [];
     routes = [];
     usingDomains = false;
     matchers = new Matchers();
-    constructor(app, encryption, middlewareStore, qsParser) {
+    constructor(app, encryption, qsParser) {
         super(encryption, qsParser);
         this.#app = app;
-        this.#middlewareStore = middlewareStore;
     }
     #pushToRoutes(entity) {
         const openedGroup = this.#openedGroups[this.#openedGroups.length - 1];
@@ -30,8 +31,15 @@ export class Router extends LookupStore {
         }
         this.routes.push(entity);
     }
+    use(middleware) {
+        middleware.forEach((one) => this.#middleware.push(moduleImporter(one, 'handle').toHandleMethod()));
+        return this;
+    }
+    named(collection) {
+        return defineNamedMiddleware(collection);
+    }
     route(pattern, methods, handler) {
-        const route = new Route(this.#app, this.#middlewareStore, {
+        const route = new Route(this.#app, this.#middleware, {
             pattern,
             methods,
             handler,
@@ -59,7 +67,7 @@ export class Router extends LookupStore {
         return this.route(pattern, ['DELETE'], handler);
     }
     group(callback) {
-        const group = new RouteGroup([], this.#middlewareStore);
+        const group = new RouteGroup([]);
         this.#pushToRoutes(group);
         this.#openedGroups.push(group);
         callback();
@@ -67,7 +75,7 @@ export class Router extends LookupStore {
         return group;
     }
     resource(resource, controller) {
-        const resourceInstance = new RouteResource(this.#app, this.#middlewareStore, {
+        const resourceInstance = new RouteResource(this.#app, this.#middleware, {
             resource,
             controller,
             shallow: false,
@@ -77,7 +85,7 @@ export class Router extends LookupStore {
         return resourceInstance;
     }
     shallowResource(resource, controller) {
-        const resourceInstance = new RouteResource(this.#app, this.#middlewareStore, {
+        const resourceInstance = new RouteResource(this.#app, this.#middleware, {
             resource,
             controller,
             shallow: true,
@@ -87,7 +95,7 @@ export class Router extends LookupStore {
         return resourceInstance;
     }
     on(pattern) {
-        const briskRoute = new BriskRoute(this.#app, this.#middlewareStore, {
+        const briskRoute = new BriskRoute(this.#app, this.#middleware, {
             pattern,
             globalMatchers: this.#globalMatchers,
         });
@@ -126,6 +134,7 @@ export class Router extends LookupStore {
         this.usingDomains = this.#store.usingDomains;
         this.routes = [];
         this.#globalMatchers = {};
+        this.#middleware = [];
     }
     match(url, method, hostname) {
         const matchingDomain = this.#store.matchDomain(hostname);

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

@@ -1,14 +1,12 @@
 import { Macroable } from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
 import { Route } from './route.js';
-import type { LazyImport } from '../types/base.js';
-import type { MiddlewareStore } from '../middleware/store.js';
-import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { ParsedGlobalMiddleware } from '../types/middleware.js';
 import type { ResourceActionNames, RouteMatcher, RouteMatchers } from '../types/route.js';
-export declare class RouteResource<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+export declare class RouteResource extends Macroable {
     #private;
     routes: Route[];
-    constructor(app: Application<any, any, any>, middlewareStore: MiddlewareStore<NamedMiddleware>, options: {
+    constructor(app: Application<any, any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
         resource: string;
         controller: string;
         globalMatchers: RouteMatchers;
@@ -18,8 +16,8 @@ export declare class RouteResource<NamedMiddleware extends Record<string, LazyIm
     except(names: ResourceActionNames[]): this;
     apiOnly(): this;
     where(key: string, matcher: RouteMatcher | string | RegExp): this;
-    tap(callback: (route: Route<NamedMiddleware>) => void): this;
-    tap(actions: ResourceActionNames | ResourceActionNames[], callback: (route: Route<NamedMiddleware>) => void): this;
+    tap(callback: (route: Route) => void): this;
+    tap(actions: ResourceActionNames | ResourceActionNames[], callback: (route: Route) => void): this;
     params(resources: {
         [resource: string]: string;
     }): this;

package/build/src/router/resource.js

@@ -8,16 +8,16 @@ export class RouteResource extends Macroable {
     #shallow = false;
     #globalMatchers;
     #app;
-    #middlewareStore;
+    #routerMiddleware;
     #params = {};
     #routesBaseName;
     routes = [];
-    constructor(app, middlewareStore, options) {
+    constructor(app, routerMiddleware, options) {
         super();
         this.#validateResourceName(options.resource);
         this.#app = app;
         this.#shallow = options.shallow;
-        this.#middlewareStore = middlewareStore;
+        this.#routerMiddleware = routerMiddleware;
         this.#controller = options.controller;
         this.#globalMatchers = options.globalMatchers;
         this.#resource = this.#normalizeResourceName(options.resource);
@@ -39,7 +39,7 @@ export class RouteResource extends Macroable {
             .join('.');
     }
     #createRoute(pattern, methods, action) {
-        const route = new Route(this.#app, this.#middlewareStore, {
+        const route = new Route(this.#app, this.#routerMiddleware, {
             pattern,
             methods,
             handler: `${this.#controller}.${action}`,

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

@@ -1,12 +1,10 @@
 import { Macroable } from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
-import type { MiddlewareStore } from '../middleware/store.js';
-import type { LazyImport, UnWrapLazyImport } from '../types/base.js';
-import type { GetMiddlewareArgs, MiddlewareAsClass, MiddlewareFn } from '../types/middleware.js';
+import type { MiddlewareFn, ParsedNamedMiddleware, ParsedGlobalMiddleware } from '../types/middleware.js';
 import type { RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteMiddleware } from '../types/route.js';
-export declare class Route<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+export declare class Route extends Macroable {
     #private;
-    constructor(app: Application<any, any, any>, middlewareStore: MiddlewareStore<NamedMiddleware>, options: {
+    constructor(app: Application<any, any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
         pattern: string;
         methods: string[];
         handler: RouteFn | string;
@@ -15,8 +13,8 @@ export declare class Route<NamedMiddleware extends Record<string, LazyImport<Mid
     where(param: string, matcher: RouteMatcher | string | RegExp): this;
     prefix(prefix: string): this;
     domain(domain: string, overwrite?: boolean): this;
-    middleware<Name extends keyof NamedMiddleware>(middleware: Name, ...args: GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[Name]>>): this;
-    middleware(middleware: MiddlewareFn): this;
+    use(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
+    middleware(middleware: MiddlewareFn | ParsedNamedMiddleware): this;
     as(name: string, prepend?: boolean): this;
     isDeleted(): boolean;
     markAsDeleted(): void;

package/build/src/router/route.js

@@ -13,15 +13,15 @@ export class Route extends Macroable {
     #handler;
     #globalMatchers;
     #app;
-    #middlewareStore;
+    #routerMiddleware;
     #routeDomain = 'root';
     #matchers = {};
     #prefixes = [];
     #middleware = [];
-    constructor(app, middlewareStore, options) {
+    constructor(app, routerMiddleware, options) {
         super();
         this.#app = app;
-        this.#middlewareStore = middlewareStore;
+        this.#routerMiddleware = routerMiddleware;
         this.#pattern = options.pattern;
         this.#methods = options.methods;
         this.#handler = this.#resolveRouteHandle(options.handler);
@@ -73,16 +73,13 @@ export class Route extends Macroable {
         }
         return this;
     }
-    middleware(middleware, args) {
-        if (typeof middleware === 'string') {
-            this.#middleware.push([this.#middlewareStore.get(middleware, args)]);
-            return this;
-        }
-        if (typeof middleware === 'function') {
-            this.#middleware.push([middleware]);
-        }
+    use(middleware) {
+        this.#middleware.push([middleware]);
         return this;
     }
+    middleware(middleware) {
+        return this.use(middleware);
+    }
     as(name, prepend = false) {
         if (prepend) {
             if (!this.#name) {
@@ -115,7 +112,7 @@ export class Route extends Macroable {
     }
     #getMiddlewareForStore() {
         const middleware = new Middleware();
-        this.#middlewareStore.list().forEach((one) => middleware.add(one));
+        this.#routerMiddleware.forEach((one) => middleware.add(one));
         this.#middleware.flat().forEach((one) => middleware.add(one));
         return middleware;
     }

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

@@ -1,23 +1,24 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import type { Encryption } from '@adonisjs/encryption';
-import type { Application } from '@adonisjs/application';
 import type { Server as HttpsServer } from 'node:https';
+import type { Application } from '@adonisjs/application';
 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 { ErrorHandlerAsAClass, ServerConfig } from '../types/server.js';
 import { Router } from '../router/main.js';
-export declare class Server<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> {
+import { HttpContext } from '../http_context/main.js';
+export declare class Server {
     #private;
     get usingAsyncLocalStorage(): boolean;
-    constructor(app: Application<any, any, any>, encryption: Encryption, config: ServerConfig);
-    use(serverMiddleware: LazyImport<MiddlewareAsClass>[], routerMiddleware: LazyImport<MiddlewareAsClass>[], namedMiddleware: NamedMiddleware): this;
+    constructor(app: Application<any, any>, encryption: Encryption, config: ServerConfig);
+    use(middleware: LazyImport<MiddlewareAsClass>[]): this;
     errorHandler(handler: LazyImport<ErrorHandlerAsAClass>): this;
     boot(): Promise<void>;
     setNodeServer(server: HttpServer | HttpsServer): void;
-    close(): Promise<void>;
     getNodeServer(): HttpServer<typeof IncomingMessage, typeof ServerResponse> | HttpsServer<typeof IncomingMessage, typeof ServerResponse> | undefined;
-    getRouter(): Router<any> | undefined;
+    getRouter(): Router;
+    onRequest(callback: (ctx: HttpContext) => void): this;
     handle(req: IncomingMessage, res: ServerResponse): Promise<any>;
 }

package/build/src/server/main.js

@@ -1,18 +1,18 @@
 import Middleware from '@poppinss/middleware';
-import { RuntimeException } from '@poppinss/utils';
+import { moduleImporter } from '@adonisjs/fold';
 import { Qs } from '../qs.js';
 import debug from '../debug.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 { MiddlewareStore } from '../middleware/store.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 = {
         handle(error, ctx) {
@@ -25,43 +25,45 @@ export class Server {
     #qsParser;
     #serverMiddlewareStack;
     #router;
-    #underlyingHttpServer;
+    #nodeHttpServer;
+    #middleware = [];
     get usingAsyncLocalStorage() {
         return asyncLocalStorage.isEnabled;
     }
     constructor(app, encryption, config) {
         this.#app = app;
-        this.#encryption = encryption;
         this.#config = config;
+        this.#encryption = encryption;
         this.#qsParser = new Qs(this.#config.qs);
+        this.#router = new Router(this.#app, this.#encryption, this.#qsParser);
         this.#createAsyncLocalStore();
         debug('server config: %O', this.#config);
     }
     #createAsyncLocalStore() {
         if (this.#config.useAsyncLocalStorage) {
-            debug('creating http context async local storage');
+            debug('creating ALS store for HTTP context');
             asyncLocalStorage.create();
         }
         else {
             asyncLocalStorage.destroy();
         }
     }
-    #createRouter(middlewareStore) {
-        this.#router = new Router(this.#app, this.#encryption, middlewareStore, this.#qsParser);
-    }
-    #createServerMiddlewareStack(middlewareStore) {
+    #createServerMiddlewareStack() {
         this.#serverMiddlewareStack = new Middleware();
-        middlewareStore.list().forEach((middleware) => this.#serverMiddlewareStack.add(middleware));
+        this.#middleware.forEach((middleware) => this.#serverMiddlewareStack.add(middleware));
         this.#serverMiddlewareStack.freeze();
+        this.#middleware = [];
     }
-    #createContext(req, res) {
-        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);
-        return new HttpContext(request, response, this.#app.logger.child({}));
+    #handleRequest(ctx, resolver) {
+        return this.#serverMiddlewareStack.runner()
+            .finalHandler(finalHandler(this.#router, resolver, ctx))
+            .run(middlewareHandler(resolver, ctx))
+            .then(useReturnValue(ctx))
+            .catch((error) => this.#resolvedErrorHandler.handle(error, ctx))
+            .finally(writeResponse(ctx));
     }
-    use(serverMiddleware, routerMiddleware, namedMiddleware) {
-        this.#createRouter(new MiddlewareStore(routerMiddleware, namedMiddleware));
-        this.#createServerMiddlewareStack(new MiddlewareStore(serverMiddleware));
+    use(middleware) {
+        middleware.forEach((one) => this.#middleware.push(moduleImporter(one, 'handle').toHandleMethod()));
         return this;
     }
     errorHandler(handler) {
@@ -70,9 +72,7 @@ export class Server {
     }
     async boot() {
         debug('booting HTTP server');
-        if (!this.#router) {
-            throw new RuntimeException('Cannot boot HTTP server. Register middleware using "server.use" first');
-        }
+        this.#createServerMiddlewareStack();
         this.#router.commit();
         if (this.#errorHandler) {
             if (debug.enabled) {
@@ -82,40 +82,27 @@ export class Server {
             this.#resolvedErrorHandler = await this.#app.container.make(moduleExports.default);
         }
     }
-    #handleRequest(ctx, resolver) {
-        return this.#serverMiddlewareStack.runner()
-            .finalHandler(finalHandler(this.#router, resolver, ctx))
-            .run(middlewareHandler(resolver, ctx))
-            .then(useReturnValue(ctx))
-            .catch((error) => this.#resolvedErrorHandler.handle(error, ctx))
-            .finally(writeResponse(ctx));
-    }
     setNodeServer(server) {
-        this.#underlyingHttpServer = server;
-    }
-    close() {
-        return new Promise((resolve, reject) => {
-            if (!this.#underlyingHttpServer || !this.#underlyingHttpServer.listening) {
-                resolve();
-                return;
-            }
-            this.#underlyingHttpServer.close((error) => {
-                if (error) {
-                    return reject(error);
-                }
-                resolve();
-            });
-        });
+        this.#nodeHttpServer = server;
     }
     getNodeServer() {
-        return this.#underlyingHttpServer;
+        return this.#nodeHttpServer;
     }
     getRouter() {
         return this.#router;
     }
+    onRequest(callback) {
+        this.#requestHooks.add(callback);
+        return this;
+    }
     handle(req, res) {
-        const ctx = this.#createContext(req, res);
         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);
+        }
         if (this.usingAsyncLocalStorage) {
             return asyncLocalStorage.storage.run(ctx, () => this.#handleRequest(ctx, resolver));
         }

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

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

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

@@ -1,14 +1,17 @@
 import type { ContainerResolver } from '@adonisjs/fold';
-import type { NextFn } from '@poppinss/middleware/types';
-import type { Constructor } from './base.js';
+import type { Constructor, NextFn } from './base.js';
 import type { HttpContext } from '../http_context/main.js';
 export type MiddlewareAsClass = Constructor<{
     handle: (ctx: HttpContext, next: NextFn, args?: any) => any;
 }>;
 type HasUndefined<T> = T extends NonNullable<T> ? true : false;
-export type GetMiddlewareArgs<Middleware extends MiddlewareAsClass> = HasUndefined<Parameters<InstanceType<Middleware>['handle']>[2]> extends true ? [Parameters<InstanceType<Middleware>['handle']>[2]] : [Parameters<InstanceType<Middleware>['handle']>[2]?];
+export type GetMiddlewareArgs<Middleware extends MiddlewareAsClass> = Parameters<InstanceType<Middleware>['handle']>[2] extends undefined ? [] : HasUndefined<Parameters<InstanceType<Middleware>['handle']>[2]> extends true ? [Parameters<InstanceType<Middleware>['handle']>[2]] : [Parameters<InstanceType<Middleware>['handle']>[2]?];
 export type MiddlewareFn = (ctx: HttpContext, next: NextFn) => any;
 export type ParsedGlobalMiddleware = {
     handle: (resolver: ContainerResolver<any>, ...args: [ctx: HttpContext, next: NextFn, params?: any]) => any;
 };
+export type ParsedNamedMiddleware = ParsedGlobalMiddleware & {
+    name: string;
+    args: any;
+};
 export {};

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

@@ -1,8 +1,8 @@
+import type { QSParserConfig } from './qs.js';
 import type { Constructor } from './base.js';
 import type { RequestConfig } from './request.js';
 import type { ResponseConfig } from './response.js';
 import type { HttpContext } from '../http_context/main.js';
-import { QSParserConfig } from './qs.js';
 export type ServerErrorHandler = {
     handle: (error: any, ctx: HttpContext) => any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/http-server",
-  "version": "6.0.1-0",
+  "version": "6.1.0-0",
   "description": "AdonisJS HTTP server with support packed with Routing and Cookies",
   "main": "build/index.js",
   "type": "module",
@@ -37,11 +37,10 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^6.2.0-0",
-    "@adonisjs/config": "^4.1.1-0",
+    "@adonisjs/application": "^6.3.1-0",
+    "@adonisjs/config": "^4.1.2-0",
     "@adonisjs/encryption": "^5.0.2-0",
-    "@adonisjs/env": "^4.0.3-0",
-    "@adonisjs/fold": "^9.5.0-0",
+    "@adonisjs/fold": "^9.6.0-0",
     "@adonisjs/logger": "^5.1.0-0",
     "@commitlint/cli": "^17.3.0",
     "@commitlint/config-conventional": "^17.3.0",
@@ -114,9 +113,9 @@
     "vary": "^1.1.2"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^6.2.0-0",
+    "@adonisjs/application": "^6.3.1-0",
     "@adonisjs/encryption": "^5.0.2-0",
-    "@adonisjs/fold": "^9.5.0-0"
+    "@adonisjs/fold": "^9.6.0-0"
   },
   "repository": {
     "type": "git",

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

@@ -1,11 +0,0 @@
-import type { LazyImport, UnWrapLazyImport } from '../types/base.js';
-import type { GetMiddlewareArgs, MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js';
-export declare class MiddlewareStore<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>> {
-    #private;
-    constructor(middleware: LazyImport<MiddlewareAsClass>[], namedMiddleware?: NamedMiddleware);
-    get<Name extends keyof NamedMiddleware, Args extends GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[Name]>>>(name: Name, ...args: Args): {
-        name: Name;
-        args: any;
-    } & ParsedGlobalMiddleware;
-    list(): ParsedGlobalMiddleware[];
-}

package/build/src/middleware/store.js

@@ -1,33 +0,0 @@
-import { moduleImporter } from '@adonisjs/fold';
-import { RuntimeException } from '@poppinss/utils';
-export class MiddlewareStore {
-    #namedMiddleware;
-    #middleware;
-    #resolvedMiddleware = new Map();
-    constructor(middleware, namedMiddleware) {
-        this.#middleware = middleware.map((one) => moduleImporter(one, 'handle').toHandleMethod());
-        this.#namedMiddleware = namedMiddleware;
-    }
-    get(name, ...args) {
-        if (this.#resolvedMiddleware.has(name)) {
-            return {
-                name,
-                args: args[0],
-                ...this.#resolvedMiddleware.get(name),
-            };
-        }
-        if (!this.#namedMiddleware || !this.#namedMiddleware[name]) {
-            throw new RuntimeException(`Cannot resolve "${String(name)}" middleware. Make sure the middleware is registered before using it`);
-        }
-        const handler = moduleImporter(this.#namedMiddleware[name], 'handle').toHandleMethod();
-        this.#resolvedMiddleware.set(name, handler);
-        return {
-            name,
-            args: args[0],
-            ...handler,
-        };
-    }
-    list() {
-        return this.#middleware;
-    }
-}