@invariant--labs/foundation 1.1.2

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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,38 @@
+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/error-handler.type.ts

@@ -0,0 +1,23 @@
+import { HttpException } from "@nestjs/common";
+
+import { DetailedError } from "../../../core/errors";
+
+export type DetailedErrorClass<TError extends DetailedError> = new (...args: never[]) => TError;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type HttpExceptionClass<TException extends HttpException> = new (...args: any[]) => TException;
+
+export type HttpExceptionReturn = {
+  message?: string;
+  response?: unknown;
+};
+
+export type HttpExceptionReturnFn<TError extends DetailedError> = (error: TError) => HttpExceptionReturn;
+
+export type ErrorHandlerEntry<
+  TError extends DetailedError = DetailedError,
+  TException extends HttpException = HttpException,
+> = {
+  on: DetailedErrorClass<TError>;
+  use: HttpExceptionClass<TException>;
+  return?: HttpExceptionReturnFn<TError>;
+};

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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,43 @@
+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/index.ts

@@ -0,0 +1,5 @@
+export * from "./error-handler";
+export * from "./error-handler.type";
+export * from "./generic-error-handler";
+export * from "./handle-errors.decorator";
+export * from "./validation-error-handler";

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

@@ -0,0 +1,46 @@
+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;
+  }
+}

package/src/nestjs/errors/index.ts

@@ -0,0 +1,2 @@
+export * from "./handlers";
+export * from "./parsers";

package/src/nestjs/errors/parsers/axios-metadata.parser.ts

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { AxiosError } from "axios";
+
+import { ErrorMetadata } from "./error-metadata.definition";
+
+export const axiosMetadataParser = (error: unknown, extraMetadata: ErrorMetadata = {}): ErrorMetadata => {
+  if (!(error instanceof AxiosError)) {
+    return { ...extraMetadata, rawError: error };
+  }
+
+  const { status, statusText, data, config } = error.response ?? {};
+
+  return {
+    ...extraMetadata,
+    code: status,
+    status: statusText,
+    data,
+    url: config?.url,
+    httpMethod: config?.method,
+  };
+};

package/src/nestjs/errors/parsers/error-metadata.definition.ts

@@ -0,0 +1 @@
+export type ErrorMetadata = Record<string, unknown>;

package/src/nestjs/errors/parsers/index.ts

@@ -0,0 +1,5 @@
+export * from "./axios-metadata.parser";
+export * from "./error-metadata.definition";
+export * from "./knex-metadata.parser";
+export * from "./typeorm-metadata.parser";
+export * from "./workos-metadata.parser";

package/src/nestjs/errors/parsers/knex-metadata.parser.ts

@@ -0,0 +1,18 @@
+import { ErrorMetadata } from "./error-metadata.definition";
+
+export const knexMetadataParser = (error: unknown, extraMetadata: ErrorMetadata = {}): ErrorMetadata => {
+  const knexError = error as Record<string, unknown> | null;
+
+  const metadata: ErrorMetadata = {
+    code: knexError?.code,
+    hint: knexError?.hint,
+    detail: knexError?.detail,
+    ...extraMetadata,
+  };
+
+  if (!metadata.code && !metadata.hint && !metadata.detail) {
+    metadata.rawError = error;
+  }
+
+  return metadata;
+};

package/src/nestjs/errors/parsers/typeorm-metadata.parser.ts

@@ -0,0 +1,19 @@
+import { TypeORMError } from "typeorm";
+
+import { ErrorMetadata } from "./error-metadata.definition";
+
+export const typeormMetadataParser = (error: unknown, extraMetadata: ErrorMetadata = {}): ErrorMetadata => {
+  const metadata: ErrorMetadata = {
+    detail: (error as Record<string, unknown> | null)?.detail,
+    ...extraMetadata,
+  };
+
+  if (error instanceof TypeORMError) {
+    metadata.message = error.message;
+    metadata.name = error.name;
+  } else {
+    metadata.rawError = error;
+  }
+
+  return metadata;
+};

package/src/nestjs/errors/parsers/workos-metadata.parser.ts

