n8n-nodes-mercadopago-pix-assinatura 1.0.1 → 1.0.3

package/README.md

@@ -6,6 +6,7 @@
 Node customizado do n8n para processamento de pagamentos via Mercado Pago, com suporte completo a:
 
 - 💰 **Pagamentos PIX** (criação, consulta, reembolso)
+- 📋 **Planos** (criar, consultar, listar, atualizar)
 - 🔄 **Assinaturas** (criar, pausar, retomar, cancelar, consultar, listar)
 - 📅 **Pagamentos Recorrentes** (gerenciamento completo)
 - 🔔 **Webhooks** (registro, listagem, exclusão, consulta)
@@ -21,22 +22,26 @@ Node customizado do n8n para processamento de pagamentos via Mercado Pago, com s
 ### Instalação Local (Desenvolvimento)
 
 1. Clone o repositório:
+
 ```bash
 git clone https://github.com/eliveutonsouza/n8n-nodes-mercadopago-pix-assinatura.git
 cd n8n-nodes-mercadopago-pix-assinatura
 ```
 
 2. Instale as dependências:
+
 ```bash
 npm install
 ```
 
 3. Compile o projeto:
+
 ```bash
 npm run build
 ```
 
 4. Para desenvolvimento com watch mode:
+
 ```bash
 npm run dev
 ```
@@ -46,11 +51,13 @@ npm run dev
 **Recomendado**: Instale via npm para facilitar atualizações.
 
 1. No diretório do seu n8n self-hosted, instale o pacote:
+
 ```bash
 npm install n8n-nodes-mercadopago-pix-assinatura
 ```
 
 2. Reinicie o n8n:
