create-nexst-monorepo 0.1.0

package/template/apps/api/src/utils/catch-everything-exception.filter.spec.ts

@@ -0,0 +1,292 @@
+import type { ArgumentsHost } from "@nestjs/common";
+import { HttpException, HttpStatus } from "@nestjs/common";
+import { HttpAdapterHost } from "@nestjs/core";
+import type { TestingModule } from "@nestjs/testing";
+import { Test } from "@nestjs/testing";
+import { vi } from "vitest";
+import type { Mock } from "vitest";
+import { AppException } from "#src/errors/app.exception.js";
+import { ErrorCode } from "#src/errors/error-code.enum.js";
+import { ContextLogger } from "#src/logging/context-logger.js";
+import { CatchEverythingFilter } from "#src/utils/catch-everything-exception.filter.js";
+
+const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+describe("catchEverythingFilter", () => {
+  let filter: CatchEverythingFilter;
+  let mockArgumentsHost: ArgumentsHost;
+  let mockHttpAdapter: {
+    getRequestUrl: Mock;
+    reply: Mock;
+  };
+  let mockRequest: object;
+  let mockResponse: object;
+
+  beforeEach(async () => {
+    mockHttpAdapter = {
+      getRequestUrl: vi.fn().mockReturnValue("/test-path"),
+      reply: vi.fn(),
+    };
+
+    mockRequest = {};
+    mockResponse = {};
+
+    const mockHttpArgumentsHost = {
+      getNext: vi.fn(),
+      getRequest: vi.fn().mockReturnValue(mockRequest),
+      getResponse: vi.fn().mockReturnValue(mockResponse),
+    };
+
+    mockArgumentsHost = {
+      getArgByIndex: vi.fn(),
+      getArgs: vi.fn(),
+      getType: vi.fn().mockReturnValue("http"),
+      switchToHttp: vi.fn().mockReturnValue(mockHttpArgumentsHost),
+      switchToRpc: vi.fn(),
+      switchToWs: vi.fn(),
+    };
+
+    const mockHttpAdapterHost = {
+      httpAdapter: mockHttpAdapter,
+    };
+
+    const mockLogger = { debug: vi.fn(), error: vi.fn(), setContext: vi.fn() };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        CatchEverythingFilter,
+        { provide: ContextLogger, useValue: mockLogger },
+        {
+          provide: HttpAdapterHost,
+          useValue: mockHttpAdapterHost,
+        },
+      ],
+    }).compile();
+
+    filter = module.get<CatchEverythingFilter>(CatchEverythingFilter);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("catch", () => {
+    it("should fall back to a generic code for a plain HttpException with a string message", () => {
+      const exception = new HttpException("Test error message", HttpStatus.BAD_REQUEST);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockArgumentsHost.switchToHttp).toHaveBeenCalled();
+      expect(mockHttpAdapter.getRequestUrl).toHaveBeenCalledWith(mockRequest);
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.BAD_REQUEST,
+          path: "/test-path",
+          statusCode: HttpStatus.BAD_REQUEST,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.BAD_REQUEST,
+      );
+    });
+
+    it("should fall back to a generic code for a plain HttpException with an object response", () => {
+      const exception = new HttpException(
+        { errors: ["field1", "field2"], message: "Validation failed" },
+        HttpStatus.UNPROCESSABLE_ENTITY,
+      );
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.UNPROCESSABLE_ENTITY,
+          path: "/test-path",
+          statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.UNPROCESSABLE_ENTITY,
+      );
+    });
+
+    it("should handle generic errors as internal server error", () => {
+      const exception = new Error("Something went wrong");
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.INTERNAL_SERVER_ERROR,
+          path: "/test-path",
+          statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    });
+
+    it("should handle unknown exceptions as internal server error", () => {
+      const exception = "Unknown error type";
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.INTERNAL_SERVER_ERROR,
+          path: "/test-path",
+          statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    });
+
+    it("should pass an AppException's own code and params through directly", () => {
+      const exception = new AppException(ErrorCode.NOT_FOUND, HttpStatus.NOT_FOUND, {
+        userId: "user-1",
+      });
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.NOT_FOUND,
+          params: { userId: "user-1" },
+          path: "/test-path",
+          statusCode: HttpStatus.NOT_FOUND,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.NOT_FOUND,
+      );
+    });
+
+    it("should omit params for an AppException that carries none", () => {
+      const exception = new AppException(ErrorCode.VALIDATION_FAILED, HttpStatus.BAD_REQUEST);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.VALIDATION_FAILED,
+          path: "/test-path",
+          statusCode: HttpStatus.BAD_REQUEST,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.BAD_REQUEST,
+      );
+    });
+
+    it("should format timestamp as ISO string", () => {
+      const exception = new HttpException("Test", HttpStatus.BAD_REQUEST);
+      const beforeCall = new Date().toISOString();
+
+      filter.catch(exception, mockArgumentsHost);
+
+      const responseBody = mockHttpAdapter.reply.mock.calls[0][1];
+      const afterCall = new Date().toISOString();
+
+      expect(responseBody.timestamp).toMatch(ISO_TIMESTAMP_RE);
+      expect(responseBody.timestamp >= beforeCall).toBe(true);
+      expect(responseBody.timestamp <= afterCall).toBe(true);
+    });
+
+    it("should throw exception when context type is not http", () => {
+      const exception = new Error("Test error");
+      const nonHttpHost = {
+        ...mockArgumentsHost,
+        getType: vi.fn().mockReturnValue("rpc"),
+      };
+
+      expect(() => {
+        filter.catch(exception, nonHttpHost);
+      }).toThrow(exception);
+    });
+
+    it("should handle NotFoundException correctly", () => {
+      const exception = new HttpException("Resource not found", HttpStatus.NOT_FOUND);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.NOT_FOUND,
+          path: "/test-path",
+          statusCode: HttpStatus.NOT_FOUND,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.NOT_FOUND,
+      );
+    });
+
+    it("should handle ForbiddenException correctly", () => {
+      const exception = new HttpException("Access denied", HttpStatus.FORBIDDEN);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.FORBIDDEN,
+          path: "/test-path",
+          statusCode: HttpStatus.FORBIDDEN,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.FORBIDDEN,
+      );
+    });
+
+    it("should handle UnauthorizedException correctly", () => {
+      const exception = new HttpException("Unauthorized", HttpStatus.UNAUTHORIZED);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.UNAUTHORIZED,
+          path: "/test-path",
+          statusCode: HttpStatus.UNAUTHORIZED,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.UNAUTHORIZED,
+      );
+    });
+
+    it("should map a 429 to TOO_MANY_REQUESTS rather than INTERNAL_SERVER_ERROR", () => {
+      const exception = new HttpException(
+        "ThrottlerException: Too Many Requests",
+        HttpStatus.TOO_MANY_REQUESTS,
+      );
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockHttpAdapter.reply).toHaveBeenCalledWith(
+        mockResponse,
+        {
+          code: ErrorCode.TOO_MANY_REQUESTS,
+          path: "/test-path",
+          statusCode: HttpStatus.TOO_MANY_REQUESTS,
+          timestamp: expect.any(String),
+        },
+        HttpStatus.TOO_MANY_REQUESTS,
+      );
+    });
+
+    it("should extract correct path from request", () => {
+      mockHttpAdapter.getRequestUrl.mockReturnValue("/api/v1/users/123");
+      const exception = new HttpException("Test", HttpStatus.OK);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      const responseBody = mockHttpAdapter.reply.mock.calls[0][1];
+
+      expect(responseBody.path).toBe("/api/v1/users/123");
+    });
+  });
+});

