@shadow-library/fastify 0.0.3 → 0.0.5

package/cjs/classes/default-error-handler.js

@@ -2,22 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultErrorHandler = void 0;
 const common_1 = require("@shadow-library/common");
+const constants_1 = require("../constants.js");
 const server_error_1 = require("../server.error.js");
 const unexpectedError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S001);
 const validationError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S003);
 class DefaultErrorHandler {
-    logger = common_1.Logger.getLogger(DefaultErrorHandler.name);
+    logger = common_1.Logger.getLogger(constants_1.NAMESPACE, 'DefaultErrorHandler');
     parseFastifyError(err) {
         if (err.statusCode === 500)
             return { statusCode: 500, error: unexpectedError.toObject() };
-        return {
-            statusCode: err.statusCode,
-            error: {
-                code: err.code,
-                type: common_1.ErrorType.CLIENT_ERROR,
-                message: err.message,
-            },
-        };
+        return { statusCode: err.statusCode, error: { code: err.code, type: common_1.ErrorType.CLIENT_ERROR, message: err.message } };
     }
     handle(err, _req, res) {
         this.logger.warn('Handling error', err);

package/cjs/constants.d.ts

@@ -1,3 +1,4 @@
+export declare const NAMESPACE = "@shadow-library/fastify";
 export declare const PARAMTYPES_METADATA = "design:paramtypes";
 export declare const FASTIFY_CONFIG: unique symbol;
 export declare const FASTIFY_INSTANCE: unique symbol;

package/cjs/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTP_CONTROLLER_INPUTS = exports.HTTP_CONTROLLER_TYPE = exports.FASTIFY_INSTANCE = exports.FASTIFY_CONFIG = exports.PARAMTYPES_METADATA = void 0;
+exports.HTTP_CONTROLLER_INPUTS = exports.HTTP_CONTROLLER_TYPE = exports.FASTIFY_INSTANCE = exports.FASTIFY_CONFIG = exports.PARAMTYPES_METADATA = exports.NAMESPACE = void 0;
+exports.NAMESPACE = '@shadow-library/fastify';
 exports.PARAMTYPES_METADATA = 'design:paramtypes';
 exports.FASTIFY_CONFIG = Symbol('fastify-config');
 exports.FASTIFY_INSTANCE = Symbol('fastify-instance');

package/cjs/module/fastify-router.d.ts

@@ -3,6 +3,7 @@ import { type FastifyInstance } from 'fastify';
 import { Chain as MockRequestChain, InjectOptions as MockRequestOptions, Response as MockResponse } from 'light-my-request';
 import { JsonObject } from 'type-fest';
 import { HttpRequest, HttpResponse, ServerMetadata } from '../interfaces/index.js';
+import { Context } from '../services/index.js';
 import { type FastifyConfig } from './fastify-module.interface.js';
 declare module 'fastify' {
     interface FastifyRequest {
@@ -19,13 +20,30 @@ export interface RequestContext {
     query: Record<string, string>;
     body: JsonObject;
 }
+export interface RequestMetadata {
+    rid?: string;
+    srid?: string;
+    method?: string;
+    url?: string;
+    status?: number;
+    reqLen?: string;
+    reqIp?: string;
+    resLen?: string;
+    timeTaken?: string;
+    body?: any;
+    query?: object;
+    service?: string;
+    [key: string]: any;
+}
 export declare class FastifyRouter extends Router {
     private readonly config;
     private readonly instance;
+    private readonly context;
     private readonly logger;
-    constructor(config: FastifyConfig, instance: FastifyInstance);
+    constructor(config: FastifyConfig, instance: FastifyInstance, context: Context);
     getInstance(): FastifyInstance;
     private registerRawBody;
+    private getRequestLogger;
     private parseControllers;
     private getStatusCode;
     private generateRouteHandler;

package/cjs/module/fastify-router.js

@@ -14,7 +14,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var FastifyRouter_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyRouter = void 0;
 const assert_1 = __importDefault(require("assert"));
@@ -23,15 +22,18 @@ const common_1 = require("@shadow-library/common");
 const deepmerge_1 = __importDefault(require("deepmerge"));
 const constants_1 = require("../constants.js");
 const decorators_1 = require("../decorators/index.js");
+const services_1 = require("../services/index.js");
 const httpMethods = Object.values(decorators_1.HttpMethod).filter(m => m !== decorators_1.HttpMethod.ALL);
-let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends app_1.Router {
+let FastifyRouter = class FastifyRouter extends app_1.Router {
     config;
     instance;
-    logger = common_1.Logger.getLogger(FastifyRouter_1.name);
-    constructor(config, instance) {
+    context;
+    logger = common_1.Logger.getLogger(constants_1.NAMESPACE, 'FastifyRouter');
+    constructor(config, instance, context) {
         super();
         this.config = config;
         this.instance = instance;
+        this.context = context;
     }
     getInstance() {
         return this.instance;
@@ -46,6 +48,33 @@ let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends app_1.Router {
             return parser(req, body.toString(), done);
         });
     }
+    getRequestLogger() {
+        return (req, res, done) => {
+            const startTime = process.hrtime();
+            res.raw.on('finish', () => {
+                const isLoggingDisabled = this.context.get('DISABLE_REQUEST_LOGGING') ?? false;
+                if (isLoggingDisabled)
+                    return done();
+                const metadata = {};
+                metadata.rid = this.context.getRID();
+                metadata.url = req.url;
+                metadata.method = req.method;
+                metadata.status = res.statusCode;
+                metadata.service = req.headers['x-service'];
+                metadata.reqLen = req.headers['content-length'];
+                metadata.reqIp = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+                metadata.resLen = res.getHeader('content-length');
+                const resTime = process.hrtime(startTime);
+                metadata.timeTaken = (resTime[0] * 1e3 + resTime[1] * 1e-6).toFixed(3);
+                if (req.query)
+                    metadata.query = req.query;
+                if (req.body)
+                    metadata.body = req.body;
+                this.logger.http('http', metadata);
+            });
+            return done();
+        };
+    }
     parseControllers(controllers) {
         const parsedControllers = { middlewares: [], routes: [] };
         for (const controller of controllers) {
@@ -123,6 +152,10 @@ let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends app_1.Router {
         const hasRawBody = routes.some(r => r.metadata.rawBody);
         if (hasRawBody)
             this.registerRawBody();
+        this.logger.debug('Registering the global middlewares');
+        this.instance.addHook('onRequest', this.context.init());
+        this.instance.addHook('onRequest', this.getRequestLogger());
+        this.logger.info('Registered global middlewares');
         for (const route of routes) {
             const metadata = route.metadata;
             (0, assert_1.default)(metadata.path, 'Route path is required');
@@ -166,17 +199,18 @@ let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends app_1.Router {
         this.logger.info(`server started at ${address}`);
     }
     async stop() {
-        this.logger.info('stopping server');
+        this.logger.debug('stopping server');
         await this.instance.close();
+        this.logger.info('server stopped');
     }
     mockRequest(options) {
         return options ? this.instance.inject(options) : this.instance.inject();
     }
 };
 exports.FastifyRouter = FastifyRouter;
-exports.FastifyRouter = FastifyRouter = FastifyRouter_1 = __decorate([
+exports.FastifyRouter = FastifyRouter = __decorate([
     (0, app_1.Injectable)(),
     __param(0, (0, app_1.Inject)(constants_1.FASTIFY_CONFIG)),
     __param(1, (0, app_1.Inject)(constants_1.FASTIFY_INSTANCE)),
-    __metadata("design:paramtypes", [Object, Object])
+    __metadata("design:paramtypes", [Object, Object, services_1.Context])
 ], FastifyRouter);

package/cjs/module/fastify.module.js

@@ -22,7 +22,6 @@ class FastifyModule {
             ignoreDuplicateSlashes: true,
             requestIdLogLabel: 'rid',
             genReqId: () => (0, uuid_1.v4)(),
-            ajv: { customOptions: { removeAdditional: true, useDefaults: true, allErrors: true } },
         };
     }
     static forRoot(options) {

package/cjs/module/fastify.utils.d.ts

@@ -1,7 +1,9 @@
 import { ValidationError } from '@shadow-library/common';
+import { SchemaObject } from 'ajv';
 import { FastifyInstance } from 'fastify';
-import { FastifySchemaValidationError, SchemaErrorDataVar } from 'fastify/types/schema';
+import { FastifyRouteSchemaDef, FastifySchemaValidationError, FastifyValidationResult, SchemaErrorDataVar } from 'fastify/types/schema';
 import { FastifyConfig, FastifyModuleOptions } from './fastify-module.interface.js';
 export declare const notFoundHandler: () => never;
+export declare function compileValidator(routeSchema: FastifyRouteSchemaDef<SchemaObject>): FastifyValidationResult;
 export declare function formatSchemaErrors(errors: FastifySchemaValidationError[], dataVar: SchemaErrorDataVar): ValidationError;
 export declare function createFastifyInstance(config: FastifyConfig, fastifyFactory?: FastifyModuleOptions['fastifyFactory']): Promise<FastifyInstance>;

package/cjs/module/fastify.utils.js

@@ -1,14 +1,41 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.notFoundHandler = void 0;
+exports.compileValidator = compileValidator;
 exports.formatSchemaErrors = formatSchemaErrors;
 exports.createFastifyInstance = createFastifyInstance;
+const assert_1 = __importDefault(require("assert"));
 const common_1 = require("@shadow-library/common");
+const ajv_1 = __importDefault(require("ajv"));
 const fastify_1 = require("fastify");
 const server_error_1 = require("../server.error.js");
+const allowedHttpParts = ['body', 'params', 'querystring'];
+const strictValidator = new ajv_1.default({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true });
+const lenientValidator = new ajv_1.default({ allErrors: true, coerceTypes: true, useDefaults: true, removeAdditional: true, strict: true });
 const notFoundError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S002);
 const notFoundHandler = () => (0, common_1.throwError)(notFoundError);
 exports.notFoundHandler = notFoundHandler;
+function compileValidator(routeSchema) {
+    (0, assert_1.default)(allowedHttpParts.includes(routeSchema.httpPart), `Invalid httpPart: ${routeSchema.httpPart}`);
+    if (routeSchema.httpPart !== 'querystring')
+        return strictValidator.compile(routeSchema.schema);
+    const validate = lenientValidator.compile(routeSchema.schema);
+    return (data) => {
+        validate(data);
+        for (const error of validate.errors ?? []) {
+            const path = error.instancePath.substring(1);
+            const defaultValue = routeSchema.schema.properties?.[path]?.default;
+            if (defaultValue !== undefined)
+                data[path] = defaultValue;
+            else
+                delete data[path];
+        }
+        return { value: data };
+    };
+}
 function formatSchemaErrors(errors, dataVar) {
     const validationError = new common_1.ValidationError();
     for (const error of errors) {
@@ -29,5 +56,6 @@ async function createFastifyInstance(config, fastifyFactory) {
     instance.setSchemaErrorFormatter(formatSchemaErrors);
     instance.setNotFoundHandler(exports.notFoundHandler);
     instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
+    instance.setValidatorCompiler(compileValidator);
     return fastifyFactory ? await fastifyFactory(instance) : instance;
 }

package/cjs/services/context.service.d.ts

@@ -3,9 +3,9 @@ type Key = string | symbol;
 export declare class Context {
     private readonly storage;
     init(): MiddlewareHandler;
-    protected get<T>(key: Key, throwOnMissing: true): T;
-    protected get<T>(key: Key, throwOnMissing?: false): T | null;
-    protected set<T>(key: Key, value: T): this;
+    get<T>(key: Key, throwOnMissing: true): T;
+    get<T>(key: Key, throwOnMissing?: false): T | null;
+    set<T>(key: Key, value: T): this;
     getRequest(): Request;
     getResponse(): Response;
     getRID(): string;

package/esm/classes/default-error-handler.js

@@ -1,20 +1,14 @@
 import { AppError, ErrorType, Logger, ValidationError } from '@shadow-library/common';
+import { NAMESPACE } from '../constants.js';
 import { ServerError, ServerErrorCode } from '../server.error.js';
 const unexpectedError = new ServerError(ServerErrorCode.S001);
 const validationError = new ServerError(ServerErrorCode.S003);
 export class DefaultErrorHandler {
-    logger = Logger.getLogger(DefaultErrorHandler.name);
+    logger = Logger.getLogger(NAMESPACE, 'DefaultErrorHandler');
     parseFastifyError(err) {
         if (err.statusCode === 500)
             return { statusCode: 500, error: unexpectedError.toObject() };
-        return {
-            statusCode: err.statusCode,
-            error: {
-                code: err.code,
-                type: ErrorType.CLIENT_ERROR,
-                message: err.message,
-            },
-        };
+        return { statusCode: err.statusCode, error: { code: err.code, type: ErrorType.CLIENT_ERROR, message: err.message } };
     }
     handle(err, _req, res) {
         this.logger.warn('Handling error', err);

package/esm/constants.d.ts

@@ -1,3 +1,4 @@
+export declare const NAMESPACE = "@shadow-library/fastify";
 export declare const PARAMTYPES_METADATA = "design:paramtypes";
 export declare const FASTIFY_CONFIG: unique symbol;
 export declare const FASTIFY_INSTANCE: unique symbol;

package/esm/constants.js

@@ -1,3 +1,4 @@
+export const NAMESPACE = '@shadow-library/fastify';
 export const PARAMTYPES_METADATA = 'design:paramtypes';
 export const FASTIFY_CONFIG = Symbol('fastify-config');
 export const FASTIFY_INSTANCE = Symbol('fastify-instance');

package/esm/module/fastify-router.d.ts

@@ -3,6 +3,7 @@ import { type FastifyInstance } from 'fastify';
 import { Chain as MockRequestChain, InjectOptions as MockRequestOptions, Response as MockResponse } from 'light-my-request';
 import { JsonObject } from 'type-fest';
 import { HttpRequest, HttpResponse, ServerMetadata } from '../interfaces/index.js';
+import { Context } from '../services/index.js';
 import { type FastifyConfig } from './fastify-module.interface.js';
 declare module 'fastify' {
     interface FastifyRequest {
@@ -19,13 +20,30 @@ export interface RequestContext {
     query: Record<string, string>;
     body: JsonObject;
 }
+export interface RequestMetadata {
+    rid?: string;
+    srid?: string;
+    method?: string;
+    url?: string;
+    status?: number;
+    reqLen?: string;
+    reqIp?: string;
+    resLen?: string;
+    timeTaken?: string;
+    body?: any;
+    query?: object;
+    service?: string;
+    [key: string]: any;
+}
 export declare class FastifyRouter extends Router {
     private readonly config;
     private readonly instance;
+    private readonly context;
     private readonly logger;
-    constructor(config: FastifyConfig, instance: FastifyInstance);
+    constructor(config: FastifyConfig, instance: FastifyInstance, context: Context);
     getInstance(): FastifyInstance;
     private registerRawBody;
+    private getRequestLogger;
     private parseControllers;
     private getStatusCode;
     private generateRouteHandler;

package/esm/module/fastify-router.js

@@ -10,22 +10,24 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var FastifyRouter_1;
 import assert from 'assert';
 import { Inject, Injectable, Router } from '@shadow-library/app';
 import { InternalError, Logger, utils } from '@shadow-library/common';
 import merge from 'deepmerge';
-import { FASTIFY_CONFIG, FASTIFY_INSTANCE, HTTP_CONTROLLER_INPUTS, HTTP_CONTROLLER_TYPE } from '../constants.js';
+import { FASTIFY_CONFIG, FASTIFY_INSTANCE, HTTP_CONTROLLER_INPUTS, HTTP_CONTROLLER_TYPE, NAMESPACE } from '../constants.js';
 import { HttpMethod } from '../decorators/index.js';
+import { Context } from '../services/index.js';
 const httpMethods = Object.values(HttpMethod).filter(m => m !== HttpMethod.ALL);
-let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends Router {
+let FastifyRouter = class FastifyRouter extends Router {
     config;
     instance;
-    logger = Logger.getLogger(FastifyRouter_1.name);
-    constructor(config, instance) {
+    context;
+    logger = Logger.getLogger(NAMESPACE, 'FastifyRouter');
+    constructor(config, instance, context) {
         super();
         this.config = config;
         this.instance = instance;
+        this.context = context;
     }
     getInstance() {
         return this.instance;
@@ -40,6 +42,33 @@ let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends Router {
             return parser(req, body.toString(), done);
         });
     }
+    getRequestLogger() {
+        return (req, res, done) => {
+            const startTime = process.hrtime();
+            res.raw.on('finish', () => {
+                const isLoggingDisabled = this.context.get('DISABLE_REQUEST_LOGGING') ?? false;
+                if (isLoggingDisabled)
+                    return done();
+                const metadata = {};
+                metadata.rid = this.context.getRID();
+                metadata.url = req.url;
+                metadata.method = req.method;
+                metadata.status = res.statusCode;
+                metadata.service = req.headers['x-service'];
+                metadata.reqLen = req.headers['content-length'];
+                metadata.reqIp = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+                metadata.resLen = res.getHeader('content-length');
+                const resTime = process.hrtime(startTime);
+                metadata.timeTaken = (resTime[0] * 1e3 + resTime[1] * 1e-6).toFixed(3);
+                if (req.query)
+                    metadata.query = req.query;
+                if (req.body)
+                    metadata.body = req.body;
+                this.logger.http('http', metadata);
+            });
+            return done();
+        };
+    }
     parseControllers(controllers) {
         const parsedControllers = { middlewares: [], routes: [] };
         for (const controller of controllers) {
@@ -117,6 +146,10 @@ let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends Router {
         const hasRawBody = routes.some(r => r.metadata.rawBody);
         if (hasRawBody)
             this.registerRawBody();
+        this.logger.debug('Registering the global middlewares');
+        this.instance.addHook('onRequest', this.context.init());
+        this.instance.addHook('onRequest', this.getRequestLogger());
+        this.logger.info('Registered global middlewares');
         for (const route of routes) {
             const metadata = route.metadata;
             assert(metadata.path, 'Route path is required');
@@ -160,17 +193,18 @@ let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends Router {
         this.logger.info(`server started at ${address}`);
     }
     async stop() {
-        this.logger.info('stopping server');
+        this.logger.debug('stopping server');
         await this.instance.close();
+        this.logger.info('server stopped');
     }
     mockRequest(options) {
         return options ? this.instance.inject(options) : this.instance.inject();
     }
 };
-FastifyRouter = FastifyRouter_1 = __decorate([
+FastifyRouter = __decorate([
     Injectable(),
     __param(0, Inject(FASTIFY_CONFIG)),
     __param(1, Inject(FASTIFY_INSTANCE)),
-    __metadata("design:paramtypes", [Object, Object])
+    __metadata("design:paramtypes", [Object, Object, Context])
 ], FastifyRouter);
 export { FastifyRouter };

package/esm/module/fastify.module.js

@@ -19,7 +19,6 @@ export class FastifyModule {
             ignoreDuplicateSlashes: true,
             requestIdLogLabel: 'rid',
             genReqId: () => uuid(),
-            ajv: { customOptions: { removeAdditional: true, useDefaults: true, allErrors: true } },
         };
     }
     static forRoot(options) {

package/esm/module/fastify.utils.d.ts

@@ -1,7 +1,9 @@
 import { ValidationError } from '@shadow-library/common';
+import { SchemaObject } from 'ajv';
 import { FastifyInstance } from 'fastify';
-import { FastifySchemaValidationError, SchemaErrorDataVar } from 'fastify/types/schema';
+import { FastifyRouteSchemaDef, FastifySchemaValidationError, FastifyValidationResult, SchemaErrorDataVar } from 'fastify/types/schema';
 import { FastifyConfig, FastifyModuleOptions } from './fastify-module.interface.js';
 export declare const notFoundHandler: () => never;
+export declare function compileValidator(routeSchema: FastifyRouteSchemaDef<SchemaObject>): FastifyValidationResult;
 export declare function formatSchemaErrors(errors: FastifySchemaValidationError[], dataVar: SchemaErrorDataVar): ValidationError;
 export declare function createFastifyInstance(config: FastifyConfig, fastifyFactory?: FastifyModuleOptions['fastifyFactory']): Promise<FastifyInstance>;

package/esm/module/fastify.utils.js

@@ -1,8 +1,31 @@
+import assert from 'assert';
 import { ValidationError, throwError, utils } from '@shadow-library/common';
+import Ajv from 'ajv';
 import { fastify } from 'fastify';
 import { ServerError, ServerErrorCode } from '../server.error.js';
+const allowedHttpParts = ['body', 'params', 'querystring'];
+const strictValidator = new Ajv({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true });
+const lenientValidator = new Ajv({ allErrors: true, coerceTypes: true, useDefaults: true, removeAdditional: true, strict: true });
 const notFoundError = new ServerError(ServerErrorCode.S002);
 export const notFoundHandler = () => throwError(notFoundError);
+export function compileValidator(routeSchema) {
+    assert(allowedHttpParts.includes(routeSchema.httpPart), `Invalid httpPart: ${routeSchema.httpPart}`);
+    if (routeSchema.httpPart !== 'querystring')
+        return strictValidator.compile(routeSchema.schema);
+    const validate = lenientValidator.compile(routeSchema.schema);
+    return (data) => {
+        validate(data);
+        for (const error of validate.errors ?? []) {
+            const path = error.instancePath.substring(1);
+            const defaultValue = routeSchema.schema.properties?.[path]?.default;
+            if (defaultValue !== undefined)
+                data[path] = defaultValue;
+            else
+                delete data[path];
+        }
+        return { value: data };
+    };
+}
 export function formatSchemaErrors(errors, dataVar) {
     const validationError = new ValidationError();
     for (const error of errors) {
@@ -23,5 +46,6 @@ export async function createFastifyInstance(config, fastifyFactory) {
     instance.setSchemaErrorFormatter(formatSchemaErrors);
     instance.setNotFoundHandler(notFoundHandler);
     instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
+    instance.setValidatorCompiler(compileValidator);
     return fastifyFactory ? await fastifyFactory(instance) : instance;
 }

package/esm/services/context.service.d.ts

@@ -3,9 +3,9 @@ type Key = string | symbol;
 export declare class Context {
     private readonly storage;
     init(): MiddlewareHandler;
-    protected get<T>(key: Key, throwOnMissing: true): T;
-    protected get<T>(key: Key, throwOnMissing?: false): T | null;
-    protected set<T>(key: Key, value: T): this;
+    get<T>(key: Key, throwOnMissing: true): T;
+    get<T>(key: Key, throwOnMissing?: false): T | null;
+    set<T>(key: Key, value: T): this;
     getRequest(): Request;
     getResponse(): Response;
     getRID(): string;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@shadow-library/fastify",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.5",
+  "sideEffects": false,
   "description": "A Fastify wrapper featuring decorator-based routing, middleware and error handling",
   "repository": {
     "type": "git",
@@ -14,17 +15,19 @@
   },
   "homepage": "https://github.com/shadow-library/fastify#readme",
   "dependencies": {
-    "@shadow-library/class-schema": "^0.0.5",
+    "@fastify/middie": "^9.0.3",
+    "ajv": "^8.17.1",
     "deepmerge": "^4.3.1",
-    "fastify": "^5.2.1",
+    "fastify": "^5.3.3",
     "jest": "^29.7.0",
-    "type-fest": "^4.33.0",
-    "uuid": "^11.0.5"
+    "type-fest": "^4.41.0",
+    "uuid": "^11.1.0"
   },
   "peerDependencies": {
     "@fastify/view": "^10.0.0",
-    "@shadow-library/app": "^1.0.4",
-    "@shadow-library/common": "^1.0.0",
+    "@shadow-library/app": "^1.0.7",
+    "@shadow-library/class-schema": "^0.0.5",
+    "@shadow-library/common": "^1.0.13",
     "reflect-metadata": "^0.2.2"
   },
   "peerDependenciesMeta": {