+
 ```bash
 # Se estiver usando Docker
 docker restart n8n
@@ -88,11 +95,13 @@ docker restart n8n
 Cria um novo pagamento PIX e retorna o QR Code para pagamento.
 
 **Campos obrigatórios:**
+
 - Valor (em reais, ex: 10.50)
 - Descrição
 - E-mail do Pagador
 
 **Campos opcionais:**
+
 - CPF/CNPJ do Pagador
 - Nome do Pagador
 - Data de Expiração
@@ -100,6 +109,7 @@ Cria um novo pagamento PIX e retorna o QR Code para pagamento.
 - Chave de Idempotência
 
 **Resposta:**
+
 ```json
 {
   "id": "123456789",
@@ -120,9 +130,11 @@ Cria um novo pagamento PIX e retorna o QR Code para pagamento.
 Consulta o status de um pagamento PIX existente.
 
 **Campos obrigatórios:**
+
 - ID do Pagamento
 
 **Resposta:**
+
 ```json
 {
   "id": "123456789",
@@ -139,9 +151,11 @@ Consulta o status de um pagamento PIX existente.
 Reembolsa total ou parcialmente um pagamento PIX.
 
 **Campos obrigatórios:**
+
 - ID do Pagamento
 
 **Campos opcionais:**
+
 - Valor do Reembolso (deixe vazio para reembolso total)
 
 ### Assinaturas - Criar
@@ -149,10 +163,12 @@ Reembolsa total ou parcialmente um pagamento PIX.
 Cria uma nova assinatura baseada em um plano existente.
 
 **Campos obrigatórios:**
+
 - ID do Plano
 - E-mail do Pagador
 
 **Campos opcionais:**
+
 - CPF/CNPJ do Pagador
 - Data de Início
 - Período de Trial (dias)
@@ -162,6 +178,7 @@ Cria uma nova assinatura baseada em um plano existente.
 Gerencia o status de uma assinatura existente.
 
 **Campos obrigatórios:**
+
 - ID da Assinatura
 
 ### Assinaturas - Consultar/Listar
@@ -173,6 +190,7 @@ Consulta uma assinatura específica ou lista todas as assinaturas.
 Gerencia pagamentos recorrentes com histórico e próxima cobrança.
 
 **Operações disponíveis:**
+
 - Criar
 - Listar
 - Cancelar
@@ -183,13 +201,16 @@ Gerencia pagamentos recorrentes com histórico e próxima cobrança.
 Registra um novo webhook para receber notificações de eventos.
 
 **Campos obrigatórios:**
+
 - URL (deve ser acessível publicamente)
 
 **Campos opcionais:**
+
 - Eventos (payment, subscription)
 - Descrição
 
 **Eventos disponíveis:**
+
 - `payment` - Notificações de pagamentos
 - `subscription` - Notificações de assinaturas
 
@@ -211,6 +232,7 @@ Para testar localmente:
 
 1. Configure credenciais sandbox do Mercado Pago
 2. Execute o n8n em modo desenvolvimento:
+
 ```bash
 npm run dev
 ```
@@ -226,10 +248,12 @@ Todas as respostas seguem um formato padronizado:
 {
   "id": "string",
   "status": "string",
-  "amount": 0.00,
+  "amount": 0.0,
   "currency": "BRL",
   "createdAt": "ISO8601",
-  "raw": { /* Dados completos da API */ }
+  "raw": {
+    /* Dados completos da API */
+  }
 }
 ```
 
@@ -238,22 +262,27 @@ O campo `raw` contém a resposta completa da API do Mercado Pago para acesso a t
 ## 🐛 Troubleshooting
 
 ### Erro: "Credenciais não encontradas"
+
 - Verifique se as credenciais foram configuradas corretamente no n8n
 - Certifique-se de que o Access Token está válido
 
 ### Erro: "E-mail do pagador inválido"
+
 - Verifique o formato do e-mail (deve conter @ e domínio válido)
 
 ### Erro: "CPF/CNPJ inválido"
+
 - CPF deve conter 11 dígitos numéricos
 - CNPJ deve conter 14 dígitos numéricos
 - Caracteres especiais são removidos automaticamente
 
 ### Erro: "Valor do pagamento deve ser maior que zero"
+
 - Verifique se o valor está correto
 - Valores são convertidos automaticamente para centavos
 
 ### Webhook não recebe notificações
+
 - Verifique se a URL é acessível publicamente
 - Certifique-se de que o servidor está rodando e acessível
 - Verifique os logs do Mercado Pago no painel de desenvolvedores
@@ -290,4 +319,3 @@ Eliveuton Souza - eliveuton3m@hotmail.com
 
 - Equipe do n8n pela excelente plataforma
 - Mercado Pago pela API robusta e documentação completa
-

package/dist/nodes/PixPayment/PixPayment.node.d.ts

@@ -6,6 +6,11 @@ export declare class PixPayment implements INodeType {
     private static createPixPayment;
     private static getPixPayment;
     private static refundPixPayment;
+    private static handlePlanOperation;
+    private static createPlan;
+    private static getPlan;
+    private static listPlans;
+    private static updatePlan;
     private static handleSubscriptionOperation;
     private static createSubscription;
     private static getSubscription;

package/dist/nodes/PixPayment/PixPayment.node.js

@@ -34,6 +34,10 @@ class PixPayment {
                             name: 'PIX',
                             value: 'pix',
                         },
+                        {
+                            name: 'Plano',
+                            value: 'plans',
+                        },
                         {
                             name: 'Assinatura',
                             value: 'subscriptions',
@@ -233,6 +237,154 @@ class PixPayment {
                     default: 0,
                     description: 'Valor do reembolso em reais (deixe vazio para reembolso total)',
                 },
+                // Plan Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Criar',
+                            value: 'create',
+                            description: 'Criar um plano de assinatura',
+                            action: 'Criar plano',
+                        },
+                        {
+                            name: 'Consultar',
+                            value: 'get',
+                            description: 'Consultar um plano',
+                            action: 'Consultar plano',
+                        },
+                        {
+                            name: 'Listar',
+                            value: 'list',
+                            description: 'Listar planos',
+                            action: 'Listar planos',
+                        },
+                        {
+                            name: 'Atualizar',
+                            value: 'update',
+                            description: 'Atualizar um plano',
+                            action: 'Atualizar plano',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // Plan Create Fields
+                {
+                    displayName: 'Nome do Plano',
+                    name: 'reason',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'Nome/descrição do plano',
+                },
+                {
+                    displayName: 'Valor',
+                    name: 'amount',
+                    type: 'number',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: 0,
+                    description: 'Valor do plano em reais (ex: 99.99)',
+                },
+                {
+                    displayName: 'Frequência',
+                    name: 'frequency',
+                    type: 'number',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: 1,
+                    description: 'Frequência de cobrança (ex: 1 para mensal)',
+                },
+                {
+                    displayName: 'Tipo de Frequência',
+                    name: 'frequencyType',
+                    type: 'options',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                            operation: ['create'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Dias',
+                            value: 'days',
+                        },
+                        {
+                            name: 'Meses',
+                            value: 'months',
+                        },
+                    ],
+                    default: 'months',
+                    description: 'Tipo de frequência (dias ou meses)',
+                },
+                // Plan Get/Update Fields
+                {
+                    displayName: 'ID do Plano',
+                    name: 'planId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                            operation: ['get', 'update'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do plano',
+                },
+                // Plan Update Fields
+                {
+                    displayName: 'Nome do Plano',
+                    name: 'reason',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                            operation: ['update'],
+                        },
+                    },
+                    default: '',
+                    description: 'Novo nome/descrição do plano',
+                },
+                {
+                    displayName: 'Valor',
+                    name: 'amount',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            resource: ['plans'],
+                            operation: ['update'],
+                        },
+                    },
+                    default: 0,
+                    description: 'Novo valor do plano em reais',
+                },
                 // Subscription Operations
                 {
                     displayName: 'Operation',
@@ -577,6 +729,9 @@ class PixPayment {
                     case 'pix':
                         responseData = await PixPayment.handlePixOperation(this, operation, i, baseUrl, credentials);
                         break;
+                    case 'plans':
+                        responseData = await PixPayment.handlePlanOperation(this, operation, i, baseUrl, credentials);
+                        break;
                     case 'subscriptions':
                         responseData = await PixPayment.handleSubscriptionOperation(this, operation, i, baseUrl, credentials);
                         break;
@@ -721,6 +876,120 @@ class PixPayment {
         });
         return response;
     }
