@shadow-library/fastify 1.6.3 → 1.7.0

package/README.md

@@ -663,6 +663,66 @@ childRouteHeaders: (contextService) => {
 
 ## Configuration
 
+### Default Configuration
+
+The `FastifyModule` automatically provides sensible defaults for core server options. The `host`, `port`, and `errorHandler` properties are all **optional** — if not specified, they are resolved from `@shadow-library/common`'s `Config` or fall back to built-in defaults:
+
+| Property       | Config Key | Default Value         |
+| -------------- | ---------- | --------------------- |
+| `host`         | `app.host` | `'localhost'`         |
+| `port`         | `app.port` | `8080`                |
+| `errorHandler` | —          | `DefaultErrorHandler` |
+
+The `Config.load()` calls register `app.host` and `app.port` with the `Config` system, so they can be overridden via environment variables or any config source supported by `@shadow-library/common` without changing your module setup:
+
+```typescript
+// No explicit host/port needed — defaults are loaded from Config
+FastifyModule.forRoot({
+  controllers: [UserController],
+});
+```
+
+> **Note:** When using `forRootAsync`, the defaults are automatically merged with the config returned by your factory function, so you only need to specify the properties you want to override.
+
+### Developer Options
+
+The library registers additional config keys under the `app.dev` namespace for development and debugging convenience. These are controlled via environment variables (or any config source) and require no changes to your module setup.
+
+| Config Key            | Type      | Default                        | Description                                       |
+| --------------------- | --------- | ------------------------------ | ------------------------------------------------- |
+| `app.dev.delay`       | `integer` | — (disabled)                   | Adds an artificial delay (in ms) to every request |
+| `app.dev.stack-trace` | `boolean` | `true` in dev, `false` in prod | Appends the error `stack` to error responses      |
+
+#### `app.dev.stack-trace`
+
+When enabled, the `DefaultErrorHandler` includes the error's `stack` property in the response body alongside the standard error fields. This is automatically enabled in non-production environments and disabled in production.
+
+A warning is logged if stack trace logging is active in a production environment.
+
+The response shape when enabled matches `DevErrorResponseDto`:
+
+```typescript
+import { DevErrorResponseDto } from '@shadow-library/fastify';
+
+// Error response shape with stack trace enabled:
+// {
+//   code: "S001",
+//   message: "An unexpected error has occurred",
+//   stack: "Error: ...\n    at ..."
+// }
+```
+
+#### `app.dev.delay`
+
+Adds an artificial delay in milliseconds to every incoming request via an `onRequest` hook. Useful for simulating slow networks or testing loading states in your frontend without modifying application code.
+
+A warning is logged if a dev delay is active in a production environment.
+
+```bash
+# Add a 500ms delay to every request
+APP_DEV_DELAY=500 node dist/main.js
+```
+
 ### Dynamic Module Configuration
 
 `FastifyModule` is a **dynamic module** that configures itself based on the options you provide. Unlike static modules, dynamic modules return a module configuration object at runtime, allowing for flexible dependency injection and configuration.
@@ -740,7 +800,7 @@ export class AppModule {}
 
 #### Asynchronous Configuration (forRootAsync)
 
-Use `forRootAsync` when you need to inject dependencies or load configuration dynamically:
+Use `forRootAsync` when you need to inject dependencies or load configuration dynamically. The config returned by your `useFactory` is automatically merged with the default configuration, so you only need to provide the properties you want to override:
 
 ```typescript
 @Module({
@@ -758,6 +818,8 @@ Use `forRootAsync` when you need to inject dependencies or load configuration dy
 export class AppModule {}
 ```
 
+If your factory returns a `Promise`, the defaults are merged after the promise resolves. This works seamlessly with both sync and async factories.
+
 #### Dynamic Module Benefits
 
 - **Flexible Configuration**: Configure the module differently for different environments

package/cjs/classes/default-error-handler.d.ts

@@ -13,6 +13,9 @@ export interface ParsedFastifyError {
 }
 export declare class DefaultErrorHandler implements ErrorHandler {
     private readonly logger;
+    private readonly isStackTraceEnabled;
+    constructor();
     protected parseFastifyError(err: FastifyError): ParsedFastifyError;
+    private handleError;
     handle(err: Error, _req: HttpRequest, res: HttpResponse): HttpResponse;
 }

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

@@ -18,27 +18,35 @@ const validationError = new server_error_1.ServerError(server_error_1.ServerErro
 const invalidRequestError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S006);
 class DefaultErrorHandler {
     logger = common_1.Logger.getLogger(constants_1.NAMESPACE, 'DefaultErrorHandler');
+    isStackTraceEnabled = common_1.Config.get('app.dev.stack-trace');
+    constructor() {
+        if (this.isStackTraceEnabled && common_1.Config.isProd())
+            this.logger.warn('Stack trace logging is enabled in production');
+    }
     parseFastifyError(err) {
         if (err.statusCode === 500)
             return { statusCode: 500, error: unexpectedError.toObject() };
         return { statusCode: err.statusCode, error: { ...invalidRequestError.toObject(), message: err.message } };
     }
-    handle(err, _req, res) {
-        this.logger.warn('Handling error', err);
-        if (err.cause)
-            this.logger.warn('Caused by', err.cause);
+    handleError(err) {
         if (err instanceof server_error_1.ServerError)
-            return res.status(err.getStatusCode()).send(err.toObject());
+            return { statusCode: err.getStatusCode(), error: err.toObject() };
         else if (err instanceof common_1.ValidationError)
-            return res.status(validationError.getStatusCode()).send({ ...err.toObject(), ...validationError.toObject() });
+            return { statusCode: validationError.getStatusCode(), error: { ...err.toObject(), ...validationError.toObject() } };
         else if (err instanceof common_1.AppError)
-            return res.status(500).send(err.toObject());
-        else if (err.name === 'FastifyError') {
-            const { statusCode, error } = this.parseFastifyError(err);
-            return res.status(statusCode).send(error);
-        }
+            return { statusCode: 500, error: err.toObject() };
+        else if (err.name === 'FastifyError')
+            return this.parseFastifyError(err);
         this.logger.error('Unhandled error has occurred', err);
-        return res.status(500).send(unexpectedError.toObject());
+        return { statusCode: unexpectedError.getStatusCode(), error: unexpectedError.toObject() };
+    }
+    handle(err, _req, res) {
+        this.logger.warn('Handling error', err);
+        if (err.cause)
+            this.logger.warn('Caused by', err.cause);
+        const { statusCode, error } = this.handleError(err);
+        const payload = this.isStackTraceEnabled ? { ...error, stack: err.stack } : error;
+        return res.status(statusCode).send(payload);
     }
 }
 exports.DefaultErrorHandler = DefaultErrorHandler;

package/cjs/config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+declare module '@shadow-library/common' {
+    interface ConfigRecords {
+        'app.port': number;
+        'app.host': string;
+        'app.dev.delay': number;
+        'app.dev.stack-trace': boolean;
+    }
+}
+export {};

package/cjs/config.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Importing npm packages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@shadow-library/common");
+/**
+ * Declaring the constants
+ */
+const isDevValue = String(common_1.Config.isDev());
+common_1.Config.load('app.host', { defaultValue: 'localhost' });
+common_1.Config.load('app.port', { defaultValue: '8080', validateType: 'integer' });
+common_1.Config.load('app.dev.delay', { validateType: 'integer' });
+common_1.Config.load('app.dev.stack-trace', { defaultValue: isDevValue, validateType: 'boolean' });

package/cjs/index.d.ts

@@ -1,7 +1,8 @@
 /**
- * Importing npm packages
+ * Importing side-effect packages
  */
 import 'reflect-metadata';
+import './config.js';
 /**
  * exporting modules
  */

package/cjs/index.js

@@ -16,9 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FASTIFY_INSTANCE = void 0;
 /**
- * Importing npm packages
+ * Importing side-effect packages
  */
 require("reflect-metadata");
+require("./config.js");
 /**
  * exporting modules
  */

package/cjs/module/error-response.dto.d.ts

@@ -17,3 +17,6 @@ export declare class ErrorResponseDto {
     message: string;
     fields?: ErrorFieldDto[];
 }
+export declare class DevErrorResponseDto extends ErrorResponseDto {
+    stack?: string;
+}

package/cjs/module/error-response.dto.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorResponseDto = exports.ErrorFieldDto = void 0;
+exports.DevErrorResponseDto = exports.ErrorResponseDto = exports.ErrorFieldDto = void 0;
 /**
  * Importing npm packages
  */
@@ -65,3 +65,14 @@ __decorate([
 exports.ErrorResponseDto = ErrorResponseDto = __decorate([
     (0, class_schema_1.Schema)()
 ], ErrorResponseDto);
+let DevErrorResponseDto = class DevErrorResponseDto extends ErrorResponseDto {
+    stack;
+};
+exports.DevErrorResponseDto = DevErrorResponseDto;
+__decorate([
+    (0, class_schema_1.Field)({ optional: true }),
+    __metadata("design:type", String)
+], DevErrorResponseDto.prototype, "stack", void 0);
+exports.DevErrorResponseDto = DevErrorResponseDto = __decorate([
+    (0, class_schema_1.Schema)()
+], DevErrorResponseDto);

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

@@ -17,19 +17,19 @@ import { ContextService } from '../services/index.js';
 export interface FastifyConfig extends FastifyServerOptions {
     /**
      * The host on which the Fastify instance is to be started
-     * @default '127.0.0.1'
+     * @default localhost
      */
-    host: string;
+    host?: string;
     /**
      * The port on which the Fastify instance is to be started
      * @default 8080
      */
-    port: number;
+    port?: number;
     /**
      * The error handler to be used to handle errors thrown by the Fastify instance
      * @default DefaultErrorHandler
      */
-    errorHandler: ErrorHandler;
+    errorHandler?: ErrorHandler;
     /**
      * The schema to be used to validate the response of the Fastify instance
      * @default { '4xx': errorResponseSchema, '5xx': errorResponseSchema }

package/cjs/module/fastify-router.js

@@ -291,6 +291,12 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
         this.instance.addHook('onRequest', this.context.init());
         this.instance.addHook('onRequest', this.getRequestLogger());
         this.logger.info('Registered global middlewares');
+        const delay = common_1.Config.get('app.dev.delay');
+        if (delay) {
+            if (common_1.Config.isProd())
+                this.logger.warn('Dev delay is enabled in production');
+            this.instance.addHook('onRequest', (_req, _res, done) => setTimeout(done, delay));
+        }
         for (const route of routes) {
             const metadata = route.metadata;
             (0, node_assert_1.default)(metadata.path, 'Route path is required');

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

@@ -11,6 +11,7 @@ import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-modul
  */
 export declare class FastifyModule {
     private static getDefaultConfig;
+    private static createConfigFactory;
     static forRoot(options: FastifyModuleOptions): DynamicModule;
     static forRootAsync(options: FastifyModuleAsyncOptions): DynamicModule;
 }

package/cjs/module/fastify.module.js

@@ -32,10 +32,12 @@ const fastify_utils_1 = require("./fastify.utils.js");
  */
 let FastifyModule = FastifyModule_1 = class FastifyModule {
     static getDefaultConfig() {
-        const errorResponseSchema = class_schema_1.ClassSchema.generate(error_response_dto_1.ErrorResponseDto);
+        const stackTrace = common_1.Config.get('app.dev.stack-trace');
+        const errorResponseClass = stackTrace ? error_response_dto_1.DevErrorResponseDto : error_response_dto_1.ErrorResponseDto;
+        const errorResponseSchema = class_schema_1.ClassSchema.generate(errorResponseClass);
         return {
-            host: 'localhost',
-            port: 8080,
+            host: common_1.Config.get('app.host'),
+            port: common_1.Config.get('app.port'),
             responseSchema: { '4xx': errorResponseSchema, '5xx': errorResponseSchema },
             errorHandler: new classes_1.DefaultErrorHandler(),
             maskSensitiveData: common_1.Config.isProd(),
@@ -47,6 +49,14 @@ let FastifyModule = FastifyModule_1 = class FastifyModule {
             },
         };
     }
+    static createConfigFactory(factory) {
+        return (...args) => {
+            const config = factory(...args);
+            if (config instanceof Promise)
+                return config.then(resolvedConfig => Object.assign({}, this.getDefaultConfig(), resolvedConfig));
+            return Object.assign({}, this.getDefaultConfig(), config);
+        };
+    }
     static forRoot(options) {
         const config = Object.assign({}, this.getDefaultConfig(), common_1.utils.object.omitKeys(options, ['imports', 'controllers', 'providers', 'exports', 'fastifyFactory']));
         return this.forRootAsync({
@@ -61,7 +71,7 @@ let FastifyModule = FastifyModule_1 = class FastifyModule {
     static forRootAsync(options) {
         const fastifyFactory = (config) => (0, fastify_utils_1.createFastifyInstance)(config, options.fastifyFactory);
         const providers = [{ token: app_1.Router, useClass: fastify_router_1.FastifyRouter }, services_1.ContextService];
-        providers.push({ token: constants_1.FASTIFY_CONFIG, useFactory: options.useFactory, inject: options.inject });
+        providers.push({ token: constants_1.FASTIFY_CONFIG, useFactory: this.createConfigFactory(options.useFactory), inject: options.inject });
         providers.push({ token: constants_1.FASTIFY_INSTANCE, useFactory: fastifyFactory, inject: [constants_1.FASTIFY_CONFIG] });
         if (options.providers)
             providers.push(...options.providers);

package/cjs/module/fastify.utils.js

@@ -86,7 +86,8 @@ async function createFastifyInstance(config, fastifyFactory) {
     const instance = (0, fastify_1.fastify)(options);
     instance.setSchemaErrorFormatter(formatSchemaErrors);
     instance.setNotFoundHandler(exports.notFoundHandler);
-    instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
     instance.setValidatorCompiler(routeSchema => compileValidator(routeSchema, { strictValidator, lenientValidator }));
+    if (errorHandler)
+        instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
     return fastifyFactory ? await fastifyFactory(instance) : instance;
 }

package/esm/classes/default-error-handler.d.ts

@@ -13,6 +13,9 @@ export interface ParsedFastifyError {
 }
 export declare class DefaultErrorHandler implements ErrorHandler {
     private readonly logger;
+    private readonly isStackTraceEnabled;
+    constructor();
     protected parseFastifyError(err: FastifyError): ParsedFastifyError;
+    private handleError;
     handle(err: Error, _req: HttpRequest, res: HttpResponse): HttpResponse;
 }

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

@@ -1,7 +1,7 @@
 /**
  * Importing npm packages
  */
-import { AppError, Logger, ValidationError } from '@shadow-library/common';
+import { AppError, Config, Logger, ValidationError } from '@shadow-library/common';
 /**
  * Importing user defined packages
  */
@@ -15,26 +15,34 @@ const validationError = new ServerError(ServerErrorCode.S003);
 const invalidRequestError = new ServerError(ServerErrorCode.S006);
 export class DefaultErrorHandler {
     logger = Logger.getLogger(NAMESPACE, 'DefaultErrorHandler');
+    isStackTraceEnabled = Config.get('app.dev.stack-trace');
+    constructor() {
+        if (this.isStackTraceEnabled && Config.isProd())
+            this.logger.warn('Stack trace logging is enabled in production');
+    }
     parseFastifyError(err) {
         if (err.statusCode === 500)
             return { statusCode: 500, error: unexpectedError.toObject() };
         return { statusCode: err.statusCode, error: { ...invalidRequestError.toObject(), message: err.message } };
     }
-    handle(err, _req, res) {
-        this.logger.warn('Handling error', err);
-        if (err.cause)
-            this.logger.warn('Caused by', err.cause);
+    handleError(err) {
         if (err instanceof ServerError)
-            return res.status(err.getStatusCode()).send(err.toObject());
+            return { statusCode: err.getStatusCode(), error: err.toObject() };
         else if (err instanceof ValidationError)
-            return res.status(validationError.getStatusCode()).send({ ...err.toObject(), ...validationError.toObject() });
+            return { statusCode: validationError.getStatusCode(), error: { ...err.toObject(), ...validationError.toObject() } };
         else if (err instanceof AppError)
-            return res.status(500).send(err.toObject());
-        else if (err.name === 'FastifyError') {
-            const { statusCode, error } = this.parseFastifyError(err);
-            return res.status(statusCode).send(error);
-        }
+            return { statusCode: 500, error: err.toObject() };
+        else if (err.name === 'FastifyError')
+            return this.parseFastifyError(err);
         this.logger.error('Unhandled error has occurred', err);
-        return res.status(500).send(unexpectedError.toObject());
+        return { statusCode: unexpectedError.getStatusCode(), error: unexpectedError.toObject() };
+    }
+    handle(err, _req, res) {
+        this.logger.warn('Handling error', err);
+        if (err.cause)
+            this.logger.warn('Caused by', err.cause);
+        const { statusCode, error } = this.handleError(err);
+        const payload = this.isStackTraceEnabled ? { ...error, stack: err.stack } : error;
+        return res.status(statusCode).send(payload);
     }
 }

package/esm/config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+declare module '@shadow-library/common' {
+    interface ConfigRecords {
+        'app.port': number;
+        'app.host': string;
+        'app.dev.delay': number;
+        'app.dev.stack-trace': boolean;
+    }
+}
+export {};

package/esm/config.js

@@ -0,0 +1,12 @@
+/**
+ * Importing npm packages
+ */
+import { Config } from '@shadow-library/common';
+/**
+ * Declaring the constants
+ */
+const isDevValue = String(Config.isDev());
+Config.load('app.host', { defaultValue: 'localhost' });
+Config.load('app.port', { defaultValue: '8080', validateType: 'integer' });
+Config.load('app.dev.delay', { validateType: 'integer' });
+Config.load('app.dev.stack-trace', { defaultValue: isDevValue, validateType: 'boolean' });

package/esm/index.d.ts

@@ -1,7 +1,8 @@
 /**
- * Importing npm packages
+ * Importing side-effect packages
  */
 import 'reflect-metadata';
+import './config.js';
 /**
  * exporting modules
  */

package/esm/index.js

@@ -1,7 +1,8 @@
 /**
- * Importing npm packages
+ * Importing side-effect packages
  */
 import 'reflect-metadata';
+import './config.js';
 /**
  * exporting modules
  */

package/esm/module/error-response.dto.d.ts

@@ -17,3 +17,6 @@ export declare class ErrorResponseDto {
     message: string;
     fields?: ErrorFieldDto[];
 }
+export declare class DevErrorResponseDto extends ErrorResponseDto {
+    stack?: string;
+}

package/esm/module/error-response.dto.js

@@ -62,3 +62,14 @@ ErrorResponseDto = __decorate([
     Schema()
 ], ErrorResponseDto);
 export { ErrorResponseDto };
+let DevErrorResponseDto = class DevErrorResponseDto extends ErrorResponseDto {
+    stack;
+};
+__decorate([
+    Field({ optional: true }),
+    __metadata("design:type", String)
+], DevErrorResponseDto.prototype, "stack", void 0);
+DevErrorResponseDto = __decorate([
+    Schema()
+], DevErrorResponseDto);
+export { DevErrorResponseDto };

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

@@ -17,19 +17,19 @@ import { ContextService } from '../services/index.js';
 export interface FastifyConfig extends FastifyServerOptions {
     /**
      * The host on which the Fastify instance is to be started
-     * @default '127.0.0.1'
+     * @default localhost
      */
-    host: string;
+    host?: string;
     /**
      * The port on which the Fastify instance is to be started
      * @default 8080
      */
-    port: number;
+    port?: number;
     /**
      * The error handler to be used to handle errors thrown by the Fastify instance
      * @default DefaultErrorHandler
      */
-    errorHandler: ErrorHandler;
+    errorHandler?: ErrorHandler;
     /**
      * The schema to be used to validate the response of the Fastify instance
      * @default { '4xx': errorResponseSchema, '5xx': errorResponseSchema }

package/esm/module/fastify-router.js

@@ -16,7 +16,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import assert from 'node:assert';
 import { Inject, Injectable, Router } from '@shadow-library/app';
 import { ClassSchema, TransformerFactory } from '@shadow-library/class-schema';
-import { InternalError, Logger, utils } from '@shadow-library/common';
+import { Config, InternalError, Logger, utils } from '@shadow-library/common';
 import { all as deepmerge } from 'deepmerge';
 import findMyWay from 'find-my-way';
 import stringify from 'json-stable-stringify';
@@ -285,6 +285,12 @@ let FastifyRouter = class FastifyRouter extends Router {
         this.instance.addHook('onRequest', this.context.init());
         this.instance.addHook('onRequest', this.getRequestLogger());
         this.logger.info('Registered global middlewares');
+        const delay = Config.get('app.dev.delay');
+        if (delay) {
+            if (Config.isProd())
+                this.logger.warn('Dev delay is enabled in production');
+            this.instance.addHook('onRequest', (_req, _res, done) => setTimeout(done, delay));
+        }
         for (const route of routes) {
             const metadata = route.metadata;
             assert(metadata.path, 'Route path is required');

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

@@ -11,6 +11,7 @@ import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-modul
  */
 export declare class FastifyModule {
     private static getDefaultConfig;
+    private static createConfigFactory;
     static forRoot(options: FastifyModuleOptions): DynamicModule;
     static forRootAsync(options: FastifyModuleAsyncOptions): DynamicModule;
 }

package/esm/module/fastify.module.js

@@ -18,7 +18,7 @@ import { v4 as uuid } from 'uuid';
 import { DefaultErrorHandler } from '../classes/index.js';
 import { FASTIFY_CONFIG, FASTIFY_INSTANCE } from '../constants.js';
 import { ContextService } from '../services/index.js';
-import { ErrorResponseDto } from './error-response.dto.js';
+import { DevErrorResponseDto, ErrorResponseDto } from './error-response.dto.js';
 import { FastifyRouter } from './fastify-router.js';
 import { createFastifyInstance } from './fastify.utils.js';
 /**
@@ -29,10 +29,12 @@ import { createFastifyInstance } from './fastify.utils.js';
  */
 let FastifyModule = FastifyModule_1 = class FastifyModule {
     static getDefaultConfig() {
-        const errorResponseSchema = ClassSchema.generate(ErrorResponseDto);
+        const stackTrace = Config.get('app.dev.stack-trace');
+        const errorResponseClass = stackTrace ? DevErrorResponseDto : ErrorResponseDto;
+        const errorResponseSchema = ClassSchema.generate(errorResponseClass);
         return {
-            host: 'localhost',
-            port: 8080,
+            host: Config.get('app.host'),
+            port: Config.get('app.port'),
             responseSchema: { '4xx': errorResponseSchema, '5xx': errorResponseSchema },
             errorHandler: new DefaultErrorHandler(),
             maskSensitiveData: Config.isProd(),
@@ -44,6 +46,14 @@ let FastifyModule = FastifyModule_1 = class FastifyModule {
             },
         };
     }
+    static createConfigFactory(factory) {
+        return (...args) => {
+            const config = factory(...args);
+            if (config instanceof Promise)
+                return config.then(resolvedConfig => Object.assign({}, this.getDefaultConfig(), resolvedConfig));
+            return Object.assign({}, this.getDefaultConfig(), config);
+        };
+    }
     static forRoot(options) {
         const config = Object.assign({}, this.getDefaultConfig(), utils.object.omitKeys(options, ['imports', 'controllers', 'providers', 'exports', 'fastifyFactory']));
         return this.forRootAsync({
@@ -58,7 +68,7 @@ let FastifyModule = FastifyModule_1 = class FastifyModule {
     static forRootAsync(options) {
         const fastifyFactory = (config) => createFastifyInstance(config, options.fastifyFactory);
         const providers = [{ token: Router, useClass: FastifyRouter }, ContextService];
-        providers.push({ token: FASTIFY_CONFIG, useFactory: options.useFactory, inject: options.inject });
+        providers.push({ token: FASTIFY_CONFIG, useFactory: this.createConfigFactory(options.useFactory), inject: options.inject });
         providers.push({ token: FASTIFY_INSTANCE, useFactory: fastifyFactory, inject: [FASTIFY_CONFIG] });
         if (options.providers)
             providers.push(...options.providers);

package/esm/module/fastify.utils.js

@@ -76,7 +76,8 @@ export async function createFastifyInstance(config, fastifyFactory) {
     const instance = fastify(options);
     instance.setSchemaErrorFormatter(formatSchemaErrors);
     instance.setNotFoundHandler(notFoundHandler);
-    instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
     instance.setValidatorCompiler(routeSchema => compileValidator(routeSchema, { strictValidator, lenientValidator }));
+    if (errorHandler)
+        instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
     return fastifyFactory ? await fastifyFactory(instance) : instance;
 }

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@shadow-library/fastify",
   "type": "module",
-  "version": "1.6.3",
-  "sideEffects": false,
+  "version": "1.7.0",
+  "sideEffects": [
+    "./esm/config.js",
+    "./cjs/config.js"
+  ],
   "description": "A Fastify wrapper featuring decorator-based routing, middleware and error handling",
   "repository": {
     "type": "git",
@@ -27,9 +30,9 @@
   },
   "peerDependencies": {
     "@fastify/view": "^10.0.0",
-    "@shadow-library/app": "^1.3.1",
-    "@shadow-library/class-schema": "^0.2.0",
-    "@shadow-library/common": "^1.5.2",
+    "@shadow-library/app": "^1.3.2",
+    "@shadow-library/class-schema": "^0.4.2",
+    "@shadow-library/common": "^1.6.0",
     "reflect-metadata": "^0.2.2"
   },
   "peerDependenciesMeta": {