package/template/apps/api/src/utils/catch-everything-exception.filter.ts

@@ -0,0 +1,70 @@
+import { Catch, HttpException, HttpStatus } from "@nestjs/common";
+import type { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+import { HttpAdapterHost } from "@nestjs/core";
+import { AppException } from "#src/errors/app.exception.js";
+import { fallbackCodeForStatus } from "#src/errors/http-status-fallback-code.util.js";
+import { ContextLogger } from "#src/logging/context-logger.js";
+import { handleError } from "#src/utils/error-handler.util.js";
+
+/**
+ * Global exception filter that catches all unhandled exceptions in HTTP contexts.
+ *
+ * This filter provides a consistent error response format for all exceptions
+ * that are not caught by more specific exception filters. It handles both
+ * NestJS HttpExceptions and unexpected errors.
+ */
+@Catch()
+export class CatchEverythingFilter implements ExceptionFilter {
+  constructor(
+    private readonly httpAdapterHost: HttpAdapterHost,
+    private readonly logger: ContextLogger,
+  ) {}
+
+  /**
+   * Catches and processes all exceptions.
+   *
+   * @param exception - The exception that was thrown (can be any type)
+   * @param host - The arguments host containing request/response context
+   *
+   * @throws Re-throws the exception if the context is not HTTP
+   */
+  catch(exception: unknown, host: ArgumentsHost): void {
+    if (host.getType() !== "http") {
+      throw exception;
+    }
+
+    const { httpAdapter } = this.httpAdapterHost;
+
+    const ctx = host.switchToHttp();
+
+    const httpStatus =
+      exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    if (!(exception instanceof HttpException) || httpStatus >= HttpStatus.INTERNAL_SERVER_ERROR) {
+      const url = httpAdapter.getRequestUrl(ctx.getRequest());
+      this.logger.error(
+        {
+          error: handleError(exception),
+          stack: exception instanceof Error ? exception.stack : undefined,
+          url: String(url),
+        },
+        "Unhandled exception",
+      );
+    }
+
+    const { code, params } =
+      exception instanceof AppException
+        ? { code: exception.code, params: exception.params }
+        : { code: fallbackCodeForStatus(httpStatus), params: undefined };
+
+    const responseBody = {
+      code,
+      ...(params ? { params } : {}),
+      path: httpAdapter.getRequestUrl(ctx.getRequest()),
+      statusCode: httpStatus,
+      timestamp: new Date().toISOString(),
+    };
+
+    httpAdapter.reply(ctx.getResponse(), responseBody, httpStatus);
+  }
+}

package/template/apps/api/src/utils/error-handler.util.spec.ts

@@ -0,0 +1,20 @@
+import { handleError } from "#src/utils/error-handler.util.js";
+
+describe("handleError", () => {
+  it("should return error message for Error instances", () => {
+    const error = new Error("Test error");
+
+    expect(handleError(error)).toBe("Test error");
+  });
+
+  it("should convert non-Error objects to string", () => {
+    expect(handleError("string error")).toBe("string error");
+    expect(handleError(123)).toBe("123");
+    expect(handleError({ message: "object" })).toBe("[object Object]");
+  });
+
+  it("should handle null and undefined", () => {
+    expect(handleError(null)).toBe("null");
+    expect(handleError(undefined)).toBe("undefined");
+  });
+});

package/template/apps/api/src/utils/error-handler.util.ts

@@ -0,0 +1,12 @@
+/**
+ * Converts an unknown error to a string message.
+ *
+ * @param error - The error to convert
+ * @returns Error message string
+ */
+export function handleError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}

