n8n-nodes-sotoros-gotenberg 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-# n8n-nodes-gotenberg
+# n8n-nodes-sotoros-gotenberg
 
 Custom n8n node for integrating with Gotenberg API to convert documents to PDF.
 

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 import { Gotenberg } from './Gotenberg.node';
-export { Gotenberg };
+export default Gotenberg;

package/dist/index.js

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Gotenberg = void 0;
 const Gotenberg_node_1 = require("./Gotenberg.node");
-Object.defineProperty(exports, "Gotenberg", { enumerable: true, get: function () { return Gotenberg_node_1.Gotenberg; } });
+exports.default = Gotenberg_node_1.Gotenberg;

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

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

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

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gotenberg = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const n8n_workflow_2 = require("n8n-workflow");
+const form_data_1 = __importDefault(require("form-data"));
+class Gotenberg {
+    constructor() {
+        this.description = {
+            displayName: 'Gotenberg',
+            name: 'gotenberg',
+            icon: 'file:gotenberg.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Convert documents to PDF using Gotenberg',
+            defaults: {
+                name: 'Gotenberg',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Gotenberg URL',
+                    name: 'gotenbergUrl',
+                    type: 'string',
+                    default: 'http://localhost:3000',
+                    placeholder: 'http://localhost:3000',
+                    description: 'Base URL of the Gotenberg server',
+                    required: true,
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Convert HTML',
+                            value: 'html',
+                            action: 'Convert html to PDF',
+                            description: 'Convert HTML to PDF',
+                        },
+                        {
+                            name: 'Convert Markdown',
+                            value: 'markdown',
+                            action: 'Convert markdown to PDF',
+                            description: 'Convert Markdown to PDF',
+                        },
+                        {
+                            name: 'Convert Office Documents',
+                            value: 'office',
+                            action: 'Convert office documents to PDF',
+                            description: 'Convert Office documents (Word, Excel, PowerPoint) to PDF',
+                        },
+                        {
+                            name: 'Convert URL',
+                            value: 'url',
+                            action: 'Convert url to PDF',
+                            description: 'Convert URL to PDF',
+                        },
+                        {
+                            name: 'Merge PDFs',
+                            value: 'merge',
+                            action: 'Merge multiple PDF files into one',
+                            description: 'Merge multiple PDF files into one',
+                        },
+                    ],
+                    default: 'office',
+                    required: true,
+                },
+                {
+                    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.',
+                },
+                {
+                    displayName: 'Output Binary Property',
+                    name: 'outputBinaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    description: 'Name of the binary property to save the converted PDF',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Landscape',
+                            name: 'landscape',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to use landscape orientation',
+                        },
+                        {
+                            displayName: 'Page Ranges',
+                            name: 'pageRanges',
+                            type: 'string',
+                            default: '',
+                            description: 'Page ranges to include (e.g., "1-2,4-5")',
+                        },
+                        {
+                            displayName: 'Scale',
+                            name: 'scale',
+                            type: 'number',
+                            typeOptions: {
+                                minValue: 0.1,
+                                maxValue: 2,
+                            },
+                            default: 1,
+                            description: 'Scale factor for the PDF',
+                        },
+                        {
+                            displayName: 'Wait Timeout',
+                            name: 'waitTimeout',
+                            type: 'string',
+                            default: '30s',
+                            description: 'Maximum time to wait for conversion (e.g., "30s", "1m")',
+                        },
+                        {
+                            displayName: 'Wait Delay',
+                            name: 'waitDelay',
+                            type: 'string',
+                            default: '0s',
+                            description: 'Delay before starting conversion (e.g., "1s")',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    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, {});
+        // Вспомогательная функция для получения расширения файла из MIME типа
+        const getFileExtensionFromMimeType = (mimeType) => {
+            const mimeToExt = {
+                'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+                'application/msword': 'doc',
+                'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+                'application/vnd.ms-excel': 'xls',
+                'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'pptx',
+                'application/vnd.ms-powerpoint': 'ppt',
+                'text/html': 'html',
+                'text/markdown': 'md',
+                'application/pdf': 'pdf',
+            };
+            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 });
+                }
+                // Создаем 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 {
+                            // Если это одиночное значение, используем helper
+                            dataBuffer = await this.helpers.getBinaryDataBuffer(itemIndex, propName);
+                        }
+                        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 (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);
+                    }
+                }
+                // Определяем 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 });
+                }
+                // Отправляем запрос в 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 });
+                }
+                // Получаем PDF buffer
+                let pdfBuffer;
+                if (Buffer.isBuffer(response.body)) {
+                    pdfBuffer = response.body;
+                }
+                else if (typeof response.body === 'string') {
+                    pdfBuffer = Buffer.from(response.body, 'base64');
+                }
+                else {
+                    // Если это ArrayBuffer или другой тип
+                    const bodyArray = new Uint8Array(response.body);
+                    pdfBuffer = Buffer.from(bodyArray);
+                }
+                // Создаем выходной элемент
+                const newItem = {
+                    json: {
+                        ...item.json,
+                        success: true,
+                        operation,
+                        fileCount: totalFilesCount,
+                    },
+                    binary: {
+                        ...item.binary,
+                        [outputBinaryPropertyName]: {
+                            data: pdfBuffer.toString('base64'),
+                            mimeType: 'application/pdf',
+                            fileName: `converted_${itemIndex}.pdf`,
+                        },
+                    },
+                };
+                returnData.push(newItem);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : String(error),
+                            success: false,
+                        },
+                        binary: items[itemIndex].binary,
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Gotenberg = Gotenberg;

package/dist/nodes/Gotenberg/index.d.ts

@@ -0,0 +1,2 @@
+import { Gotenberg } from './Gotenberg.node';
+export = Gotenberg;

package/dist/nodes/Gotenberg/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const Gotenberg_node_1 = require("./Gotenberg.node");
+module.exports = Gotenberg_node_1.Gotenberg;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-sotoros-gotenberg",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "n8n custom node for Gotenberg integration with binary data support",
   "keywords": [
     "n8n-community-node",
@@ -10,7 +10,7 @@
   ],
   "license": "MIT",
   "homepage": "",
-  "author": "Danila Fokin <sir.sotoros@ys.ru> (https://github.com/sotoros)",
+  "author": "Danila Fokin <sir.sotoros@ya.ru> (https://github.com/sotoros)",
   "repository": {
     "type": "git",
     "url": ""