@shadow-library/fastify 1.6.2 → 1.6.4

package/README.md

@@ -663,6 +663,27 @@ 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.
+
 ### 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 +761,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 +779,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/decorators/api-operation.decorator.js

@@ -9,5 +9,5 @@ const app_1 = require("@shadow-library/app");
  * Declaring the constants
  */
 function ApiOperation(options) {
-    return (0, app_1.Route)({ operation: options });
+    return (0, app_1.Route)({ operation: options }, { arrayStrategy: 'replace' });
 }

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

@@ -14,22 +14,28 @@ import { ContextService } from '../services/index.js';
 /**
  * Defining types
  */
+declare module '@shadow-library/common' {
+    interface ConfigRecords {
+        'app.port': number;
+        'app.host': string;
+    }
+}
 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.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() {
+        common_1.Config.load('app.host', { defaultValue: 'localhost' });
+        common_1.Config.load('app.port', { defaultValue: '8080', validateType: 'number' });
         const errorResponseSchema = class_schema_1.ClassSchema.generate(error_response_dto_1.ErrorResponseDto);
         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/cjs/server.error.js

@@ -23,6 +23,10 @@ const ERROR_STATUS_CODES = {
     [common_1.ErrorType.UNAUTHORIZED]: 403,
     [common_1.ErrorType.VALIDATION_ERROR]: 422,
     [common_1.ErrorType.CONFLICT]: 409,
+    [common_1.ErrorType.INVALID_REQUEST]: 400,
+    [common_1.ErrorType.IO_ERROR]: 400,
+    [common_1.ErrorType.PERMISSION_DENIED]: 403,
+    [common_1.ErrorType.INTERNAL_ERROR]: 500,
 };
 class ServerError extends common_1.AppError {
     getStatusCode() {

package/esm/decorators/api-operation.decorator.js

@@ -6,5 +6,5 @@ import { Route } from '@shadow-library/app';
  * Declaring the constants
  */
 export function ApiOperation(options) {
-    return Route({ operation: options });
+    return Route({ operation: options }, { arrayStrategy: 'replace' });
 }

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

@@ -14,22 +14,28 @@ import { ContextService } from '../services/index.js';
 /**
  * Defining types
  */
+declare module '@shadow-library/common' {
+    interface ConfigRecords {
+        'app.port': number;
+        'app.host': string;
+    }
+}
 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.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

@@ -29,10 +29,12 @@ import { createFastifyInstance } from './fastify.utils.js';
  */
 let FastifyModule = FastifyModule_1 = class FastifyModule {
     static getDefaultConfig() {
+        Config.load('app.host', { defaultValue: 'localhost' });
+        Config.load('app.port', { defaultValue: '8080', validateType: 'number' });
         const errorResponseSchema = ClassSchema.generate(ErrorResponseDto);
         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/esm/server.error.js

@@ -20,6 +20,10 @@ const ERROR_STATUS_CODES = {
     [ErrorType.UNAUTHORIZED]: 403,
     [ErrorType.VALIDATION_ERROR]: 422,
     [ErrorType.CONFLICT]: 409,
+    [ErrorType.INVALID_REQUEST]: 400,
+    [ErrorType.IO_ERROR]: 400,
+    [ErrorType.PERMISSION_DENIED]: 403,
+    [ErrorType.INTERNAL_ERROR]: 500,
 };
 export class ServerError extends AppError {
     getStatusCode() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shadow-library/fastify",
   "type": "module",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "sideEffects": false,
   "description": "A Fastify wrapper featuring decorator-based routing, middleware and error handling",
   "repository": {
@@ -27,9 +27,9 @@
   },
   "peerDependencies": {
     "@fastify/view": "^10.0.0",
-    "@shadow-library/app": "^1.0.11",
-    "@shadow-library/class-schema": "^0.1.3",
-    "@shadow-library/common": "^1.0.22",
+    "@shadow-library/app": "^1.3.1",
+    "@shadow-library/class-schema": "^0.2.0",
+    "@shadow-library/common": "^1.5.2",
     "reflect-metadata": "^0.2.2"
   },
   "peerDependenciesMeta": {