n8n-nodes-sotoros-gotenberg 1.0.2 → 1.0.5

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

@@ -72,12 +72,21 @@ class Gotenberg {
                     default: 'office',
                     required: true,
                 },
+                {
+                    displayName: 'List Property',
+                    name: 'listPropertyName',
+                    type: 'string',
+                    default: 'items',
+                    description: 'Name of the JSON property that contains the array/list of items from the aggregation node (e.g., "items", "data"). ' +
+                        'Leave empty if the aggregated item JSON itself is an array.',
+                },
                 {
                     displayName: 'Binary Property',
                     name: 'binaryPropertyName',
                     type: 'string',
-                    default: '',
-                    description: 'Name of the binary property that contains the file(s) to convert. If empty, all binary properties from the previous node will be processed.',
+                    default: 'data',
+                    description: 'Name of the binary property in each item of the list that contains the file(s) to convert',
+                    required: true,
                 },
                 {
                     displayName: 'Output Binary Property',
@@ -138,13 +147,44 @@ class Gotenberg {
         };
     }
     async execute() {
+        // Работаем с одним элементом, который содержит список (результат узла агрегации)
         const items = this.getInputData();
         const returnData = [];
-        const gotenbergUrl = this.getNodeParameter('gotenbergUrl', 0);
-        const operation = this.getNodeParameter('operation', 0);
-        const binaryPropertyName = this.getNodeParameter('binaryPropertyName', 0) || '';
-        const outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', 0);
-        const options = this.getNodeParameter('options', 0, {});
+        if (items.length === 0) {
+            return [returnData];
+        }
+        // Берем первый элемент (результат узла агрегации)
+        const aggregatedItem = items[0];
+        let gotenbergUrl;
+        let operation;
+        let listPropertyName;
+        let binaryPropertyName;
+        let outputBinaryPropertyName;
+        let options;
+        try {
+            gotenbergUrl = this.getNodeParameter('gotenbergUrl', 0);
+            operation = this.getNodeParameter('operation', 0);
+            listPropertyName = this.getNodeParameter('listPropertyName', 0);
+            binaryPropertyName = this.getNodeParameter('binaryPropertyName', 0);
+            outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', 0);
+            options = this.getNodeParameter('options', 0, {});
+        }
+        catch (error) {
+            if (this.continueOnFail()) {
+                returnData.push({
+                    json: {
+                        ...aggregatedItem.json,
+                        error: error instanceof Error ? error.message : String(error),
+                        success: false,
+                    },
+                    binary: aggregatedItem.binary,
+                });
+                return [returnData];
+            }
+            else {
+                throw error;
+            }
+        }
         // Вспомогательная функция для получения расширения файла из MIME типа
         const getFileExtensionFromMimeType = (mimeType) => {
             const mimeToExt = {
@@ -160,174 +200,238 @@ class Gotenberg {
             };
             return mimeToExt[mimeType] || 'bin';
         };
-        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-            try {
-                const item = items[itemIndex];
-                const binaryData = item.binary;
-                if (!binaryData || Object.keys(binaryData).length === 0) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No binary data found in item ${itemIndex}. Please make sure the binary property exists.`, { itemIndex });
+        try {
+            // Извлекаем список из JSON свойства агрегированного элемента
+            let listData;
+            // Если listPropertyName пустой или не указан, проверяем, является ли сам json массивом
+            if (!listPropertyName || listPropertyName.trim() === '') {
+                if (Array.isArray(aggregatedItem.json)) {
+                    listData = aggregatedItem.json;
                 }
-                // Создаем FormData для отправки в Gotenberg
-                const formData = new form_data_1.default();
-                let totalFilesCount = 0;
-                // Определяем, какие binary свойства обрабатывать
-                const binaryPropertiesToProcess = binaryPropertyName
-                    ? [binaryPropertyName]
-                    : Object.keys(binaryData);
-                // Обрабатываем все указанные binary свойства
-                for (const propName of binaryPropertiesToProcess) {
-                    const binaryProperty = binaryData[propName];
-                    if (!binaryProperty) {
-                        if (binaryPropertyName) {
-                            // Если явно указано свойство, но его нет - ошибка
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Binary property "${propName}" not found in item ${itemIndex}`, { itemIndex });
-                        }
-                        // Если не указано явно - просто пропускаем отсутствующие свойства
-                        continue;
-                    }
-                    // Обрабатываем как одиночное значение, так и массив
-                    const binaryItems = Array.isArray(binaryProperty) ? binaryProperty : [binaryProperty];
-                    // Добавляем все файлы из этого свойства
-                    for (let i = 0; i < binaryItems.length; i++) {
-                        const binaryItem = binaryItems[i];
-                        if (!binaryItem || !binaryItem.data) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Binary item ${i} in property "${propName}" is missing data`, { itemIndex });
-                        }
-                        // Получаем buffer из binary данных
-                        // В n8n, когда binary данные приходят как массив, каждый элемент уже содержит data в base64
-                        let dataBuffer;
-                        if (Array.isArray(binaryProperty)) {
-                            // Если это массив, декодируем base64 из элемента массива
-                            dataBuffer = Buffer.from(binaryItem.data, 'base64');
+                else {
+                    // Показываем доступные свойства для помощи пользователю
+                    const availableProperties = Object.keys(aggregatedItem.json || {}).join(', ');
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `List Property is empty, but aggregated item JSON is not an array. ` +
+                        `Available properties: ${availableProperties || 'none'}. ` +
+                        `Please specify the property name that contains the array of items.`);
+                }
+            }
+            else {
+                listData = aggregatedItem.json[listPropertyName];
+                if (!listData) {
+                    // Показываем доступные свойства для помощи пользователю
+                    const availableProperties = Object.keys(aggregatedItem.json || {}).join(', ');
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Property "${listPropertyName}" not found in aggregated item. ` +
+                        `Available properties: ${availableProperties || 'none'}. ` +
+                        `Please check the property name.`);
+                }
+                if (!Array.isArray(listData)) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Property "${listPropertyName}" is not an array. ` +
+                        `Current type: ${typeof listData}. ` +
+                        `Expected an array of items from aggregation node.`);
+                }
+            }
+            if (listData.length === 0) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The list ${listPropertyName ? `in property "${listPropertyName}"` : ''} is empty. No items to process.`);
+            }
+            // Создаем FormData для отправки в Gotenberg - один запрос для всех элементов списка
+            const formData = new form_data_1.default();
+            let totalFilesCount = 0;
+            // Собираем все binary данные из всех элементов списка
+            for (let listIndex = 0; listIndex < listData.length; listIndex++) {
+                const listItem = listData[listIndex];
+                if (!listItem || typeof listItem !== 'object') {
+                    continue; // Пропускаем некорректные элементы
+                }
+                // Элемент списка может быть INodeExecutionData (с полями json и binary)
+                // или обычным объектом с binary данными в разных местах
+                let itemBinary;
+                // Вариант 1: элемент имеет структуру INodeExecutionData (json и binary)
+                if ('binary' in listItem && listItem.binary && typeof listItem.binary === 'object') {
+                    itemBinary = listItem.binary;
+                }
+                // Вариант 2: binary данные находятся в свойстве элемента напрямую
+                else if (binaryPropertyName in listItem) {
+                    const binaryProp = listItem[binaryPropertyName];
+                    if (binaryProp && typeof binaryProp === 'object') {
+                        // Может быть одиночным объектом или массивом
+                        if (binaryProp.data) {
+                            // Это одиночный binary объект
+                            itemBinary = { [binaryPropertyName]: binaryProp };
                         }
-                        else {
-                            // Если это одиночное значение, используем helper
-                            dataBuffer = await this.helpers.getBinaryDataBuffer(itemIndex, propName);
+                        else if (Array.isArray(binaryProp)) {
+                            // Это массив binary объектов
+                            itemBinary = { [binaryPropertyName]: binaryProp };
                         }
-                        const fileName = binaryItem.fileName ||
-                            `${propName}_${i}.${getFileExtensionFromMimeType(binaryItem.mimeType || '')}`;
-                        formData.append('files', dataBuffer, {
-                            filename: fileName,
-                            contentType: binaryItem.mimeType || 'application/octet-stream',
-                        });
-                        totalFilesCount++;
                     }
                 }
-                if (totalFilesCount === 0) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No valid binary files found in item ${itemIndex}`, { itemIndex });
+                if (!itemBinary || Object.keys(itemBinary).length === 0) {
+                    continue; // Пропускаем элементы без binary данных
                 }
-                // Добавляем опции в зависимости от операции
-                if (operation === 'office' || operation === 'html' || operation === 'markdown') {
-                    if (options.landscape) {
-                        formData.append('landscape', 'true');
-                    }
-                    if (options.pageRanges) {
-                        formData.append('pageRanges', options.pageRanges);
-                    }
-                    if (options.scale !== undefined) {
-                        formData.append('scale', options.scale.toString());
-                    }
-                    if (options.waitTimeout) {
-                        formData.append('waitTimeout', options.waitTimeout);
-                    }
-                    if (options.waitDelay) {
-                        formData.append('waitDelay', options.waitDelay);
+                // Получаем binary свойство
+                const binaryProperty = itemBinary[binaryPropertyName];
+                if (!binaryProperty) {
+                    continue; // Пропускаем элементы без указанного binary свойства
+                }
+                // Обрабатываем как одиночное значение, так и массив
+                const binaryItems = Array.isArray(binaryProperty) ? binaryProperty : [binaryProperty];
+                // Добавляем все файлы из этого элемента списка
+                for (let i = 0; i < binaryItems.length; i++) {
+                    const binaryItem = binaryItems[i];
+                    if (!binaryItem || !binaryItem.data) {
+                        continue; // Пропускаем файлы без данных
                     }
+                    // Получаем buffer из binary данных (всегда base64 в n8n)
+                    const dataBuffer = Buffer.from(binaryItem.data, 'base64');
+                    const fileName = binaryItem.fileName ||
+                        `${binaryPropertyName}_${listIndex}_${i}.${getFileExtensionFromMimeType(binaryItem.mimeType || '')}`;
+                    formData.append('files', dataBuffer, {
+                        filename: fileName,
+                        contentType: binaryItem.mimeType || 'application/octet-stream',
+                    });
+                    totalFilesCount++;
                 }
-                // Определяем endpoint в зависимости от операции
-                let endpoint = '';
-                switch (operation) {
-                    case 'office':
-                        endpoint = '/convert/office';
-                        break;
-                    case 'html':
-                        endpoint = '/convert/html';
-                        break;
-                    case 'markdown':
-                        endpoint = '/convert/markdown';
-                        break;
-                    case 'url':
-                        endpoint = '/convert/url';
-                        // Для URL операции нужен параметр url
-                        if (item.json.url) {
-                            formData.append('url', item.json.url);
-                        }
-                        break;
-                    case 'merge':
-                        endpoint = '/forms/pdfengines/merge';
-                        break;
-                    default:
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex });
+            }
+            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.');
+            }
+            // Добавляем опции в зависимости от операции
+            if (operation === 'office' || operation === 'html' || operation === 'markdown') {
+                if (options.landscape) {
+                    formData.append('landscape', 'true');
                 }
-                // Отправляем запрос в Gotenberg
-                const url = `${gotenbergUrl.replace(/\/$/, '')}${endpoint}`;
-                const response = await this.helpers.httpRequest({
-                    method: 'POST',
-                    url,
-                    body: formData,
-                    returnFullResponse: true,
-                    headers: formData.getHeaders(),
-                });
-                // Проверяем статус ответа
-                if (response.statusCode && response.statusCode >= 400) {
-                    let errorText;
-                    if (Buffer.isBuffer(response.body)) {
-                        errorText = response.body.toString('utf-8');
-                    }
-                    else if (typeof response.body === 'string') {
-                        errorText = response.body;
-                    }
-                    else {
-                        errorText = JSON.stringify(response.body);
-                    }
-                    throw new n8n_workflow_2.NodeApiError(this.getNode(), {
-                        message: `Gotenberg API error: ${response.statusCode}`,
-                        description: errorText,
-                    }, { itemIndex });
+                if (options.pageRanges) {
+                    formData.append('pageRanges', options.pageRanges);
                 }
-                // Получаем PDF buffer
-                let pdfBuffer;
+                if (options.scale !== undefined) {
+                    formData.append('scale', options.scale.toString());
+                }
+                if (options.waitTimeout) {
+                    formData.append('waitTimeout', options.waitTimeout);
+                }
+                if (options.waitDelay) {
+                    formData.append('waitDelay', options.waitDelay);
+                }
+            }
+            // Определяем endpoint в зависимости от операции
+            let endpoint = '';
+            switch (operation) {
+                case 'office':
+                    endpoint = '/convert/office';
+                    break;
+                case 'html':
+                    endpoint = '/convert/html';
+                    break;
+                case 'markdown':
+                    endpoint = '/convert/markdown';
+                    break;
+                case 'url':
+                    endpoint = '/convert/url';
+                    // Для URL операции нужен параметр url из первого элемента списка
+                    if (listData.length > 0 && listData[0] && typeof listData[0] === 'object' && 'url' in listData[0]) {
+                        formData.append('url', listData[0].url);
+                    }
+                    break;
+                case 'merge':
+                    endpoint = '/forms/pdfengines/merge';
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            // Отправляем запрос в Gotenberg
+            const url = `${gotenbergUrl.replace(/\/$/, '')}${endpoint}`;
+            const response = await this.helpers.httpRequest({
+                method: 'POST',
+                url,
+                body: formData,
+                returnFullResponse: true,
+                headers: formData.getHeaders(),
+            });
+            // Проверяем статус ответа
+            if (response.statusCode && response.statusCode >= 400) {
+                let errorText;
                 if (Buffer.isBuffer(response.body)) {
-                    pdfBuffer = response.body;
+                    errorText = response.body.toString('utf-8');
                 }
                 else if (typeof response.body === 'string') {
-                    pdfBuffer = Buffer.from(response.body, 'base64');
+                    errorText = response.body;
                 }
                 else {
-                    // Если это ArrayBuffer или другой тип
-                    const bodyArray = new Uint8Array(response.body);
-                    pdfBuffer = Buffer.from(bodyArray);
+                    errorText = JSON.stringify(response.body);
                 }
-                // Создаем выходной элемент
-                const newItem = {
-                    json: {
-                        ...item.json,
-                        success: true,
-                        operation,
-                        fileCount: totalFilesCount,
+                throw new n8n_workflow_2.NodeApiError(this.getNode(), {
+                    message: `Gotenberg API error: ${response.statusCode}`,
+                    description: errorText,
+                });
+            }
+            // Получаем PDF buffer - Gotenberg возвращает PDF как binary данные
+            let pdfBuffer;
+            if (Buffer.isBuffer(response.body)) {
+                // Если это уже Buffer - используем напрямую
+                pdfBuffer = response.body;
+            }
+            else if (response.body instanceof ArrayBuffer) {
+                // Если это ArrayBuffer - конвертируем в Buffer
+                pdfBuffer = Buffer.from(response.body);
+            }
+            else if (typeof response.body === 'string') {
+                // Если это строка - это может быть base64 или raw binary
+                // Попробуем сначала как base64, если не получится - как raw
+                try {
+                    pdfBuffer = Buffer.from(response.body, 'base64');
+                    // Проверяем, что это действительно валидный PDF (начинается с %PDF)
+                    if (pdfBuffer.length > 4 && pdfBuffer.toString('ascii', 0, 4) !== '%PDF') {
+                        // Если не PDF, попробуем как raw binary
+                        pdfBuffer = Buffer.from(response.body, 'binary');
+                    }
+                }
+                catch {
+                    // Если не получилось декодировать как base64, используем как raw binary
+                    pdfBuffer = Buffer.from(response.body, 'binary');
+                }
+            }
+            else {
+                // Если это другой тип - конвертируем через Uint8Array
+                const bodyArray = new Uint8Array(response.body);
+                pdfBuffer = Buffer.from(bodyArray);
+            }
+            // Проверяем, что получили валидный PDF
+            if (pdfBuffer.length < 4 || pdfBuffer.toString('ascii', 0, 4) !== '%PDF') {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid PDF received from Gotenberg. The response does not appear to be a valid PDF file.');
+            }
+            // Создаем один выходной элемент с результатом
+            const newItem = {
+                json: {
+                    ...aggregatedItem.json,
+                    success: true,
+                    operation,
+                    fileCount: totalFilesCount,
+                    processedItems: listData.length,
+                },
+                binary: {
+                    ...aggregatedItem.binary,
+                    [outputBinaryPropertyName]: {
+                        data: pdfBuffer.toString('base64'),
+                        mimeType: 'application/pdf',
+                        fileName: 'converted.pdf',
                     },
-                    binary: {
-                        ...item.binary,
-                        [outputBinaryPropertyName]: {
-                            data: pdfBuffer.toString('base64'),
-                            mimeType: 'application/pdf',
-                            fileName: `converted_${itemIndex}.pdf`,
-                        },
+                },
+            };
+            returnData.push(newItem);
+        }
+        catch (error) {
+            if (this.continueOnFail()) {
+                // Если continueOnFail включен, возвращаем элемент с ошибкой
+                returnData.push({
+                    json: {
+                        ...aggregatedItem.json,
+                        error: error instanceof Error ? error.message : String(error),
+                        success: false,
                     },
-                };
-                returnData.push(newItem);
+                    binary: aggregatedItem.binary,
+                });
             }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({
-                        json: {
-                            error: error instanceof Error ? error.message : String(error),
-                            success: false,
-                        },
-                        binary: items[itemIndex].binary,
-                    });
-                    continue;
-                }
+            else {
                 throw error;
             }
         }

package/package.json

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