@@ -0,0 +1,17 @@
+import { ErrorMetadata } from "./error-metadata.definition";
+
+export const workosMetadataParser = (error: unknown, extraMetadata: ErrorMetadata = {}): ErrorMetadata => {
+  const rawData = (error as Record<string, Record<string, unknown>> | null)?.rawData;
+
+  const metadata: ErrorMetadata = {
+    code: rawData?.code,
+    message: rawData?.message,
+    ...extraMetadata,
+  };
+
+  if (!metadata.code) {
+    metadata.rawError = error;
+  }
+
+  return metadata;
+};

package/src/nestjs/http/decorators/index.ts

@@ -0,0 +1 @@
+export * from "./log-app-ctx.decorator";

package/src/nestjs/http/decorators/log-app-ctx.decorator.ts

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access */
+import { Inject } from "@nestjs/common";
+
+import { ArchitectureLayer, ArchitectureLevel } from "../../../core/types";
+import { LoggerService } from "../../../modules/logger/logger.service";
+
+export function LogAppCtx() {
+  const injectLogger = Inject(LoggerService);
+
+  return function (target: object, _propertyKey: string, descriptor: unknown) {
+    injectLogger(target, "logger");
+
+    const originalMethod = (descriptor as PropertyDescriptor).value;
+
+    (descriptor as PropertyDescriptor).value = function (...args: unknown[]) {
+      const className = target.constructor.name;
+      const type = className.includes("CommandHandler")
+        ? "command"
+        : className.includes("QueryHandler")
+          ? "query"
+          : null;
+
+      if (type) {
+        (this as { logger: LoggerService }).logger?.ctx({
+          [ArchitectureLevel.APPLICATION]: { [type]: { className } },
+        } as ArchitectureLayer);
+      }
+
+      return originalMethod.apply(this, args);
+    };
+  };
+}

package/src/nestjs/http/dtos/date-range.dto.ts

@@ -0,0 +1,15 @@
+import { Type } from "class-transformer";
+import { IsDate, IsOptional } from "class-validator";
+
+// NOTE: only use this dto for POST query
+export class DateRangeDto {
+  @IsOptional()
+  @Type(() => Date)
+  @IsDate()
+  from?: Date;
+
+  @IsOptional()
+  @Type(() => Date)
+  @IsDate()
+  to?: Date;
+}

package/src/nestjs/http/dtos/index.ts

@@ -0,0 +1 @@
+export * from "./date-range.dto";

package/src/nestjs/http/filters/all-exceptions.filter.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */
+import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from "@nestjs/common";
+import { HttpArgumentsHost, RpcArgumentsHost } from "@nestjs/common/interfaces";
+import * as Sentry from "@sentry/nestjs";
+import { Response } from "express";
+
+import { ArchitectureLayer, ArchitectureLevel } from "../../../core/types";
+import { GenericErrorHandler } from "../../errors/handlers/generic-error-handler";
+import { LoggerService } from "../../../modules/logger/logger.service";
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  private readonly genericErrorHandler = new GenericErrorHandler();
+  private readonly currentLayer: ArchitectureLayer = {
+    [ArchitectureLevel.INFRASTRUCTURE]: {
+      "web-rest": {
+        className: AllExceptionsFilter.name,
+      },
+    },
+  };
+
+  constructor(private readonly loggerService: LoggerService) {}
+
+  catch(error: unknown, host: ArgumentsHost) {
+    if (!(error instanceof HttpException)) {
+      Sentry.captureException(error);
+    }
+
+    if (host.getType() === "http") {
+      return this.throwHttp(error, host.switchToHttp());
+    }
+
+    if (host.getType() === "rpc") {
+      this.logRpc(error, host.switchToRpc());
+      return;
+    }
+
+    this.loggerService.warn("Unhandled error", error instanceof Error ? { error: error.message, stack: error.stack } : undefined);
+  }
+
+  private throwHttp(error: unknown, httpContext: HttpArgumentsHost) {
+    const response = httpContext.getResponse<Response>();
+
+    if (error instanceof HttpException) {
+      return this.throwHttpException(error, response);
+    }
+
+    const genericHttpException = this.genericErrorHandler.toHttpException(error);
+    if (genericHttpException) {
+      return this.throwHttpException(genericHttpException, response);
+    }
+
+    return this.throwUnhandledException(error, response);
+  }
+
+  private throwHttpException(exception: HttpException, response: Response<unknown, Record<string, unknown>>) {
+    const statusCode = exception.getStatus();
+    const cause = exception.cause as Record<string, unknown> | undefined;
+
+    const layer = (cause?.layer ?? cause?.layerObject ?? this.currentLayer) as ArchitectureLayer;
+    const details = (cause?.details ?? cause?.detailsObject ?? {}) as Record<string, unknown>;
+    const message = (cause?.message as string) ?? "";
+    const errorResponse = cause?.response ?? {};
+
+    this.loggerService.ctx(layer, { ...details });
+    this.loggerService.info(`[Platform] error thrown: ${message}`);
+
+    return response.status(statusCode).json({
+      statusCode,
+      message: exception.message,
+      cause: errorResponse,
+    });
+  }
+
+  private throwUnhandledException(error: unknown, response: Response<unknown, Record<string, unknown>>) {
+    this.loggerService.warn(`Unhandled error: ${String(error)}`, error instanceof Error ? { error: error.message, stack: error.stack } : undefined);
+    return response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+      statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+      message: "Unexpected error",
+    });
+  }
+
+  private logRpc(error: unknown, rpcContext: RpcArgumentsHost) {
+    const context = rpcContext.getContext();
+    const queue = context.args[0].fields.routingKey;
+    const pattern = context.args[2];
+    this.loggerService.warn(
+      "RPC error",
+      error instanceof Error ? { error, queue, pattern, payload: rpcContext.getData() } : undefined,
+    );
+  }
+}

