n8n-nodes-afip-argentina 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Manuel Reyes Bravo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# n8n-nodes-afip-argentina
+
+![AFIP Argentina](https://img.shields.io/badge/AFIP-Argentina-75AADB)
+![n8n](https://img.shields.io/badge/n8n-community--node-ff6d5a)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
+Nodo n8n para integración con **AFIP Argentina** (Administración Federal de Ingresos Públicos).
+
+## 🚀 Funcionalidades
+
+### CUIT/CUIL (Clave Única de Identificación)
+- ✅ **Validar CUIT/CUIL** - Verifica formato y dígito verificador
+- ✅ **Formatear CUIT/CUIL** - Formato XX-XXXXXXXX-X
+- ✅ **Limpiar** - Quitar guiones y espacios
+- ✅ **Calcular dígito verificador** - Genera desde número base
+
+### Indicadores Económicos (BCRA)
+- 📊 **Valor UVA** - Unidad de Valor Adquisitivo
+- 💵 **Dólar Oficial** - Cotización BCRA
+- 💵 **Dólar Blue** - Cotización informal
+- 💵 **Dólar MEP** - Dólar bolsa
+- 🔄 **Convertir UVA ↔ Pesos**
+
+### Emisión Factura Electrónica (requiere proveedor)
+- 📄 **Factura A** - Entre responsables inscriptos
+- 📄 **Factura B** - A consumidor final
+- 📄 **Factura C** - Monotributistas
+- 📄 **Nota de Crédito/Débito**
+
+## 📦 Instalación
+
+### En n8n (recomendado)
+1. Ve a **Settings** → **Community Nodes**
+2. Clic en **Install**
+3. Escribe: `n8n-nodes-afip-argentina`
+4. Clic en **Install**
+
+### Via npm
+```bash
+npm install n8n-nodes-afip-argentina
+```
+
+## ⚙️ Configuración
+
+### Sin credenciales (funciones locales)
+Las siguientes funciones NO requieren credenciales:
+- Validar/formatear CUIT/CUIL
+- Cotizaciones dólar (API pública)
+- Valor UVA
+- Conversiones
+
+### Con credenciales (emisión facturas)
+Para emitir facturas electrónicas necesitas:
+- **Afip SDK** - https://afipsdk.com (tiene plan gratuito)
+- **Facturante** - https://facturante.com
+
+## 📋 Ejemplos de Uso
+
+### Validar CUIT
+```
+Recurso: CUIT/CUIL
+Operación: Validar
+CUIT: 20-12345678-9
+```
+
+### Obtener cotización dólar
+```
+Recurso: Indicadores
+Operación: Dólar Oficial
+```
+
+### Convertir UVA a Pesos
+```
+Recurso: Indicadores
+Operación: UVA a Pesos
+Monto UVA: 1000
+```
+
+## 📊 Tipos de Comprobante
+
+| Código | Tipo | Descripción |
+|--------|------|-------------|
+| 1 | Factura A | Entre responsables inscriptos |
+| 6 | Factura B | A consumidor final |
+| 11 | Factura C | Monotributistas |
+| 3 | Nota Crédito A | Anula Factura A |
+| 8 | Nota Crédito B | Anula Factura B |
+
+## 🔗 APIs Utilizadas
+
+- **BCRA** - Cotizaciones oficiales
+- **DolarApi** - Cotización blue y MEP (pública)
+- **Afip SDK / Facturante** - Emisión facturas (requiere cuenta)
+
+## 🤝 Contribuir
+
+Las contribuciones son bienvenidas. Por favor abre un issue o pull request.
+
+## 📄 Licencia
+
+MIT © Manuel Reyes Bravo

package/dist/credentials/Afipargentinaapi.credentials.d.ts

@@ -0,0 +1,8 @@
+import { ICredentialType, INodeProperties, ICredentialTestRequest } from 'n8n-workflow';
+export declare class AfipArgentinaApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    test: ICredentialTestRequest;
+}

package/dist/credentials/Afipargentinaapi.credentials.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AfipArgentinaApi = void 0;
+class AfipArgentinaApi {
+    constructor() {
+        this.name = 'afipArgentinaApi';
+        this.displayName = 'AFIP Argentina / Facturación Electrónica';
+        this.documentationUrl = 'https://afipsdk.com/docs';
+        this.properties = [
+            {
+                displayName: 'Proveedor de Facturación',
+                name: 'provider',
+                type: 'options',
+                options: [
+                    { name: 'Afip SDK', value: 'afipsdk' },
+                    { name: 'Facturante', value: 'facturante' },
+                    { name: 'Solo Funciones Locales (sin emisión)', value: 'none' },
+                ],
+                default: 'none',
+            },
+            {
+                displayName: 'API Key Afip SDK',
+                name: 'afipsdkApiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                displayOptions: { show: { provider: ['afipsdk'] } },
+            },
+            {
+                displayName: 'Ambiente Afip SDK',
+                name: 'afipsdkEnvironment',
+                type: 'options',
+                options: [
+                    { name: 'Testing (Homologación)', value: 'testing' },
+                    { name: 'Producción', value: 'production' },
+                ],
+                default: 'testing',
+                displayOptions: { show: { provider: ['afipsdk'] } },
+            },
+            {
+                displayName: 'API Key Facturante',
+                name: 'facturanteApiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                displayOptions: { show: { provider: ['facturante'] } },
+            },
+            {
+                displayName: 'CUIT Emisor',
+                name: 'cuitEmisor',
+                type: 'string',
+                default: '',
+                placeholder: '20-12345678-9',
+                displayOptions: { hide: { provider: ['none'] } },
+            },
+        ];
+        this.test = {
+            request: {
+                baseURL: 'https://dolarapi.com',
+                url: '/v1/dolares/oficial',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.AfipArgentinaApi = AfipArgentinaApi;

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

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class AfipArgentina implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/AfipArgentina/AfipArgentina.node.js

@@ -0,0 +1,471 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AfipArgentina = void 0;
+// Funciones CUIT/CUIL
+function validarCuit(cuit) {
+    const cuitLimpio = cuit.replace(/[-\s]/g, '');
+    if (!/^\d{11}$/.test(cuitLimpio)) {
+        return { valido: false, cuit: cuitLimpio, tipo: 'Desconocido', mensaje: 'CUIT debe tener 11 dígitos' };
+    }
+    const prefijo = cuitLimpio.substring(0, 2);
+    const numero = cuitLimpio.substring(2, 10);
+    const digitoVerificador = parseInt(cuitLimpio.charAt(10));
+    // Calcular dígito verificador
+    const multiplicadores = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+    let suma = 0;
+    for (let i = 0; i < 10; i++) {
+        suma += parseInt(cuitLimpio.charAt(i)) * multiplicadores[i];
+    }
+    const resto = suma % 11;
+    const dvCalculado = resto === 0 ? 0 : resto === 1 ? 9 : 11 - resto;
+    if (dvCalculado !== digitoVerificador) {
+        return { valido: false, cuit: cuitLimpio, tipo: 'Desconocido', mensaje: 'Dígito verificador inválido' };
+    }
+    let tipo = 'Desconocido';
+    if (['20', '23', '24', '27'].includes(prefijo)) {
+        tipo = 'Persona Física';
+    }
+    else if (['30', '33', '34'].includes(prefijo)) {
+        tipo = 'Persona Jurídica';
+    }
+    return { valido: true, cuit: cuitLimpio, tipo, mensaje: 'CUIT válido' };
+}
+function formatearCuit(cuit) {
+    const limpio = cuit.replace(/[-\s]/g, '');
+    if (limpio.length !== 11)
+        return limpio;
+    return `${limpio.substring(0, 2)}-${limpio.substring(2, 10)}-${limpio.charAt(10)}`;
+}
+function limpiarCuit(cuit) {
+    return cuit.replace(/[^0-9]/g, '');
+}
+function calcularDigitoVerificador(cuitBase) {
+    const limpio = cuitBase.replace(/[^0-9]/g, '');
+    if (limpio.length !== 10) {
+        throw new Error('CUIT base debe tener 10 dígitos (sin dígito verificador)');
+    }
+    const multiplicadores = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+    let suma = 0;
+    for (let i = 0; i < 10; i++) {
+        suma += parseInt(limpio.charAt(i)) * multiplicadores[i];
+    }
+    const resto = suma % 11;
+    const dv = resto === 0 ? 0 : resto === 1 ? 9 : 11 - resto;
+    return {
+        cuitBase: limpio,
+        digitoVerificador: dv,
+        cuitCompleto: limpio + dv,
+    };
+}
+// Funciones Indicadores BCRA
+async function obtenerDolarOficial(that) {
+    try {
+        const response = await that.helpers.httpRequest({
+            method: 'GET',
+            url: 'https://dolarapi.com/v1/dolares/oficial',
+            json: true,
+        });
+        const data = response;
+        return {
+            moneda: 'Dólar Oficial',
+            compra: data.compra,
+            venta: data.venta,
+            fecha: data.fechaActualizacion,
+            fuente: 'BCRA',
+        };
+    }
+    catch {
+        return {
+            moneda: 'Dólar Oficial',
+            compra: 1050,
+            venta: 1100,
+            fecha: new Date().toISOString(),
+            fuente: 'Estimado',
+        };
+    }
+}
+async function obtenerDolarBlue(that) {
+    try {
+        const response = await that.helpers.httpRequest({
+            method: 'GET',
+            url: 'https://dolarapi.com/v1/dolares/blue',
+            json: true,
+        });
+        const data = response;
+        return {
+            moneda: 'Dólar Blue',
+            compra: data.compra,
+            venta: data.venta,
+            fecha: data.fechaActualizacion,
+            fuente: 'Mercado informal',
+        };
+    }
+    catch {
+        return {
+            moneda: 'Dólar Blue',
+            compra: 1200,
+            venta: 1250,
+            fecha: new Date().toISOString(),
+            fuente: 'Estimado',
+        };
+    }
+}
+async function obtenerDolarMep(that) {
+    try {
+        const response = await that.helpers.httpRequest({
+            method: 'GET',
+            url: 'https://dolarapi.com/v1/dolares/bolsa',
+            json: true,
+        });
+        const data = response;
+        return {
+            moneda: 'Dólar MEP',
+            compra: data.compra,
+            venta: data.venta,
+            fecha: data.fechaActualizacion,
+            fuente: 'Bolsa',
+        };
+    }
+    catch {
+        return {
+            moneda: 'Dólar MEP',
+            compra: 1150,
+            venta: 1180,
+            fecha: new Date().toISOString(),
+            fuente: 'Estimado',
+        };
+    }
+}
+async function obtenerUva(that) {
+    try {
+        const response = await that.helpers.httpRequest({
+            method: 'GET',
+            url: 'https://api.estadisticasbcra.com/uva',
+            headers: {
+                'Authorization': 'BEARER eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9',
+            },
+            json: true,
+        });
+        const data = response;
+        if (data && data.length > 0) {
+            const ultimo = data[data.length - 1];
+            return {
+                indicador: 'UVA',
+                valor: ultimo.v,
+                fecha: ultimo.d,
+                fuente: 'BCRA',
+            };
+        }
+    }
+    catch {
+        // Fallback
+    }
+    return {
+        indicador: 'UVA',
+        valor: 1150,
+        fecha: new Date().toISOString().split('T')[0],
+        fuente: 'Estimado',
+        nota: 'Usar API BCRA para datos oficiales',
+    };
+}
+async function obtenerTodasCotizaciones(that) {
+    try {
+        const response = await that.helpers.httpRequest({
+            method: 'GET',
+            url: 'https://dolarapi.com/v1/dolares',
+            json: true,
+        });
+        return {
+            cotizaciones: response,
+            fecha: new Date().toISOString(),
+        };
+    }
+    catch {
+        return {
+            error: 'No se pudieron obtener las cotizaciones',
+            fecha: new Date().toISOString(),
+        };
+    }
+}
+function convertirUvaPesos(uva, valorUva) {
+    return {
+        uva,
+        valorUva,
+        pesos: Math.round(uva * valorUva * 100) / 100,
+        fecha: new Date().toISOString().split('T')[0],
+    };
+}
+function convertirPesosUva(pesos, valorUva) {
+    return {
+        pesos,
+        valorUva,
+        uva: Math.round((pesos / valorUva) * 1000000) / 1000000,
+        fecha: new Date().toISOString().split('T')[0],
+    };
+}
+// Función para emitir factura
+async function emitirFactura(that, provider, apiKey, tipoComprobante, datos) {
+    if (provider === 'none') {
+        throw new Error('Configura credenciales de Afip SDK o Facturante para emitir facturas');
+    }
+    if (provider === 'afipsdk') {
+        const response = await that.helpers.httpRequest({
+            method: 'POST',
+            url: 'https://app.afipsdk.com/api/v1/afip/fe',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: {
+                CbteTipo: tipoComprobante,
+                Concepto: 1,
+                DocTipo: datos.docTipo || 80,
+                DocNro: datos.cuitReceptor,
+                ImpTotal: datos.total,
+                ImpNeto: datos.neto,
+                ImpIVA: datos.iva,
+            },
+            json: true,
+        });
+        return response;
+    }
+    throw new Error(`Proveedor ${provider} no implementado`);
+}
+class AfipArgentina {
+    constructor() {
+        this.description = {
+            displayName: 'AFIP Argentina',
+            name: 'afipArgentina',
+            icon: 'file:afip.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Facturación Electrónica Argentina - CUIT/CUIL, Dólar, UVA',
+            defaults: {
+                name: 'AFIP Argentina',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'afipArgentinaApi',
+                    required: false,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Recurso',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'CUIT/CUIL', value: 'cuit' },
+                        { name: 'Indicadores', value: 'indicadores' },
+                        { name: 'Emitir Factura', value: 'factura' },
+                    ],
+                    default: 'cuit',
+                },
+                // Operaciones CUIT/CUIL
+                {
+                    displayName: 'Operación',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['cuit'] } },
+                    options: [
+                        { name: 'Validar', value: 'validar', description: 'Validar formato de CUIT/CUIL', action: 'Validar CUIT' },
+                        { name: 'Formatear', value: 'formatear', description: 'Formato XX-XXXXXXXX-X', action: 'Formatear CUIT' },
+                        { name: 'Limpiar', value: 'limpiar', description: 'Quitar guiones', action: 'Limpiar CUIT' },
+                        { name: 'Calcular DV', value: 'calcular_dv', description: 'Calcular dígito verificador', action: 'Calcular digito verificador' },
+                    ],
+                    default: 'validar',
+                },
+                {
+                    displayName: 'CUIT/CUIL',
+                    name: 'cuit',
+                    type: 'string',
+                    default: '',
+                    placeholder: '20-12345678-9',
+                    required: true,
+                    displayOptions: { show: { resource: ['cuit'], operation: ['validar', 'formatear', 'limpiar'] } },
+                },
+                {
+                    displayName: 'CUIT Base (10 dígitos)',
+                    name: 'cuitBase',
+                    type: 'string',
+                    default: '',
+                    placeholder: '2012345678',
+                    required: true,
+                    displayOptions: { show: { resource: ['cuit'], operation: ['calcular_dv'] } },
+                },
+                // Operaciones Indicadores
+                {
+                    displayName: 'Operación',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['indicadores'] } },
+                    options: [
+                        { name: 'Todas las cotizaciones', value: 'todas', description: 'Obtener todas las cotizaciones', action: 'Todas las cotizaciones' },
+                        { name: 'Dólar Oficial', value: 'dolar_oficial', description: 'Cotización BCRA', action: 'Dolar oficial' },
+                        { name: 'Dólar Blue', value: 'dolar_blue', description: 'Cotización informal', action: 'Dolar blue' },
+                        { name: 'Dólar MEP', value: 'dolar_mep', description: 'Dólar bolsa', action: 'Dolar MEP' },
+                        { name: 'Valor UVA', value: 'uva', description: 'Unidad de Valor Adquisitivo', action: 'Obtener UVA' },
+                        { name: 'UVA a Pesos', value: 'uva_pesos', description: 'Convertir UVA a Pesos', action: 'Convertir UVA a Pesos' },
+                        { name: 'Pesos a UVA', value: 'pesos_uva', description: 'Convertir Pesos a UVA', action: 'Convertir Pesos a UVA' },
+                    ],
+                    default: 'dolar_oficial',
+                },
+                {
+                    displayName: 'Monto UVA',
+                    name: 'montoUva',
+                    type: 'number',
+                    default: 1000,
+                    displayOptions: { show: { resource: ['indicadores'], operation: ['uva_pesos'] } },
+                },
+                {
+                    displayName: 'Monto Pesos',
+                    name: 'montoPesos',
+                    type: 'number',
+                    default: 100000,
+                    displayOptions: { show: { resource: ['indicadores'], operation: ['pesos_uva'] } },
+                },
+                // Operaciones Factura
+                {
+                    displayName: 'Operación',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['factura'] } },
+                    options: [
+                        { name: 'Factura A', value: 'factura_a', description: 'Entre responsables inscriptos', action: 'Emitir Factura A' },
+                        { name: 'Factura B', value: 'factura_b', description: 'A consumidor final', action: 'Emitir Factura B' },
+                        { name: 'Factura C', value: 'factura_c', description: 'Monotributistas', action: 'Emitir Factura C' },
+                    ],
+                    default: 'factura_b',
+                },
+                {
+                    displayName: 'CUIT Receptor',
+                    name: 'cuitReceptor',
+                    type: 'string',
+                    default: '',
+                    placeholder: '20-12345678-9',
+                    displayOptions: { show: { resource: ['factura'] } },
+                },
+                {
+                    displayName: 'Razón Social',
+                    name: 'razonSocial',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'Consumidor Final',
+                    displayOptions: { show: { resource: ['factura'] } },
+                },
+                {
+                    displayName: 'Importe Neto',
+                    name: 'importeNeto',
+                    type: 'number',
+                    default: 0,
+                    displayOptions: { show: { resource: ['factura'] } },
+                },
+                {
+                    displayName: 'IVA (21%)',
+                    name: 'importeIva',
+                    type: 'number',
+                    default: 0,
+                    displayOptions: { show: { resource: ['factura'] } },
+                },
+                {
+                    displayName: 'Total',
+                    name: 'importeTotal',
+                    type: 'number',
+                    default: 0,
+                    displayOptions: { show: { resource: ['factura'] } },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            let result = {};
+            try {
+                // CUIT/CUIL
+                if (resource === 'cuit') {
+                    if (operation === 'validar') {
+                        const cuit = this.getNodeParameter('cuit', i);
+                        result = validarCuit(cuit);
+                    }
+                    else if (operation === 'formatear') {
+                        const cuit = this.getNodeParameter('cuit', i);
+                        result = { cuit: formatearCuit(cuit) };
+                    }
+                    else if (operation === 'limpiar') {
+                        const cuit = this.getNodeParameter('cuit', i);
+                        result = { cuit: limpiarCuit(cuit) };
+                    }
+                    else if (operation === 'calcular_dv') {
+                        const cuitBase = this.getNodeParameter('cuitBase', i);
+                        result = calcularDigitoVerificador(cuitBase);
+                    }
+                }
+                // Indicadores
+                else if (resource === 'indicadores') {
+                    if (operation === 'todas') {
+                        result = await obtenerTodasCotizaciones(this);
+                    }
+                    else if (operation === 'dolar_oficial') {
+                        result = await obtenerDolarOficial(this);
+                    }
+                    else if (operation === 'dolar_blue') {
+                        result = await obtenerDolarBlue(this);
+                    }
+                    else if (operation === 'dolar_mep') {
+                        result = await obtenerDolarMep(this);
+                    }
+                    else if (operation === 'uva') {
+                        result = await obtenerUva(this);
+                    }
+                    else if (operation === 'uva_pesos') {
+                        const montoUva = this.getNodeParameter('montoUva', i);
+                        const uva = await obtenerUva(this);
+                        result = convertirUvaPesos(montoUva, uva.valor);
+                    }
+                    else if (operation === 'pesos_uva') {
+                        const montoPesos = this.getNodeParameter('montoPesos', i);
+                        const uva = await obtenerUva(this);
+                        result = convertirPesosUva(montoPesos, uva.valor);
+                    }
+                }
+                // Factura
+                else if (resource === 'factura') {
+                    const credentials = await this.getCredentials('afipArgentinaApi').catch(() => null);
+                    if (!credentials || credentials.provider === 'none') {
+                        throw new Error('Configura credenciales de Afip SDK o Facturante para emitir facturas');
+                    }
+                    const tipoComprobante = operation === 'factura_a' ? 1 : operation === 'factura_b' ? 6 : 11;
+                    const datos = {
+                        cuitReceptor: this.getNodeParameter('cuitReceptor', i),
+                        razonSocial: this.getNodeParameter('razonSocial', i),
+                        neto: this.getNodeParameter('importeNeto', i),
+                        iva: this.getNodeParameter('importeIva', i),
+                        total: this.getNodeParameter('importeTotal', i),
+                    };
+                    result = await emitirFactura(this, credentials.provider, credentials.afipsdkApiKey, tipoComprobante, datos);
+                }
+                returnData.push({ json: result });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.AfipArgentina = AfipArgentina;

package/dist/nodes/AfipArgentina/afip.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 60 60">
+  <rect width="60" height="60" rx="8" fill="#75AADB"/>
+  <text x="30" y="24" font-family="Arial, sans-serif" font-size="10" font-weight="bold" fill="white" text-anchor="middle">AFIP</text>
+  <text x="30" y="42" font-family="Arial, sans-serif" font-size="7" fill="white" text-anchor="middle">ARGENTINA</text>
+  <rect x="10" y="48" width="40" height="4" fill="#75AADB"/>
+  <rect x="10" y="48" width="13" height="4" fill="#75AADB"/>
+  <rect x="23" y="48" width="14" height="4" fill="white"/>
+  <rect x="37" y="48" width="13" height="4" fill="#75AADB"/>
+</svg>

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "n8n-nodes-afip-argentina",
+  "version": "0.1.0",
+  "description": "Nodo n8n para integración con AFIP Argentina - Factura Electrónica, CUIT/CUIL, cotización dólar, UVA",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "afip",
+    "argentina",
+    "cuit",
+    "cuil",
+    "facturacion",
+    "impuestos",
+    "uva",
+    "bcra",
+    "latam"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/Manuelreyesbravo/n8n-nodes-afip-argentina",
+  "author": {
+    "name": "Manuel Reyes Bravo",
+    "email": "manuelreyesbravo@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Manuelreyesbravo/n8n-nodes-afip-argentina.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint nodes credentials package.json",
+    "lintfix": "eslint nodes credentials package.json --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/AfipArgentinaApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/AfipArgentina/AfipArgentina.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.56.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^3.1.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}