package/template/apps/api/src/utils/escape-like-pattern.util.spec.ts

@@ -0,0 +1,29 @@
+import { escapeLikePattern } from "#src/utils/escape-like-pattern.util.js";
+
+describe("escapeLikePattern", () => {
+  it("should escape percent signs", () => {
+    expect(escapeLikePattern("100%")).toBe("100\\%");
+  });
+
+  it("should escape underscores", () => {
+    expect(escapeLikePattern("TU_Berlin")).toBe("TU\\_Berlin");
+  });
+
+  it("should escape backslashes", () => {
+    expect(escapeLikePattern("a\\b")).toBe("a\\\\b");
+  });
+
+  it("should escape mixed metacharacters without double-escaping", () => {
+    expect(escapeLikePattern("%%%%")).toBe("\\%\\%\\%\\%");
+    expect(escapeLikePattern("____")).toBe("\\_\\_\\_\\_");
+    expect(escapeLikePattern("100%_off\\now")).toBe("100\\%\\_off\\\\now");
+  });
+
+  it("should leave plain strings unchanged", () => {
+    expect(escapeLikePattern("Karlsruhe")).toBe("Karlsruhe");
+  });
+
+  it("should handle an empty string", () => {
+    expect(escapeLikePattern("")).toBe("");
+  });
+});

package/template/apps/api/src/utils/escape-like-pattern.util.ts

@@ -0,0 +1,11 @@
+/**
+ * Escapes Postgres LIKE/ILIKE wildcard characters (`%`, `_`, `\`) in raw user
+ * input so `contains`/`startsWith`/`endsWith` filters match them literally
+ * instead of as pattern wildcards.
+ *
+ * @param value - Raw user-supplied search string
+ * @returns The string with LIKE metacharacters backslash-escaped
+ */
+export function escapeLikePattern(value: string): string {
+  return value.replace(/[\\%_]/g, "\\$&");
+}

