@myko.pk/response 1.0.0

package/dist/index.js

@@ -0,0 +1,883 @@
+import { Catch, BadRequestException, HttpException, UnauthorizedException, ForbiddenException, Injectable, Module, HttpStatus, SetMetadata, applyDecorators } from '@nestjs/common';
+import { Logger } from '@myko.pk/logger';
+import { map } from 'rxjs/operators';
+import { AsyncLocalStorage } from 'async_hooks';
+import { randomUUID } from 'crypto';
+import { IsOptional, IsInt, Min, Max, IsString } from 'class-validator';
+import { Type } from 'class-transformer';
+import { ApiExtraModels, ApiOkResponse, getSchemaPath } from '@nestjs/swagger';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { APP_FILTER, APP_INTERCEPTOR } from '@nestjs/core';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/response.constants.ts
+var RESPONSE_FILTERS = {
+  GLOBAL: "global",
+  VALIDATION: "validation",
+  HTTP: "http",
+  DATABASE: "database",
+  AUTH: "auth"
+};
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTI_STATUS: 207,
+  FOUND: 302,
+  BAD_REQUEST: 400
+};
+var RESPONSE_MESSAGES = {
+  SUCCESS: "Success",
+  CREATED: "Created successfully",
+  ACCEPTED: "Request accepted",
+  NO_CONTENT: "No content",
+  UPDATED: "Updated successfully",
+  DELETED: "Deleted successfully",
+  PARTIAL_SUCCESS: "Partially successful",
+  REDIRECTING: "Redirecting",
+  FILE_READY: "File ready for download"
+};
+
+// src/builders/response.builder.ts
+var ResponseBuilder = class {
+  static {
+    __name(this, "ResponseBuilder");
+  }
+  /**
+   * Build a success response
+   * @template T - Type of response data
+   * @param data - Response data
+   * @param message - Success message
+   * @param statusCode - HTTP status code
+   * @param requestId - Request tracking ID for correlation
+   * @returns ApiResponse with success data
+   */
+  static success(data, message = RESPONSE_MESSAGES.SUCCESS, statusCode = HTTP_STATUS.OK, requestId) {
+    return {
+      success: true,
+      statusCode,
+      message,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Shorthand success response with no data payload (e.g. status-only endpoints)
+   * @param message - Success message
+   * @param statusCode - HTTP status code
+   * @param requestId - Request tracking ID for correlation
+   * @returns ApiResponse with no data field
+   */
+  static ok(message = RESPONSE_MESSAGES.SUCCESS, statusCode = HTTP_STATUS.OK, requestId) {
+    return {
+      success: true,
+      statusCode,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Build an error response
+   * @param message - Error message
+   * @param code - Error code for categorization
+   * @param statusCode - HTTP status code
+   * @param details - Additional error details
+   * @param requestId - Request tracking ID for correlation
+   * @returns ApiResponse with error information
+   */
+  static error(message, code, statusCode = HTTP_STATUS.BAD_REQUEST, details, requestId) {
+    return {
+      success: false,
+      statusCode,
+      message,
+      error: {
+        code,
+        details
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Build a paginated response
+   * @template T - Type of array items
+   * @param data - Array of items
+   * @param total - Total number of items available
+   * @param page - Current page number
+   * @param limit - Items per page
+   * @param message - Success message
+   * @param statusCode - HTTP status code
+   * @param requestId - Request tracking ID for correlation
+   * @returns PaginatedResponse with pagination metadata
+   */
+  static paginated(data, total, page, limit, message = RESPONSE_MESSAGES.SUCCESS, statusCode = HTTP_STATUS.OK, requestId) {
+    const pages = Math.ceil(total / limit);
+    return {
+      success: true,
+      statusCode,
+      message,
+      data,
+      pagination: {
+        total,
+        page,
+        limit,
+        pages
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Build a cursor-based paginated response for infinite-scroll / "load more" patterns
+   * @template T - Type of array items
+   * @param data - Array of items for the current page
+   * @param total - Total number of items available
+   * @param nextCursor - Cursor string for the next page
+   * @param hasNextPage - Whether more items exist after this page
+   * @param limit - Items per page
+   * @param message - Success message
+   * @param statusCode - HTTP status code
+   * @param requestId - Request tracking ID for correlation
+   * @returns CursorPaginatedResponse with cursor metadata
+   */
+  static cursorPaginated(data, total, nextCursor, hasNextPage, limit, previousCursor, hasPreviousPage, message = RESPONSE_MESSAGES.SUCCESS, statusCode = HTTP_STATUS.OK, requestId) {
+    return {
+      success: true,
+      statusCode,
+      message,
+      data,
+      pagination: {
+        total,
+        nextCursor,
+        previousCursor,
+        hasNextPage,
+        hasPreviousPage: hasPreviousPage ?? false,
+        limit
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Build a created (201) response
+   * @template T - Type of response data
+   * @param data - Created resource data
+   * @param message - Success message
+   * @param requestId - Request tracking ID for correlation
+   * @returns ApiResponse with 201 status code
+   */
+  static created(data, message = RESPONSE_MESSAGES.CREATED, requestId) {
+    return this.success(data, message, HTTP_STATUS.CREATED, requestId);
+  }
+  /**
+   * Build an accepted (202) response for async operations
+   * @template T - Type of response data
+   * @param data - Response data (optional)
+   * @param message - Success message
+   * @param requestId - Request tracking ID for correlation
+   * @returns ApiResponse with 202 status code
+   */
+  static accepted(data, message = RESPONSE_MESSAGES.ACCEPTED, requestId) {
+    return this.success(data, message, HTTP_STATUS.ACCEPTED, requestId);
+  }
+  /**
+   * Build a no content (204) response
+   * @param message - Success message
+   * @param requestId - Request tracking ID for correlation
+   * @returns ApiResponse with 204 status code
+   */
+  static noContent(message = RESPONSE_MESSAGES.NO_CONTENT, requestId) {
+    return {
+      success: true,
+      statusCode: HTTP_STATUS.NO_CONTENT,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Response for successful update operations
+   * @param data - Updated resource data
+   * @param message - Success message
+   * @param requestId - Request tracking ID
+   */
+  static updated(data, message = RESPONSE_MESSAGES.UPDATED, requestId) {
+    return this.success(data, message, HTTP_STATUS.OK, requestId);
+  }
+  /**
+   * Response for successful delete operations
+   * @param message - Success message
+   * @param requestId - Request tracking ID
+   */
+  static deleted(message = RESPONSE_MESSAGES.DELETED, requestId) {
+    return {
+      success: true,
+      statusCode: HTTP_STATUS.OK,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Response for bulk operations (create, update, delete multiple)
+   * @param succeeded - Number of successful operations
+   * @param failed - Number of failed operations
+   * @param total - Total operations attempted
+   * @param requestId - Request tracking ID
+   */
+  static bulkOperation(succeeded, failed, total, requestId) {
+    const message = failed === 0 ? `All ${total} operations completed successfully` : `${succeeded} succeeded, ${failed} failed out of ${total} operations`;
+    return {
+      success: failed === 0,
+      statusCode: failed === 0 ? HTTP_STATUS.OK : HTTP_STATUS.MULTI_STATUS,
+      message,
+      data: {
+        succeeded,
+        failed,
+        total
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Response for partial success scenarios
+   * @param data - Partial data that was processed
+   * @param message - Message describing the partial success
+   * @param requestId - Request tracking ID
+   */
+  static partialSuccess(data, message = RESPONSE_MESSAGES.PARTIAL_SUCCESS, requestId) {
+    return {
+      success: true,
+      statusCode: HTTP_STATUS.MULTI_STATUS,
+      message,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Response for redirect operations
+   * @param url - Redirect URL
+   * @param statusCode - HTTP status code (301, 302, 307, 308)
+   * @param message - Redirect message
+   * @param requestId - Request tracking ID
+   */
+  static redirect(url, statusCode = HTTP_STATUS.FOUND, message = RESPONSE_MESSAGES.REDIRECTING, requestId) {
+    return {
+      success: true,
+      statusCode,
+      message,
+      data: { url },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Response for file download operations
+   * @param filename - Name of the file being downloaded
+   * @param size - File size in bytes
+   * @param mimeType - MIME type of the file
+   * @param requestId - Request tracking ID
+   */
+  static fileDownload(filename, size, mimeType, requestId) {
+    return {
+      success: true,
+      statusCode: HTTP_STATUS.OK,
+      message: RESPONSE_MESSAGES.FILE_READY,
+      data: {
+        filename,
+        size,
+        mimeType
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+  /**
+   * Response for import/export operations
+   * @param processed - Number of records processed
+   * @param imported - Number of records imported
+   * @param skipped - Number of records skipped
+   * @param errors - Array of error messages
+   * @param requestId - Request tracking ID
+   */
+  static importExport(processed, imported, skipped, errors = [], requestId) {
+    const hasErrors = errors.length > 0;
+    const message = hasErrors ? `Imported ${imported} records with ${errors.length} errors` : `Successfully imported ${imported} records`;
+    return {
+      success: !hasErrors,
+      statusCode: hasErrors ? HTTP_STATUS.MULTI_STATUS : HTTP_STATUS.OK,
+      message,
+      data: {
+        processed,
+        imported,
+        skipped,
+        errors: hasErrors ? errors : void 0
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+};
+var ERROR_TITLES = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Page Not Found",
+  405: "Method Not Allowed",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+var ERROR_DESCRIPTIONS = {
+  400: "The request could not be processed due to invalid data. Please check your input and try again.",
+  401: "You need to be signed in to access this page. Please sign in and try again.",
+  403: "You don't have permission to access this page. If you believe this is a mistake, contact support.",
+  404: "The page you're looking for doesn't exist or has been moved. Check the URL and try again.",
+  405: "This page does not support the request method used.",
+  408: "The server timed out waiting for your request. Please try again.",
+  409: "The request could not be completed due to a conflict with the current state of the resource.",
+  422: "The submitted data could not be processed. Please review your input and try again.",
+  429: "Too many requests. Please wait a moment before trying again.",
+  500: "Something went wrong on our end. Please try again later.",
+  502: "The server received an invalid response from an upstream server. Please try again later.",
+  503: "The server is temporarily unavailable. Please try again later.",
+  504: "The server timed out waiting for an upstream server. Please try again later."
+};
+function getErrorTitle(statusCode) {
+  return ERROR_TITLES[statusCode] || "Something Went Wrong";
+}
+__name(getErrorTitle, "getErrorTitle");
+function getErrorDescription(statusCode) {
+  return ERROR_DESCRIPTIONS[statusCode] || "An unexpected error occurred. Please try again later.";
+}
+__name(getErrorDescription, "getErrorDescription");
+function isBrowserRequest(request) {
+  const accept = request.headers?.accept;
+  return typeof accept === "string" && accept.includes("text/html");
+}
+__name(isBrowserRequest, "isBrowserRequest");
+var GlobalExceptionFilter = class {
+  logger = new Logger(GlobalExceptionFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const requestId = request.headers["x-request-id"];
+    let statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message = "Internal server error";
+    let errorCode = "INTERNAL_ERROR";
+    let details = void 0;
+    if (exception instanceof HttpException) {
+      statusCode = exception.getStatus();
+      const exceptionResponse = exception.getResponse();
+      if (typeof exceptionResponse === "object") {
+        const responseObj = exceptionResponse;
+        message = responseObj.message || exception.message;
+        details = responseObj.error || responseObj.errors;
+        errorCode = responseObj.code || exception.constructor.name.replace("Exception", "").toUpperCase();
+        if (exception instanceof BadRequestException && !responseObj.code) {
+          errorCode = "VALIDATION_ERROR";
+          message = "Validation failed";
+        }
+      } else {
+        message = exceptionResponse;
+        errorCode = exception.constructor.name.replace("Exception", "").toUpperCase();
+      }
+    } else if (exception instanceof Error) {
+      message = exception.message;
+      errorCode = exception.name || "ERROR";
+    }
+    const errorResponse = {
+      success: false,
+      statusCode,
+      message,
+      error: {
+        code: errorCode,
+        details
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+    const logContext = {
+      statusCode,
+      message,
+      method: request.method,
+      url: request.url,
+      ip: request.ip,
+      userAgent: request.headers["user-agent"],
+      errorCode
+    };
+    if (statusCode >= 500) {
+      this.logger.error(`[${requestId}] ${errorCode}:`, logContext);
+    } else if (statusCode >= 400) {
+      this.logger.warn(`[${requestId}] ${errorCode}:`, logContext);
+    } else {
+      this.logger.debug(`[${requestId}] ${errorCode}:`, logContext);
+    }
+    if (response.headersSent) return;
+    if (isBrowserRequest(request)) {
+      const showMessage = statusCode < 500 || process.env.NODE_ENV !== "production";
+      const renderOptions = {
+        statusCode,
+        title: getErrorTitle(statusCode),
+        description: getErrorDescription(statusCode),
+        message: showMessage ? message : "Something went wrong. Please try again later.",
+        errorCode,
+        showMessage
+      };
+      response.setHeader(
+        "Content-Security-Policy",
+        "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self'; connect-src 'self'"
+      );
+      response.status(statusCode);
+      response.render("error", renderOptions, (renderErr, html) => {
+        if (renderErr) {
+          this.logger.error(`[${requestId}] Failed to render error page:`, renderErr);
+          return response.json(errorResponse);
+        }
+        response.send(html);
+      });
+    } else {
+      response.status(statusCode).json(errorResponse);
+    }
+  }
+};
+__name(GlobalExceptionFilter, "GlobalExceptionFilter");
+GlobalExceptionFilter = __decorateClass([
+  Catch()
+], GlobalExceptionFilter);
+var ValidationExceptionFilter = class {
+  logger = new Logger(ValidationExceptionFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const requestId = request.headers["x-request-id"];
+    const exceptionResponse = exception.getResponse();
+    const rawErrors = exceptionResponse.message;
+    const errors = Array.isArray(rawErrors) ? rawErrors : typeof rawErrors === "string" ? [rawErrors] : [];
+    const formattedErrors = this.formatValidationErrors(errors);
+    const errorResponse = {
+      success: false,
+      statusCode: 400,
+      message: "Validation failed",
+      error: {
+        code: "VALIDATION_ERROR",
+        details: formattedErrors
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+    this.logger.warn(`[${requestId}] Validation error:`, {
+      method: request.method,
+      url: request.url,
+      errors: formattedErrors
+    });
+    response.status(400).json(errorResponse);
+  }
+  /**
+   * Format validation errors from class-validator
+   */
+  formatValidationErrors(errors) {
+    const messages = [];
+    if (Array.isArray(errors)) {
+      errors.forEach((error) => {
+        if (typeof error === "string") {
+          messages.push(error);
+        } else if (error?.constraints) {
+          messages.push(...Object.values(error.constraints));
+        }
+      });
+    }
+    return messages;
+  }
+};
+__name(ValidationExceptionFilter, "ValidationExceptionFilter");
+ValidationExceptionFilter = __decorateClass([
+  Catch(BadRequestException)
+], ValidationExceptionFilter);
+var HttpExceptionFilter = class {
+  logger = new Logger(HttpExceptionFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const requestId = request.headers["x-request-id"];
+    const statusCode = exception.getStatus();
+    const exceptionResponse = exception.getResponse();
+    const message = typeof exceptionResponse === "string" ? exceptionResponse : exceptionResponse.message || exception.message;
+    const errorCode = this.getErrorCode(exception, statusCode);
+    const errorResponse = {
+      success: false,
+      statusCode,
+      message,
+      error: {
+        code: errorCode,
+        details: exceptionResponse.error || exceptionResponse.errors
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+    const logContext = {
+      statusCode,
+      message,
+      method: request.method,
+      url: request.url,
+      ip: request.ip
+    };
+    if (statusCode >= 500) {
+      this.logger.error(`[${requestId}] ${errorCode}:`, logContext);
+    } else if (statusCode >= 400) {
+      this.logger.warn(`[${requestId}] ${errorCode}:`, logContext);
+    }
+    response.status(statusCode).json(errorResponse);
+  }
+  /**
+   * Get error code from exception type
+   */
+  getErrorCode(exception, statusCode) {
+    const exceptionName = exception.constructor.name;
+    const errorCodeMap = {
+      400: "BAD_REQUEST",
+      401: "UNAUTHORIZED",
+      403: "FORBIDDEN",
+      404: "NOT_FOUND",
+      409: "CONFLICT",
+      422: "UNPROCESSABLE_ENTITY",
+      429: "TOO_MANY_REQUESTS",
+      500: "INTERNAL_SERVER_ERROR",
+      502: "BAD_GATEWAY",
+      503: "SERVICE_UNAVAILABLE"
+    };
+    return errorCodeMap[statusCode] || exceptionName.replace("Exception", "").toUpperCase();
+  }
+};
+__name(HttpExceptionFilter, "HttpExceptionFilter");
+HttpExceptionFilter = __decorateClass([
+  Catch(HttpException)
+], HttpExceptionFilter);
+var DatabaseExceptionFilter = class {
+  logger = new Logger(DatabaseExceptionFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const requestId = request.headers["x-request-id"];
+    if (!this.isDatabaseError(exception)) {
+      throw exception;
+    }
+    const { statusCode, message, errorCode } = this.parseError(exception);
+    const errorResponse = {
+      success: false,
+      statusCode,
+      message,
+      error: {
+        code: errorCode
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+    this.logger.error(`[${requestId}] Database error:`, {
+      statusCode,
+      message,
+      errorCode,
+      method: request.method,
+      url: request.url,
+      // Log full error details in development only
+      ...process.env.NODE_ENV !== "production" && { details: exception.message }
+    });
+    response.status(statusCode).json(errorResponse);
+  }
+  /**
+   * Check if exception is a database error
+   */
+  isDatabaseError(exception) {
+    const errorName = exception.constructor.name;
+    const errorMessage = exception.message || "";
+    if (errorName.includes("QueryFailedError") || errorName.includes("EntityNotFound")) {
+      return true;
+    }
+    if (errorName.includes("PrismaClientKnownRequestError") || errorName.includes("PrismaClientValidationError")) {
+      return true;
+    }
+    if (errorMessage.includes("UNIQUE constraint failed") || errorMessage.includes("Foreign key constraint") || errorMessage.includes("Duplicate entry") || errorMessage.includes("violates unique constraint")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Parse database error and return user-friendly message
+   */
+  parseError(exception) {
+    const errorMessage = exception.message || "";
+    const errorCode = exception.code || "DATABASE_ERROR";
+    if (errorMessage.includes("UNIQUE constraint failed") || errorMessage.includes("Duplicate entry") || errorMessage.includes("violates unique constraint") || errorCode === "P2002") {
+      return {
+        statusCode: 409,
+        message: "This record already exists",
+        errorCode: "DUPLICATE_ENTRY"
+      };
+    }
+    if (errorMessage.includes("Foreign key constraint") || errorMessage.includes("FOREIGN KEY constraint failed") || errorCode === "P2003") {
+      return {
+        statusCode: 400,
+        message: "Invalid reference to related record",
+        errorCode: "INVALID_REFERENCE"
+      };
+    }
+    if (errorMessage.includes("No entity found") || errorCode === "P2025") {
+      return {
+        statusCode: 404,
+        message: "Record not found",
+        errorCode: "NOT_FOUND"
+      };
+    }
+    if (errorMessage.includes("Validation failed") || errorCode === "P2007") {
+      return {
+        statusCode: 400,
+        message: "Invalid data provided",
+        errorCode: "VALIDATION_ERROR"
+      };
+    }
+    return {
+      statusCode: 500,
+      message: "Database operation failed",
+      errorCode: "DATABASE_ERROR"
+    };
+  }
+};
+__name(DatabaseExceptionFilter, "DatabaseExceptionFilter");
+DatabaseExceptionFilter = __decorateClass([
+  Catch()
+], DatabaseExceptionFilter);
+var AuthExceptionFilter = class {
+  logger = new Logger(AuthExceptionFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const requestId = request.headers["x-request-id"];
+    const statusCode = exception.getStatus();
+    const exceptionResponse = exception.getResponse();
+    const message = typeof exceptionResponse === "string" ? exceptionResponse : exceptionResponse.message || exception.message;
+    const errorCode = statusCode === 401 ? "UNAUTHORIZED" : "FORBIDDEN";
+    const errorResponse = {
+      success: false,
+      statusCode,
+      message,
+      error: {
+        code: errorCode
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+    this.logger.warn(`[${requestId}] Auth error:`, {
+      statusCode,
+      message,
+      errorCode,
+      method: request.method,
+      url: request.url,
+      ip: request.ip
+    });
+    response.status(statusCode).json(errorResponse);
+  }
+};
+__name(AuthExceptionFilter, "AuthExceptionFilter");
+AuthExceptionFilter = __decorateClass([
+  Catch(UnauthorizedException, ForbiddenException)
+], AuthExceptionFilter);
+var SKIP_RESPONSE_WRAPPER = "SKIP_RESPONSE_WRAPPER";
+var SkipResponseWrapper = /* @__PURE__ */ __name(() => SetMetadata(SKIP_RESPONSE_WRAPPER, true), "SkipResponseWrapper");
+var RESPONSE_MESSAGE = "RESPONSE_MESSAGE";
+var ResponseMessage = /* @__PURE__ */ __name((message) => SetMetadata(RESPONSE_MESSAGE, message), "ResponseMessage");
+var responseContext = new AsyncLocalStorage();
+
+// src/interceptors/response.interceptor.ts
+var ResponseInterceptor = class {
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  reflector;
+  intercept(context, next) {
+    const skip = this.reflector.getAllAndOverride(SKIP_RESPONSE_WRAPPER, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (skip) return next.handle();
+    const customMessage = this.reflector.getAllAndOverride(RESPONSE_MESSAGE, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    return next.handle().pipe(
+      map((data) => {
+        const response = context.switchToHttp().getResponse();
+        if (response.headersSent) return data;
+        if (data && typeof data === "object" && "success" in data && "statusCode" in data) {
+          return data;
+        }
+        const requestId = context.switchToHttp().getRequest().headers["x-request-id"] ?? responseContext.getStore()?.requestId;
+        return ResponseBuilder.success(data, customMessage ?? "Success", response.statusCode, requestId);
+      })
+    );
+  }
+};
+__name(ResponseInterceptor, "ResponseInterceptor");
+ResponseInterceptor = __decorateClass([
+  Injectable()
+], ResponseInterceptor);
+var RequestContextInterceptor = class {
+  intercept(context, next) {
+    const request = context.switchToHttp().getRequest();
+    const requestId = request.headers["x-request-id"] ?? randomUUID();
+    return responseContext.run(
+      { requestId, path: request.path, method: request.method },
+      () => next.handle()
+    );
+  }
+};
+__name(RequestContextInterceptor, "RequestContextInterceptor");
+RequestContextInterceptor = __decorateClass([
+  Injectable()
+], RequestContextInterceptor);
+var PaginatedQueryDto = class {
+  static {
+    __name(this, "PaginatedQueryDto");
+  }
+  page = 1;
+  limit = 20;
+};
+__decorateClass([
+  IsOptional(),
+  Type(() => Number),
+  IsInt(),
+  Min(1)
+], PaginatedQueryDto.prototype, "page", 2);
+__decorateClass([
+  IsOptional(),
+  Type(() => Number),
+  IsInt(),
+  Min(1),
+  Max(100)
+], PaginatedQueryDto.prototype, "limit", 2);
+var CursorPaginatedQueryDto = class {
+  static {
+    __name(this, "CursorPaginatedQueryDto");
+  }
+  cursor;
+  limit = 20;
+};
+__decorateClass([
+  IsOptional(),
+  IsString()
+], CursorPaginatedQueryDto.prototype, "cursor", 2);
+__decorateClass([
+  IsOptional(),
+  Type(() => Number),
+  IsInt(),
+  Min(1),
+  Max(100)
+], CursorPaginatedQueryDto.prototype, "limit", 2);
+var ApiResponseEnvelope = /* @__PURE__ */ __name((model) => applyDecorators(
+  ApiExtraModels(model),
+  ApiOkResponse({
+    schema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        statusCode: { type: "number" },
+        message: { type: "string" },
+        data: { $ref: getSchemaPath(model) },
+        error: {
+          type: "object",
+          properties: {
+            code: { type: "string" },
+            details: { type: "string" }
+          }
+        },
+        timestamp: { type: "string", format: "date-time" },
+        requestId: { type: "string" }
+      }
+    }
+  })
+), "ApiResponseEnvelope");
+
+// src/validation/validation-formatter.ts
+function formatValidationErrors(errors) {
+  return errors.map((error) => {
+    const formatted = {
+      field: error.property,
+      constraints: error.constraints ? Object.values(error.constraints) : []
+    };
+    if (error.children?.length) {
+      formatted.children = formatValidationErrors(error.children);
+    }
+    return formatted;
+  });
+}
+__name(formatValidationErrors, "formatValidationErrors");
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+var ERROR_VIEWS_DIR = join(__dirname$1, "views");
+var FILTER_MAP = {
+  GLOBAL: { provide: APP_FILTER, useClass: GlobalExceptionFilter },
+  VALIDATION: { provide: APP_FILTER, useClass: ValidationExceptionFilter },
+  HTTP: { provide: APP_FILTER, useClass: HttpExceptionFilter },
+  DATABASE: { provide: APP_FILTER, useClass: DatabaseExceptionFilter },
+  AUTH: { provide: APP_FILTER, useClass: AuthExceptionFilter }
+};
+var ResponseModule = class {
+  static forRoot(options) {
+    const providers = [];
+    const filterKeys = options?.filters ?? Object.keys(FILTER_MAP);
+    for (const key of filterKeys) {
+      providers.push(FILTER_MAP[key]);
+    }
+    if (options?.enableRequestContext) {
+      providers.push({
+        provide: APP_INTERCEPTOR,
+        useClass: RequestContextInterceptor
+      });
+    }
+    if (options?.enableResponseWrapper) {
+      providers.push({
+        provide: APP_INTERCEPTOR,
+        useClass: ResponseInterceptor
+      });
+    }
+    return {
+      module: ResponseModule,
+      providers
+    };
+  }
+};
+__name(ResponseModule, "ResponseModule");
+ResponseModule = __decorateClass([
+  Module({})
+], ResponseModule);
+
+export { ApiResponseEnvelope, AuthExceptionFilter, CursorPaginatedQueryDto, DatabaseExceptionFilter, ERROR_VIEWS_DIR, GlobalExceptionFilter, HTTP_STATUS, HttpExceptionFilter, PaginatedQueryDto, RESPONSE_FILTERS, RESPONSE_MESSAGE, RESPONSE_MESSAGES, RequestContextInterceptor, ResponseBuilder, ResponseInterceptor, ResponseMessage, ResponseModule, SKIP_RESPONSE_WRAPPER, SkipResponseWrapper, ValidationExceptionFilter, formatValidationErrors, responseContext };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map