package/src/nestjs/http/filters/command-failure.filter.ts

@@ -0,0 +1,12 @@
+import { ArgumentsHost, Catch } from "@nestjs/common";
+import { GqlArgumentsHost, GqlExceptionFilter } from "@nestjs/graphql";
+
+import { CommandFailureError } from "../../../core/errors/command-failure.error";
+
+@Catch(CommandFailureError)
+export class CommandFailureFilter implements GqlExceptionFilter {
+  catch(error: CommandFailureError, host: ArgumentsHost) {
+    if (GqlArgumentsHost.create(host).getInfo() != null) {return error;}
+    throw error;
+  }
+}

package/src/nestjs/http/filters/index.ts

@@ -0,0 +1,4 @@
+export * from "./all-exceptions.filter";
+export * from "./command-failure.filter";
+export * from "./rpc-exceptions.filter";
+export * from "./too-many-results.filter";

package/src/nestjs/http/filters/rpc-exceptions.filter.ts

@@ -0,0 +1,10 @@
+import { Catch, RpcExceptionFilter as NestRpcExceptionFilter } from "@nestjs/common";
+import { RpcException } from "@nestjs/microservices";
+import { Observable, throwError } from "rxjs";
+
+@Catch(RpcException)
+export class RpcExceptionFilter implements NestRpcExceptionFilter {
+  catch(exception: RpcException): Observable<unknown> {
+    return throwError(() => exception.getError());
+  }
+}

package/src/nestjs/http/filters/too-many-results.filter.ts

@@ -0,0 +1,12 @@
+import { ArgumentsHost, Catch } from "@nestjs/common";
+import { GqlArgumentsHost, GqlExceptionFilter } from "@nestjs/graphql";
+
+import { TooManyResultsError } from "../../../core/errors/too-many-results.error";
+
+@Catch(TooManyResultsError)
+export class TooManyResultsFilter implements GqlExceptionFilter {
+  catch(error: TooManyResultsError, host: ArgumentsHost) {
+    if (GqlArgumentsHost.create(host).getInfo() != null) {return error;}
+    throw error;
+  }
+}

package/src/nestjs/http/index.ts

@@ -0,0 +1,6 @@
+export * from "./decorators";
+export * from "./dtos";
+export * from "./filters";
+export * from "./interceptors";
+export * from "./middleware";
+export * from "./swagger";

package/src/nestjs/http/interceptors/index.ts

@@ -0,0 +1,2 @@
+export * from "./log-app-ctx.interceptor";
+export * from "./serialize-output.interceptor";