package/template/apps/api/src/utils/pagination.input.ts

@@ -0,0 +1,20 @@
+import { Field, InputType, Int } from "@nestjs/graphql";
+import { IsInt, IsOptional, Max, Min } from "class-validator";
+
+const MAX_PAGE_SIZE = 100;
+
+@InputType()
+export class PaginationInput {
+  @Field(() => Int, { nullable: true })
+  @IsInt()
+  @IsOptional()
+  @Min(0)
+  skip?: number;
+
+  @Field(() => Int, { nullable: true })
+  @IsInt()
+  @IsOptional()
+  @Max(MAX_PAGE_SIZE)
+  @Min(1)
+  take?: number;
+}

package/template/apps/api/src/utils/prisma-exception.filter.spec.ts

@@ -0,0 +1,186 @@
+import type { ArgumentsHost } from "@nestjs/common";
+import { HttpStatus } from "@nestjs/common";
+import { HttpAdapterHost } from "@nestjs/core";
+import type { TestingModule } from "@nestjs/testing";
+import { Test } from "@nestjs/testing";
+import { vi } from "vitest";
+import type { Mock, MockInstance } from "vitest";
+import { ErrorCode } from "#src/errors/error-code.enum.js";
+import { Prisma } from "#src/generated/prisma/client.js";
+import { ContextLogger } from "#src/logging/context-logger.js";
+import { PrismaExceptionFilter } from "#src/utils/prisma-exception.filter.js";
+
+describe("prismaExceptionFilter", () => {
+  let filter: PrismaExceptionFilter;
+  let mockArgumentsHost: ArgumentsHost;
+  let mockResponse: {
+    send: Mock;
+    status: Mock;
+  };
+  let loggerErrorSpy: MockInstance;
+
+  beforeEach(async () => {
+    mockResponse = {
+      send: vi.fn(),
+      status: vi.fn().mockReturnThis(),
+    };
+
+    const mockHttpArgumentsHost = {
+      getNext: vi.fn(),
+      getRequest: vi.fn(),
+      getResponse: vi.fn().mockReturnValue(mockResponse),
+    };
+
+    mockArgumentsHost = {
+      getArgByIndex: vi.fn(),
+      getArgs: vi.fn(),
+      getType: vi.fn().mockReturnValue("http"),
+      switchToHttp: vi.fn().mockReturnValue(mockHttpArgumentsHost),
+      switchToRpc: vi.fn(),
+      switchToWs: vi.fn(),
+    };
+
+    const mockHttpAdapterHost = {
+      httpAdapter: {},
+    };
+
+    const mockLogger = { debug: vi.fn(), error: vi.fn(), setContext: vi.fn() };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        PrismaExceptionFilter,
+        { provide: ContextLogger, useValue: mockLogger },
+        {
+          provide: HttpAdapterHost,
+          useValue: mockHttpAdapterHost,
+        },
+      ],
+    }).compile();
+
+    filter = module.get<PrismaExceptionFilter>(PrismaExceptionFilter);
+    loggerErrorSpy = mockLogger.error;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("catch", () => {
+    it("should handle P2002 (unique constraint violation) error", () => {
+      const prismaError = new Prisma.PrismaClientKnownRequestError(
+        "Unique constraint failed on the fields: (`email`)",
+        {
+          clientVersion: "5.0.0",
+          code: "P2002",
+          meta: { target: ["email"] },
+        },
+      );
+
+      filter.catch(prismaError, mockArgumentsHost);
+
+      expect(loggerErrorSpy).toHaveBeenCalledWith(
+        { code: "P2002", error: prismaError.message },
+        "Prisma error",
+      );
+      expect(mockResponse.status).toHaveBeenCalledWith(HttpStatus.CONFLICT);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        code: ErrorCode.CONFLICT,
+        params: { target: ["email"] },
+        statusCode: HttpStatus.CONFLICT,
+      });
+    });
+
+    it("should omit params when the constraint carries no target field", () => {
+      const prismaError = new Prisma.PrismaClientKnownRequestError(
+        "Unique constraint failed on the fields: (`email`)",
+        { clientVersion: "5.0.0", code: "P2002" },
+      );
+
+      filter.catch(prismaError, mockArgumentsHost);
+
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        code: ErrorCode.CONFLICT,
+        statusCode: HttpStatus.CONFLICT,
+      });
+    });
+
+    it("should log error for non-P2002 errors", () => {
+      const prismaError = new Prisma.PrismaClientKnownRequestError("Record not found", {
+        clientVersion: "5.0.0",
+        code: "P2025",
+      });
+
+      expect(() => {
+        filter.catch(prismaError, mockArgumentsHost);
+      }).toThrow();
+
+      expect(loggerErrorSpy).toHaveBeenCalledWith(
+        { code: "P2025", error: prismaError.message },
+        "Prisma error",
+      );
+    });
+
+    it("should handle P2002 error with multiple fields", () => {
+      const prismaError = new Prisma.PrismaClientKnownRequestError(
+        "Unique constraint failed on the fields: (`userId`, `postId`)",
+        {
+          clientVersion: "5.0.0",
+          code: "P2002",
+          meta: { target: ["userId", "postId"] },
+        },
+      );
+
+      filter.catch(prismaError, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(HttpStatus.CONFLICT);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        code: ErrorCode.CONFLICT,
+        params: { target: ["userId", "postId"] },
+        statusCode: HttpStatus.CONFLICT,
+      });
+    });
+
+    it("should log error message to console", () => {
+      const prismaError = new Prisma.PrismaClientKnownRequestError("Test error message", {
+        clientVersion: "5.0.0",
+        code: "P2002",
+      });
+
+      filter.catch(prismaError, mockArgumentsHost);
+
+      expect(loggerErrorSpy).toHaveBeenCalledWith(
+        { code: "P2002", error: "Test error message" },
+        "Prisma error",
+      );
+    });
+
+    it("should log error for P2003 (foreign key constraint) error", () => {
+      const prismaError = new Prisma.PrismaClientKnownRequestError(
+        "Foreign key constraint failed",
+        {
+          clientVersion: "5.0.0",
+          code: "P2003",
+        },
+      );
+
+      expect(() => {
+        filter.catch(prismaError, mockArgumentsHost);
+      }).toThrow();
+
+      expect(loggerErrorSpy).toHaveBeenCalled();
+    });
+
+    it("should log error for P2001 (record not found) error", () => {
+      const prismaError = new Prisma.PrismaClientKnownRequestError("Record not found", {
+        clientVersion: "5.0.0",
+        code: "P2001",
+      });
+
+      expect(() => {
+        filter.catch(prismaError, mockArgumentsHost);
+      }).toThrow();
+
+      expect(loggerErrorSpy).toHaveBeenCalled();
+    });
+  });
+});

