n8n-nodes-sotoros-gotenberg 1.0.0

package/README.md

@@ -0,0 +1,123 @@
+# n8n-nodes-gotenberg
+
+Custom n8n node for integrating with Gotenberg API to convert documents to PDF.
+
+## Features
+
+- Convert Office documents (Word, Excel, PowerPoint) to PDF
+- Convert HTML to PDF
+- Convert Markdown to PDF
+- Convert URLs to PDF
+- Merge multiple PDF files
+- Support for single binary files and arrays of binary files
+- Automatic processing of all binary properties from previous nodes
+- Configurable conversion options (landscape, page ranges, scale, etc.)
+
+## Installation
+
+1. Clone this repository or copy the files to your n8n custom nodes directory
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the project:
+   ```bash
+   npm run build
+   ```
+4. Copy the `dist` folder to your n8n custom nodes directory, or install it as a package
+
+## Configuration
+
+### Gotenberg URL
+The base URL of your Gotenberg server (default: `http://localhost:3000`)
+
+### Operation
+Select the type of conversion:
+- **Convert Office Documents**: Convert Word, Excel, PowerPoint files to PDF
+- **Convert HTML**: Convert HTML content to PDF
+- **Convert Markdown**: Convert Markdown content to PDF
+- **Convert URL**: Convert a web page URL to PDF
+- **Merge PDFs**: Merge multiple PDF files into one
+
+### Binary Property
+Name of the binary property containing the file(s) to convert. If left empty, all binary properties from the previous node will be processed automatically.
+
+### Output Binary Property
+Name of the binary property where the converted PDF will be saved (default: `data`)
+
+### Options
+- **Landscape**: Use landscape orientation
+- **Page Ranges**: Specify page ranges (e.g., "1-2,4-5")
+- **Scale**: Scale factor for the PDF (0.1 to 2)
+- **Wait Timeout**: Maximum time to wait for conversion (e.g., "30s", "1m")
+- **Wait Delay**: Delay before starting conversion (e.g., "1s")
+
+## Usage Examples
+
+### Example 1: Convert a single Office document
+
+1. Use a node that reads a file (e.g., "Read Binary File")
+2. Connect it to the Gotenberg node
+3. Configure:
+   - Operation: "Convert Office Documents"
+   - Binary Property: (leave empty to use all binary properties)
+   - Gotenberg URL: Your Gotenberg server URL
+
+### Example 2: Convert multiple files from an array
+
+1. Use a node that returns multiple binary files (e.g., "Read Binary Files" with multiple files)
+2. The Gotenberg node will automatically process all files in the array
+3. All files will be converted and merged into a single PDF
+
+### Example 3: Convert HTML to PDF
+
+1. Use a node that provides HTML content as binary data
+2. Configure:
+   - Operation: "Convert HTML"
+   - Binary Property: Name of the property containing HTML
+
+## Binary Data Handling
+
+The node supports both single binary files and arrays of binary files:
+
+- **Single file**: If a binary property contains a single file, it will be processed directly
+- **Array of files**: If a binary property contains an array of files, all files will be processed and sent to Gotenberg
+- **Multiple properties**: If no specific binary property is specified, all binary properties from the previous node will be processed
+
+## Requirements
+
+- n8n (self-hosted or cloud)
+- Gotenberg server running and accessible
+- Node.js 18+ and npm
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Watch mode for development
+npm run dev
+
+# Lint code
+npm run lint
+
+# Format code
+npm run format
+```
+
+## License
+
+MIT
+
+## Author
+
+Danila Fokin <sir.sotoros@ys.ru>
+
+## Links
+
+- [Gotenberg Documentation](https://gotenberg.dev/)
+- [n8n Documentation](https://docs.n8n.io/)

package/README.ru.md

@@ -0,0 +1,123 @@
+# n8n-nodes-sotoros-gotenberg
+
+Кастомный узел n8n для интеграции с API Gotenberg для конвертации документов в PDF.
+
+## Возможности
+
+- Конвертация документов Office (Word, Excel, PowerPoint) в PDF
+- Конвертация HTML в PDF
+- Конвертация Markdown в PDF
+- Конвертация URL в PDF
+- Объединение нескольких PDF файлов
+- Поддержка одиночных бинарных файлов и массивов бинарных файлов
+- Автоматическая обработка всех бинарных свойств из предыдущих узлов
+- Настраиваемые опции конвертации (альбомная ориентация, диапазоны страниц, масштаб и т.д.)
+
+## Установка
+
+1. Клонируйте этот репозиторий или скопируйте файлы в директорию кастомных узлов n8n
+2. Установите зависимости:
+   ```bash
+   npm install
+   ```
+3. Соберите проект:
+   ```bash
+   npm run build
+   ```
+4. Скопируйте папку `dist` в директорию кастомных узлов n8n, или установите как пакет
+
+## Конфигурация
+
+### Gotenberg URL
+Базовый URL вашего сервера Gotenberg (по умолчанию: `http://localhost:3000`)
+
+### Операция
+Выберите тип конвертации:
+- **Convert Office Documents**: Конвертация файлов Word, Excel, PowerPoint в PDF
+- **Convert HTML**: Конвертация HTML контента в PDF
+- **Convert Markdown**: Конвертация Markdown контента в PDF
+- **Convert URL**: Конвертация веб-страницы по URL в PDF
+- **Merge PDFs**: Объединение нескольких PDF файлов в один
+
+### Binary Property
+Имя бинарного свойства, содержащего файл(ы) для конвертации. Если оставить пустым, будут автоматически обработаны все бинарные свойства из предыдущего узла.
+
+### Output Binary Property
+Имя бинарного свойства, в которое будет сохранен сконвертированный PDF (по умолчанию: `data`)
+
+### Опции
+- **Landscape**: Использовать альбомную ориентацию
+- **Page Ranges**: Указать диапазоны страниц (например, "1-2,4-5")
+- **Scale**: Коэффициент масштабирования для PDF (от 0.1 до 2)
+- **Wait Timeout**: Максимальное время ожидания конвертации (например, "30s", "1m")
+- **Wait Delay**: Задержка перед началом конвертации (например, "1s")
+
+## Примеры использования
+
+### Пример 1: Конвертация одного документа Office
+
+1. Используйте узел, который читает файл (например, "Read Binary File")
+2. Подключите его к узлу Gotenberg
+3. Настройте:
+   - Operation: "Convert Office Documents"
+   - Binary Property: (оставьте пустым для использования всех бинарных свойств)
+   - Gotenberg URL: URL вашего сервера Gotenberg
+
+### Пример 2: Конвертация нескольких файлов из массива
+
+1. Используйте узел, который возвращает несколько бинарных файлов (например, "Read Binary Files" с несколькими файлами)
+2. Узел Gotenberg автоматически обработает все файлы в массиве
+3. Все файлы будут сконвертированы и объединены в один PDF
+
+### Пример 3: Конвертация HTML в PDF
+
+1. Используйте узел, который предоставляет HTML контент как бинарные данные
+2. Настройте:
+   - Operation: "Convert HTML"
+   - Binary Property: Имя свойства, содержащего HTML
+
+## Обработка бинарных данных
+
+Узел поддерживает как одиночные бинарные файлы, так и массивы бинарных файлов:
+
+- **Одиночный файл**: Если бинарное свойство содержит один файл, он будет обработан напрямую
+- **Массив файлов**: Если бинарное свойство содержит массив файлов, все файлы будут обработаны и отправлены в Gotenberg
+- **Несколько свойств**: Если конкретное бинарное свойство не указано, будут обработаны все бинарные свойства из предыдущего узла
+
+## Требования
+
+- n8n (self-hosted или cloud)
+- Работающий и доступный сервер Gotenberg
+- Node.js 18+ и npm
+
+## Разработка
+
+```bash
+# Установка зависимостей
+npm install
+
+# Сборка проекта
+npm run build
+
+# Режим наблюдения для разработки
+npm run dev
+
+# Проверка кода линтером
+npm run lint
+
+# Форматирование кода
+npm run format
+```
+
+## Лицензия
+
+MIT
+
+## Автор
+
+Danila Fokin <sir.sotoros@ys.ru>
+
+## Ссылки
+
+- [Документация Gotenberg](https://gotenberg.dev/)
+- [Документация n8n](https://docs.n8n.io/)

package/dist/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/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/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,5 @@
+"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; } });

package/dist/nodes/Gotenberg/gotenberg.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
+  <polyline points="14 2 14 8 20 8"></polyline>
+  <line x1="16" y1="13" x2="8" y2="13"></line>
+  <line x1="16" y1="17" x2="8" y2="17"></line>
+  <polyline points="10 9 9 9 8 9"></polyline>
+</svg>
+

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "n8n-nodes-sotoros-gotenberg",
+  "version": "1.0.0",
+  "description": "n8n custom node for Gotenberg integration with binary data support",
+  "keywords": [
+    "n8n-community-node",
+    "gotenberg",
+    "pdf",
+    "converter"
+  ],
+  "license": "MIT",
+  "homepage": "",
+  "author": "Danila Fokin <sir.sotoros@ys.ru> (https://github.com/sotoros)",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes --write",
+    "lint": "eslint nodes",
+    "lintfix": "eslint nodes --fix",
+    "prepublishOnly": "npm run build && npm run lint -s"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/Gotenberg/Gotenberg.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^18.15.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-n8n-nodes-base": "~1.11.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^2.7.1",
+    "typescript": "^5.2.0"
+  },
+  "dependencies": {
+    "form-data": "^4.0.0",
+    "n8n-workflow": "*"
+  }
+}
+