@decaf-ts/for-nest 0.0.4 → 0.0.5

package/lib/esm/factory/NestBootstraper.d.ts

@@ -0,0 +1,214 @@
+import { INestApplication, Logger, NestInterceptor, PipeTransform } from "@nestjs/common";
+/**
+ * @description
+ * Defines all customizable parameters for Swagger setup.
+ *
+ * @summary
+ * This interface allows developers to customize how Swagger UI is configured
+ * within the NestJS application. It includes parameters for titles, paths,
+ * color schemes, and asset paths to tailor the API documentation experience.
+ *
+ * @param {string} title - Title displayed in Swagger UI.
+ * @param {string} description - Description shown below the title.
+ * @param {string} version - API version displayed in the documentation.
+ * @param {string} [path] - Optional path where Swagger will be available.
+ * @param {boolean} [persistAuthorization] - Whether authorization tokens persist across reloads.
+ * @param {string} [assetsPath] - Path to custom assets for Swagger UI.
+ * @param {string} [topbarBgColor] - Custom background color for the Swagger top bar.
+ * @param {string} [topbarIconPath] - Path to a custom icon displayed in the top bar.
+ * @param {string} [faviconPath] - Path to a custom favicon.
+ */
+export interface SwaggerSetupOptions {
+    title: string;
+    description: string;
+    version: string;
+    path?: string;
+    persistAuthorization?: boolean;
+    assetsPath?: string;
+    topbarBgColor?: string;
+    topbarIconPath?: string;
+    faviconPath?: string;
+}
+/**
+ * @description
+ * A fluent, static bootstrap class for initializing and configuring a NestJS application.
+ *
+ * @summary
+ * The `NestBootstraper` class provides a chainable API for configuring
+ * a NestJS application instance. It includes built-in methods for enabling
+ * CORS, Helmet security, Swagger documentation, global pipes, filters,
+ * interceptors, and starting the server.
+ *
+ * This class promotes consistency and reduces repetitive setup code
+ * across multiple NestJS projects.
+ *
+ * @example
+ * ```ts
+ * import { NestFactory } from "@nestjs/core";
+ * import { AppModule } from "./app.module";
+ * import { MyLogger } from "./MyLogger";
+ * import { NestBootstraper } from "@decaf-ts/for-nest";
+ *
+ * async function bootstrap() {
+ *   const app = await NestFactory.create(AppModule);
+ *
+ *   await NestBootstraper
+ *     .initialize(app)
+ *     .enableLogger(new MyLogger())
+ *     .enableCors(["http://localhost:4200"])
+ *     .useHelmet()
+ *     .setupSwagger({
+ *       title: "OpenAPI by TradeMark™",
+ *       description: "TradeMark™ API documentation",
+ *       version: "1.0.0",
+ *       path: "api",
+ *       persistAuthorization: true,
+ *       topbarBgColor: "#2C3E50",
+ *       topbarIconPath: "/assets/logo.svg",
+ *       faviconPath: "/assets/favicon.ico"
+ *     })
+ *     .useGlobalFilters()
+ *     .useGlobalPipes(...)
+ *     .useGlobalInterceptors(...)
+ *     .start(3000);
+ * }
+ *
+ * bootstrap();
+ * ```
+ * @class
+ */
+export declare class NestBootstraper {
+    private static app;
+    private static _logger;
+    /**
+     * @description
+     * Returns the current logger instance, creating a default one if not set.
+     *
+     * @summary
+     * Ensures that a valid `Logger` instance is always available
+     * for logging bootstrap-related messages.
+     *
+     * @return {Logger} The active logger instance.
+     */
+    private static get logger();
+    /**
+     * @description
+     * Initializes the bootstrapper with a given NestJS application.
+     *
+     * @summary
+     * Binds the provided NestJS app instance to the bootstrapper, enabling
+     * chained configuration methods.
+     *
+     * @param {INestApplication} app - The NestJS application instance to initialize.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration methods.
+     */
+    static initialize(app: INestApplication): typeof NestBootstraper;
+    /**
+     * @description
+     * Enables or replaces the global logger for the NestJS application.
+     *
+     * @summary
+     * If a custom logger is provided, it replaces the default logger. Otherwise,
+     * a new logger named `"NestBootstrap"` is used. This logger is also registered
+     * with the NestJS application.
+     *
+     * @param {Logger} [customLogger] - Optional custom logger instance.
+     * @return {typeof NestBootstraper} Returns the class for chaining.
+     */
+    static enableLogger(customLogger?: Logger): typeof NestBootstraper;
+    /**
+     * @description
+     * Enables Cross-Origin Resource Sharing (CORS) for the application.
+     *
+     * @summary
+     * Allows defining either a wildcard origin (`"*"`) or a list of allowed origins.
+     * Automatically accepts local development requests and those without origin headers.
+     * Throws a `CorsError` for unauthorized origins.
+     *
+     * @param {'*' | string[]} [origins=[]] - List of allowed origins or `"*"` to allow all.
+     * @param {string[]} [allowMethods=['GET', 'POST', 'PUT', 'DELETE']] - Allowed HTTP methods.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     *
+     */
+    static enableCors(origins?: "*" | string[], allowMethods?: string[]): typeof NestBootstraper;
+    /**
+     * @description
+     * Applies the Helmet middleware for enhanced security.
+     *
+     * @summary
+     * Dynamically loads the `helmet` package if available and registers it
+     * as middleware to improve HTTP header security. If not installed, logs a warning
+     * and continues execution without throwing errors.
+     *
+     * @param {Record<string, any>} [options] - Optional configuration passed to Helmet.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useHelmet(options?: Record<string, any>): typeof NestBootstraper;
+    /**
+     * @description
+     * Configures and initializes Swagger UI for API documentation.
+     *
+     * @summary
+     * Uses the `SwaggerBuilder` utility to configure API documentation
+     * with detailed customization for title, version, paths, and colors.
+     * Swagger is automatically exposed at the configured path.
+     *
+     * @param {SwaggerSetupOptions} options - Swagger configuration options.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static setupSwagger(options: SwaggerSetupOptions): typeof NestBootstraper;
+    /**
+     * @description
+     * Registers one or more global validation pipes.
+     *
+     * @summary
+     * Enables request payload validation and transformation globally across
+     * the entire NestJS application. Multiple pipes can be chained together
+     * for modular input validation.
+     *
+     * @param {...PipeTransform[]} pipes - Pipe instances to register globally.
+     * @return {typeof NestBootstraper} Returns the class for chaining.
+     */
+    static useGlobalPipes(...pipes: PipeTransform[]): typeof NestBootstraper;
+    /**
+     * @description
+     * Registers one or more global exception filters.
+     *
+     * @summary
+     * If no filters are provided, it automatically registers a default
+     * set of standard exception filters for common error types like
+     * `HttpException`, `ValidationException`, `ConflictException`, and others.
+     *
+     * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useGlobalFilters(...filters: any[]): typeof NestBootstraper;
+    /**
+     * @description
+     * Registers global interceptors for request and response transformation.
+     *
+     * @summary
+     * Interceptors allow advanced request/response manipulation such as
+     * serialization, logging, or transformation. Multiple interceptors
+     * can be added for modular configuration.
+     *
+     * @param {...NestInterceptor[]} interceptors - Interceptor instances to register.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useGlobalInterceptors(...interceptors: NestInterceptor[]): typeof NestBootstraper;
+    /**
+     * @description
+     * Starts the NestJS application and binds it to the given port and host.
+     *
+     * @summary
+     * Listens on the specified port and optionally a host. Once started,
+     * logs the application URL for easy access. The startup process resolves
+     * once the application is successfully running.
+     *
+     * @param {number} [port=3000] - Port number to listen on.
+     * @param {string} [host] - Optional host or IP address to bind to.
+     * @param {boolean} [log=true] - Whether to log the application URL upon startup.
+     * @return {Promise<void>} Resolves once the application starts successfully.
+     */
+    static start(port?: number, host?: string | undefined, log?: boolean): Promise<void>;
+}