+    static async handlePlanOperation(executeFunctions, operation, itemIndex, baseUrl, credentials) {
+        switch (operation) {
+            case 'create':
+                return await PixPayment.createPlan(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'get':
+                return await PixPayment.getPlan(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'list':
+                return await PixPayment.listPlans(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'update':
+                return await PixPayment.updatePlan(executeFunctions, itemIndex, baseUrl, credentials);
+            default:
+                throw new Error(`Operação de plano "${operation}" não é suportada`);
+        }
+    }
+    static async createPlan(executeFunctions, itemIndex, baseUrl, credentials) {
+        const reason = executeFunctions.getNodeParameter('reason', itemIndex);
+        const amount = executeFunctions.getNodeParameter('amount', itemIndex);
+        const frequency = executeFunctions.getNodeParameter('frequency', itemIndex);
+        const frequencyType = executeFunctions.getNodeParameter('frequencyType', itemIndex);
+        if (!reason || reason.trim() === '') {
+            throw new Error('Nome do plano é obrigatório');
+        }
+        if (amount <= 0) {
+            throw new Error('Valor do plano deve ser maior que zero');
+        }
+        if (frequency <= 0) {
+            throw new Error('Frequência deve ser maior que zero');
+        }
+        if (frequencyType !== 'days' && frequencyType !== 'months') {
+            throw new Error('Tipo de frequência deve ser "days" ou "months"');
+        }
+        const body = {
+            reason,
+            auto_recurring: {
+                frequency,
+                frequency_type: frequencyType,
+                transaction_amount: (0, helpers_1.normalizeAmount)(amount),
+                currency_id: 'BRL',
+            },
+            payment_methods_allowed: {
+                payment_types: [
+                    { id: 'credit_card' },
+                ],
+            },
+        };
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'POST',
+            url: `${baseUrl}/preapproval_plan`,
+            body,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async getPlan(executeFunctions, itemIndex, baseUrl, credentials) {
+        const planId = executeFunctions.getNodeParameter('planId', itemIndex);
+        if (!planId || planId.trim() === '') {
+            throw new Error('ID do plano é obrigatório');
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/preapproval_plan/${planId}`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async listPlans(executeFunctions, _itemIndex, baseUrl, credentials) {
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/preapproval_plan/search`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async updatePlan(executeFunctions, itemIndex, baseUrl, credentials) {
+        const planId = executeFunctions.getNodeParameter('planId', itemIndex);
+        const reason = executeFunctions.getNodeParameter('reason', itemIndex);
+        const amount = executeFunctions.getNodeParameter('amount', itemIndex);
+        if (!planId || planId.trim() === '') {
+            throw new Error('ID do plano é obrigatório');
+        }
+        const body = {};
+        if (reason && reason.trim() !== '') {
+            body.reason = reason;
+        }
+        if (amount && amount > 0) {
+            body.auto_recurring = {
+                transaction_amount: (0, helpers_1.normalizeAmount)(amount),
+            };
+        }
+        if (Object.keys(body).length === 0) {
+            throw new Error('É necessário fornecer pelo menos um campo para atualizar (nome ou valor)');
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'PUT',
+            url: `${baseUrl}/preapproval_plan/${planId}`,
+            body,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
     static async handleSubscriptionOperation(executeFunctions, operation, itemIndex, baseUrl, credentials) {
         switch (operation) {
             case 'create':
@@ -1017,6 +1286,11 @@ class PixPayment {
                 normalized.description = data.description;
                 normalized.payerEmail = data.payer?.email;
                 break;
+            case 'plans':
+                normalized.planId = data.id;
+                normalized.amount = data.auto_recurring?.transaction_amount ? data.auto_recurring.transaction_amount / 100 : undefined;
+                normalized.description = data.reason;
+                break;
             case 'subscriptions':
                 normalized.planId = data.preapproval_plan_id;
                 normalized.payerEmail = data.payer_email;

package/dist/nodes/PixPayment/types.d.ts

@@ -58,6 +58,27 @@ export interface Subscription {
     recurring_application_id?: number;
     operation_type?: string;
 }
+export interface Plan {
+    id: string;
+    status: string;
+    reason: string;
+    auto_recurring: {
+        frequency: number;
+        frequency_type: string;
+        transaction_amount: number;
+        currency_id: string;
+    };
+    payment_methods_allowed?: {
+        payment_types?: Array<{
+            id: string;
+        }>;
+        payment_methods?: Array<{
+            id: string;
+        }>;
+    };
+    date_created?: string;
+    last_modified?: string;
+}
 export interface RecurringPayment {
     id: string;
     status: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-mercadopago-pix-assinatura",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "n8n node para processamento de pagamentos PIX e assinaturas via Mercado Pago",
   "keywords": [
     "n8n",