@decaf-ts/for-nest 0.11.2-refactor.5 → 0.11.2-refactor.6

package/lib/cjs/factory/exceptions/DecafErrorFilter.cjs

@@ -11,31 +11,67 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
                 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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+        return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); };
+};
 const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const logging_1 = require("@decaf-ts/logging");
-const core_1 = require("@decaf-ts/core");
+const core_2 = require("@decaf-ts/core");
 const throttling_js_1 = require("./../errors/throttling.cjs");
+const DecafRequestContext_js_1 = require("./../../request/DecafRequestContext.cjs");
+/**
+ * @description Maps well-known NestJS `HttpException` subclasses (as guards, pipes, or
+ * other framework-level code would throw them) onto the equivalent decaf-ts `BaseError`.
+ * @summary Only `BaseError` instances carry the `.code` the response body relies on, so
+ * without this map every non-decaf exception — including perfectly legitimate ones like a
+ * guard's `ForbiddenException` — would be flattened into a generic 500 `InternalError`.
+ */
+const HTTP_EXCEPTION_TO_DECAF_ERROR = new Map([
+    [common_1.UnauthorizedException, (msg) => new core_2.AuthorizationError(msg)],
+    [common_1.ForbiddenException, (msg) => new core_2.ForbiddenError(msg)],
+    [common_1.BadRequestException, (msg) => new db_decorators_1.BadRequestError(msg)],
+    [common_1.ConflictException, (msg) => new db_decorators_1.ConflictError(msg)],
+    [common_1.UnprocessableEntityException, (msg) => new db_decorators_1.ValidationError(msg)],
+]);
 let DecafExceptionFilter = class DecafExceptionFilter {
-    catch(exception, host) {
+    constructor(moduleRef) {
+        this.moduleRef = moduleRef;
+    }
+    async catch(exception, host) {
         const ctx = host.switchToHttp();
         const response = ctx.getResponse();
         const request = ctx.getRequest();
         const isProduction = logging_1.LoggedEnvironment.env === "production";
         let statusCode;
         if (exception instanceof common_1.NotFoundException ||
-            exception instanceof core_1.UnsupportedError) {
+            exception instanceof core_2.UnsupportedError) {
             exception = new common_1.NotAcceptableException(exception.message);
             statusCode = exception.getStatus();
         }
         else if (!(exception instanceof db_decorators_1.BaseError)) {
-            if (exception.status === 429) {
+            const toDecafError = this.decafErrorFor(exception);
+            if (toDecafError) {
+                exception = toDecafError(exception.message);
+            }
+            else if (exception.status === 429) {
                 exception = new throttling_js_1.ToManyRequestsError(exception.message);
             }
+            else if (exception instanceof common_1.HttpException) {
+                // A recognized but unmapped HttpException (e.g. thrown by a guard or
+                // pipe) — preserve its real status instead of flattening it to 500.
+                statusCode = exception.getStatus();
+            }
             else {
                 exception = new db_decorators_1.InternalError(exception.message);
             }
         }
+        await this.logError(request, exception);
         response.status(exception.code || statusCode).json({
             status: exception.code || statusCode,
             error: isProduction ? exception.name : exception.message,
@@ -44,10 +80,73 @@ let DecafExceptionFilter = class DecafExceptionFilter {
             method: request.method,
         });
     }
+    /**
+     * @description Finds the decaf-ts `BaseError` constructor mapped to this exception's type, if any.
+     * @summary Walks `HTTP_EXCEPTION_TO_DECAF_ERROR` with `instanceof` (rather than a straight
+     * `Map.get`) so subclasses of a mapped exception are matched too.
+     */
+    decafErrorFor(exception) {
+        for (const [type, factory] of HTTP_EXCEPTION_TO_DECAF_ERROR) {
+            if (exception instanceof type)
+                return factory;
+        }
+        return undefined;
+    }
+    /**
+     * @description Logs the exception without ever letting logging failures block the response.
+     * @summary A guard (or middleware/CORS check) can throw before any decaf-aware provider ran,
+     * so the request-bound Context may not exist yet — or the resolved logger's `.error()` itself
+     * could throw (broken transport, formatter bug, etc.). Either way the client-facing error
+     * response below must still go out, so every failure mode here is swallowed, falling back to
+     * the plain `Logging.get()` logger and, as a last resort, doing nothing at all.
+     */
+    async logError(request, exception) {
+        const message = `Unhandled error on ${request?.method} ${request?.url}`;
+        try {
+            const log = await this.resolveLogger(request);
+            log.error(message, exception);
+        }
+        catch {
+            try {
+                logging_1.Logging.get().error(message, exception);
+            }
+            catch {
+                // logging is unavailable — the response is still sent below
+            }
+        }
+    }
+    /**
+     * @description Resolves the logger bound to the originating request's decaf-ts Context.
+     * @summary Global filters are singletons, so the request-scoped {@link DecafRequestContext}
+     * (and the client/user-bound logger it carries) can't be constructor-injected. Instead, this
+     * looks up the same request's context id and re-resolves the already-accumulated instance
+     * through `ModuleRef`. Falls back to the generic `Logging.get()` logger when the filter wasn't
+     * constructed with a `ModuleRef` (e.g. manually `new`'d) or no request-scoped context exists
+     * for this request (e.g. the error happened before any decaf-aware provider ran, as is the
+     * case when a guard rejects the request before interceptors get to bind the client-scoped
+     * logger onto the Context).
+     */
+    async resolveLogger(request) {
+        if (this.moduleRef) {
+            try {
+                const contextId = core_1.ContextIdFactory.getByRequest(request);
+                const requestContext = await this.moduleRef.resolve(DecafRequestContext_js_1.DecafRequestContext, contextId, { strict: false });
+                if (requestContext?.logger)
+                    return requestContext.logger;
+            }
+            catch {
+                // no request-scoped context bound for this request — fall back below
+            }
+        }
+        return logging_1.Logging.get();
+    }
 };
 exports.DecafExceptionFilter = DecafExceptionFilter;
 exports.DecafExceptionFilter = DecafExceptionFilter = __decorate([
-    (0, common_1.Catch)()
+    (0, common_1.Catch)(),
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [core_1.ModuleRef])
 ], DecafExceptionFilter);
-//# sourceMappingURL=data:application/json;base64,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
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DecafErrorFilter.js","sourceRoot":"","sources":["DecafErrorFilter.js"],"names":[],"mappings":"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","sourcesContent":["var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    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;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { Catch, NotAcceptableException, NotFoundException, } from \"@nestjs/common\";\nimport { BaseError, InternalError } from \"@decaf-ts/db-decorators\";\nimport { LoggedEnvironment } from \"@decaf-ts/logging\";\nimport { UnsupportedError } from \"@decaf-ts/core\";\nimport { ToManyRequestsError } from \"./../errors/throttling.js\";\nlet DecafExceptionFilter = class DecafExceptionFilter {\n    catch(exception, host) {\n        const ctx = host.switchToHttp();\n        const response = ctx.getResponse();\n        const request = ctx.getRequest();\n        const isProduction = LoggedEnvironment.env === \"production\";\n        let statusCode;\n        if (exception instanceof NotFoundException ||\n            exception instanceof UnsupportedError) {\n            exception = new NotAcceptableException(exception.message);\n            statusCode = exception.getStatus();\n        }\n        else if (!(exception instanceof BaseError)) {\n            if (exception.status === 429) {\n                exception = new ToManyRequestsError(exception.message);\n            }\n            else {\n                exception = new InternalError(exception.message);\n            }\n        }\n        response.status(exception.code || statusCode).json({\n            status: exception.code || statusCode,\n            error: isProduction ? exception.name : exception.message,\n            timestamp: new Date().toISOString(),\n            path: request.url,\n            method: request.method,\n        });\n    }\n};\nDecafExceptionFilter = __decorate([\n    Catch()\n], DecafExceptionFilter);\nexport { DecafExceptionFilter };\n//# sourceMappingURL=data:application/json;base64,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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DecafErrorFilter.js","sourceRoot":"","sources":["../../../../src/factory/exceptions/DecafErrorFilter.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ArgumentsHost,\n  BadRequestException,\n  Catch,\n  ConflictException,\n  ExceptionFilter,\n  ForbiddenException,\n  HttpException,\n  Injectable,\n  NotAcceptableException,\n  NotFoundException,\n  Optional,\n  UnauthorizedException,\n  UnprocessableEntityException,\n} from \"@nestjs/common\";\nimport { ContextIdFactory, ModuleRef } from \"@nestjs/core\";\nimport {\n  BadRequestError,\n  BaseError,\n  ConflictError,\n  InternalError,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { LoggedEnvironment, Logging } from \"@decaf-ts/logging\";\nimport { AuthorizationError, ForbiddenError, UnsupportedError } from \"@decaf-ts/core\";\nimport { ToManyRequestsError } from \"../errors/throttling\";\nimport { DecafRequestContext } from \"../../request/DecafRequestContext\";\nimport type { RequestLogger } from \"@decaf-ts/for-http/server\";\n\n/**\n * @description Maps well-known NestJS `HttpException` subclasses (as guards, pipes, or\n * other framework-level code would throw them) onto the equivalent decaf-ts `BaseError`.\n * @summary Only `BaseError` instances carry the `.code` the response body relies on, so\n * without this map every non-decaf exception — including perfectly legitimate ones like a\n * guard's `ForbiddenException` — would be flattened into a generic 500 `InternalError`.\n */\nconst HTTP_EXCEPTION_TO_DECAF_ERROR = new Map<\n  new (...args: any[]) => HttpException,\n  (msg: string) => BaseError\n>([\n  [UnauthorizedException, (msg) => new AuthorizationError(msg)],\n  [ForbiddenException, (msg) => new ForbiddenError(msg)],\n  [BadRequestException, (msg) => new BadRequestError(msg)],\n  [ConflictException, (msg) => new ConflictError(msg)],\n  [UnprocessableEntityException, (msg) => new ValidationError(msg)],\n]);\n\n@Catch()\n@Injectable()\nexport class DecafExceptionFilter implements ExceptionFilter {\n  constructor(@Optional() protected readonly moduleRef?: ModuleRef) {}\n\n  async catch(exception: Error, host: ArgumentsHost) {\n    const ctx = host.switchToHttp();\n    const response = ctx.getResponse();\n    const request = ctx.getRequest();\n\n    const isProduction = LoggedEnvironment.env === \"production\";\n    let statusCode;\n\n    if (\n      exception instanceof NotFoundException ||\n      exception instanceof UnsupportedError\n    ) {\n      exception = new NotAcceptableException(exception.message);\n      statusCode = (exception as NotAcceptableException).getStatus();\n    } else if (!(exception instanceof BaseError)) {\n      const toDecafError = this.decafErrorFor(exception);\n      if (toDecafError) {\n        exception = toDecafError(exception.message);\n      } else if ((exception as any).status === 429) {\n        exception = new ToManyRequestsError(exception.message);\n      } else if (exception instanceof HttpException) {\n        // A recognized but unmapped HttpException (e.g. thrown by a guard or\n        // pipe) — preserve its real status instead of flattening it to 500.\n        statusCode = exception.getStatus();\n      } else {\n        exception = new InternalError(exception.message);\n      }\n    }\n\n    await this.logError(request, exception);\n\n    response.status((exception as BaseError).code || statusCode).json({\n      status: (exception as BaseError).code || statusCode,\n      error: isProduction ? exception.name : exception.message,\n      timestamp: new Date().toISOString(),\n      path: request.url,\n      method: request.method,\n    });\n  }\n\n  /**\n   * @description Finds the decaf-ts `BaseError` constructor mapped to this exception's type, if any.\n   * @summary Walks `HTTP_EXCEPTION_TO_DECAF_ERROR` with `instanceof` (rather than a straight\n   * `Map.get`) so subclasses of a mapped exception are matched too.\n   */\n  protected decafErrorFor(\n    exception: Error\n  ): ((msg: string) => BaseError) | undefined {\n    for (const [type, factory] of HTTP_EXCEPTION_TO_DECAF_ERROR) {\n      if (exception instanceof type) return factory;\n    }\n    return undefined;\n  }\n\n  /**\n   * @description Logs the exception without ever letting logging failures block the response.\n   * @summary A guard (or middleware/CORS check) can throw before any decaf-aware provider ran,\n   * so the request-bound Context may not exist yet — or the resolved logger's `.error()` itself\n   * could throw (broken transport, formatter bug, etc.). Either way the client-facing error\n   * response below must still go out, so every failure mode here is swallowed, falling back to\n   * the plain `Logging.get()` logger and, as a last resort, doing nothing at all.\n   */\n  protected async logError(\n    request: Record<string, any>,\n    exception: Error\n  ): Promise<void> {\n    const message = `Unhandled error on ${request?.method} ${request?.url}`;\n    try {\n      const log = await this.resolveLogger(request);\n      log.error(message, exception);\n    } catch {\n      try {\n        Logging.get().error(message, exception);\n      } catch {\n        // logging is unavailable — the response is still sent below\n      }\n    }\n  }\n\n  /**\n   * @description Resolves the logger bound to the originating request's decaf-ts Context.\n   * @summary Global filters are singletons, so the request-scoped {@link DecafRequestContext}\n   * (and the client/user-bound logger it carries) can't be constructor-injected. Instead, this\n   * looks up the same request's context id and re-resolves the already-accumulated instance\n   * through `ModuleRef`. Falls back to the generic `Logging.get()` logger when the filter wasn't\n   * constructed with a `ModuleRef` (e.g. manually `new`'d) or no request-scoped context exists\n   * for this request (e.g. the error happened before any decaf-aware provider ran, as is the\n   * case when a guard rejects the request before interceptors get to bind the client-scoped\n   * logger onto the Context).\n   */\n  protected async resolveLogger(\n    request: Record<string, any>\n  ): Promise<RequestLogger> {\n    if (this.moduleRef) {\n      try {\n        const contextId = ContextIdFactory.getByRequest(request);\n        const requestContext = await this.moduleRef.resolve(\n          DecafRequestContext,\n          contextId,\n          { strict: false }\n        );\n        if (requestContext?.logger) return requestContext.logger;\n      } catch {\n        // no request-scoped context bound for this request — fall back below\n      }\n    }\n    return Logging.get() as unknown as RequestLogger;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DecafErrorFilter.js","sourceRoot":"","sources":["DecafErrorFilter.js"],"names":[],"mappings":"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","sourcesContent":["var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    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;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nimport { BadRequestException, Catch, ConflictException, ForbiddenException, HttpException, Injectable, NotAcceptableException, NotFoundException, Optional, UnauthorizedException, UnprocessableEntityException, } from \"@nestjs/common\";\nimport { ContextIdFactory, ModuleRef } from \"@nestjs/core\";\nimport { BadRequestError, BaseError, ConflictError, InternalError, ValidationError, } from \"@decaf-ts/db-decorators\";\nimport { LoggedEnvironment, Logging } from \"@decaf-ts/logging\";\nimport { AuthorizationError, ForbiddenError, UnsupportedError } from \"@decaf-ts/core\";\nimport { ToManyRequestsError } from \"./../errors/throttling.js\";\nimport { DecafRequestContext } from \"./../../request/DecafRequestContext.js\";\n/**\n * @description Maps well-known NestJS `HttpException` subclasses (as guards, pipes, or\n * other framework-level code would throw them) onto the equivalent decaf-ts `BaseError`.\n * @summary Only `BaseError` instances carry the `.code` the response body relies on, so\n * without this map every non-decaf exception — including perfectly legitimate ones like a\n * guard's `ForbiddenException` — would be flattened into a generic 500 `InternalError`.\n */\nconst HTTP_EXCEPTION_TO_DECAF_ERROR = new Map([\n    [UnauthorizedException, (msg) => new AuthorizationError(msg)],\n    [ForbiddenException, (msg) => new ForbiddenError(msg)],\n    [BadRequestException, (msg) => new BadRequestError(msg)],\n    [ConflictException, (msg) => new ConflictError(msg)],\n    [UnprocessableEntityException, (msg) => new ValidationError(msg)],\n]);\nlet DecafExceptionFilter = class DecafExceptionFilter {\n    constructor(moduleRef) {\n        this.moduleRef = moduleRef;\n    }\n    async catch(exception, host) {\n        const ctx = host.switchToHttp();\n        const response = ctx.getResponse();\n        const request = ctx.getRequest();\n        const isProduction = LoggedEnvironment.env === \"production\";\n        let statusCode;\n        if (exception instanceof NotFoundException ||\n            exception instanceof UnsupportedError) {\n            exception = new NotAcceptableException(exception.message);\n            statusCode = exception.getStatus();\n        }\n        else if (!(exception instanceof BaseError)) {\n            const toDecafError = this.decafErrorFor(exception);\n            if (toDecafError) {\n                exception = toDecafError(exception.message);\n            }\n            else if (exception.status === 429) {\n                exception = new ToManyRequestsError(exception.message);\n            }\n            else if (exception instanceof HttpException) {\n                // A recognized but unmapped HttpException (e.g. thrown by a guard or\n                // pipe) — preserve its real status instead of flattening it to 500.\n                statusCode = exception.getStatus();\n            }\n            else {\n                exception = new InternalError(exception.message);\n            }\n        }\n        await this.logError(request, exception);\n        response.status(exception.code || statusCode).json({\n            status: exception.code || statusCode,\n            error: isProduction ? exception.name : exception.message,\n            timestamp: new Date().toISOString(),\n            path: request.url,\n            method: request.method,\n        });\n    }\n    /**\n     * @description Finds the decaf-ts `BaseError` constructor mapped to this exception's type, if any.\n     * @summary Walks `HTTP_EXCEPTION_TO_DECAF_ERROR` with `instanceof` (rather than a straight\n     * `Map.get`) so subclasses of a mapped exception are matched too.\n     */\n    decafErrorFor(exception) {\n        for (const [type, factory] of HTTP_EXCEPTION_TO_DECAF_ERROR) {\n            if (exception instanceof type)\n                return factory;\n        }\n        return undefined;\n    }\n    /**\n     * @description Logs the exception without ever letting logging failures block the response.\n     * @summary A guard (or middleware/CORS check) can throw before any decaf-aware provider ran,\n     * so the request-bound Context may not exist yet — or the resolved logger's `.error()` itself\n     * could throw (broken transport, formatter bug, etc.). Either way the client-facing error\n     * response below must still go out, so every failure mode here is swallowed, falling back to\n     * the plain `Logging.get()` logger and, as a last resort, doing nothing at all.\n     */\n    async logError(request, exception) {\n        const message = `Unhandled error on ${request?.method} ${request?.url}`;\n        try {\n            const log = await this.resolveLogger(request);\n            log.error(message, exception);\n        }\n        catch {\n            try {\n                Logging.get().error(message, exception);\n            }\n            catch {\n                // logging is unavailable — the response is still sent below\n            }\n        }\n    }\n    /**\n     * @description Resolves the logger bound to the originating request's decaf-ts Context.\n     * @summary Global filters are singletons, so the request-scoped {@link DecafRequestContext}\n     * (and the client/user-bound logger it carries) can't be constructor-injected. Instead, this\n     * looks up the same request's context id and re-resolves the already-accumulated instance\n     * through `ModuleRef`. Falls back to the generic `Logging.get()` logger when the filter wasn't\n     * constructed with a `ModuleRef` (e.g. manually `new`'d) or no request-scoped context exists\n     * for this request (e.g. the error happened before any decaf-aware provider ran, as is the\n     * case when a guard rejects the request before interceptors get to bind the client-scoped\n     * logger onto the Context).\n     */\n    async resolveLogger(request) {\n        if (this.moduleRef) {\n            try {\n                const contextId = ContextIdFactory.getByRequest(request);\n                const requestContext = await this.moduleRef.resolve(DecafRequestContext, contextId, { strict: false });\n                if (requestContext?.logger)\n                    return requestContext.logger;\n            }\n            catch {\n                // no request-scoped context bound for this request — fall back below\n            }\n        }\n        return Logging.get();\n    }\n};\nDecafExceptionFilter = __decorate([\n    Catch(),\n    Injectable(),\n    __param(0, Optional()),\n    __metadata(\"design:paramtypes\", [ModuleRef])\n], DecafExceptionFilter);\nexport { DecafExceptionFilter };\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DecafErrorFilter.js","sourceRoot":"","sources":["../../../../src/factory/exceptions/DecafErrorFilter.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ArgumentsHost,\n  BadRequestException,\n  Catch,\n  ConflictException,\n  ExceptionFilter,\n  ForbiddenException,\n  HttpException,\n  Injectable,\n  NotAcceptableException,\n  NotFoundException,\n  Optional,\n  UnauthorizedException,\n  UnprocessableEntityException,\n} from \"@nestjs/common\";\nimport { ContextIdFactory, ModuleRef } from \"@nestjs/core\";\nimport {\n  BadRequestError,\n  BaseError,\n  ConflictError,\n  InternalError,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { LoggedEnvironment, Logging } from \"@decaf-ts/logging\";\nimport { AuthorizationError, ForbiddenError, UnsupportedError } from \"@decaf-ts/core\";\nimport { ToManyRequestsError } from \"../errors/throttling\";\nimport { DecafRequestContext } from \"../../request/DecafRequestContext\";\nimport type { RequestLogger } from \"@decaf-ts/for-http/server\";\n\n/**\n * @description Maps well-known NestJS `HttpException` subclasses (as guards, pipes, or\n * other framework-level code would throw them) onto the equivalent decaf-ts `BaseError`.\n * @summary Only `BaseError` instances carry the `.code` the response body relies on, so\n * without this map every non-decaf exception — including perfectly legitimate ones like a\n * guard's `ForbiddenException` — would be flattened into a generic 500 `InternalError`.\n */\nconst HTTP_EXCEPTION_TO_DECAF_ERROR = new Map<\n  new (...args: any[]) => HttpException,\n  (msg: string) => BaseError\n>([\n  [UnauthorizedException, (msg) => new AuthorizationError(msg)],\n  [ForbiddenException, (msg) => new ForbiddenError(msg)],\n  [BadRequestException, (msg) => new BadRequestError(msg)],\n  [ConflictException, (msg) => new ConflictError(msg)],\n  [UnprocessableEntityException, (msg) => new ValidationError(msg)],\n]);\n\n@Catch()\n@Injectable()\nexport class DecafExceptionFilter implements ExceptionFilter {\n  constructor(@Optional() protected readonly moduleRef?: ModuleRef) {}\n\n  async catch(exception: Error, host: ArgumentsHost) {\n    const ctx = host.switchToHttp();\n    const response = ctx.getResponse();\n    const request = ctx.getRequest();\n\n    const isProduction = LoggedEnvironment.env === \"production\";\n    let statusCode;\n\n    if (\n      exception instanceof NotFoundException ||\n      exception instanceof UnsupportedError\n    ) {\n      exception = new NotAcceptableException(exception.message);\n      statusCode = (exception as NotAcceptableException).getStatus();\n    } else if (!(exception instanceof BaseError)) {\n      const toDecafError = this.decafErrorFor(exception);\n      if (toDecafError) {\n        exception = toDecafError(exception.message);\n      } else if ((exception as any).status === 429) {\n        exception = new ToManyRequestsError(exception.message);\n      } else if (exception instanceof HttpException) {\n        // A recognized but unmapped HttpException (e.g. thrown by a guard or\n        // pipe) — preserve its real status instead of flattening it to 500.\n        statusCode = exception.getStatus();\n      } else {\n        exception = new InternalError(exception.message);\n      }\n    }\n\n    await this.logError(request, exception);\n\n    response.status((exception as BaseError).code || statusCode).json({\n      status: (exception as BaseError).code || statusCode,\n      error: isProduction ? exception.name : exception.message,\n      timestamp: new Date().toISOString(),\n      path: request.url,\n      method: request.method,\n    });\n  }\n\n  /**\n   * @description Finds the decaf-ts `BaseError` constructor mapped to this exception's type, if any.\n   * @summary Walks `HTTP_EXCEPTION_TO_DECAF_ERROR` with `instanceof` (rather than a straight\n   * `Map.get`) so subclasses of a mapped exception are matched too.\n   */\n  protected decafErrorFor(\n    exception: Error\n  ): ((msg: string) => BaseError) | undefined {\n    for (const [type, factory] of HTTP_EXCEPTION_TO_DECAF_ERROR) {\n      if (exception instanceof type) return factory;\n    }\n    return undefined;\n  }\n\n  /**\n   * @description Logs the exception without ever letting logging failures block the response.\n   * @summary A guard (or middleware/CORS check) can throw before any decaf-aware provider ran,\n   * so the request-bound Context may not exist yet — or the resolved logger's `.error()` itself\n   * could throw (broken transport, formatter bug, etc.). Either way the client-facing error\n   * response below must still go out, so every failure mode here is swallowed, falling back to\n   * the plain `Logging.get()` logger and, as a last resort, doing nothing at all.\n   */\n  protected async logError(\n    request: Record<string, any>,\n    exception: Error\n  ): Promise<void> {\n    const message = `Unhandled error on ${request?.method} ${request?.url}`;\n    try {\n      const log = await this.resolveLogger(request);\n      log.error(message, exception);\n    } catch {\n      try {\n        Logging.get().error(message, exception);\n      } catch {\n        // logging is unavailable — the response is still sent below\n      }\n    }\n  }\n\n  /**\n   * @description Resolves the logger bound to the originating request's decaf-ts Context.\n   * @summary Global filters are singletons, so the request-scoped {@link DecafRequestContext}\n   * (and the client/user-bound logger it carries) can't be constructor-injected. Instead, this\n   * looks up the same request's context id and re-resolves the already-accumulated instance\n   * through `ModuleRef`. Falls back to the generic `Logging.get()` logger when the filter wasn't\n   * constructed with a `ModuleRef` (e.g. manually `new`'d) or no request-scoped context exists\n   * for this request (e.g. the error happened before any decaf-aware provider ran, as is the\n   * case when a guard rejects the request before interceptors get to bind the client-scoped\n   * logger onto the Context).\n   */\n  protected async resolveLogger(\n    request: Record<string, any>\n  ): Promise<RequestLogger> {\n    if (this.moduleRef) {\n      try {\n        const contextId = ContextIdFactory.getByRequest(request);\n        const requestContext = await this.moduleRef.resolve(\n          DecafRequestContext,\n          contextId,\n          { strict: false }\n        );\n        if (requestContext?.logger) return requestContext.logger;\n      } catch {\n        // no request-scoped context bound for this request — fall back below\n      }\n    }\n    return Logging.get() as unknown as RequestLogger;\n  }\n}\n"]}"]}

package/lib/cjs/factory/exceptions/decorators.cjs

@@ -5,11 +5,14 @@ exports.UseDecafHeaders = UseDecafHeaders;
 const common_1 = require("@nestjs/common");
 const DecafErrorFilter_js_1 = require("./DecafErrorFilter.cjs");
 const index_js_1 = require("./../../request/index.cjs");
+// No ModuleRef available at decoration time, so this instance falls back to
+// Logging.get() rather than the request-bound context logger; prefer
+// NestBootstraper.useGlobalFilters() for context-aware error logging.
 function UseDecafFilter() {
     return (0, common_1.UseFilters)(new DecafErrorFilter_js_1.DecafExceptionFilter());
 }
 function UseDecafHeaders() {
     return (0, common_1.UseInterceptors)(index_js_1.DecafResponseInterceptor);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9mYWN0b3J5L2V4Y2VwdGlvbnMvZGVjb3JhdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLGVBQWUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSw4QkFBMkI7QUFDMUQsT0FBTyxFQUFFLHdCQUF3QixFQUFFLGlDQUE0QjtBQUUvRCxNQUFNLFVBQVUsY0FBYztJQUM1QixPQUFPLFVBQVUsQ0FBQyxJQUFJLG9CQUFvQixFQUFFLENBQUMsQ0FBQztBQUNoRCxDQUFDO0FBRUQsTUFBTSxVQUFVLGVBQWU7SUFDN0IsT0FBTyxlQUFlLENBQUMsd0JBQXdCLENBQUMsQ0FBQztBQUNuRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXNlRmlsdGVycywgVXNlSW50ZXJjZXB0b3JzIH0gZnJvbSBcIkBuZXN0anMvY29tbW9uXCI7XG5pbXBvcnQgeyBEZWNhZkV4Y2VwdGlvbkZpbHRlciB9IGZyb20gXCIuL0RlY2FmRXJyb3JGaWx0ZXJcIjtcbmltcG9ydCB7IERlY2FmUmVzcG9uc2VJbnRlcmNlcHRvciB9IGZyb20gXCIuLi8uLi9yZXF1ZXN0L2luZGV4XCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBVc2VEZWNhZkZpbHRlcigpIHtcbiAgcmV0dXJuIFVzZUZpbHRlcnMobmV3IERlY2FmRXhjZXB0aW9uRmlsdGVyKCkpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gVXNlRGVjYWZIZWFkZXJzKCkge1xuICByZXR1cm4gVXNlSW50ZXJjZXB0b3JzKERlY2FmUmVzcG9uc2VJbnRlcmNlcHRvcik7XG59XG4iXX0=
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9mYWN0b3J5L2V4Y2VwdGlvbnMvZGVjb3JhdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLGVBQWUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSw4QkFBMkI7QUFDMUQsT0FBTyxFQUFFLHdCQUF3QixFQUFFLGlDQUE0QjtBQUUvRCw0RUFBNEU7QUFDNUUscUVBQXFFO0FBQ3JFLHNFQUFzRTtBQUN0RSxNQUFNLFVBQVUsY0FBYztJQUM1QixPQUFPLFVBQVUsQ0FBQyxJQUFJLG9CQUFvQixFQUFFLENBQUMsQ0FBQztBQUNoRCxDQUFDO0FBRUQsTUFBTSxVQUFVLGVBQWU7SUFDN0IsT0FBTyxlQUFlLENBQUMsd0JBQXdCLENBQUMsQ0FBQztBQUNuRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXNlRmlsdGVycywgVXNlSW50ZXJjZXB0b3JzIH0gZnJvbSBcIkBuZXN0anMvY29tbW9uXCI7XG5pbXBvcnQgeyBEZWNhZkV4Y2VwdGlvbkZpbHRlciB9IGZyb20gXCIuL0RlY2FmRXJyb3JGaWx0ZXJcIjtcbmltcG9ydCB7IERlY2FmUmVzcG9uc2VJbnRlcmNlcHRvciB9IGZyb20gXCIuLi8uLi9yZXF1ZXN0L2luZGV4XCI7XG5cbi8vIE5vIE1vZHVsZVJlZiBhdmFpbGFibGUgYXQgZGVjb3JhdGlvbiB0aW1lLCBzbyB0aGlzIGluc3RhbmNlIGZhbGxzIGJhY2sgdG9cbi8vIExvZ2dpbmcuZ2V0KCkgcmF0aGVyIHRoYW4gdGhlIHJlcXVlc3QtYm91bmQgY29udGV4dCBsb2dnZXI7IHByZWZlclxuLy8gTmVzdEJvb3RzdHJhcGVyLnVzZUdsb2JhbEZpbHRlcnMoKSBmb3IgY29udGV4dC1hd2FyZSBlcnJvciBsb2dnaW5nLlxuZXhwb3J0IGZ1bmN0aW9uIFVzZURlY2FmRmlsdGVyKCkge1xuICByZXR1cm4gVXNlRmlsdGVycyhuZXcgRGVjYWZFeGNlcHRpb25GaWx0ZXIoKSk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBVc2VEZWNhZkhlYWRlcnMoKSB7XG4gIHJldHVybiBVc2VJbnRlcmNlcHRvcnMoRGVjYWZSZXNwb25zZUludGVyY2VwdG9yKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/index.cjs

@@ -60,21 +60,21 @@ __exportStar(require("./events-module/index.cjs"), exports);
  * @constant
  * @type {string}
  */
-exports.VERSION = "0.11.2-refactor.4";
+exports.VERSION = "0.11.2-refactor.5";
 /**
  * @description Represents the current commit hash of the module build.
  * @summary Stores the current git commit hash for the package. The build replaces
  * the placeholder with the actual commit hash at publish time.
  * @const COMMIT
  */
-exports.COMMIT = "1b4f98c";
+exports.COMMIT = "3009b85";
 /**
  * @description Represents the full version string of the module.
  * @summary Stores the semver version and commit hash for the package.
  * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.
  * @const FULL_VERSION
  */
-exports.FULL_VERSION = "0.11.2-refactor.4-1b4f98c";
+exports.FULL_VERSION = "0.11.2-refactor.5-3009b85";
 exports.PACKAGE_NAME = "@decaf-ts/for-nest";
 decoration_1.Metadata.allowReregistration(true);
 decoration_1.Metadata.registerLibrary(exports.PACKAGE_NAME, exports.VERSION);

package/lib/esm/factory/NestBootstraper.js

@@ -1,4 +1,5 @@
 import { Logger, } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
 import { DecafExceptionFilter } from "./exceptions/index.js";
 import { SwaggerBuilder } from "./openapi/index.js";
 import { CorsError } from "./errors/index.js";
@@ -213,10 +214,17 @@ export class NestBootstraper {
      * set of standard exception filters for common error types like
      * `HttpException`, `ValidationException`, `ConflictException`, and others.
      *
+     * The default `DecafExceptionFilter` is constructed with the application's
+     * `ModuleRef` so it can resolve the request-scoped `DecafRequestContext` (and
+     * its client-bound logger) for the request that threw, instead of logging
+     * through the generic global logger.
+     *
      * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.
      */
     static useGlobalFilters(...filters) {
-        this.app.useGlobalFilters(...(filters.length > 0 ? filters : [new DecafExceptionFilter()]));
+        this.app.useGlobalFilters(...(filters.length > 0
+            ? filters
+            : [new DecafExceptionFilter(this.app.get(ModuleRef, { strict: false }))]));
         return this;
     }
     /**
@@ -259,4 +267,4 @@ export class NestBootstraper {
         });
     }
 }
-//# 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  INestApplication,\n  Logger,\n  NestInterceptor,\n  PipeTransform,\n} from \"@nestjs/common\";\nimport { DecafExceptionFilter } 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   * Path to expose the OpenAPI specification in JSON format.\n   * Example: /api/openapi.json\n   */\n  openApiJsonPath?: string;\n  /**\n   * Path to expose the OpenAPI specification in YAML format.\n   * Requires 'yaml' package as peer dependency.\n   * Example: /api/openapi.yaml\n   */\n  openApiYamlPath?: 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 {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 {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 {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 {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 {\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 {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      openApiJsonPath: options.openApiJsonPath,\n      openApiYamlPath: options.openApiYamlPath,\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 {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   */\n  static useGlobalFilters(...filters: any[]) {\n    this.app.useGlobalFilters(\n      ...(filters.length > 0 ? filters : [new DecafExceptionFilter()])\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 {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"]}
+//# 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  INestApplication,\n  Logger,\n  NestInterceptor,\n  PipeTransform,\n} from \"@nestjs/common\";\nimport { ModuleRef } from \"@nestjs/core\";\nimport { DecafExceptionFilter } 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   * Path to expose the OpenAPI specification in JSON format.\n   * Example: /api/openapi.json\n   */\n  openApiJsonPath?: string;\n  /**\n   * Path to expose the OpenAPI specification in YAML format.\n   * Requires 'yaml' package as peer dependency.\n   * Example: /api/openapi.yaml\n   */\n  openApiYamlPath?: 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 {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 {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 {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 {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 {\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 {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      openApiJsonPath: options.openApiJsonPath,\n      openApiYamlPath: options.openApiYamlPath,\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 {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   * The default `DecafExceptionFilter` is constructed with the application's\n   * `ModuleRef` so it can resolve the request-scoped `DecafRequestContext` (and\n   * its client-bound logger) for the request that threw, instead of logging\n   * through the generic global logger.\n   *\n   * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.\n   */\n  static useGlobalFilters(...filters: any[]) {\n    this.app.useGlobalFilters(\n      ...(filters.length > 0\n        ? filters\n        : [new DecafExceptionFilter(this.app.get(ModuleRef, { strict: false }))])\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 {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"]}