@decaf-ts/for-nest 0.11.2-refactor.4 → 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 = "55b8f3e";
+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-55b8f3e";
+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/cjs/request/DecafRequestContext.cjs

@@ -38,7 +38,6 @@ let DecafRequestContext = class DecafRequestContext extends server_1.RequestCont
         let overrides;
         try {
             overrides = this.get("overrides");
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
         }
         catch (e) {
             overrides = {};
@@ -54,5 +53,5 @@ exports.DecafRequestContext = DecafRequestContext = __decorate([
     __param(0, (0, common_1.Inject)(core_1.REQUEST)),
     __metadata("design:paramtypes", [Object])
 ], DecafRequestContext);
-//# sourceMappingURL=data:application/json;base64,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
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DecafRequestContext.js","sourceRoot":"","sources":["DecafRequestContext.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 { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { REQUEST } from \"@nestjs/core\";\nimport { UUID } from \"@decaf-ts/core\";\nimport { RequestContext } from \"@decaf-ts/for-http/server\";\nlet DecafRequestContext = class DecafRequestContext extends RequestContext {\n    constructor(req) {\n        super({\n            headersOf: (request) => request?.headers || undefined,\n        }, req);\n        this.req = req;\n        this.uuid = UUID.instance.generate();\n        this.request = req;\n    }\n    get headers() {\n        return this.getOrUndefined(\"headers\");\n    }\n    put(record) {\n        let overrides;\n        try {\n            overrides = this.get(\"overrides\");\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        }\n        catch (e) {\n            overrides = {};\n        }\n        this.accumulate({\n            overrides: Object.assign(overrides, record),\n        });\n    }\n};\nDecafRequestContext = __decorate([\n    Injectable({ scope: Scope.REQUEST }),\n    __param(0, Inject(REQUEST)),\n    __metadata(\"design:paramtypes\", [Object])\n], DecafRequestContext);\nexport { DecafRequestContext };\n//# sourceMappingURL=data:application/json;base64,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"]}
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DecafRequestContext.js","sourceRoot":"","sources":["DecafRequestContext.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 { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { REQUEST } from \"@nestjs/core\";\nimport { UUID } from \"@decaf-ts/core\";\nimport { RequestContext } from \"@decaf-ts/for-http/server\";\nlet DecafRequestContext = class DecafRequestContext extends RequestContext {\n    constructor(req) {\n        super({\n            headersOf: (request) => request?.headers || undefined,\n        }, req);\n        this.req = req;\n        this.uuid = UUID.instance.generate();\n        this.request = req;\n    }\n    get headers() {\n        return this.getOrUndefined(\"headers\");\n    }\n    put(record) {\n        let overrides;\n        try {\n            overrides = this.get(\"overrides\");\n        }\n        catch (e) {\n            overrides = {};\n        }\n        this.accumulate({\n            overrides: Object.assign(overrides, record),\n        });\n    }\n};\nDecafRequestContext = __decorate([\n    Injectable({ scope: Scope.REQUEST }),\n    __param(0, Inject(REQUEST)),\n    __metadata(\"design:paramtypes\", [Object])\n], DecafRequestContext);\nexport { DecafRequestContext };\n//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/request/DecafResponseInterceptor.cjs

@@ -24,7 +24,9 @@ let DecafResponseInterceptor = class DecafResponseInterceptor {
     }
     intercept(context, next) {
         let response = context.switchToHttp().getResponse();
-        return next.handle().pipe((0, rxjs_1.tap)((data) => {
+        return next.handle().pipe(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        (0, rxjs_1.tap)((data) => {
             response = this.ctx.toResponse(response);
         }));
     }
@@ -34,5 +36,5 @@ exports.DecafResponseInterceptor = DecafResponseInterceptor = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [DecafRequestContext_js_1.DecafRequestContext])
 ], DecafResponseInterceptor);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVjYWZSZXNwb25zZUludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JlcXVlc3QvRGVjYWZSZXNwb25zZUludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBLE9BQU8sRUFDTCxVQUFVLEdBSVgsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QixPQUFPLEVBQWMsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxpQ0FBOEI7QUFHckQsSUFBTSx3QkFBd0IsR0FBOUIsTUFBTSx3QkFBd0I7SUFDbkMsWUFBc0IsR0FBd0I7UUFBeEIsUUFBRyxHQUFILEdBQUcsQ0FBcUI7SUFBRyxDQUFDO0lBRWxELFNBQVMsQ0FBQyxPQUF5QixFQUFFLElBQWlCO1FBQ3BELElBQUksUUFBUSxHQUFHLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUVwRCxPQUFPLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJLENBQ3ZCLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFO1lBQ1gsUUFBUSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzNDLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDO0NBQ0YsQ0FBQTtBQVpZLHdCQUF3QjtJQURwQyxVQUFVLEVBQUU7cUNBRWdCLG1CQUFtQjtHQURuQyx3QkFBd0IsQ0FZcEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBJbmplY3RhYmxlLFxuICBOZXN0SW50ZXJjZXB0b3IsXG4gIEV4ZWN1dGlvbkNvbnRleHQsXG4gIENhbGxIYW5kbGVyLFxufSBmcm9tIFwiQG5lc3Rqcy9jb21tb25cIjtcbmltcG9ydCB7IE9ic2VydmFibGUsIHRhcCB9IGZyb20gXCJyeGpzXCI7XG5pbXBvcnQgeyBEZWNhZlJlcXVlc3RDb250ZXh0IH0gZnJvbSBcIi4vRGVjYWZSZXF1ZXN0Q29udGV4dFwiO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgRGVjYWZSZXNwb25zZUludGVyY2VwdG9yIGltcGxlbWVudHMgTmVzdEludGVyY2VwdG9yIHtcbiAgY29uc3RydWN0b3IocHJvdGVjdGVkIGN0eDogRGVjYWZSZXF1ZXN0Q29udGV4dCkge31cblxuICBpbnRlcmNlcHQoY29udGV4dDogRXhlY3V0aW9uQ29udGV4dCwgbmV4dDogQ2FsbEhhbmRsZXIpOiBPYnNlcnZhYmxlPGFueT4ge1xuICAgIGxldCByZXNwb25zZSA9IGNvbnRleHQuc3dpdGNoVG9IdHRwKCkuZ2V0UmVzcG9uc2UoKTtcblxuICAgIHJldHVybiBuZXh0LmhhbmRsZSgpLnBpcGUoXG4gICAgICB0YXAoKGRhdGEpID0+IHtcbiAgICAgICAgcmVzcG9uc2UgPSB0aGlzLmN0eC50b1Jlc3BvbnNlKHJlc3BvbnNlKTtcbiAgICAgIH0pXG4gICAgKTtcbiAgfVxufVxuIl19
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVjYWZSZXNwb25zZUludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JlcXVlc3QvRGVjYWZSZXNwb25zZUludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBLE9BQU8sRUFDTCxVQUFVLEdBSVgsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QixPQUFPLEVBQWMsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxpQ0FBOEI7QUFHckQsSUFBTSx3QkFBd0IsR0FBOUIsTUFBTSx3QkFBd0I7SUFDbkMsWUFBc0IsR0FBd0I7UUFBeEIsUUFBRyxHQUFILEdBQUcsQ0FBcUI7SUFBRyxDQUFDO0lBRWxELFNBQVMsQ0FBQyxPQUF5QixFQUFFLElBQWlCO1FBQ3BELElBQUksUUFBUSxHQUFHLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUVwRCxPQUFPLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJO1FBQ3ZCLDZEQUE2RDtRQUM3RCxHQUFHLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRTtZQUNYLFFBQVEsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUMzQyxDQUFDLENBQUMsQ0FDSCxDQUFDO0lBQ0osQ0FBQztDQUNGLENBQUE7QUFiWSx3QkFBd0I7SUFEcEMsVUFBVSxFQUFFO3FDQUVnQixtQkFBbUI7R0FEbkMsd0JBQXdCLENBYXBDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgSW5qZWN0YWJsZSxcbiAgTmVzdEludGVyY2VwdG9yLFxuICBFeGVjdXRpb25Db250ZXh0LFxuICBDYWxsSGFuZGxlcixcbn0gZnJvbSBcIkBuZXN0anMvY29tbW9uXCI7XG5pbXBvcnQgeyBPYnNlcnZhYmxlLCB0YXAgfSBmcm9tIFwicnhqc1wiO1xuaW1wb3J0IHsgRGVjYWZSZXF1ZXN0Q29udGV4dCB9IGZyb20gXCIuL0RlY2FmUmVxdWVzdENvbnRleHRcIjtcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIERlY2FmUmVzcG9uc2VJbnRlcmNlcHRvciBpbXBsZW1lbnRzIE5lc3RJbnRlcmNlcHRvciB7XG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBjdHg6IERlY2FmUmVxdWVzdENvbnRleHQpIHt9XG5cbiAgaW50ZXJjZXB0KGNvbnRleHQ6IEV4ZWN1dGlvbkNvbnRleHQsIG5leHQ6IENhbGxIYW5kbGVyKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICBsZXQgcmVzcG9uc2UgPSBjb250ZXh0LnN3aXRjaFRvSHR0cCgpLmdldFJlc3BvbnNlKCk7XG5cbiAgICByZXR1cm4gbmV4dC5oYW5kbGUoKS5waXBlKFxuICAgICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFyc1xuICAgICAgdGFwKChkYXRhKSA9PiB7XG4gICAgICAgIHJlc3BvbnNlID0gdGhpcy5jdHgudG9SZXNwb25zZShyZXNwb25zZSk7XG4gICAgICB9KVxuICAgICk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/swagger-types.cjs

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/types.cjs

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUNBLGtnSUFBa2dJIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHt9O1xuLy8jIHNvdXJjZU1hcHBpbmdVUkw9ZGF0YTphcHBsaWNhdGlvbi9qc29uO2Jhc2U2NCxleUoyWlhKemFXOXVJam96TENKbWFXeGxJam9pZEhsd1pYTXVhbk1pTENKemIzVnlZMlZTYjI5MElqb2lJaXdpYzI5MWNtTmxjeUk2V3lJdUxpOHVMaTl6Y21NdmRIbHdaWE11ZEhNaVhTd2libUZ0WlhNaU9sdGRMQ0p0WVhCd2FXNW5jeUk2SWlJc0luTnZkWEpqWlhORGIyNTBaVzUwSWpwYkltbHRjRzl5ZENCN0lFRmtZWEIwWlhJc0lFTnZibVpwWjA5bUxDQkRiMjUwWlhoMFQyWWdmU0JtY205dElGd2lRR1JsWTJGbUxYUnpMMk52Y21WY0lqdGNibWx0Y0c5eWRDQjdJRU52Ym5OMGNuVmpkRzl5SUgwZ1puSnZiU0JjSWtCa1pXTmhaaTEwY3k5a1pXTnZjbUYwYVc5dVhDSTdYRzVwYlhCdmNuUWdleUJGZUdWamRYUnBiMjVEYjI1MFpYaDBMQ0JVZVhCbElIMGdabkp2YlNCY0lrQnVaWE4wYW5NdlkyOXRiVzl1WENJN1hHNXBiWEJ2Y25RZ2UxeHVJQ0JTWlhGMVpYTjBWRzlEYjI1MFpYaDBWSEpoYm5ObWIzSnRaWElzWEc0Z0lIUjVjR1VnVFc5a1pXeERiMjUwY205c2JHVnlSbUZqZEc5eWVVTnZibVpwWnl4Y2JpQWdkSGx3WlNCQmRYUm9TR0Z1Wkd4bGNpQmhjeUJCZFhSb1NHRnVaR3hsY2tKaGMyVXNYRzU5SUdaeWIyMGdYQ0pBWkdWallXWXRkSE12Wm05eUxXaDBkSEF2YzJWeWRtVnlYQ0k3WEc1cGJYQnZjblFnZXlCRVpXTmhabEpsY1hWbGMzUkRiMjUwWlhoMElIMGdabkp2YlNCY0lpNHZjbVZ4ZFdWemRDOXBibVJsZUZ3aU8xeHVYRzVsZUhCdmNuUWdhVzUwWlhKbVlXTmxJRVJsWTJGbVVtVnhkV1Z6ZEVoaGJtUnNaWEk4WEc0Z0lFTWdaWGgwWlc1a2N5QkVaV05oWmxKbGNYVmxjM1JEYjI1MFpYaDBJRDBnUkdWallXWlNaWEYxWlhOMFEyOXVkR1Y0ZEN4Y2JqNGdlMXh1SUNCb1lXNWtiR1VvWTI5dWRHVjRkRG9nUXl3Z2NtVnhPaUJTWlhGMVpYTjBMQ0J5WlhNNklGSmxjM0J2Ym5ObEtUb2dVSEp2YldselpUeDJiMmxrUGp0Y2JuMWNibHh1Wlhod2IzSjBJR2x1ZEdWeVptRmpaU0JQWW5ObGNuWmxja1YyWlc1MGMwOXdkR2x2Ym5NZ2UxeHVJQ0F2S2lwY2JpQWdJQ29nUlc1aFlteGxjeUJ2Y2lCa2FYTmhZbXhsY3lCVFUwVWdjM1J5WldGdElHVjJaVzUwY3lCbmJHOWlZV3hzZVZ4dUlDQWdLaTljYmlBZ1pXNWhZbXhsVDJKelpYSjJaWEpGZG1WdWRITS9PaUJpYjI5c1pXRnVPMXh1WEc0Z0lDOHFLbHh1SUNBZ0tpQk1hWE4wSUc5bUlHRmtZWEIwWlhJZ1pteGhkbTkxY25NZ2RHaGhkQ0IzYVd4c0lHVnRhWFFnYzNSeVpXRnRJR1YyWlc1MGMxeHVJQ0FnS2lCSlppQnZiV2wwZEdWa0xDQmhiR3dnY21WbmFYTjBaWEpsWkNCbWJHRjJiM1Z5Y3lCdFlYa2dZbVVnZFhObFpGeHVJQ0FnS2k5Y2JpQWdiMkp6WlhKMlpYSkdiR0YyYjNWeWN6ODZJR0Z1ZVZ0ZE8xeHVYRzRnSUM4cUtseHVJQ0FnS2lCVFUwVWdaVzVrY0c5cGJuUWdjR0YwYUZ4dUlDQWdLaUJBWkdWbVlYVnNkQ0JjSWk5bGRtVnVkSE5jSWx4dUlDQWdLaTljYmlBZ2IySnpaWEoyWlhKQmNHbFFZWFJvUHpvZ2MzUnlhVzVuTzF4dWZWeHVYRzR2S2lwY2JpQXFJRUJ3ZFdKc2FXTkJjR2xjYmlBcUwxeHVaWGh3YjNKMElIUjVjR1VnUkdWallXWk5iMlIxYkdWUGNIUnBiMjV6UEZ4dUlDQkRUMDVHSUQwZ1lXNTVMRnh1SUNCQklHVjRkR1Z1WkhNZ1FXUmhjSFJsY2p4RFQwNUdMQ0JoYm5rc0lHRnVlU3dnWVc1NVBpQTlJRUZrWVhCMFpYSThRMDlPUml3Z1lXNTVMQ0JoYm5rc0lHRnVlVDRzWEc0K0lEMGdlMXh1SUNCamIyNW1PaUJiWEc0Z0lDQWdRMjl1YzNSeWRXTjBiM0k4UVQ0c1hHNGdJQ0FnUTI5dVptbG5UMlk4UVQ0c1hHNGdJQ0FnTGk0dVlYSm5jenBjYmlBZ0lDQWdJSHdnWVc1NVcxMWNiaUFnSUNBZ0lId2dXMXh1SUNBZ0lDQWdJQ0FnSUM0dUxtRnVlVnRkTEZ4dUlDQWdJQ0FnSUNBZ0lDaGNiaUFnSUNBZ0lDQWdJQ0FnSUh3Z1VtVnhkV1Z6ZEZSdlEyOXVkR1Y0ZEZSeVlXNXpabTl5YldWeVBFTnZiblJsZUhSUFpqeEJQajVjYmlBZ0lDQWdJQ0FnSUNBZ0lId2dRMjl1YzNSeWRXTjBiM0k4VW1WeGRXVnpkRlJ2UTI5dWRHVjRkRlJ5WVc1elptOXliV1Z5UEVOdmJuUmxlSFJQWmp4QlBqNCtYRzRnSUNBZ0lDQWdJQ0FnS1N4Y2JpQWdJQ0FnSUNBZ1hTeGNiaUFnWFZ0ZE8xeHVJQ0JoYkdsaGN6ODZJSE4wY21sdVp6dGNiaUFnWVhWMGIwTnZiblJ5YjJ4c1pYSnpPaUJpYjI5c1pXRnVPMXh1SUNCaGRYUnZVMlZ5ZG1salpYTS9PaUJpYjI5c1pXRnVPMXh1SUNCamIyNTBjbTlzYkdWeVJYaHdiM04xY21VL09pQlNaV052Y21ROGMzUnlhVzVuTENCaWIyOXNaV0Z1SUh3Z2MzUnlhVzVuVzEwK08xeHVJQ0JqYjI1MGNtOXNiR1Z5UTI5dVptbG5Qem9nVW1WamIzSmtQSE4wY21sdVp5d2dUVzlrWld4RGIyNTBjbTlzYkdWeVJtRmpkRzl5ZVVOdmJtWnBaejQ3WEc0Z0lHOWljMlZ5ZG1WeVQzQjBhVzl1Y3o4NklFOWljMlZ5ZG1WeVJYWmxiblJ6VDNCMGFXOXVjenRjYmlBZ1lXZG5jbVZuWVhScGIyNXpQem9nWW05dmJHVmhianRjYmlBZ2FHRnVaR3hsY25NL09pQlVlWEJsUEVSbFkyRm1VbVZ4ZFdWemRFaGhibVJzWlhJK1cxMDdYRzRnSUdsdWFYUnBZV3hwZW1GMGFXOXVQem9nS0NrZ1BUNGdVSEp2YldselpUeDJiMmxrUGp0Y2JuMDdYRzVjYmk4cUtseHVJQ29nVG1WemRFcFRMVzVoY25KdmQyVmtJR0ZzYVdGeklHWnZjaUIwYUdVZ1ltRnpaU0I3UUd4cGJtc2dRWFYwYUVoaGJtUnNaWEpDWVhObGZTQmpiR0Z6Y3lCbWNtOXRYRzRnS2lCZ1FHUmxZMkZtTFhSekwyWnZjaTFvZEhSd0wzTmxjblpsY21Bc0lITndaV05wWVd4cGVtbHVaeUIwYUdVZ1pYaGxZM1YwYVc5dUlHTnZiblJsZUhRZ2RHOWNiaUFxSUdCRmVHVmpkWFJwYjI1RGIyNTBaWGgwWUNCaGJtUWdkR2hsSUhKbGNYVmxjM1FnWTI5dWRHVjRkQ0IwYnlCN1FHeHBibXNnUkdWallXWlNaWEYxWlhOMFEyOXVkR1Y0ZEgwdVhHNGdLbHh1SUNvZ1EyOXVZM0psZEdVZ2FHRnVaR3hsY25NZ1pYaDBaVzVrSUhSb2FYTWdZMnhoYzNNZ1lXNWtJRzkyWlhKeWFXUmxJR0JsZUhSeVlXTjBSbkp2YlVGMWRHaGdMbHh1SUNwY2JpQXFJRUJsZUdGdGNHeGxYRzRnS2lCbGVIQnZjblFnWTJ4aGMzTWdRM1Z6ZEc5dFFYVjBhRWhoYm1Sc1pYSWdaWGgwWlc1a2N5QkJkWFJvU0dGdVpHeGxjaUI3WEc0Z0tpQWdJSEJ5YjNSbFkzUmxaQ0JsZUhSeVlXTjBSbkp2YlVGMWRHZ29ZM1I0T2lCRmVHVmpkWFJwYjI1RGIyNTBaWGgwS1NCN1hHNGdLaUFnSUNBZ1kyOXVjM1FnY21WeElEMGdZM1I0TG5OM2FYUmphRlJ2U0hSMGNDZ3BMbWRsZEZKbGNYVmxjM1FvS1R0Y2JpQXFJQ0FnSUNCamIyNXpkQ0IxYzJWeVVtOXNaU0E5SUhKbGNTNW9aV0ZrWlhKekxtRjFkR2h2Y21sNllYUnBiMjQvTG5Od2JHbDBLRndpSUZ3aUtWc3hYU0JoY3lCemRISnBibWM3WEc0Z0tpQWdJQ0FnYVdZZ0tDRjFjMlZ5VW05c1pTa2dkR2h5YjNjZ2JtVjNJRUYxZEdodmNtbDZZWFJwYjI1RmNuSnZjaWhjSWxWdVlYVjBhR1Z1ZEdsallYUmxaRndpS1R0Y2JpQXFJQ0FnSUNCeVpYUjFjbTRnZXlCMWMyVnlPaUIxYzJWeVVtOXNaU3dnY205c1pYTTZJRnQxYzJWeVVtOXNaVjBnZlR0Y2JpQXFJQ0FnZlZ4dUlDb2dmVnh1SUNwY2JpQXFJQzh2SUdGMWRHZ3ViVzlrZFd4bExuUnpYRzRnS2lCQVIyeHZZbUZzS0NsY2JpQXFJRUJOYjJSMWJHVW9lMXh1SUNvZ0lIQnliM1pwWkdWeWN6b2dXMXh1SUNvZ0lDQWdRWFYwYUVsdWRHVnlZMlZ3ZEc5eUxGeHVJQ29nSUNBZ1EzVnpkRzl0UVhWMGFFaGhibVJzWlhJc1hHNGdLaUFnSUNCN0lIQnliM1pwWkdVNklFRlZWRWhmU0VGT1JFeEZVaXdnZFhObFEyeGhjM002SUVOMWMzUnZiVUYxZEdoSVlXNWtiR1Z5SUgwc1hHNGdLaUFnWFN4Y2JpQXFJQ0JsZUhCdmNuUnpPaUJiUVZWVVNGOUlRVTVFVEVWU0xDQkJkWFJvU1c1MFpYSmpaWEIwYjNKZExGeHVJQ29nZlNsY2JpQXFJR1Y0Y0c5eWRDQmpiR0Z6Y3lCQmRYUm9UVzlrZFd4bElIdDlYRzRnS2k5Y2JtVjRjRzl5ZENCMGVYQmxJRUYxZEdoSVlXNWtiR1Z5UEZ4dUlDQkZReUE5SUVWNFpXTjFkR2x2YmtOdmJuUmxlSFFzWEc0Z0lFTWdaWGgwWlc1a2N5QkVaV05oWmxKbGNYVmxjM1JEYjI1MFpYaDBJRDBnUkdWallXWlNaWEYxWlhOMFEyOXVkR1Y0ZEN4Y2JqNGdQU0JCZFhSb1NHRnVaR3hsY2tKaGMyVThSVU1zSUVNK08xeHVJbDE5Il19