package/lib/esm/factory/NestBootstraper.js

@@ -0,0 +1,269 @@
+import { Logger, } from "@nestjs/common";
+import { AuthorizationExceptionFilter, ConflictExceptionFilter, GlobalExceptionFilter, HttpExceptionFilter, NotFoundExceptionFilter, ValidationExceptionFilter, } from "./exceptions/index.js";
+import { SwaggerBuilder } from "./openapi/index.js";
+import { CorsError } from "./errors/index.js";
+/**
+ * @description
+ * A fluent, static bootstrap class for initializing and configuring a NestJS application.
+ *
+ * @summary
+ * The `NestBootstraper` class provides a chainable API for configuring
+ * a NestJS application instance. It includes built-in methods for enabling
+ * CORS, Helmet security, Swagger documentation, global pipes, filters,
+ * interceptors, and starting the server.
+ *
+ * This class promotes consistency and reduces repetitive setup code
+ * across multiple NestJS projects.
+ *
+ * @example
+ * ```ts
+ * import { NestFactory } from "@nestjs/core";
+ * import { AppModule } from "./app.module";
+ * import { MyLogger } from "./MyLogger";
+ * import { NestBootstraper } from "@decaf-ts/for-nest";
+ *
+ * async function bootstrap() {
+ *   const app = await NestFactory.create(AppModule);
+ *
+ *   await NestBootstraper
+ *     .initialize(app)
+ *     .enableLogger(new MyLogger())
+ *     .enableCors(["http://localhost:4200"])
+ *     .useHelmet()
+ *     .setupSwagger({
+ *       title: "OpenAPI by TradeMark™",
+ *       description: "TradeMark™ API documentation",
+ *       version: "1.0.0",
+ *       path: "api",
+ *       persistAuthorization: true,
+ *       topbarBgColor: "#2C3E50",
+ *       topbarIconPath: "/assets/logo.svg",
+ *       faviconPath: "/assets/favicon.ico"
+ *     })
+ *     .useGlobalFilters()
+ *     .useGlobalPipes(...)
+ *     .useGlobalInterceptors(...)
+ *     .start(3000);
+ * }
+ *
+ * bootstrap();
+ * ```
+ * @class
+ */
+export class NestBootstraper {
+    /**
+     * @description
+     * Returns the current logger instance, creating a default one if not set.
+     *
+     * @summary
+     * Ensures that a valid `Logger` instance is always available
+     * for logging bootstrap-related messages.
+     *
+     * @return {Logger} The active logger instance.
+     */
+    static get logger() {
+        if (!this._logger) {
+            // fallback
+            this._logger = new Logger("NestBootstrap");
+        }
+        return this._logger;
+    }
+    /**
+     * @description
+     * Initializes the bootstrapper with a given NestJS application.
+     *
+     * @summary
+     * Binds the provided NestJS app instance to the bootstrapper, enabling
+     * chained configuration methods.
+     *
+     * @param {INestApplication} app - The NestJS application instance to initialize.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration methods.
+     */
+    static initialize(app) {
+        this.app = app;
+        return this;
+    }
+    /**
+     * @description
+     * Enables or replaces the global logger for the NestJS application.
+     *
+     * @summary
+     * If a custom logger is provided, it replaces the default logger. Otherwise,
+     * a new logger named `"NestBootstrap"` is used. This logger is also registered
+     * with the NestJS application.
+     *
+     * @param {Logger} [customLogger] - Optional custom logger instance.
+     * @return {typeof NestBootstraper} Returns the class for chaining.
+     */
+    static enableLogger(customLogger) {
+        this._logger = customLogger || new Logger("NestBootstrap");
+        this.app.useLogger(this._logger);
+        return this;
+    }
+    /**
+     * @description
+     * Enables Cross-Origin Resource Sharing (CORS) for the application.
+     *
+     * @summary
+     * Allows defining either a wildcard origin (`"*"`) or a list of allowed origins.
+     * Automatically accepts local development requests and those without origin headers.
+     * Throws a `CorsError` for unauthorized origins.
+     *
+     * @param {'*' | string[]} [origins=[]] - List of allowed origins or `"*"` to allow all.
+     * @param {string[]} [allowMethods=['GET', 'POST', 'PUT', 'DELETE']] - Allowed HTTP methods.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     *
+     */
+    static enableCors(origins = [], allowMethods = ["GET", "POST", "PUT", "DELETE"]) {
+        const allowedOrigins = origins === "*" ? "*" : origins.map((o) => o.trim().toLowerCase());
+        const corsOptions = {
+            origin: (origin, callback) => {
+                // Allow request without origin...
+                if (!origin)
+                    return callback(null, true);
+                if (allowedOrigins === "*" ||
+                    (Array.isArray(allowedOrigins) &&
+                        allowedOrigins.includes(origin.toLowerCase()))) {
+                    return callback(null, true);
+                }
+                callback(new CorsError(`Origin ${origin} not allowed`));
+            },
+            credentials: true,
+            methods: allowMethods.join(","),
+        };
+        this.app.enableCors(corsOptions);
+        return this;
+    }
+    /**
+     * @description
+     * Applies the Helmet middleware for enhanced security.
+     *
+     * @summary
+     * Dynamically loads the `helmet` package if available and registers it
+     * as middleware to improve HTTP header security. If not installed, logs a warning
+     * and continues execution without throwing errors.
+     *
+     * @param {Record<string, any>} [options] - Optional configuration passed to Helmet.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useHelmet(options) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const helmet = require("helmet"); // Dynamic import to avoid hard dependency
+            this.app.use(helmet(options));
+            this.logger.log("Helmet middleware enabled successfully.");
+        }
+        catch (e) {
+            this.logger.warn("Helmet not installed. Skipping middleware.");
+        }
+        return this;
+    }
+    /**
+     * @description
+     * Configures and initializes Swagger UI for API documentation.
+     *
+     * @summary
+     * Uses the `SwaggerBuilder` utility to configure API documentation
+     * with detailed customization for title, version, paths, and colors.
+     * Swagger is automatically exposed at the configured path.
+     *
+     * @param {SwaggerSetupOptions} options - Swagger configuration options.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static setupSwagger(options) {
+        const swagger = new SwaggerBuilder(this.app, {
+            title: options.title,
+            description: options.description,
+            version: options.version,
+            path: options.path || "api",
+            persistAuthorization: options.persistAuthorization ?? true,
+            assetsPath: options.assetsPath,
+            faviconFilePath: options.faviconPath,
+            topbarIconFilePath: options.topbarIconPath,
+            topbarBgColor: options.topbarBgColor,
+        });
+        swagger.setupSwagger();
+        return this;
+    }
+    /**
+     * @description
+     * Registers one or more global validation pipes.
+     *
+     * @summary
+     * Enables request payload validation and transformation globally across
+     * the entire NestJS application. Multiple pipes can be chained together
+     * for modular input validation.
+     *
+     * @param {...PipeTransform[]} pipes - Pipe instances to register globally.
+     * @return {typeof NestBootstraper} Returns the class for chaining.
+     */
+    static useGlobalPipes(...pipes) {
+        if (pipes.length > 0)
+            this.app.useGlobalPipes(...pipes);
+        return this;
+    }
+    /**
+     * @description
+     * Registers one or more global exception filters.
+     *
+     * @summary
+     * If no filters are provided, it automatically registers a default
+     * set of standard exception filters for common error types like
+     * `HttpException`, `ValidationException`, `ConflictException`, and others.
+     *
+     * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useGlobalFilters(...filters) {
+        const defaultFilters = [
+            new HttpExceptionFilter(),
+            new ValidationExceptionFilter(),
+            new NotFoundExceptionFilter(),
+            new ConflictExceptionFilter(),
+            new AuthorizationExceptionFilter(),
+            new GlobalExceptionFilter(),
+        ];
+        this.app.useGlobalFilters(...(filters.length > 0 ? filters : defaultFilters));
+        return this;
+    }
+    /**
+     * @description
+     * Registers global interceptors for request and response transformation.
+     *
+     * @summary
+     * Interceptors allow advanced request/response manipulation such as
+     * serialization, logging, or transformation. Multiple interceptors
+     * can be added for modular configuration.
+     *
+     * @param {...NestInterceptor[]} interceptors - Interceptor instances to register.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useGlobalInterceptors(...interceptors) {
+        if (interceptors.length > 0)
+            this.app.useGlobalInterceptors(...interceptors);
+        return this;
+    }
+    /**
+     * @description
+     * Starts the NestJS application and binds it to the given port and host.
+     *
+     * @summary
+     * Listens on the specified port and optionally a host. Once started,
+     * logs the application URL for easy access. The startup process resolves
+     * once the application is successfully running.
+     *
+     * @param {number} [port=3000] - Port number to listen on.
+     * @param {string} [host] - Optional host or IP address to bind to.
+     * @param {boolean} [log=true] - Whether to log the application URL upon startup.
+     * @return {Promise<void>} Resolves once the application starts successfully.
+     */
+    static async start(port = Number(process.env.PORT) || 3000, host = undefined, log = true) {
+        this.app.listen(port, host).then(async () => {
+            if (log) {
+                const url = await this.app.getUrl();
+                this.logger.log(`🚀 Application is running at: ${url}`);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NestBootstraper.js","sourceRoot":"","sources":["../../../src/factory/NestBootstraper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ExceptionFilter,\n  INestApplication,\n  Logger,\n  NestInterceptor,\n  PipeTransform,\n} from \"@nestjs/common\";\nimport {\n  AuthorizationExceptionFilter,\n  ConflictExceptionFilter,\n  GlobalExceptionFilter,\n  HttpExceptionFilter,\n  NotFoundExceptionFilter,\n  ValidationExceptionFilter,\n} from \"./exceptions\";\nimport { SwaggerBuilder } from \"./openapi\";\nimport { CorsOptions } from \"@nestjs/common/interfaces/external/cors-options.interface\";\nimport { CorsError } from \"./errors\";\n\n/**\n * @description\n * Defines all customizable parameters for Swagger setup.\n *\n * @summary\n * This interface allows developers to customize how Swagger UI is configured\n * within the NestJS application. It includes parameters for titles, paths,\n * color schemes, and asset paths to tailor the API documentation experience.\n *\n * @param {string} title - Title displayed in Swagger UI.\n * @param {string} description - Description shown below the title.\n * @param {string} version - API version displayed in the documentation.\n * @param {string} [path] - Optional path where Swagger will be available.\n * @param {boolean} [persistAuthorization] - Whether authorization tokens persist across reloads.\n * @param {string} [assetsPath] - Path to custom assets for Swagger UI.\n * @param {string} [topbarBgColor] - Custom background color for the Swagger top bar.\n * @param {string} [topbarIconPath] - Path to a custom icon displayed in the top bar.\n * @param {string} [faviconPath] - Path to a custom favicon.\n */\nexport interface SwaggerSetupOptions {\n  title: string;\n  description: string;\n  version: string;\n  path?: string;\n  persistAuthorization?: boolean;\n  assetsPath?: string;\n  topbarBgColor?: string;\n  topbarIconPath?: string;\n  faviconPath?: string;\n}\n\n/**\n * @description\n * A fluent, static bootstrap class for initializing and configuring a NestJS application.\n *\n * @summary\n * The `NestBootstraper` class provides a chainable API for configuring\n * a NestJS application instance. It includes built-in methods for enabling\n * CORS, Helmet security, Swagger documentation, global pipes, filters,\n * interceptors, and starting the server.\n *\n * This class promotes consistency and reduces repetitive setup code\n * across multiple NestJS projects.\n *\n * @example\n * ```ts\n * import { NestFactory } from \"@nestjs/core\";\n * import { AppModule } from \"./app.module\";\n * import { MyLogger } from \"./MyLogger\";\n * import { NestBootstraper } from \"@decaf-ts/for-nest\";\n *\n * async function bootstrap() {\n *   const app = await NestFactory.create(AppModule);\n *\n *   await NestBootstraper\n *     .initialize(app)\n *     .enableLogger(new MyLogger())\n *     .enableCors([\"http://localhost:4200\"])\n *     .useHelmet()\n *     .setupSwagger({\n *       title: \"OpenAPI by TradeMark™\",\n *       description: \"TradeMark™ API documentation\",\n *       version: \"1.0.0\",\n *       path: \"api\",\n *       persistAuthorization: true,\n *       topbarBgColor: \"#2C3E50\",\n *       topbarIconPath: \"/assets/logo.svg\",\n *       faviconPath: \"/assets/favicon.ico\"\n *     })\n *     .useGlobalFilters()\n *     .useGlobalPipes(...)\n *     .useGlobalInterceptors(...)\n *     .start(3000);\n * }\n *\n * bootstrap();\n * ```\n * @class\n */\nexport class NestBootstraper {\n  private static app: INestApplication;\n  private static _logger: Logger;\n\n  /**\n   * @description\n   * Returns the current logger instance, creating a default one if not set.\n   *\n   * @summary\n   * Ensures that a valid `Logger` instance is always available\n   * for logging bootstrap-related messages.\n   *\n   * @return {Logger} The active logger instance.\n   */\n  private static get logger(): Logger {\n    if (!this._logger) {\n      // fallback\n      this._logger = new Logger(\"NestBootstrap\");\n    }\n    return this._logger;\n  }\n\n  /**\n   * @description\n   * Initializes the bootstrapper with a given NestJS application.\n   *\n   * @summary\n   * Binds the provided NestJS app instance to the bootstrapper, enabling\n   * chained configuration methods.\n   *\n   * @param {INestApplication} app - The NestJS application instance to initialize.\n   * @return {typeof NestBootstraper} Returns the class for chaining configuration methods.\n   */\n  static initialize(app: INestApplication) {\n    this.app = app;\n    return this;\n  }\n\n  /**\n   * @description\n   * Enables or replaces the global logger for the NestJS application.\n   *\n   * @summary\n   * If a custom logger is provided, it replaces the default logger. Otherwise,\n   * a new logger named `\"NestBootstrap\"` is used. This logger is also registered\n   * with the NestJS application.\n   *\n   * @param {Logger} [customLogger] - Optional custom logger instance.\n   * @return {typeof NestBootstraper} Returns the class for chaining.\n   */\n  static enableLogger(customLogger?: Logger) {\n    this._logger = customLogger || new Logger(\"NestBootstrap\");\n    this.app.useLogger(this._logger);\n    return this;\n  }\n\n  /**\n   * @description\n   * Enables Cross-Origin Resource Sharing (CORS) for the application.\n   *\n   * @summary\n   * Allows defining either a wildcard origin (`\"*\"`) or a list of allowed origins.\n   * Automatically accepts local development requests and those without origin headers.\n   * Throws a `CorsError` for unauthorized origins.\n   *\n   * @param {'*' | string[]} [origins=[]] - List of allowed origins or `\"*\"` to allow all.\n   * @param {string[]} [allowMethods=['GET', 'POST', 'PUT', 'DELETE']] - Allowed HTTP methods.\n   * @return {typeof NestBootstraper} Returns the class for chaining configuration.\n   *\n   */\n  static enableCors(\n    origins: \"*\" | string[] = [],\n    allowMethods: string[] = [\"GET\", \"POST\", \"PUT\", \"DELETE\"]\n  ) {\n    const allowedOrigins =\n      origins === \"*\" ? \"*\" : origins.map((o) => o.trim().toLowerCase());\n\n    const corsOptions: CorsOptions = {\n      origin: (origin, callback) => {\n        // Allow request without origin...\n        if (!origin) return callback(null, true);\n\n        if (\n          allowedOrigins === \"*\" ||\n          (Array.isArray(allowedOrigins) &&\n            allowedOrigins.includes(origin.toLowerCase()))\n        ) {\n          return callback(null, true);\n        }\n\n        callback(new CorsError(`Origin ${origin} not allowed`));\n      },\n      credentials: true,\n      methods: allowMethods.join(\",\"),\n    };\n\n    this.app.enableCors(corsOptions);\n    return this;\n  }\n\n  /**\n   * @description\n   * Applies the Helmet middleware for enhanced security.\n   *\n   * @summary\n   * Dynamically loads the `helmet` package if available and registers it\n   * as middleware to improve HTTP header security. If not installed, logs a warning\n   * and continues execution without throwing errors.\n   *\n   * @param {Record<string, any>} [options] - Optional configuration passed to Helmet.\n   * @return {typeof NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useHelmet(options?: Record<string, any>) {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      const helmet = require(\"helmet\"); // Dynamic import to avoid hard dependency\n      this.app.use(helmet(options));\n      this.logger.log(\"Helmet middleware enabled successfully.\");\n    } catch (e: any) {\n      this.logger.warn(\"Helmet not installed. Skipping middleware.\");\n    }\n\n    return this;\n  }\n\n  /**\n   * @description\n   * Configures and initializes Swagger UI for API documentation.\n   *\n   * @summary\n   * Uses the `SwaggerBuilder` utility to configure API documentation\n   * with detailed customization for title, version, paths, and colors.\n   * Swagger is automatically exposed at the configured path.\n   *\n   * @param {SwaggerSetupOptions} options - Swagger configuration options.\n   * @return {typeof NestBootstraper} Returns the class for chaining configuration.\n   */\n  static setupSwagger(options: SwaggerSetupOptions) {\n    const swagger = new SwaggerBuilder(this.app, {\n      title: options.title,\n      description: options.description,\n      version: options.version,\n      path: options.path || \"api\",\n      persistAuthorization: options.persistAuthorization ?? true,\n      assetsPath: options.assetsPath,\n      faviconFilePath: options.faviconPath,\n      topbarIconFilePath: options.topbarIconPath,\n      topbarBgColor: options.topbarBgColor,\n    });\n    swagger.setupSwagger();\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers one or more global validation pipes.\n   *\n   * @summary\n   * Enables request payload validation and transformation globally across\n   * the entire NestJS application. Multiple pipes can be chained together\n   * for modular input validation.\n   *\n   * @param {...PipeTransform[]} pipes - Pipe instances to register globally.\n   * @return {typeof NestBootstraper} Returns the class for chaining.\n   */\n  static useGlobalPipes(...pipes: PipeTransform[]) {\n    if (pipes.length > 0) this.app.useGlobalPipes(...pipes);\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers one or more global exception filters.\n   *\n   * @summary\n   * If no filters are provided, it automatically registers a default\n   * set of standard exception filters for common error types like\n   * `HttpException`, `ValidationException`, `ConflictException`, and others.\n   *\n   * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.\n   * @return {typeof NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useGlobalFilters(...filters: any[]) {\n    const defaultFilters = [\n      new HttpExceptionFilter(),\n      new ValidationExceptionFilter(),\n      new NotFoundExceptionFilter(),\n      new ConflictExceptionFilter(),\n      new AuthorizationExceptionFilter(),\n      new GlobalExceptionFilter(),\n    ];\n\n    this.app.useGlobalFilters(\n      ...(filters.length > 0 ? filters : defaultFilters)\n    );\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers global interceptors for request and response transformation.\n   *\n   * @summary\n   * Interceptors allow advanced request/response manipulation such as\n   * serialization, logging, or transformation. Multiple interceptors\n   * can be added for modular configuration.\n   *\n   * @param {...NestInterceptor[]} interceptors - Interceptor instances to register.\n   * @return {typeof NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useGlobalInterceptors(...interceptors: NestInterceptor[]) {\n    if (interceptors.length > 0)\n      this.app.useGlobalInterceptors(...interceptors);\n    return this;\n  }\n\n  /**\n   * @description\n   * Starts the NestJS application and binds it to the given port and host.\n   *\n   * @summary\n   * Listens on the specified port and optionally a host. Once started,\n   * logs the application URL for easy access. The startup process resolves\n   * once the application is successfully running.\n   *\n   * @param {number} [port=3000] - Port number to listen on.\n   * @param {string} [host] - Optional host or IP address to bind to.\n   * @param {boolean} [log=true] - Whether to log the application URL upon startup.\n   * @return {Promise<void>} Resolves once the application starts successfully.\n   */\n  static async start(\n    port: number = Number(process.env.PORT) || 3000,\n    host: string | undefined = undefined,\n    log: boolean = true\n  ) {\n    this.app.listen(port, host as any).then(async () => {\n      if (log) {\n        const url = await this.app.getUrl();\n        this.logger.log(`🚀 Application is running at: ${url}`);\n      }\n    });\n  }\n}\n"]}

package/lib/esm/factory/errors/cors.d.ts

@@ -0,0 +1,4 @@
+import { ForbiddenError } from "@decaf-ts/core";
+export declare class CorsError extends ForbiddenError {
+    constructor(msg: string | Error);
+}

package/lib/esm/factory/errors/cors.js

@@ -0,0 +1,7 @@
+import { ForbiddenError } from "@decaf-ts/core";
+export class CorsError extends ForbiddenError {
+    constructor(msg) {
+        super(msg, CorsError.name);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9mYWN0b3J5L2Vycm9ycy9jb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBa0IsY0FBYyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFFL0QsTUFBTSxPQUFPLFNBQVUsU0FBUSxjQUFjO0lBQzVDLFlBQVksR0FBbUI7UUFDOUIsS0FBSyxDQUFDLEdBQUcsRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUIsQ0FBQztDQUNEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb25uZWN0aW9uRXJyb3IsIEZvcmJpZGRlbkVycm9yfSBmcm9tIFwiQGRlY2FmLXRzL2NvcmVcIjtcblxuZXhwb3J0IGNsYXNzIENvcnNFcnJvciBleHRlbmRzIEZvcmJpZGRlbkVycm9yIHtcblx0Y29uc3RydWN0b3IobXNnOiBzdHJpbmcgfCBFcnJvcikge1xuXHRcdHN1cGVyKG1zZywgQ29yc0Vycm9yLm5hbWUpO1xuXHR9XG59Il19

package/lib/esm/factory/errors/index.d.ts

@@ -0,0 +1 @@
+export * from "./cors";

package/lib/esm/factory/errors/index.js

@@ -0,0 +1,2 @@
+export * from "./cors.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZmFjdG9yeS9lcnJvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMEJBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29yc1wiO1xuIl19

package/lib/esm/factory/exceptions/AuthorizationExceptionFilter.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+export declare class AuthorizationError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message?: string);
+}
+export declare class AuthorizationExceptionFilter implements ExceptionFilter {
+    catch(exception: AuthorizationError, host: ArgumentsHost): void;
+}

package/lib/esm/factory/exceptions/AuthorizationExceptionFilter.js

@@ -0,0 +1,35 @@
+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;
+};
+import { Catch, HttpStatus } from "@nestjs/common";
+import { HttpResponseError } from "./HttpResponseError.js";
+export class AuthorizationError extends Error {
+    constructor(message = "Unauthorized") {
+        super(message);
+        this.name = "AuthorizationError";
+        this.status = 401;
+        this.code = "UNAUTHORIZED";
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+    }
+}
+let AuthorizationExceptionFilter = class AuthorizationExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const request = ctx.getRequest();
+        const response = ctx.getResponse();
+        const httpResponseError = new HttpResponseError(request, {
+            error: "UNAUTHORIZED",
+            status: HttpStatus.UNAUTHORIZED,
+            message: exception.message,
+        });
+        response.status(HttpStatus.UNAUTHORIZED).json(httpResponseError);
+    }
+};
+AuthorizationExceptionFilter = __decorate([
+    Catch(AuthorizationError)
+], AuthorizationExceptionFilter);
+export { AuthorizationExceptionFilter };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/factory/exceptions/ConflictExceptionFilter.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+export declare class ConflictError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message?: string);
+}
+export declare class ConflictExceptionFilter implements ExceptionFilter {
+    catch(exception: ConflictError, host: ArgumentsHost): void;
+}

package/lib/esm/factory/exceptions/ConflictExceptionFilter.js

@@ -0,0 +1,35 @@
+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;
+};
+import { Catch, HttpStatus } from "@nestjs/common";
+import { HttpResponseError } from "./HttpResponseError.js";
+export class ConflictError extends Error {
+    constructor(message = "Conflict") {
+        super(message);
+        this.name = "ConflictError";
+        this.status = 409;
+        this.code = "CONFLICT";
+        Object.setPrototypeOf(this, ConflictError.prototype);
+    }
+}
+let ConflictExceptionFilter = class ConflictExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const httpResponseError = new HttpResponseError(request, {
+            status: HttpStatus.CONFLICT,
+            message: exception.message,
+            error: "CONFLICT"
+        });
+        response.status(httpResponseError.status).json(httpResponseError);
+    }
+};
+ConflictExceptionFilter = __decorate([
+    Catch(ConflictError)
+], ConflictExceptionFilter);
+export { ConflictExceptionFilter };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/factory/exceptions/GlobalExceptionFilter.d.ts

@@ -0,0 +1,4 @@
+import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+export declare class GlobalExceptionFilter implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): void;
+}