@shadow-library/fastify 0.0.13 → 1.0.0

package/README.md

@@ -13,6 +13,7 @@ A powerful TypeScript-first Fastify wrapper featuring decorator-based routing, a
 - 🔄 **Middleware Support**: Flexible middleware system with lifecycle hooks
 - 📊 **Type Safety**: Full TypeScript support with schema generation
 - 🎨 **Templating Ready**: Built-in support for templating engines
+- ⚡ **Dynamic Module**: Configurable module with `forRoot()` and `forRootAsync()` methods
 
 ## Installation
 
@@ -78,15 +79,23 @@ export class UserController {
 
 ### 2. Create a Module
 
+`FastifyModule` is a dynamic module that provides both synchronous and asynchronous configuration methods.
+
 ```typescript
+import { Module } from '@shadow-library/app';
 import { FastifyModule } from '@shadow-library/fastify';
 import { UserController } from './user.controller';
 
-export const AppModule = FastifyModule.forRoot({
-  controllers: [UserController],
-  port: 3000,
-  host: '0.0.0.0',
-});
+@Module({
+  imports: [
+    FastifyModule.forRoot({
+      controllers: [UserController],
+      port: 3000,
+      host: '0.0.0.0',
+    }),
+  ],
+})
+export class AppModule {}
 ```
 
 ### 3. Bootstrap Your Application
@@ -216,136 +225,168 @@ export class RoutesController {
 
 ## Configuration
 
-### Module Configuration
+### 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.
+
+The module provides two configuration methods:
+
+#### Synchronous Configuration (forRoot)
 
 ```typescript
-const AppModule = FastifyModule.forRoot({
-  // Basic server configuration
-  host: 'localhost',
-  port: 8080,
+@Module({
+  imports: [
+    FastifyModule.forRoot({
+      // Basic server configuration
+      host: 'localhost',
+      port: 8080,
 
-  // Controllers to register
-  controllers: [UserController, AuthController],
+      // Controllers to register
+      controllers: [UserController, AuthController],
 
-  // Additional providers
-  providers: [UserService, AuthService],
+      // Additional providers
+      providers: [UserService, AuthService],
 
-  // Error handling
-  errorHandler: new CustomErrorHandler(),
+      // Error handling
+      errorHandler: new CustomErrorHandler(),
 
-  // Security
-  maskSensitiveData: true,
+      // Security
+      maskSensitiveData: true,
 
-  // Request ID generation
-  requestIdLogLabel: 'rid',
-  genReqId: () => uuid(),
+      // Request ID generation
+      requestIdLogLabel: 'rid',
+      genReqId: () => uuid(),
 
-  // Router options
-  routerOptions: {
-    ignoreTrailingSlash: true,
-    ignoreDuplicateSlashes: true,
-  },
+      // Router options
+      routerOptions: {
+        ignoreTrailingSlash: true,
+        ignoreDuplicateSlashes: true,
+      },
 
-  // Response schemas for error handling
-  responseSchema: {
-    '4xx': ErrorResponseSchema,
-    '5xx': ErrorResponseSchema,
-  },
+      // Response schemas for error handling
+      responseSchema: {
+        '4xx': ErrorResponseSchema,
+        '5xx': ErrorResponseSchema,
+      },
 
-  // Extend Fastify instance before registering controllers
-  fastifyFactory: async fastify => {
-    // Register plugins, add hooks, or configure Fastify
-    await fastify.register(require('@fastify/cors'), {
-      origin: true,
-    });
+      // Extend Fastify instance before registering controllers
+      fastifyFactory: async fastify => {
+        // Register plugins, add hooks, or configure Fastify
+        await fastify.register(require('@fastify/cors'), {
+          origin: true,
+        });
 
-    fastify.addHook('onRequest', async (request, reply) => {
-      console.log(`Incoming request: ${request.method} ${request.url}`);
-    });
+        fastify.addHook('onRequest', async (request, reply) => {
+          console.log(`Incoming request: ${request.method} ${request.url}`);
+        });
 
-    return fastify;
-  },
-});
+        return fastify;
+      },
+    }),
+  ],
+})
+export class AppModule {}
 ```
 
-### Async Configuration
+#### Asynchronous Configuration (forRootAsync)
+
+Use `forRootAsync` when you need to inject dependencies or load configuration dynamically:
 
 ```typescript
-const AppModule = FastifyModule.forRootAsync({
-  useFactory: async (configService: ConfigService) => ({
-    host: configService.get('HOST'),
-    port: configService.get('PORT'),
-    controllers: [UserController],
-  }),
-  inject: [ConfigService],
-});
+@Module({
+  imports: [
+    FastifyModule.forRootAsync({
+      useFactory: async (configService: ConfigService) => ({
+        host: configService.get('HOST'),
+        port: configService.get('PORT'),
+        controllers: [UserController],
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class AppModule {}
 ```
 
+#### Dynamic Module Benefits
+
+- **Flexible Configuration**: Configure the module differently for different environments
+- **Dependency Injection**: Inject services into the module configuration
+- **Runtime Configuration**: Load configuration from external sources (databases, config files, etc.)
+- **Type Safety**: Full TypeScript support for all configuration options
+- **Modular Design**: Easy to compose with other modules in your application
+
 ### Extending Fastify Instance
 
 Use the `fastifyFactory` option to customize the Fastify instance before controllers are registered. This is perfect for adding plugins, global hooks, or custom configurations:
 
 ```typescript
+import { Module } from '@shadow-library/app';
 import cors from '@fastify/cors';
 import helmet from '@fastify/helmet';
 import rateLimit from '@fastify/rate-limit';
 
-const AppModule = FastifyModule.forRoot({
-  controllers: [UserController],
-  fastifyFactory: async fastify => {
-    // Register security plugins
-    await fastify.register(helmet, {
-      contentSecurityPolicy: {
-        directives: {
-          defaultSrc: ["'self'"],
-          styleSrc: ["'self'", "'unsafe-inline'"],
-        },
+@Module({
+  imports: [
+    FastifyModule.forRoot({
+      controllers: [UserController],
+      fastifyFactory: async fastify => {
+        // Register security plugins
+        await fastify.register(helmet, {
+          contentSecurityPolicy: {
+            directives: {
+              defaultSrc: ["'self'"],
+              styleSrc: ["'self'", "'unsafe-inline'"],
+            },
+          },
+        });
+
+        // Add CORS support
+        await fastify.register(cors, {
+          origin: (origin, callback) => {
+            const allowedOrigins = ['http://localhost:3000', 'https://myapp.com'];
+            if (!origin || allowedOrigins.includes(origin)) {
+              callback(null, true);
+            } else {
+              callback(new Error('Not allowed by CORS'), false);
+            }
+          },
+          credentials: true,
+        });
+
+        // Add rate limiting
+        await fastify.register(rateLimit, {
+          max: 100,
+          timeWindow: '1 minute',
+        });
+
+        // Add global hooks
+        fastify.addHook('onRequest', async (request, reply) => {
+          console.log(`[${new Date().toISOString()}] ${request.method} ${request.url}`);
+        });
+
+        fastify.addHook('onResponse', async (request, reply) => {
+          const responseTime = reply.elapsedTime;
+          console.log(`Response sent in ${responseTime}ms`);
+        });
+
+        // Add custom context or decorators
+        fastify.decorate('config', {
+          apiVersion: 'v1',
+          environment: process.env.NODE_ENV,
+        });
+
+        // Register custom content type parsers
+        fastify.addContentTypeParser('text/plain', { parseAs: 'string' }, (req, body, done) => {
+          done(null, body);
+        });
+
+        return fastify;
       },
-    });
-
-    // Add CORS support
-    await fastify.register(cors, {
-      origin: (origin, callback) => {
-        const allowedOrigins = ['http://localhost:3000', 'https://myapp.com'];
-        if (!origin || allowedOrigins.includes(origin)) {
-          callback(null, true);
-        } else {
-          callback(new Error('Not allowed by CORS'), false);
-        }
-      },
-      credentials: true,
-    });
-
-    // Add rate limiting
-    await fastify.register(rateLimit, {
-      max: 100,
-      timeWindow: '1 minute',
-    });
-
-    // Add global hooks
-    fastify.addHook('onRequest', async (request, reply) => {
-      console.log(`[${new Date().toISOString()}] ${request.method} ${request.url}`);
-    });
-
-    fastify.addHook('onResponse', async (request, reply) => {
-      const responseTime = reply.elapsedTime;
-      console.log(`Response sent in ${responseTime}ms`);
-    });
-
-    // Add custom context or decorators
-    fastify.decorate('config', {
-      apiVersion: 'v1',
-      environment: process.env.NODE_ENV,
-    });
-
-    // Register custom content type parsers
-    fastify.addContentTypeParser('text/plain', { parseAs: 'string' }, (req, body, done) => {
-      done(null, body);
-    });
-
-    return fastify;
-  },
-});
+    }),
+  ],
+})
+export class AppModule {}
 ```
 
 #### Common Use Cases for fastifyFactory:

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

@@ -1,4 +1,7 @@
-import { Class } from 'type-fest';
+/**
+ * Importing npm packages
+ */
+import { DynamicModule } from '@shadow-library/app';
 import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-module.interface.js';
 /**
  * Defining types
@@ -8,6 +11,6 @@ import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-modul
  */
 export declare class FastifyModule {
     private static getDefaultConfig;
-    static forRoot(options: FastifyModuleOptions): Class<FastifyModule>;
-    static forRootAsync(options: FastifyModuleAsyncOptions): Class<FastifyModule>;
+    static forRoot(options: FastifyModuleOptions): DynamicModule;
+    static forRootAsync(options: FastifyModuleAsyncOptions): DynamicModule;
 }

package/cjs/module/fastify.module.js

@@ -1,4 +1,11 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var FastifyModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyModule = void 0;
 /**
@@ -23,7 +30,7 @@ const fastify_utils_1 = require("./fastify.utils.js");
 /**
  * Declaring the constants
  */
-class FastifyModule {
+let FastifyModule = FastifyModule_1 = class FastifyModule {
     static getDefaultConfig() {
         const errorResponseSchema = class_schema_1.ClassSchema.generate(error_response_dto_1.ErrorResponseDto);
         return {
@@ -52,20 +59,24 @@ class FastifyModule {
         });
     }
     static forRootAsync(options) {
-        const imports = options.imports ?? [];
-        const controllers = options.controllers ?? [];
-        const exports = options.exports ?? [];
+        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];
-        if (options.providers)
-            providers.push(...options.providers);
         providers.push({ token: constants_1.FASTIFY_CONFIG, useFactory: options.useFactory, inject: options.inject });
-        const fastifyFactory = (config) => (0, fastify_utils_1.createFastifyInstance)(config, options.fastifyFactory);
         providers.push({ token: constants_1.FASTIFY_INSTANCE, useFactory: fastifyFactory, inject: [constants_1.FASTIFY_CONFIG] });
-        const Class = class extends FastifyModule {
-        };
-        Object.defineProperty(Class, 'name', { value: FastifyModule.name });
-        (0, app_1.Module)({ imports, controllers, providers, exports: [app_1.Router, services_1.ContextService, ...exports] })(Class);
-        return Class;
+        if (options.providers)
+            providers.push(...options.providers);
+        const exports = [app_1.Router, services_1.ContextService];
+        if (options.exports)
+            exports.push(...options.exports);
+        const Module = { module: FastifyModule_1, providers, exports };
+        if (options.imports)
+            Module.imports = options.imports;
+        if (options.controllers)
+            Module.controllers = options.controllers;
+        return Module;
     }
-}
+};
 exports.FastifyModule = FastifyModule;
+exports.FastifyModule = FastifyModule = FastifyModule_1 = __decorate([
+    (0, app_1.Module)({})
+], FastifyModule);

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

@@ -1,4 +1,7 @@
-import { Class } from 'type-fest';
+/**
+ * Importing npm packages
+ */
+import { DynamicModule } from '@shadow-library/app';
 import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-module.interface.js';
 /**
  * Defining types
@@ -8,6 +11,6 @@ import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-modul
  */
 export declare class FastifyModule {
     private static getDefaultConfig;
-    static forRoot(options: FastifyModuleOptions): Class<FastifyModule>;
-    static forRootAsync(options: FastifyModuleAsyncOptions): Class<FastifyModule>;
+    static forRoot(options: FastifyModuleOptions): DynamicModule;
+    static forRootAsync(options: FastifyModuleAsyncOptions): DynamicModule;
 }

package/esm/module/fastify.module.js

@@ -1,3 +1,10 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var FastifyModule_1;
 /**
  * Importing npm packages
  */
@@ -20,7 +27,7 @@ import { createFastifyInstance } from './fastify.utils.js';
 /**
  * Declaring the constants
  */
-export class FastifyModule {
+let FastifyModule = FastifyModule_1 = class FastifyModule {
     static getDefaultConfig() {
         const errorResponseSchema = ClassSchema.generate(ErrorResponseDto);
         return {
@@ -49,19 +56,24 @@ export class FastifyModule {
         });
     }
     static forRootAsync(options) {
-        const imports = options.imports ?? [];
-        const controllers = options.controllers ?? [];
-        const exports = options.exports ?? [];
+        const fastifyFactory = (config) => createFastifyInstance(config, options.fastifyFactory);
         const providers = [{ token: Router, useClass: FastifyRouter }, ContextService];
-        if (options.providers)
-            providers.push(...options.providers);
         providers.push({ token: FASTIFY_CONFIG, useFactory: options.useFactory, inject: options.inject });
-        const fastifyFactory = (config) => createFastifyInstance(config, options.fastifyFactory);
         providers.push({ token: FASTIFY_INSTANCE, useFactory: fastifyFactory, inject: [FASTIFY_CONFIG] });
-        const Class = class extends FastifyModule {
-        };
-        Object.defineProperty(Class, 'name', { value: FastifyModule.name });
-        Module({ imports, controllers, providers, exports: [Router, ContextService, ...exports] })(Class);
-        return Class;
+        if (options.providers)
+            providers.push(...options.providers);
+        const exports = [Router, ContextService];
+        if (options.exports)
+            exports.push(...options.exports);
+        const Module = { module: FastifyModule_1, providers, exports };
+        if (options.imports)
+            Module.imports = options.imports;
+        if (options.controllers)
+            Module.controllers = options.controllers;
+        return Module;
     }
-}
+};
+FastifyModule = FastifyModule_1 = __decorate([
+    Module({})
+], FastifyModule);
+export { FastifyModule };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shadow-library/fastify",
   "type": "module",
-  "version": "0.0.13",
+  "version": "1.0.0",
   "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.7",
+    "@shadow-library/app": "^1.0.11",
     "@shadow-library/class-schema": "^0.0.12",
-    "@shadow-library/common": "^1.0.18",
+    "@shadow-library/common": "^1.0.22",
     "reflect-metadata": "^0.2.2"
   },
   "peerDependenciesMeta": {