n8n-nodes-sotoros-gotenberg 1.0.5 → 1.0.7

package/dist/nodes/Gotenberg/Gotenberg.node.js

@@ -200,6 +200,57 @@ class Gotenberg {
             };
             return mimeToExt[mimeType] || 'bin';
         };
+        // Вспомогательная функция для форматирования структуры данных с заменой длинных base64 строк
+        const formatDataStructure = (data, maxDepth = 5, currentDepth = 0) => {
+            if (currentDepth >= maxDepth) {
+                return '[max depth reached]';
+            }
+            // Если это null или undefined
+            if (data === null || data === undefined) {
+                return data;
+            }
+            // Если это примитивный тип
+            if (typeof data !== 'object') {
+                // Если это строка и она похожа на base64 (длинная строка из base64 символов)
+                if (typeof data === 'string' && data.length > 100 && /^[A-Za-z0-9+/=]+$/.test(data)) {
+                    return `[binary data: ${data.length} bytes]`;
+                }
+                // Если это очень длинная строка (не base64, но все равно длинная)
+                if (typeof data === 'string' && data.length > 200) {
+                    return `[long string: ${data.length} chars]`;
+                }
+                return data;
+            }
+            // Если это массив
+            if (Array.isArray(data)) {
+                return data.map((item, index) => {
+                    // Ограничиваем вывод массивов до 10 элементов
+                    if (index >= 10) {
+                        return `[${data.length - 10} more items...]`;
+                    }
+                    return formatDataStructure(item, maxDepth, currentDepth + 1);
+                }).slice(0, 10);
+            }
+            // Если это объект
+            const formatted = {};
+            for (const key in data) {
+                if (Object.prototype.hasOwnProperty.call(data, key)) {
+                    const value = data[key];
+                    // Специальная обработка для binary данных
+                    if (key === 'data' && typeof value === 'string' && value.length > 50) {
+                        formatted[key] = `[binary data: ${value.length} bytes]`;
+                    }
+                    else if (key === 'binary' && typeof value === 'object' && value !== null) {
+                        // Для binary объектов показываем структуру, но заменяем data
+                        formatted[key] = formatDataStructure(value, maxDepth, currentDepth + 1);
+                    }
+                    else {
+                        formatted[key] = formatDataStructure(value, maxDepth, currentDepth + 1);
+                    }
+                }
+            }
+            return formatted;
+        };
         try {
             // Извлекаем список из JSON свойства агрегированного элемента
             let listData;
@@ -246,9 +297,11 @@ class Gotenberg {
                 // Элемент списка может быть INodeExecutionData (с полями json и binary)
                 // или обычным объектом с binary данными в разных местах
                 let itemBinary;
+                let binaryProperty;
                 // Вариант 1: элемент имеет структуру INodeExecutionData (json и binary)
                 if ('binary' in listItem && listItem.binary && typeof listItem.binary === 'object') {
                     itemBinary = listItem.binary;
+                    binaryProperty = itemBinary[binaryPropertyName];
                 }
                 // Вариант 2: binary данные находятся в свойстве элемента напрямую
                 else if (binaryPropertyName in listItem) {
@@ -257,21 +310,25 @@ class Gotenberg {
                         // Может быть одиночным объектом или массивом
                         if (binaryProp.data) {
                             // Это одиночный binary объект
-                            itemBinary = { [binaryPropertyName]: binaryProp };
+                            binaryProperty = binaryProp;
                         }
                         else if (Array.isArray(binaryProp)) {
                             // Это массив binary объектов
-                            itemBinary = { [binaryPropertyName]: binaryProp };
+                            binaryProperty = binaryProp;
                         }
                     }
                 }
-                if (!itemBinary || Object.keys(itemBinary).length === 0) {
-                    continue; // Пропускаем элементы без binary данных
+                // Вариант 3: если binary данные не найдены в элементе списка,
+                // ищем их в aggregatedItem.binary по индексу
+                // Для первого элемента (index 0) используем binaryPropertyName, для остальных - binaryPropertyName_${index}
+                if (!binaryProperty && aggregatedItem.binary) {
+                    const binaryKey = listIndex === 0 ? binaryPropertyName : `${binaryPropertyName}_${listIndex}`;
+                    if (binaryKey in aggregatedItem.binary) {
+                        binaryProperty = aggregatedItem.binary[binaryKey];
+                    }
                 }
-                // Получаем binary свойство
-                const binaryProperty = itemBinary[binaryPropertyName];
                 if (!binaryProperty) {
-                    continue; // Пропускаем элементы без указанного binary свойства
+                    continue; // Пропускаем элементы без binary данных
                 }
                 // Обрабатываем как одиночное значение, так и массив
                 const binaryItems = Array.isArray(binaryProperty) ? binaryProperty : [binaryProperty];
@@ -283,8 +340,14 @@ class Gotenberg {
                     }
                     // Получаем buffer из binary данных (всегда base64 в n8n)
                     const dataBuffer = Buffer.from(binaryItem.data, 'base64');
+                    // Используем fileName из метаданных элемента списка, если доступно
                     const fileName = binaryItem.fileName ||
-                        `${binaryPropertyName}_${listIndex}_${i}.${getFileExtensionFromMimeType(binaryItem.mimeType || '')}`;
+                        (listItem && typeof listItem === 'object' && 'fileName' in listItem
+                            ? listItem.fileName
+                            : undefined) ||
+                        (listItem && typeof listItem === 'object' && 'fileExtension' in listItem
+                            ? `${binaryPropertyName}_${listIndex}.${listItem.fileExtension}`
+                            : `${binaryPropertyName}_${listIndex}_${i}.${getFileExtensionFromMimeType(binaryItem.mimeType || '')}`);
                     formData.append('files', dataBuffer, {
                         filename: fileName,
                         contentType: binaryItem.mimeType || 'application/octet-stream',
@@ -293,7 +356,98 @@ class Gotenberg {
                 }
             }
             if (totalFilesCount === 0) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No valid binary files found in any items. Please make sure binary data exists.');
+                // Собираем информацию о структуре элементов списка
+                const sampleItems = listData.slice(0, 3).map((item, index) => {
+                    const itemInfo = {
+                        index,
+                        type: typeof item,
+                        isObject: typeof item === 'object' && item !== null,
+                        hasBinary: 'binary' in (item || {}),
+                        hasBinaryProperty: binaryPropertyName in (item || {}),
+                        keys: item && typeof item === 'object' ? Object.keys(item) : [],
+                    };
+                    // Если есть binary свойство, показываем его структуру
+                    if (item && typeof item === 'object') {
+                        if ('binary' in item && item.binary) {
+                            itemInfo.binaryKeys = Object.keys(item.binary);
+                            itemInfo.binaryStructure = formatDataStructure(item.binary);
+                        }
+                        if (binaryPropertyName in item) {
+                            itemInfo[binaryPropertyName] = formatDataStructure(item[binaryPropertyName]);
+                        }
+                        // Показываем структуру json части (без длинных строк)
+                        if ('json' in item) {
+                            itemInfo.jsonKeys = Object.keys(item.json || {});
+                            itemInfo.jsonSample = formatDataStructure(item.json);
+                        }
+                        else {
+                            // Если нет json, показываем структуру самого объекта
+                            itemInfo.objectSample = formatDataStructure(item);
+                        }
+                    }
+                    return itemInfo;
+                });
+                // Собираем информацию о binary данных в aggregatedItem
+                const aggregatedBinaryInfo = {
+                    keys: Object.keys(aggregatedItem.binary || {}),
+                    sampleBinaryData: {},
+                };
+                // Показываем структуру первых нескольких binary данных
+                const binaryKeysToShow = Object.keys(aggregatedItem.binary || {}).slice(0, 3);
+                for (const key of binaryKeysToShow) {
+                    const binaryData = aggregatedItem.binary[key];
+                    if (binaryData) {
+                        aggregatedBinaryInfo.sampleBinaryData[key] = {
+                            hasData: !!binaryData.data,
+                            dataLength: binaryData.data ? binaryData.data.length : 0,
+                            mimeType: binaryData.mimeType,
+                            fileName: binaryData.fileName,
+                        };
+                    }
+                }
+                // Форматируем структуру данных для отладки
+                const formattedStructure = formatDataStructure({
+                    aggregatedItem: {
+                        jsonKeys: Object.keys(aggregatedItem.json || {}),
+                        binaryInfo: aggregatedBinaryInfo,
+                        jsonSample: formatDataStructure(aggregatedItem.json),
+                    },
+                    listDataInfo: {
+                        length: listData.length,
+                        propertyName: listPropertyName || '(root array)',
+                        sampleItems,
+                    },
+                    configuration: {
+                        binaryPropertyName,
+                        listPropertyName: listPropertyName || '(root array)',
+                        expectedBinaryKeys: (() => {
+                            const keys = [];
+                            for (let i = 0; i < Math.min(listData.length, 10); i++) {
+                                keys.push(i === 0 ? binaryPropertyName : `${binaryPropertyName}_${i}`);
+                            }
+                            return keys;
+                        })(),
+                    },
+                });
+                const structureInfo = JSON.stringify(formattedStructure, null, 2);
+                // Проверяем, есть ли binary данные в aggregatedItem.binary
+                const aggregatedBinaryKeys = Object.keys(aggregatedItem.binary || {});
+                const expectedBinaryKeys = [];
+                for (let i = 0; i < Math.min(listData.length, 10); i++) {
+                    expectedBinaryKeys.push(i === 0 ? binaryPropertyName : `${binaryPropertyName}_${i}`);
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No valid binary files found in any items. Please make sure binary data exists.\n\n` +
+                    `Input data structure:\n${structureInfo}\n\n` +
+                    `Binary data search locations:\n` +
+                    `1. In list item: item.binary["${binaryPropertyName}"] or item["${binaryPropertyName}"]\n` +
+                    `2. In aggregated item: aggregatedItem.binary["${binaryPropertyName}"] (for first item)\n` +
+                    `3. In aggregated item: aggregatedItem.binary["${binaryPropertyName}_${1}"] (for second item), etc.\n\n` +
+                    `Found binary keys in aggregatedItem.binary: ${aggregatedBinaryKeys.length > 0 ? aggregatedBinaryKeys.join(', ') : 'none'}\n` +
+                    `Expected binary keys for first 10 items: ${expectedBinaryKeys.join(', ')}\n\n` +
+                    `Tips:\n` +
+                    `- Check that binaryPropertyName "${binaryPropertyName}" matches the property name\n` +
+                    `- Verify that binary data exists in aggregatedItem.binary with keys: "${binaryPropertyName}", "${binaryPropertyName}_1", "${binaryPropertyName}_2", etc.\n` +
+                    `- Make sure binary data has a "data" field with base64 content`);
             }
             // Добавляем опции в зависимости от операции
             if (operation === 'office' || operation === 'html' || operation === 'markdown') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-sotoros-gotenberg",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "n8n custom node for Gotenberg integration with binary data support",
   "keywords": [
     "n8n-community-node",