@invariant--labs/foundation 1.1.2 → 1.1.5

package/src/modules/logger/logger.service.ts

@@ -1,131 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */
-import * as cls from "cls-hooked";
-import { merge } from "lodash";
-
-import { ArchitectureLayer, ArchitectureLevel } from "../../core/types";
-import { LoggerTransport } from "./transports/logger-transport";
-import { CtxLog, DataLog, LogLevel } from "./log";
-
-const NSID = "fb8b817a-4824-4abc-a1b1-e7cbb7f420eb";
-
-export const SECRET_KEYS = [
-  "pass", "password", "token", "pendingToken",
-  "authToken", "accessToken", "refreshToken", "secret",
-] as const;
-
-const IGNORED_MESSAGES = ["Successfully connected to RMQ broker"] as const;
-
-export class LoggerService {
-  private readonly transports: LoggerTransport[];
-  private readonly service: string;
-
-  constructor({ transports, service }: { transports: LoggerTransport[]; service: string }) {
-    this.transports = transports;
-    this.service = service;
-  }
-
-  log(level: LogLevel, arg1: string | DataLog, arg2?: string | DataLog) {
-    const message = typeof arg1 === "string" ? arg1 : "";
-    if (IGNORED_MESSAGES.includes(message as any)) {return;}
-
-    const obj = typeof arg1 === "string" ? arg2 : arg1;
-    const { data, stack } = this.extractLogData(obj, message);
-    const ctx = this.getCtx();
-
-    for (const transport of this.transports) {
-      transport.add({
-        level,
-        message,
-        service: this.service,
-        stack,
-        data: { ...data, ...ctx },
-      });
-    }
-  }
-
-  error(arg1: string | DataLog, arg2?: string | DataLog) { this.log("error", arg1, arg2); }
-  warn(arg1: string | DataLog, arg2?: string | DataLog) { this.log("warn", arg1, arg2); }
-  info(arg1: string | DataLog, arg2?: string | DataLog) { this.log("info", arg1, arg2); }
-  http(arg1: string | DataLog, arg2?: string | DataLog) { this.log("http", arg1, arg2); }
-  verbose(arg1: string | DataLog, arg2?: string | DataLog) { this.log("verbose", arg1, arg2); }
-  debug(arg1: string | DataLog, arg2?: string | DataLog) { this.log("debug", arg1, arg2); }
-  silly(arg1: string | DataLog, arg2?: string | DataLog) { this.log("silly", arg1, arg2); }
-
-  init(req: any, res: any, next: any) {
-    const ns = cls.getNamespace(NSID) ?? cls.createNamespace(NSID);
-    ns.bind(req);
-    ns.bind(res);
-    ns.run(() => next());
-  }
-
-  clearCtx() {
-    const ns = cls.getNamespace(NSID);
-    if (ns?.active) {ns.set("ctx", {});}
-  }
-
-  ctx(layer: ArchitectureLayer, log?: CtxLog) {
-    const ns = cls.getNamespace(NSID);
-    const levelKeys = Object.keys(layer) as ArchitectureLevel[];
-
-    if (levelKeys.length <= 0) {
-      this.warn("[Logger] Error: layer has no architecture level, cannot set any logger context");
-      return;
-    }
-
-    try {
-      const anyLayer = layer as any;
-      const level = levelKeys[0] as string;
-      const trace = Object.keys(anyLayer[level])[0];
-      anyLayer[level][trace].meta = { ...anyLayer[level][trace].meta, ...log };
-    } catch {
-      this.warn("[Logger] Error: unable to define logger context, logging will be uncoherent", { error: "ctx parse failed" });
-    }
-
-    if (ns?.active) {
-      return ns.set("ctx", { ...merge(this.getCtx(), layer) });
-    }
-  }
-
-  private getCtx(): CtxLog {
-    return cls.getNamespace(NSID)?.active ? cls.getNamespace(NSID)!.get("ctx") : {};
-  }
-
-  private extractLogData(obj: string | DataLog | undefined, message: string) {
-    let stack: string | undefined;
-    const data: DataLog = {};
-
-    if (Array.isArray(obj)) {
-      data["list"] = this.stringifyValue(obj);
-    } else if (obj instanceof Error) {
-      stack = obj.stack;
-      if (!message) {data["text"] = obj.message;}
-    } else if (typeof obj === "object" && obj !== null) {
-      for (const [key, value] of Object.entries(obj)) {
-        if (key === "metrics") {data.metrics = { ...obj.metrics };}
-        else if (key === "stack" && typeof value === "string") {stack = this.stringifyValue(value);}
-        else {data[key] = this.sanitizeLog(key, value);}
-      }
-    } else if (typeof obj === "string") {
-      data["text"] = obj;
-    }
-
-    return { data, stack };
-  }
-
-  private stringifyValue(value: any): string {
-    try {
-      const content = value === undefined ? "" : typeof value === "string" ? value : JSON.stringify(value);
-      const secretPattern = new RegExp(`"(${SECRET_KEYS.join("|")})":"([^"]*)"`, "gm");
-      return content
-        .replace(/Bearer [^ "'\\]*/gm, "Bearer ***")
-        .replace(secretPattern, '"$1": "***"')
-        .replace(/(\.eyJ[^\s"]+\.[^\s"]+\.[^\s"]+)/, (_: string, match: string) => match.substring(0, 5) + "***");
-    } catch {
-      return "JSON.stringify did not work";
-    }
-  }
-
-  private sanitizeLog(key: string, value: any) {
-    return SECRET_KEYS.includes(key as any) ? "***" : this.stringifyValue(value);
-  }
-}

package/src/modules/logger/transports/console-color.transport.ts

@@ -1,41 +0,0 @@
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-const COLORS = {
-  Reset: "\x1b[0m",
-  Bright: "\x1b[1m",
-  Dim: "\x1b[2m",
-  FgRed: "\x1b[31m",
-  FgGreen: "\x1b[32m",
-  FgYellow: "\x1b[33m",
-  FgBlue: "\x1b[34m",
-  FgCyan: "\x1b[36m",
-  FgWhite: "\x1b[37m",
-} as const;
-
-const LEVEL_COLOR: Record<string, string> = {
-  warn: COLORS.FgYellow,
-  info: COLORS.FgCyan,
-  error: COLORS.FgRed,
-  http: COLORS.FgGreen,
-};
-
-export class ConsoleColorTransport extends LoggerTransport {
-  send(log: Log): void {
-    const level = this.bracket(log.level.toUpperCase(), LEVEL_COLOR[log.level] ?? COLORS.FgBlue);
-    const date = `${COLORS.Dim}${new Date().toISOString().substring(11, 19)}${COLORS.Reset}`;
-    const message = `${COLORS.Bright}${log.message}`;
-    const data = log.data && Object.keys(log.data).length > 0
-      ? `\n${COLORS.Dim}${JSON.stringify(log.data, null, 2)}${COLORS.Reset}`
-      : "";
-    const stack = log.stack
-      ? `\n-----\n${COLORS.Reset}${COLORS.Dim}${log.stack}${COLORS.Reset}\n-----\n`
-      : "";
-    // eslint-disable-next-line no-console
-    console.log(`${level} ${date} ${message}${data}${stack}`);
-  }
-
-  private bracket(message: string, color: string) {
-    return `${COLORS.FgWhite}[${color}${message}${COLORS.FgWhite}]${COLORS.Reset}`;
-  }
-}

package/src/modules/logger/transports/console-json.transport.ts

@@ -1,23 +0,0 @@
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-export class ConsoleJSONTransport extends LoggerTransport {
-  format(log: Log): string {
-    const { data = {}, message, service, stack, level } = log;
-    const { metrics, ...otherData } = data;
-    return JSON.stringify({
-      timestamp: new Date().toISOString(),
-      level,
-      service,
-      message,
-      data: otherData,
-      metrics,
-      stack,
-    });
-  }
-
-  send(log: Log): void {
-    // eslint-disable-next-line no-console
-    console.log(this.format(log));
-  }
-}

package/src/modules/logger/transports/console.transport.ts

@@ -1,10 +0,0 @@
-/* eslint-disable no-console */
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-export class ConsoleTransport extends LoggerTransport {
-  send(log: Log): void {
-    console.log(`[${log.level}] ${log.message}`);
-    console.log(JSON.stringify(log.data, null, 2));
-  }
-}

package/src/modules/logger/transports/fake.transport.ts

@@ -1,18 +0,0 @@
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-export class FakeTransport extends LoggerTransport {
-  public logs: Log[] = [];
-
-  send(log: Log) {
-    this.logs.push(log);
-  }
-
-  clear(): void {
-    this.logs = [];
-  }
-
-  getLastLog(): Log | undefined {
-    return this.logs.at(-1);
-  }
-}

package/src/modules/logger/transports/logger-transport.ts

@@ -1,22 +0,0 @@
-import { Log, LogLevel, LOG_LEVEL_PRIORITY } from "../log";
-
-export type LoggerTransportOptions = {
-  level: LogLevel;
-};
-
-export abstract class LoggerTransport {
-  readonly levelPriority: number;
-
-  constructor(public readonly options: LoggerTransportOptions = { level: "silly" }) {
-    this.levelPriority = LOG_LEVEL_PRIORITY[options.level];
-  }
-
-  add(log: Log): void {
-    if (this.levelPriority < LOG_LEVEL_PRIORITY[log.level]) {
-      return;
-    }
-    this.send(log);
-  }
-
-  abstract send(log: Log): void;
-}

package/src/modules/messaging/messaging.module.ts

@@ -1,92 +0,0 @@
-import { DynamicModule, Module } from "@nestjs/common";
-import { ClientProxy, ClientProxyFactory, Transport } from "@nestjs/microservices";
-
-import { MessagingService, FakeMessagingService, RabbitMessagingService } from "../../core/infrastructure/messaging";
-import { ConfigModule, ConfigService } from "../config";
-import { LoggerModule, LoggerService } from "../logger";
-
-const clientProxyCache = new Map<string, ClientProxy>();
-
-function buildRmqUrl(config: ConfigService): string {
-  const protocol = config.get("RMQ_PROTOCOL");
-  const user = config.get("RMQ_USER");
-  const password = config.get("RMQ_PASSWORD");
-  const host = config.get("RMQ_HOST");
-  const port = config.get("RMQ_PORT");
-  return `${protocol}://${user}:${password}@${host}:${port}`;
-}
-
-async function closeAllCachedProxies(logger?: { info: (msg: string) => void; error: (msg: string, data?: object) => void }) {
-  for (const [queue, proxy] of clientProxyCache) {
-    try {
-      await proxy.close();
-      logger?.info(`Closed cached client proxy for queue: ${queue}`);
-    } catch (error) {
-      logger?.error(`Error closing cached client proxy for queue ${queue}:`, { error });
-    }
-  }
-  clientProxyCache.clear();
-}
-
-@Module({})
-export class MessagingModule {
-  static register(queueName: string): DynamicModule {
-    return {
-      module: MessagingModule,
-      imports: [ConfigModule, LoggerModule],
-      providers: [
-        {
-          provide: MessagingService,
-          useFactory: (configService: ConfigService, optionalProvider: ClientProxy) => {
-            return configService.isTest() ? new FakeMessagingService() : new RabbitMessagingService(optionalProvider);
-          },
-          inject: [ConfigService, { token: queueName, optional: false }],
-        },
-        {
-          provide: queueName,
-          useFactory: async (configService: ConfigService) => {
-            if (configService.isTest()) {return {};}
-
-            const cached = clientProxyCache.get(queueName);
-            if (cached) {return cached;}
-
-            const clientProxy = ClientProxyFactory.create({
-              transport: Transport.RMQ,
-              options: {
-                urls: [buildRmqUrl(configService)],
-                queue: queueName,
-                queueOptions: {
-                  durable: configService.getBoolean("RMQ_IS_DURABLE"),
-                  exclusive: false,
-                  autoDelete: false,
-                },
-                prefetchCount: 1,
-                socketOptions: {
-                  heartbeatIntervalInSeconds: 30,
-                  reconnectTimeInSeconds: 5,
-                },
-              },
-            });
-
-            await clientProxy.connect();
-            clientProxyCache.set(queueName, clientProxy);
-            return clientProxy;
-          },
-          inject: [ConfigService],
-        },
-        {
-          provide: "MESSAGING_MODULE_CLEANUP",
-          useFactory: (logger: LoggerService) => ({
-            async onModuleDestroy() { await closeAllCachedProxies(logger); },
-          }),
-          inject: [LoggerService],
-        },
-      ],
-      exports: [MessagingService],
-    };
-  }
-}
-
-export async function cleanupMessagingConnections() {
-  await closeAllCachedProxies();
-}

package/src/modules/queue/default-queue-name.resolver.ts

@@ -1,5 +0,0 @@
-import { ConfigService } from "../../core/infrastructure/config";
-import { QueueName, QueueNameResolver } from "../../core/infrastructure/messaging/types";
-
-export const defaultQueueNameResolverFactory = (configService: ConfigService): QueueNameResolver =>
-  (queueName: QueueName) => configService.get(`${queueName}_QUEUE_RMQ`) ?? "default";

package/src/modules/queue/queue.module.ts

@@ -1,73 +0,0 @@
-import { DynamicModule, Global, Module } from "@nestjs/common";
-
-import {
-  QueueManagerService,
-  FakeQueueManagerService,
-  CLIENT_PROXY_OPTIONS,
-  ClientProxyOptions,
-  QUEUE_CORE_OPTIONS_TOKEN,
-  QUEUE_NAME_RESOLVER,
-  QueueModuleAsyncOptions,
-  QueueModuleOptions,
-  QueueNameResolver,
-} from "../../core/infrastructure/messaging";
-import { ConfigModule, ConfigService } from "../config";
-import { LoggerModule, LoggerService } from "../logger";
-import { defaultQueueNameResolverFactory } from "./default-queue-name.resolver";
-import { RabbitQueueManagerService } from "./rabbit-queue-manager.service";
-
-@Module({})
-@Global()
-export class QueueModule {
-  static forRootAsync(options?: QueueModuleAsyncOptions): DynamicModule {
-    return {
-      module: QueueModule,
-      imports: [QueueCoreModule.forRootAsync(options)],
-      exports: [QueueCoreModule],
-    };
-  }
-}
-
-@Module({})
-class QueueCoreModule {
-  static forRootAsync(options?: QueueModuleAsyncOptions): DynamicModule {
-    return {
-      module: QueueCoreModule,
-      imports: [...(options?.imports ?? []), ConfigModule, LoggerModule],
-      providers: [
-        {
-          provide: QUEUE_NAME_RESOLVER,
-          useFactory: (configService: ConfigService, option?: QueueModuleOptions) =>
-            option?.queueNameResolver ?? defaultQueueNameResolverFactory(configService),
-          inject: [ConfigService, { token: QUEUE_CORE_OPTIONS_TOKEN, optional: true }],
-        },
-        {
-          provide: CLIENT_PROXY_OPTIONS,
-          useFactory: (option?: QueueModuleOptions) => option?.clientProxyOptions,
-          inject: [QUEUE_CORE_OPTIONS_TOKEN],
-        },
-        ...(options
-          ? [{
-              provide: QUEUE_CORE_OPTIONS_TOKEN,
-              useFactory: options.useFactory,
-              inject: options.inject ?? [],
-            }]
-          : []),
-        {
-          provide: QueueManagerService,
-          useFactory: (
-            queueNameResolver: QueueNameResolver,
-            clientProxyOptions: ClientProxyOptions,
-            configService: ConfigService,
-            logger: LoggerService,
-          ) =>
-            configService.isTest()
-              ? new FakeQueueManagerService()
-              : new RabbitQueueManagerService(queueNameResolver, clientProxyOptions, logger),
-          inject: [QUEUE_NAME_RESOLVER, CLIENT_PROXY_OPTIONS, ConfigService, LoggerService],
-        },
-      ],
-      exports: [QueueManagerService],
-    };
-  }
-}

package/src/modules/queue/rabbit-queue-manager.service.ts

@@ -1,67 +0,0 @@
-import { Inject, Injectable, OnModuleDestroy } from "@nestjs/common";
-import { ClientProxy, ClientProxyFactory, Transport } from "@nestjs/microservices";
-
-import {
-  QueueMessagingService,
-  QueueManagerService,
-  CLIENT_PROXY_OPTIONS,
-  ClientProxyOptions,
-  QUEUE_NAME_RESOLVER,
-  QueueName,
-  QueueNameResolver,
-} from "../../core/infrastructure/messaging";
-import { RabbitQueueMessagingService } from "../../core/infrastructure/messaging/rabbitmq/rabbit-queue-messaging.service";
-import { LoggerService } from "../logger";
-
-@Injectable()
-export class RabbitQueueManagerService implements QueueManagerService, OnModuleDestroy {
-  private readonly queueMessagingServiceMap = new Map<QueueName, QueueMessagingService>();
-  private readonly clientProxyMap = new Map<QueueName, ClientProxy>();
-
-  constructor(
-    @Inject(QUEUE_NAME_RESOLVER) private readonly queueNameResolver: QueueNameResolver,
-    @Inject(CLIENT_PROXY_OPTIONS) private readonly clientProxyOptions: ClientProxyOptions,
-    private readonly logger: LoggerService,
-  ) {}
-
-  async onModuleDestroy() {
-    for (const [queueName, clientProxy] of this.clientProxyMap) {
-      try {
-        await clientProxy.close();
-        this.logger.info(`Closed client proxy for queue: ${queueName}`);
-      } catch (error) {
-        this.logger.error(`Error closing client proxy for queue ${queueName}:`, { error });
-      }
-    }
-    this.clientProxyMap.clear();
-    this.queueMessagingServiceMap.clear();
-  }
-
-  getMessagingService(queueName: QueueName): QueueMessagingService {
-    const existing = this.queueMessagingServiceMap.get(queueName);
-    if (existing) {return existing;}
-
-    const clientProxy = ClientProxyFactory.create({
-      transport: Transport.RMQ,
-      options: {
-        ...this.clientProxyOptions,
-        queue: this.queueNameResolver(queueName),
-        queueOptions: {
-          ...this.clientProxyOptions.queueOptions,
-          exclusive: false,
-          autoDelete: false,
-        },
-        socketOptions: {
-          heartbeatIntervalInSeconds: 30,
-          reconnectTimeInSeconds: 5,
-        },
-      },
-    });
-
-    this.clientProxyMap.set(queueName, clientProxy);
-
-    const messagingService = new RabbitQueueMessagingService(clientProxy);
-    this.queueMessagingServiceMap.set(queueName, messagingService);
-    return messagingService;
-  }
-}

package/src/nestjs/errors/handlers/error-handler.ts

@@ -1,38 +0,0 @@
-import { HttpException } from "@nestjs/common";
-
-import { DetailedError } from "../../../core/errors";
-import { ErrorHandlerEntry, HttpExceptionClass, HttpExceptionReturn } from "./error-handler.type";
-
-export class ErrorHandler {
-  constructor(private readonly entries: ErrorHandlerEntry[]) {}
-
-  toHttpException(error: unknown): HttpException | undefined {
-    if (!(error instanceof DetailedError)) {
-      return undefined;
-    }
-
-    const entry = this.entries.find((entry) => error instanceof entry.on);
-
-    if (!entry) {
-      return undefined;
-    }
-
-    return ErrorHandler.buildHttpException(error, entry.use, entry.return?.(error));
-  }
-
-  static buildHttpException<TError extends DetailedError, TException extends HttpException>(
-    error: TError,
-    exception: HttpExceptionClass<TException>,
-    exceptionReturn: HttpExceptionReturn = {},
-  ): TException {
-    return new exception(exceptionReturn.message, {
-      cause: {
-        layer: error.layer(),
-        details: error.details(),
-        stack: error.stack,
-        message: error.message,
-        response: exceptionReturn.response,
-      },
-    });
-  }
-}

package/src/nestjs/errors/handlers/generic-error-handler.ts

@@ -1,59 +0,0 @@
-import {
-  BadGatewayException,
-  BadRequestException,
-  ConflictException,
-  ForbiddenException,
-  HttpException,
-  InternalServerErrorException,
-  ServiceUnavailableException,
-  UnauthorizedException,
-  UnprocessableEntityException,
-} from "@nestjs/common";
-
-import { ArchitectureLayerType, ArchitectureLevel } from "../../../core/types";
-import { DetailedError } from "../../../core/errors";
-import { ErrorHandler } from "./error-handler";
-import { HttpExceptionClass } from "./error-handler.type";
-
-const LAYER_TO_EXCEPTION: Record<ArchitectureLayerType, HttpExceptionClass<HttpException>> = {
-  "aggregate-root": UnprocessableEntityException,
-  "entity": UnprocessableEntityException,
-  "value-object": UnprocessableEntityException,
-  "command": UnprocessableEntityException,
-  "query": BadGatewayException,
-  "event-handler": ConflictException,
-  "event-saga": ConflictException,
-  "service": InternalServerErrorException,
-  "authorization": ForbiddenException,
-  "authentication": UnauthorizedException,
-  "web-dto": BadRequestException,
-  "web-rest": InternalServerErrorException,
-  "web-graphql": InternalServerErrorException,
-  "web-socket": InternalServerErrorException,
-  "web-rpc": InternalServerErrorException,
-  "persistence-sql": InternalServerErrorException,
-  "persistence-disk": InternalServerErrorException,
-  "persistence-fake": InternalServerErrorException,
-  "persistence-saas": ServiceUnavailableException,
-  "persistence-s3": ServiceUnavailableException,
-  "persistence-other": ServiceUnavailableException,
-  "messaging-inmem": InternalServerErrorException,
-  "messaging-pubsub": ServiceUnavailableException,
-  "unknown": InternalServerErrorException,
-};
-
-export class GenericErrorHandler {
-  toHttpException(error: unknown): HttpException | undefined {
-    if (!(error instanceof DetailedError)) {return undefined;}
-
-    const layerType = this.extractArchitectureLayerType(error);
-    const ExceptionClass = LAYER_TO_EXCEPTION[layerType] ?? InternalServerErrorException;
-    return ErrorHandler.buildHttpException(error, ExceptionClass);
-  }
-
-  private extractArchitectureLayerType(error: DetailedError): ArchitectureLayerType {
-    const layer = error.layer();
-    const level = Object.keys(layer)[0] as ArchitectureLevel;
-    return Object.keys(layer[level as never])[0] as ArchitectureLayerType;
-  }
-}

package/src/nestjs/errors/handlers/handle-errors.decorator.ts

@@ -1,43 +0,0 @@
-import { isObservable, throwError } from "rxjs";
-import { catchError } from "rxjs/operators";
-
-import { DetailedError } from "../../../core/errors";
-import { ErrorHandler } from "./error-handler";
-import { ErrorHandlerEntry } from "./error-handler.type";
-
-export function HandleErrors(entries?: ErrorHandlerEntry[]) {
-  return function (_target: object, _propertyKey: string, descriptor: PropertyDescriptor) {
-    const originalMethod = descriptor.value as (...args: unknown[]) => unknown;
-    const errorHandler = new ErrorHandler(entries ?? []);
-
-    const convertError = (rawError: unknown): unknown =>
-      rawError instanceof DetailedError ? (errorHandler.toHttpException(rawError) ?? rawError) : rawError;
-
-    descriptor.value = function (...args: unknown[]) {
-      try {
-        const result = originalMethod.apply(this, args) as unknown;
-
-        if (result && typeof (result as Promise<unknown>).then === "function") {
-          return (result as Promise<unknown>).catch((err: unknown) => {
-            throw convertError(err);
-          });
-        }
-
-        if (isObservable(result)) {
-          return result.pipe(
-            catchError((err: unknown) => {
-              const converted = convertError(err);
-              return throwError(() => (converted instanceof Error ? converted : new Error(String(converted))));
-            }),
-          );
-        }
-
-        return result;
-      } catch (rawError) {
-        throw convertError(rawError);
-      }
-    };
-
-    return descriptor;
-  };
-}

package/src/nestjs/errors/handlers/validation-error-handler.ts

@@ -1,46 +0,0 @@
-import { BadRequestException } from "@nestjs/common";
-import { ValidationError } from "class-validator";
-
-import { ArchitectureLayer, ArchitectureLevel } from "../../../core/types";
-
-export class ValidationErrorHandler {
-  toHttpException(validationErrors: ValidationError[]): BadRequestException {
-    const firstError = validationErrors[0];
-    const constraints = firstError?.constraints;
-    const firstMessage = constraints?.[Object.keys(constraints ?? {})[0]];
-    const details = this.formatValidationErrorsNested(validationErrors);
-
-    return new BadRequestException(firstMessage, {
-      cause: {
-        layer: {
-          [ArchitectureLevel.INFRASTRUCTURE]: {
-            "web-dto": {
-              className: firstError?.target?.constructor.name ?? ValidationErrorHandler.name,
-            },
-          },
-        } satisfies ArchitectureLayer,
-        details,
-        response: details,
-      },
-    });
-  }
-
-  private formatValidationErrorsNested(errors: ValidationError[]): Record<string, unknown> {
-    const formatted: Record<string, unknown> = {};
-
-    for (const err of errors) {
-      if (err.constraints) {
-        formatted[err.property] = Object.values(err.constraints)[0];
-      }
-
-      if (err.children?.length) {
-        const nested = this.formatValidationErrorsNested(err.children);
-        formatted[err.property] = formatted[err.property]
-          ? { errors: formatted[err.property], children: nested }
-          : nested;
-      }
-    }
-
-    return formatted;
-  }
-}