@myko.pk/response 1.0.0

package/dist/index.cjs

@@ -0,0 +1,899 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var logger = require('@myko.pk/logger');
+var operators = require('rxjs/operators');
+var async_hooks = require('async_hooks');
+var crypto = require('crypto');
+var classValidator = require('class-validator');
+var classTransformer = require('class-transformer');
+var swagger = require('@nestjs/swagger');
+var url = require('url');
+var path = require('path');
+var core = require('@nestjs/core');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+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");
+exports.GlobalExceptionFilter = class GlobalExceptionFilter {
+  logger = new logger.Logger(exports.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 = common.HttpStatus.INTERNAL_SERVER_ERROR;
+    let message = "Internal server error";
+    let errorCode = "INTERNAL_ERROR";
+    let details = void 0;
+    if (exception instanceof common.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 common.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(exports.GlobalExceptionFilter, "GlobalExceptionFilter");
+exports.GlobalExceptionFilter = __decorateClass([
+  common.Catch()
+], exports.GlobalExceptionFilter);
+exports.ValidationExceptionFilter = class ValidationExceptionFilter {
+  logger = new logger.Logger(exports.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(exports.ValidationExceptionFilter, "ValidationExceptionFilter");
+exports.ValidationExceptionFilter = __decorateClass([
+  common.Catch(common.BadRequestException)
+], exports.ValidationExceptionFilter);
+exports.HttpExceptionFilter = class HttpExceptionFilter {
+  logger = new logger.Logger(exports.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(exports.HttpExceptionFilter, "HttpExceptionFilter");
+exports.HttpExceptionFilter = __decorateClass([
+  common.Catch(common.HttpException)
+], exports.HttpExceptionFilter);
+exports.DatabaseExceptionFilter = class DatabaseExceptionFilter {
+  logger = new logger.Logger(exports.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(exports.DatabaseExceptionFilter, "DatabaseExceptionFilter");
+exports.DatabaseExceptionFilter = __decorateClass([
+  common.Catch()
+], exports.DatabaseExceptionFilter);
+exports.AuthExceptionFilter = class AuthExceptionFilter {
+  logger = new logger.Logger(exports.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(exports.AuthExceptionFilter, "AuthExceptionFilter");
+exports.AuthExceptionFilter = __decorateClass([
+  common.Catch(common.UnauthorizedException, common.ForbiddenException)
+], exports.AuthExceptionFilter);
+var SKIP_RESPONSE_WRAPPER = "SKIP_RESPONSE_WRAPPER";
+var SkipResponseWrapper = /* @__PURE__ */ __name(() => common.SetMetadata(SKIP_RESPONSE_WRAPPER, true), "SkipResponseWrapper");
+var RESPONSE_MESSAGE = "RESPONSE_MESSAGE";
+var ResponseMessage = /* @__PURE__ */ __name((message) => common.SetMetadata(RESPONSE_MESSAGE, message), "ResponseMessage");
+var responseContext = new async_hooks.AsyncLocalStorage();
+
+// src/interceptors/response.interceptor.ts
+exports.ResponseInterceptor = class ResponseInterceptor {
+  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(
+      operators.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(exports.ResponseInterceptor, "ResponseInterceptor");
+exports.ResponseInterceptor = __decorateClass([
+  common.Injectable()
+], exports.ResponseInterceptor);
+exports.RequestContextInterceptor = class RequestContextInterceptor {
+  intercept(context, next) {
+    const request = context.switchToHttp().getRequest();
+    const requestId = request.headers["x-request-id"] ?? crypto.randomUUID();
+    return responseContext.run(
+      { requestId, path: request.path, method: request.method },
+      () => next.handle()
+    );
+  }
+};
+__name(exports.RequestContextInterceptor, "RequestContextInterceptor");
+exports.RequestContextInterceptor = __decorateClass([
+  common.Injectable()
+], exports.RequestContextInterceptor);
+var PaginatedQueryDto = class {
+  static {
+    __name(this, "PaginatedQueryDto");
+  }
+  page = 1;
+  limit = 20;
+};
+__decorateClass([
+  classValidator.IsOptional(),
+  classTransformer.Type(() => Number),
+  classValidator.IsInt(),
+  classValidator.Min(1)
+], PaginatedQueryDto.prototype, "page", 2);
+__decorateClass([
+  classValidator.IsOptional(),
+  classTransformer.Type(() => Number),
+  classValidator.IsInt(),
+  classValidator.Min(1),
+  classValidator.Max(100)
+], PaginatedQueryDto.prototype, "limit", 2);
+var CursorPaginatedQueryDto = class {
+  static {
+    __name(this, "CursorPaginatedQueryDto");
+  }
+  cursor;
+  limit = 20;
+};
+__decorateClass([
+  classValidator.IsOptional(),
+  classValidator.IsString()
+], CursorPaginatedQueryDto.prototype, "cursor", 2);
+__decorateClass([
+  classValidator.IsOptional(),
+  classTransformer.Type(() => Number),
+  classValidator.IsInt(),
+  classValidator.Min(1),
+  classValidator.Max(100)
+], CursorPaginatedQueryDto.prototype, "limit", 2);
+var ApiResponseEnvelope = /* @__PURE__ */ __name((model) => common.applyDecorators(
+  swagger.ApiExtraModels(model),
+  swagger.ApiOkResponse({
+    schema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        statusCode: { type: "number" },
+        message: { type: "string" },
+        data: { $ref: swagger.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 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+var __dirname$1 = path.dirname(__filename$1);
+var ERROR_VIEWS_DIR = path.join(__dirname$1, "views");
+var FILTER_MAP = {
+  GLOBAL: { provide: core.APP_FILTER, useClass: exports.GlobalExceptionFilter },
+  VALIDATION: { provide: core.APP_FILTER, useClass: exports.ValidationExceptionFilter },
+  HTTP: { provide: core.APP_FILTER, useClass: exports.HttpExceptionFilter },
+  DATABASE: { provide: core.APP_FILTER, useClass: exports.DatabaseExceptionFilter },
+  AUTH: { provide: core.APP_FILTER, useClass: exports.AuthExceptionFilter }
+};
+exports.ResponseModule = class ResponseModule {
+  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: core.APP_INTERCEPTOR,
+        useClass: exports.RequestContextInterceptor
+      });
+    }
+    if (options?.enableResponseWrapper) {
+      providers.push({
+        provide: core.APP_INTERCEPTOR,
+        useClass: exports.ResponseInterceptor
+      });
+    }
+    return {
+      module: exports.ResponseModule,
+      providers
+    };
+  }
+};
+__name(exports.ResponseModule, "ResponseModule");
+exports.ResponseModule = __decorateClass([
+  common.Module({})
+], exports.ResponseModule);
+
+exports.ApiResponseEnvelope = ApiResponseEnvelope;
+exports.CursorPaginatedQueryDto = CursorPaginatedQueryDto;
+exports.ERROR_VIEWS_DIR = ERROR_VIEWS_DIR;
+exports.HTTP_STATUS = HTTP_STATUS;
+exports.PaginatedQueryDto = PaginatedQueryDto;
+exports.RESPONSE_FILTERS = RESPONSE_FILTERS;
+exports.RESPONSE_MESSAGE = RESPONSE_MESSAGE;
+exports.RESPONSE_MESSAGES = RESPONSE_MESSAGES;
+exports.ResponseBuilder = ResponseBuilder;
+exports.ResponseMessage = ResponseMessage;
+exports.SKIP_RESPONSE_WRAPPER = SKIP_RESPONSE_WRAPPER;
+exports.SkipResponseWrapper = SkipResponseWrapper;
+exports.formatValidationErrors = formatValidationErrors;
+exports.responseContext = responseContext;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map