package/template/apps/api/src/utils/prisma-exception.filter.ts

@@ -0,0 +1,45 @@
+import { Catch, HttpStatus } from "@nestjs/common";
+import type { ArgumentsHost } from "@nestjs/common";
+import { BaseExceptionFilter } from "@nestjs/core";
+import type { FastifyReply } from "fastify";
+import { ErrorCode } from "#src/errors/error-code.enum.js";
+import { Prisma } from "#src/generated/prisma/client.js";
+import { ContextLogger } from "#src/logging/context-logger.js";
+
+/**
+ * Exception filter for handling Prisma database errors.
+ *
+ * This filter intercepts Prisma client errors and transforms them into
+ * appropriate HTTP responses. It specifically handles known Prisma error
+ * codes and maps them to corresponding HTTP status codes.
+ */
+@Catch(Prisma.PrismaClientKnownRequestError)
+export class PrismaExceptionFilter extends BaseExceptionFilter {
+  constructor(private readonly logger: ContextLogger) {
+    super();
+  }
+
+  /**
+   * Catches and processes Prisma client errors.
+   *
+   * @param exception - The Prisma client error that was thrown
+   * @param host - The arguments host containing request/response context
+   */
+  override catch(exception: Prisma.PrismaClientKnownRequestError, host: ArgumentsHost) {
+    this.logger.error({ code: exception.code, error: exception.message }, "Prisma error");
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<FastifyReply>();
+
+    if (exception.code === "P2002") {
+      const status = HttpStatus.CONFLICT;
+      const target = Array.isArray(exception.meta?.target) ? exception.meta.target : undefined;
+      response.status(status).send({
+        code: ErrorCode.CONFLICT,
+        ...(target ? { params: { target } } : {}),
+        statusCode: status,
+      });
+    } else {
+      super.catch(exception, host);
+    }
+  }
+}