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

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

@@ -4,13 +4,38 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Catch, NotAcceptableException, NotFoundException, } from "@nestjs/common";
-import { BaseError, InternalError } from "@decaf-ts/db-decorators";
-import { LoggedEnvironment } from "@decaf-ts/logging";
-import { UnsupportedError } from "@decaf-ts/core";
+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); }
+};
+import { BadRequestException, Catch, ConflictException, ForbiddenException, HttpException, Injectable, NotAcceptableException, NotFoundException, Optional, UnauthorizedException, UnprocessableEntityException, } from "@nestjs/common";
+import { ContextIdFactory, ModuleRef } from "@nestjs/core";
+import { BadRequestError, BaseError, ConflictError, InternalError, ValidationError, } from "@decaf-ts/db-decorators";
+import { LoggedEnvironment, Logging } from "@decaf-ts/logging";
+import { AuthorizationError, ForbiddenError, UnsupportedError } from "@decaf-ts/core";
 import { ToManyRequestsError } from "./../errors/throttling.js";
+import { DecafRequestContext } from "./../../request/DecafRequestContext.js";
+/**
+ * @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([
+    [UnauthorizedException, (msg) => new AuthorizationError(msg)],
+    [ForbiddenException, (msg) => new ForbiddenError(msg)],
+    [BadRequestException, (msg) => new BadRequestError(msg)],
+    [ConflictException, (msg) => new ConflictError(msg)],
+    [UnprocessableEntityException, (msg) => new 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();
@@ -22,13 +47,23 @@ let DecafExceptionFilter = class DecafExceptionFilter {
             statusCode = exception.getStatus();
         }
         else if (!(exception instanceof BaseError)) {
-            if (exception.status === 429) {
+            const toDecafError = this.decafErrorFor(exception);
+            if (toDecafError) {
+                exception = toDecafError(exception.message);
+            }
+            else if (exception.status === 429) {
                 exception = new ToManyRequestsError(exception.message);
             }
+            else if (exception instanceof 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 InternalError(exception.message);
             }
         }
+        await this.logError(request, exception);
         response.status(exception.code || statusCode).json({
             status: exception.code || statusCode,
             error: isProduction ? exception.name : exception.message,
@@ -37,9 +72,72 @@ 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.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 = ContextIdFactory.getByRequest(request);
+                const requestContext = await this.moduleRef.resolve(DecafRequestContext, contextId, { strict: false });
+                if (requestContext?.logger)
+                    return requestContext.logger;
+            }
+            catch {
+                // no request-scoped context bound for this request — fall back below
+            }
+        }
+        return Logging.get();
+    }
 };
 DecafExceptionFilter = __decorate([
-    Catch()
+    Catch(),
+    Injectable(),
+    __param(0, Optional()),
+    __metadata("design:paramtypes", [ModuleRef])
 ], DecafExceptionFilter);
 export { DecafExceptionFilter };
-//# 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"]}

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

@@ -1,10 +1,13 @@
 import { UseFilters, UseInterceptors } from "@nestjs/common";
 import { DecafExceptionFilter } from "./DecafErrorFilter.js";
 import { DecafResponseInterceptor } from "./../../request/index.js";
+// 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.
 export function UseDecafFilter() {
     return UseFilters(new DecafExceptionFilter());
 }
 export function UseDecafHeaders() {
     return UseInterceptors(DecafResponseInterceptor);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9mYWN0b3J5L2V4Y2VwdGlvbnMvZGVjb3JhdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLGVBQWUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSw4QkFBMkI7QUFDMUQsT0FBTyxFQUFFLHdCQUF3QixFQUFFLGlDQUE0QjtBQUUvRCxNQUFNLFVBQVUsY0FBYztJQUM1QixPQUFPLFVBQVUsQ0FBQyxJQUFJLG9CQUFvQixFQUFFLENBQUMsQ0FBQztBQUNoRCxDQUFDO0FBRUQsTUFBTSxVQUFVLGVBQWU7SUFDN0IsT0FBTyxlQUFlLENBQUMsd0JBQXdCLENBQUMsQ0FBQztBQUNuRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXNlRmlsdGVycywgVXNlSW50ZXJjZXB0b3JzIH0gZnJvbSBcIkBuZXN0anMvY29tbW9uXCI7XG5pbXBvcnQgeyBEZWNhZkV4Y2VwdGlvbkZpbHRlciB9IGZyb20gXCIuL0RlY2FmRXJyb3JGaWx0ZXJcIjtcbmltcG9ydCB7IERlY2FmUmVzcG9uc2VJbnRlcmNlcHRvciB9IGZyb20gXCIuLi8uLi9yZXF1ZXN0L2luZGV4XCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBVc2VEZWNhZkZpbHRlcigpIHtcbiAgcmV0dXJuIFVzZUZpbHRlcnMobmV3IERlY2FmRXhjZXB0aW9uRmlsdGVyKCkpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gVXNlRGVjYWZIZWFkZXJzKCkge1xuICByZXR1cm4gVXNlSW50ZXJjZXB0b3JzKERlY2FmUmVzcG9uc2VJbnRlcmNlcHRvcik7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9mYWN0b3J5L2V4Y2VwdGlvbnMvZGVjb3JhdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLGVBQWUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSw4QkFBMkI7QUFDMUQsT0FBTyxFQUFFLHdCQUF3QixFQUFFLGlDQUE0QjtBQUUvRCw0RUFBNEU7QUFDNUUscUVBQXFFO0FBQ3JFLHNFQUFzRTtBQUN0RSxNQUFNLFVBQVUsY0FBYztJQUM1QixPQUFPLFVBQVUsQ0FBQyxJQUFJLG9CQUFvQixFQUFFLENBQUMsQ0FBQztBQUNoRCxDQUFDO0FBRUQsTUFBTSxVQUFVLGVBQWU7SUFDN0IsT0FBTyxlQUFlLENBQUMsd0JBQXdCLENBQUMsQ0FBQztBQUNuRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXNlRmlsdGVycywgVXNlSW50ZXJjZXB0b3JzIH0gZnJvbSBcIkBuZXN0anMvY29tbW9uXCI7XG5pbXBvcnQgeyBEZWNhZkV4Y2VwdGlvbkZpbHRlciB9IGZyb20gXCIuL0RlY2FmRXJyb3JGaWx0ZXJcIjtcbmltcG9ydCB7IERlY2FmUmVzcG9uc2VJbnRlcmNlcHRvciB9IGZyb20gXCIuLi8uLi9yZXF1ZXN0L2luZGV4XCI7XG5cbi8vIE5vIE1vZHVsZVJlZiBhdmFpbGFibGUgYXQgZGVjb3JhdGlvbiB0aW1lLCBzbyB0aGlzIGluc3RhbmNlIGZhbGxzIGJhY2sgdG9cbi8vIExvZ2dpbmcuZ2V0KCkgcmF0aGVyIHRoYW4gdGhlIHJlcXVlc3QtYm91bmQgY29udGV4dCBsb2dnZXI7IHByZWZlclxuLy8gTmVzdEJvb3RzdHJhcGVyLnVzZUdsb2JhbEZpbHRlcnMoKSBmb3IgY29udGV4dC1hd2FyZSBlcnJvciBsb2dnaW5nLlxuZXhwb3J0IGZ1bmN0aW9uIFVzZURlY2FmRmlsdGVyKCkge1xuICByZXR1cm4gVXNlRmlsdGVycyhuZXcgRGVjYWZFeGNlcHRpb25GaWx0ZXIoKSk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBVc2VEZWNhZkhlYWRlcnMoKSB7XG4gIHJldHVybiBVc2VJbnRlcmNlcHRvcnMoRGVjYWZSZXNwb25zZUludGVyY2VwdG9yKTtcbn1cbiJdfQ==

package/lib/esm/index.js

@@ -43,21 +43,21 @@ export * from "./events-module/index.js";
  * @constant
  * @type {string}
  */
