evolution-api-sdk/lib/api/errors.js

Unofficial SDK for the Evolution Whatsapp API v2

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

// src/api/errors.ts
var errors_exports = {};
__export(errors_exports, {
  EvolutionApiError: () => EvolutionApiError,
  extractErrorMessage: () => extractErrorMessage
});
module.exports = __toCommonJS(errors_exports);
var EvolutionApiError = class _EvolutionApiError extends Error {
  constructor(message, cause, statusCode) {
    const extractedMessage = extractErrorMessage(cause);
    const finalMessage = extractedMessage || message || "Unknown error occurred";
    super(finalMessage);
    __publicField(this, "statusCode");
    __publicField(this, "details");
    this.name = _EvolutionApiError.name;
    this.message = finalMessage;
    this.statusCode = statusCode;
    this.details = cause;
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, _EvolutionApiError);
    }
  }
  /**
   * Returns a user-friendly string representation of the error
   */
  toString() {
    let result = `${this.name}: ${this.message}`;
    if (this.statusCode) {
      result += ` (${this.statusCode})`;
    }
    if (this.details && typeof this.details === "object") {
      const details = this.details;
      const relevantDetails = [];
      if (details.url) {
        relevantDetails.push(`URL: ${details.url}`);
      }
      if (details.method) {
        relevantDetails.push(`Method: ${details.method}`);
      }
      if (details.response && typeof details.response === "object") {
        const response = details.response;
        if (response.error && response.error !== this.message) {
          relevantDetails.push(`Server Error: ${response.error}`);
        }
        if (response.message && response.message !== this.message) {
          relevantDetails.push(`Server Message: ${response.message}`);
        }
      }
      if (relevantDetails.length > 0) {
        result += `
  ${relevantDetails.join("\n  ")}`;
      }
    }
    return result;
  }
  /**
   * Returns a JSON representation suitable for logging
   */
  toJSON() {
    return {
      name: this.name,
      message: this.message,
      statusCode: this.statusCode,
      details: this.details,
      stack: this.stack
    };
  }
};
function extractErrorMessage(response) {
  if (!response) {
    return null;
  }
  if (typeof response === "string") {
    return response;
  }
  if (typeof response === "object" && response !== null) {
    const errorObj = response;
    const messagePaths = [
      // Evolution API specific nested structure (most common)
      errorObj.response?.response?.message?.[0],
      errorObj.response?.response?.error,
      errorObj.response?.response?.description,
      // Evolution API first level nested
      Array.isArray(errorObj.response?.message) ? errorObj.response.message[0] : null,
      errorObj.response?.error,
      errorObj.response?.description,
      // Direct error message
      Array.isArray(errorObj.message) ? errorObj.message[0] : errorObj.message,
      errorObj.error,
      errorObj.description,
      errorObj.detail,
      // Other nested error messages
      errorObj.data?.error,
      errorObj.data?.message,
      // Array format messages (fallback)
      Array.isArray(errorObj.error) ? errorObj.error[0] : null,
      Array.isArray(errorObj.errors) ? errorObj.errors[0] : null
    ];
    for (const path of messagePaths) {
      if (typeof path === "string" && path.trim()) {
        return path.trim();
      }
      if (typeof path === "object" && path !== null) {
        const nestedMessage = extractErrorMessage(path);
        if (nestedMessage) {
          return nestedMessage;
        }
      }
    }
    if (errorObj.validation && Array.isArray(errorObj.validation)) {
      const validationErrors = errorObj.validation.map((v) => v.message || v.error || String(v)).filter(Boolean).join(", ");
      if (validationErrors) {
        return `Validation error: ${validationErrors}`;
      }
    }
    if (errorObj.statusCode && errorObj.statusText) {
      return `${errorObj.statusCode}: ${errorObj.statusText}`;
    }
    if (Object.keys(errorObj).length > 0) {
      try {
        return JSON.stringify(errorObj);
      } catch {
        return "[Complex error object]";
      }
    }
  }
  return null;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  EvolutionApiError,
  extractErrorMessage
});
//# sourceMappingURL=errors.js.map