@ai-growth/n8n-nodes-wordpress
Version:
n8n node for WordPress integration with AI GROWTH - SEO WP plugin
423 lines • 20.9 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ErrorUtils = exports.WordPressError = exports.WordPressErrorType = void 0;
const axios_1 = __importDefault(require("axios"));
/**
* Tipo de erro da API WordPress
*/
var WordPressErrorType;
(function (WordPressErrorType) {
WordPressErrorType["AUTHENTICATION"] = "authentication";
WordPressErrorType["PERMISSION"] = "permission";
WordPressErrorType["NOT_FOUND"] = "not_found";
WordPressErrorType["VALIDATION"] = "validation";
WordPressErrorType["VALIDATION_FAILED"] = "validation_failed";
WordPressErrorType["SERVER"] = "server";
WordPressErrorType["NETWORK"] = "network";
WordPressErrorType["TIMEOUT"] = "timeout";
WordPressErrorType["ROUTE_NOT_FOUND"] = "route_not_found";
WordPressErrorType["API_VERSION_MISMATCH"] = "api_version_mismatch";
WordPressErrorType["UNKNOWN"] = "unknown";
})(WordPressErrorType || (exports.WordPressErrorType = WordPressErrorType = {}));
/**
* Erro específico da API WordPress
*/
class WordPressError extends Error {
constructor(message, type = WordPressErrorType.UNKNOWN, statusCode, originalError) {
super(message);
this.name = 'WordPressError';
this.type = type;
this.statusCode = statusCode;
this.originalError = originalError;
}
/**
* Verifica se o erro é retentável
* @returns Verdadeiro se o erro pode ser tentado novamente
*/
isRetryable() {
// Erros de rede e servidor geralmente são retentáveis
return this.type === WordPressErrorType.NETWORK
|| this.type === WordPressErrorType.SERVER
|| this.type === WordPressErrorType.TIMEOUT;
}
/**
* Cria uma representação legível do erro
* @returns Objeto com informações sobre o erro
*/
toJSON() {
return {
name: this.name,
message: this.message,
type: this.type,
statusCode: this.statusCode,
stack: this.stack,
};
}
}
exports.WordPressError = WordPressError;
/**
* Classe utilitária para lidar com erros
*/
class ErrorUtils {
/**
* Detecta se o erro é relacionado a rota não encontrada em português
* @param errorMessage Mensagem de erro
* @returns True se for um erro de rota não encontrada
*/
static isPortugueseRouteError(errorMessage) {
const portugueseRoutePatterns = [
/nenhuma rota foi encontrada/i,
/rota.*não.*encontrada/i,
/endpoint.*não.*existe/i,
/caminho.*não.*encontrado/i,
/url.*não.*corresponde/i,
/método.*requisição.*não.*suportado/i,
];
return portugueseRoutePatterns.some(pattern => pattern.test(errorMessage));
}
/**
* Detecta se o erro é relacionado a parâmetros inválidos em português
* @param errorMessage Mensagem de erro
* @returns True se for um erro de parâmetros inválidos
*/
static isPortugueseParameterError(errorMessage) {
const portugueseParameterPatterns = [
/parâmetro.*inválido/i,
/parâmetros.*inválidos/i,
/parâmetro.*não.*válido/i,
/parâmetros.*não.*válidos/i,
/valor.*inválido.*para.*parâmetro/i,
/formato.*inválido.*para.*parâmetro/i,
];
return portugueseParameterPatterns.some(pattern => pattern.test(errorMessage));
}
/**
* Detecta se o erro é relacionado a parâmetros de taxonomia (categories/tags) em GET requests
* @param errorMessage Mensagem de erro
* @returns True se for um erro de parâmetros de taxonomia em GET
*/
static isGetTaxonomyParameterError(errorMessage) {
const taxonomyParameterPatterns = [
/parâmetro.*inválido.*categor/i,
/parâmetros.*inválidos.*categor/i,
/parâmetro.*inválido.*tags?/i,
/parâmetros.*inválidos.*tags?/i,
/invalid.*parameter.*categor/i,
/invalid.*parameter.*tags?/i,
/parâmetro\(s\).*inválido\(s\).*categor/i,
/parâmetro\(s\).*inválido\(s\).*tags?/i,
];
return taxonomyParameterPatterns.some(pattern => pattern.test(errorMessage));
}
/**
* Detecta se o erro é relacionado a problemas de API REST
* @param errorMessage Mensagem de erro
* @returns True se for um erro de API REST
*/
static isRestApiError(errorMessage) {
const restApiPatterns = [
/rest_no_route/i,
/rest_invalid_endpoint/i,
/rest_route_not_found/i,
/no route was found/i,
/invalid endpoint/i,
/route.*not.*found/i,
];
return restApiPatterns.some(pattern => pattern.test(errorMessage));
}
/**
* Gera sugestões para problemas comuns da API REST do WordPress
* @param endpoint Endpoint que causou o erro
* @param method Método HTTP usado
* @returns Array de sugestões
*/
static generateRestApiSuggestions(endpoint, method) {
const suggestions = [];
suggestions.push('Verify that the WordPress REST API is enabled on your site');
suggestions.push('Check if the endpoint URL is correct and follows the WordPress REST API format');
if (endpoint) {
suggestions.push(`Verify that the endpoint '${endpoint}' exists in your WordPress installation`);
// Sugestões específicas baseadas no endpoint
if (endpoint.includes('/posts/')) {
suggestions.push('Make sure the post ID exists and you have permission to access it');
}
else if (endpoint.includes('/pages/')) {
suggestions.push('Make sure the page ID exists and you have permission to access it');
}
else if (endpoint.includes('/categories/') || endpoint.includes('/tags/')) {
suggestions.push('Verify that the taxonomy term exists and is accessible');
}
else if (endpoint.includes('/media/')) {
suggestions.push('Check if the media file exists and you have permission to access it');
}
}
if (method) {
suggestions.push(`Confirm that the HTTP method '${method}' is supported for this endpoint`);
}
suggestions.push('Try using a different API version (v1, v2) if available');
suggestions.push('Check WordPress and plugin versions for compatibility issues');
suggestions.push('Verify that required plugins are active and properly configured');
return suggestions;
}
/**
* Gera sugestões para problemas de parâmetros inválidos
* @param errorMessage Mensagem de erro original
* @param endpoint Endpoint que causou o erro
* @returns Array de sugestões
*/
static generateParameterErrorSuggestions(errorMessage, endpoint) {
const suggestions = [];
// Detectar se o erro menciona categorias ou tags
const mentionsCategories = /categor/i.test(errorMessage);
const mentionsTags = /tags?/i.test(errorMessage);
const isGetTaxonomyError = this.isGetTaxonomyParameterError(errorMessage);
if (isGetTaxonomyError || mentionsCategories || mentionsTags) {
if (isGetTaxonomyError) {
suggestions.push('This WordPress installation does not support categories/tags parameters in GET requests');
suggestions.push('The system will automatically retry without these parameters and filter results client-side');
suggestions.push('This is a compatibility issue with some WordPress configurations or plugins');
suggestions.push('No action is required - the request will be handled automatically with fallback filtering');
}
else {
suggestions.push('Categories and tags must be provided as numeric IDs when sent to WordPress API');
suggestions.push('If using category/tag names, ensure they exist in WordPress or will be created automatically');
suggestions.push('Check that category/tag IDs are positive integers (e.g., 1, 2, 3)');
suggestions.push('Verify that the categories/tags exist in your WordPress installation');
}
if (mentionsCategories) {
suggestions.push('For categories: Use existing category IDs or names that can be converted to IDs');
}
if (mentionsTags) {
suggestions.push('For tags: Use existing tag IDs or names that can be converted to IDs');
}
}
else {
suggestions.push('Check that all parameter values are in the correct format');
suggestions.push('Verify that numeric parameters contain only valid numbers');
suggestions.push('Ensure required parameters are provided and not empty');
suggestions.push('Check parameter names match the WordPress REST API specification');
}
if (endpoint) {
if (endpoint.includes('/posts')) {
if (isGetTaxonomyError) {
suggestions.push('For posts: The system will fetch all posts and filter by categories/tags locally');
}
else {
suggestions.push('For posts: Ensure categories and tags are valid WordPress taxonomy terms');
}
}
else if (endpoint.includes('/pages')) {
suggestions.push('For pages: Check if your WordPress installation supports categories/tags on pages');
}
}
if (!isGetTaxonomyError) {
suggestions.push('Review the WordPress REST API documentation for parameter requirements');
}
return suggestions;
}
/**
* Cria uma mensagem de erro amigável para problemas de rota
* @param originalMessage Mensagem original do erro
* @param endpoint Endpoint que causou o erro
* @param method Método HTTP usado
* @returns Mensagem de erro melhorada
*/
static createRouteErrorMessage(originalMessage, endpoint, method) {
const isPortuguese = this.isPortugueseRouteError(originalMessage);
let baseMessage;
if (isPortuguese) {
baseMessage = 'Rota da API REST do WordPress não encontrada';
}
else {
baseMessage = 'WordPress REST API route not found';
}
if (endpoint) {
if (isPortuguese) {
baseMessage += ` para o endpoint '${endpoint}'`;
}
else {
baseMessage += ` for endpoint '${endpoint}'`;
}
}
if (method) {
if (isPortuguese) {
baseMessage += ` usando o método ${method}`;
}
else {
baseMessage += ` using method ${method}`;
}
}
const suggestions = this.generateRestApiSuggestions(endpoint, method);
const suggestionText = isPortuguese
? '\n\nSugestões para resolver o problema:'
: '\n\nSuggestions to resolve the issue:';
return `${baseMessage}.${suggestionText}\n• ${suggestions.join('\n• ')}`;
}
/**
* Cria uma mensagem de erro amigável para problemas de parâmetros
* @param originalMessage Mensagem original do erro
* @param endpoint Endpoint que causou o erro
* @returns Mensagem de erro melhorada
*/
static createParameterErrorMessage(originalMessage, endpoint) {
const isPortuguese = this.isPortugueseParameterError(originalMessage);
let baseMessage;
if (isPortuguese) {
baseMessage = 'Parâmetros inválidos enviados para a API WordPress';
}
else {
baseMessage = 'Invalid parameters sent to WordPress API';
}
if (endpoint) {
if (isPortuguese) {
baseMessage += ` no endpoint '${endpoint}'`;
}
else {
baseMessage += ` for endpoint '${endpoint}'`;
}
}
const suggestions = this.generateParameterErrorSuggestions(originalMessage, endpoint);
const suggestionText = isPortuguese
? '\n\nSugestões para resolver o problema:'
: '\n\nSuggestions to resolve the issue:';
return `${baseMessage}.\n\nOriginal error: ${originalMessage}${suggestionText}\n• ${suggestions.join('\n• ')}`;
}
/**
* Converte um erro do Axios em um WordPressError
* @param error Erro do Axios
* @returns Erro da API WordPress
*/
static fromAxiosError(error) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
if (error.response) {
// Erro com resposta do servidor
const status = error.response.status;
// Extrair mensagem de erro da resposta, se disponível
let errorMessage = 'WordPress API error';
if (error.response.data && typeof error.response.data === 'object') {
if ('message' in error.response.data) {
errorMessage = error.response.data.message || errorMessage;
}
else if ('error' in error.response.data) {
errorMessage = error.response.data.error || errorMessage;
}
}
// Detectar diferentes tipos de erro
const isRouteError = this.isPortugueseRouteError(errorMessage) || this.isRestApiError(errorMessage);
const isParameterError = this.isPortugueseParameterError(errorMessage) ||
/invalid.*parameter/i.test(errorMessage) ||
/rest_invalid_param/i.test(errorMessage);
const isGetTaxonomyError = this.isGetTaxonomyParameterError(errorMessage);
const endpoint = (_a = error.config) === null || _a === void 0 ? void 0 : _a.url;
const method = (_c = (_b = error.config) === null || _b === void 0 ? void 0 : _b.method) === null || _c === void 0 ? void 0 : _c.toUpperCase();
if (status === 401) {
return new WordPressError('Authentication failed: Invalid username or password', WordPressErrorType.AUTHENTICATION, status, error);
}
else if (status === 403) {
return new WordPressError('Permission denied: Insufficient privileges', WordPressErrorType.PERMISSION, status, error);
}
else if (status === 404) {
// Verificar se é um erro de rota não encontrada
if (isRouteError) {
const enhancedMessage = this.createRouteErrorMessage(errorMessage, endpoint, method);
return new WordPressError(enhancedMessage, WordPressErrorType.ROUTE_NOT_FOUND, status, error);
}
// Extrair informações mais específicas sobre o recurso não encontrado
let specificMessage = 'Resource not found';
// Tentar extrair informações da URL da requisição
if ((_d = error.config) === null || _d === void 0 ? void 0 : _d.url) {
const url = error.config.url;
if (url.includes('/posts/')) {
const postId = (_e = url.match(/\/posts\/(\d+)/)) === null || _e === void 0 ? void 0 : _e[1];
specificMessage = postId ? `Post with ID ${postId} not found` : 'Post not found';
}
else if (url.includes('/pages/')) {
const pageId = (_f = url.match(/\/pages\/(\d+)/)) === null || _f === void 0 ? void 0 : _f[1];
specificMessage = pageId ? `Page with ID ${pageId} not found` : 'Page not found';
}
else if (url.includes('/categories/')) {
const categoryId = (_g = url.match(/\/categories\/(\d+)/)) === null || _g === void 0 ? void 0 : _g[1];
specificMessage = categoryId ? `Category with ID ${categoryId} not found` : 'Category not found';
}
else if (url.includes('/tags/')) {
const tagId = (_h = url.match(/\/tags\/(\d+)/)) === null || _h === void 0 ? void 0 : _h[1];
specificMessage = tagId ? `Tag with ID ${tagId} not found` : 'Tag not found';
}
else if (url.includes('/media/')) {
const mediaId = (_j = url.match(/\/media\/(\d+)/)) === null || _j === void 0 ? void 0 : _j[1];
specificMessage = mediaId ? `Media with ID ${mediaId} not found` : 'Media not found';
}
else if (url.includes('/users/')) {
const userId = (_k = url.match(/\/users\/(\d+)/)) === null || _k === void 0 ? void 0 : _k[1];
specificMessage = userId ? `User with ID ${userId} not found` : 'User not found';
}
else {
specificMessage = `Resource not found: ${url}`;
}
}
// Verificar se há uma mensagem específica na resposta
if (((_l = error.response) === null || _l === void 0 ? void 0 : _l.data) && typeof error.response.data === 'object') {
if ('message' in error.response.data && error.response.data.message) {
specificMessage = error.response.data.message;
}
else if ('code' in error.response.data && error.response.data.code === 'rest_post_invalid_id') {
specificMessage = 'Invalid post ID provided';
}
else if ('code' in error.response.data && error.response.data.code === 'rest_page_invalid_id') {
specificMessage = 'Invalid page ID provided';
}
}
return new WordPressError(specificMessage, WordPressErrorType.NOT_FOUND, status, error);
}
else if (status >= 400 && status < 500) {
// Verificar se é um erro de rota mesmo com outros códigos 4xx
if (isRouteError) {
const enhancedMessage = this.createRouteErrorMessage(errorMessage, endpoint, method);
return new WordPressError(enhancedMessage, WordPressErrorType.ROUTE_NOT_FOUND, status, error);
}
// Verificar se é um erro de parâmetros inválidos
if (isParameterError || isGetTaxonomyError) {
const enhancedMessage = this.createParameterErrorMessage(errorMessage, endpoint);
// Para erros específicos de taxonomia em GET, usar um tipo mais específico
const errorType = isGetTaxonomyError
? WordPressErrorType.VALIDATION_FAILED
: WordPressErrorType.VALIDATION_FAILED;
return new WordPressError(enhancedMessage, errorType, status, error);
}
return new WordPressError(`Client error: ${errorMessage}`, WordPressErrorType.VALIDATION, status, error);
}
else if (status >= 500) {
return new WordPressError(`Server error: ${errorMessage}`, WordPressErrorType.SERVER, status, error);
}
}
else if (error.request) {
// Requisição feita mas sem resposta
if (error.code === 'ECONNABORTED') {
return new WordPressError('Request timeout: The server took too long to respond', WordPressErrorType.TIMEOUT, undefined, error);
}
return new WordPressError('Network error: Failed to connect to the WordPress server', WordPressErrorType.NETWORK, undefined, error);
}
// Erro genérico
return new WordPressError(error.message || 'Unknown error occurred', WordPressErrorType.UNKNOWN, undefined, error);
}
/**
* Converte um erro genérico em um WordPressError
* @param error Erro genérico
* @returns Erro da API WordPress
*/
static fromError(error) {
if (error instanceof WordPressError) {
return error;
}
// Verificar se é um erro do Axios
if (axios_1.default.isAxiosError(error)) {
return this.fromAxiosError(error);
}
return new WordPressError(error.message || 'Unknown error occurred', WordPressErrorType.UNKNOWN, undefined, error);
}
}
exports.ErrorUtils = ErrorUtils;
//# sourceMappingURL=ErrorUtils.js.map