-export const VERSION = "0.11.2-refactor.4";
+export const 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
  */
-export const COMMIT = "1b4f98c";
+export const 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
  */
-export const FULL_VERSION = "0.11.2-refactor.4-1b4f98c";
+export const FULL_VERSION = "0.11.2-refactor.5-3009b85";
 export const PACKAGE_NAME = "@decaf-ts/for-nest";
 Metadata.allowReregistration(true);
 Metadata.registerLibrary(PACKAGE_NAME, VERSION);

package/lib/types/factory/NestBootstraper.d.cts

@@ -190,6 +190,11 @@ export declare 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: any[]): typeof NestBootstraper;

package/lib/types/factory/NestBootstraper.d.mts

@@ -190,6 +190,11 @@ export declare 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: any[]): typeof NestBootstraper;

package/lib/types/factory/exceptions/DecafErrorFilter.d.cts

@@ -1,4 +1,36 @@
 import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+import { BaseError } from "@decaf-ts/db-decorators";
+import type { RequestLogger } from "@decaf-ts/for-http/server";
 export declare class DecafExceptionFilter implements ExceptionFilter {
-    catch(exception: Error, host: ArgumentsHost): void;
+    protected readonly moduleRef?: ModuleRef | undefined;
+    constructor(moduleRef?: ModuleRef | undefined);
+    catch(exception: Error, host: ArgumentsHost): Promise<void>;
+    /**
+     * @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.
+     */
+    protected decafErrorFor(exception: Error): ((msg: string) => BaseError) | 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.
+     */
+    protected logError(request: Record<string, any>, exception: Error): Promise<void>;
+    /**
+     * @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).
+     */
+    protected resolveLogger(request: Record<string, any>): Promise<RequestLogger>;
 }

