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

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;
@@ -212,7 +212,7 @@ export class Request extends Macroable {
             if (typeof route.handler === 'function') {
                 return false;
             }
-            return route.handler.name === identifier;
+            return route.handler.reference === identifier;
         });
     }
     is(types) {

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

@@ -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) {
@@ -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

@@ -12,7 +12,7 @@ export class RouteFinder {
             if (typeof handler === 'function') {
                 return false;
             }
-            return handler.name === routeIdentifier;
+            return handler.reference === routeIdentifier;
         }) || null);
     }
     findOrFail(routeIdentifier) {

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/main.d.ts

@@ -5,11 +5,11 @@ 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 type { Constructor, LazyImport } from '../types/base.js';
 import { LookupStore } from './lookup_store/main.js';
 import { RouteMatchers as Matchers } from './matchers.js';
 import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js';
-import type { RouteFn, MatchedRoute, RouteMatcher, MakeUrlOptions, MakeSignedUrlOptions } from '../types/route.js';
+import type { RouteFn, MatchedRoute, RouteMatcher, MakeUrlOptions, MakeSignedUrlOptions, GetControllerHandlers } from '../types/route.js';
 export declare class Router extends LookupStore {
     #private;
     routes: (Route | RouteResource | RouteGroup | BriskRoute)[];
@@ -21,13 +21,13 @@ export declare class Router extends LookupStore {
         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;
+    route<T extends Constructor<any>>(pattern: string, methods: string[], handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    any<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    get<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    post<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    put<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    patch<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
+    delete<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     group(callback: () => void): RouteGroup;
     resource(resource: string, controller: string): RouteResource;
     shallowResource(resource: string, controller: string): RouteResource;

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,20 +1,21 @@
 import { Macroable } from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
+import type { Constructor, LazyImport, OneOrMore } from '../types/base.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 extends Macroable {
+import type { GetControllerHandlers, RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteMiddleware } from '../types/route.js';
+export declare class Route<Controller extends Constructor<any> = any> extends Macroable {
     #private;
     constructor(app: Application<any, any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
         pattern: string;
         methods: string[];
-        handler: RouteFn | string;
+        handler: RouteFn | string | [LazyImport<Controller> | Controller, GetControllerHandlers<Controller>?];
         globalMatchers: RouteMatchers;
     });
     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

@@ -1,8 +1,8 @@
 import is from '@sindresorhus/is';
 import Middleware from '@poppinss/middleware';
 import { Macroable } from '@poppinss/macroable';
-import { moduleExpression } from '@adonisjs/fold';
 import { RuntimeException } from '@poppinss/utils';
+import { moduleCaller, moduleExpression, moduleImporter } from '@adonisjs/fold';
 import { execute } from './executor.js';
 import { dropSlash } from '../helpers.js';
 export class Route extends Macroable {
@@ -30,10 +30,22 @@ export class Route extends Macroable {
     #resolveRouteHandle(handler) {
         if (typeof handler === 'string') {
             return {
-                name: handler,
+                reference: handler,
                 ...moduleExpression(handler, this.#app.appRoot).toHandleMethod(),
             };
         }
+        if (Array.isArray(handler)) {
+            if (is.class_(handler[0])) {
+                return {
+                    reference: handler[0].name,
+                    ...moduleCaller(handler[0], (handler[1] || 'handle')).toHandleMethod(),
+                };
+            }
+            return {
+                reference: handler[0].name,
+                ...moduleImporter(handler[0], (handler[1] || 'handle')).toHandleMethod(),
+            };
+        }
         return handler;
     }
     #getMatchers() {
@@ -74,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

@@ -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 RouteNotFoundException(`Cannot ${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/route.d.ts

@@ -1,7 +1,11 @@
 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';
+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 MatchItRouteToken = RouteMatcher & {
     old: string;
     type: 0 | 1 | 2 | 3;
@@ -10,7 +14,7 @@ export type MatchItRouteToken = RouteMatcher & {
 };
 export type RouteFn = (ctx: HttpContext) => any;
 export type StoreRouteHandler = RouteFn | {
-    name: string;
+    reference: string | [LazyImport<Constructor<any>> | Constructor<any>, any?];
     handle: (resolver: ContainerResolver<any>, ...args: [ctx: HttpContext, ...injections: any[]]) => any;
 };
 export type StoreRouteMiddleware = MiddlewareFn | ({

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/http-server",
-  "version": "6.1.0-0",
+  "version": "6.3.0-0",
   "description": "AdonisJS HTTP server with support packed with Routing and Cookies",
   "main": "build/index.js",
   "type": "module",
@@ -37,13 +37,14 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^6.3.1-0",
-    "@adonisjs/config": "^4.1.2-0",
-    "@adonisjs/encryption": "^5.0.2-0",
-    "@adonisjs/fold": "^9.6.0-0",
-    "@adonisjs/logger": "^5.1.0-0",
-    "@commitlint/cli": "^17.3.0",
-    "@commitlint/config-conventional": "^17.3.0",
+    "@adonisjs/application": "^6.5.1-0",
+    "@adonisjs/config": "^4.1.3-0",
+    "@adonisjs/encryption": "^5.0.3-0",
+    "@adonisjs/events": "^8.3.0-0",
+    "@adonisjs/fold": "^9.9.0-0",
+    "@adonisjs/logger": "^5.1.1-0",
+    "@commitlint/cli": "^17.4.0",
+    "@commitlint/config-conventional": "^17.4.0",
     "@fastify/middie": "^8.1.0",
     "@japa/api-client": "^1.4.2",
     "@japa/assert": "^1.3.6",
@@ -51,7 +52,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.25",
     "@types/accepts": "^1.3.5",
     "@types/content-disposition": "^0.5.5",
     "@types/cookie": "^0.5.1",
@@ -73,16 +74,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 +94,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 +114,10 @@
     "vary": "^1.1.2"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^6.3.1-0",
-    "@adonisjs/encryption": "^5.0.2-0",
-    "@adonisjs/fold": "^9.6.0-0"
+    "@adonisjs/application": "^6.5.1-0",
+    "@adonisjs/events": "^8.3.0-0",
+    "@adonisjs/encryption": "^5.0.3-0",
+    "@adonisjs/fold": "^9.9.0-0"
   },
   "repository": {
     "type": "git",