package/lib/types/factory/exceptions/DecafErrorFilter.d.mts

@@ -1,4 +1,36 @@
 import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+import { ModuleRef } from "@nestjs/core";
+import { BaseError } from "@decaf-ts/db-decorators";
+import type { RequestLogger } from "@decaf-ts/for-http/server";
 export declare class DecafExceptionFilter implements ExceptionFilter {
-    catch(exception: Error, host: ArgumentsHost): void;
+    protected readonly moduleRef?: ModuleRef | undefined;
+    constructor(moduleRef?: ModuleRef | undefined);
+    catch(exception: Error, host: ArgumentsHost): Promise<void>;
+    /**
+     * @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.
+     */
+    protected decafErrorFor(exception: Error): ((msg: string) => BaseError) | 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.
+     */
+    protected logError(request: Record<string, any>, exception: Error): Promise<void>;
+    /**
+     * @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).
+     */
+    protected resolveLogger(request: Record<string, any>): Promise<RequestLogger>;
 }

package/lib/types/index.d.cts

@@ -41,19 +41,19 @@ export * from "./events-module/index.d.cts";
  * @constant
  * @type {string}
  */
-export declare const VERSION = "0.11.2-refactor.4";
+export declare const 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
  */
-export declare const COMMIT = "1b4f98c";
+export declare const 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
  */
-export declare const FULL_VERSION = "0.11.2-refactor.4-1b4f98c";
+export declare const FULL_VERSION = "0.11.2-refactor.5-3009b85";
 export declare const PACKAGE_NAME = "@decaf-ts/for-nest";

package/lib/types/index.d.mts

@@ -41,19 +41,19 @@ export * from "./events-module/index.d.mts";
  * @constant
  * @type {string}
  */
-export declare const VERSION = "0.11.2-refactor.4";
+export declare const 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
  */
-export declare const COMMIT = "1b4f98c";
+export declare const 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
  */
-export declare const FULL_VERSION = "0.11.2-refactor.4-1b4f98c";
+export declare const FULL_VERSION = "0.11.2-refactor.5-3009b85";
 export declare const PACKAGE_NAME = "@decaf-ts/for-nest";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/for-nest",
-  "version": "0.11.2-refactor.5",
+  "version": "0.11.2-refactor.6",
   "description": "NestJS decaf integration",
   "type": "module",
   "exports": {