npm - n8n-nodes-script-runner - Versions diffs - 1.16.0 → 1.16.2 - Mend

n8n-nodes-script-runner 1.16.0 → 1.16.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md +101 -3
package/dist/nodes/HtmlToPdfConverter/HtmlToPdfConverter.node.d.ts +5 -0
package/dist/nodes/HtmlToPdfConverter/HtmlToPdfConverter.node.js +270 -0
package/dist/nodes/HtmlToPdfConverter/pdf.svg +5 -0
package/dist/nodes/LinkedInFetcher/LinkedInFetcher.node.js +13 -4
package/package.json +7 -2

package/README.md CHANGED Viewed

@@ -1,15 +1,29 @@
 # n8n Script Runner Node
-A custom n8n node that allows you to run custom JavaScript scripts with **jsdom** or **cheerio** for HTML parsing and manipulation.
+A custom n8n node package that includes:
+- **Script Runner**: Run custom JavaScript scripts with **jsdom** or **cheerio** for HTML parsing
+- **HTTP Request Runner**: Execute HTTP requests with axios
+- **LinkedIn Fetcher**: Fetch LinkedIn data via Unipile API
+- **HTML to PDF Converter**: Convert HTML content or URLs to PDF files
 ## Features
+### Script Runner
 - ⚡ Fast HTML parsing with Cheerio (jQuery-like syntax)
 - 🌐 Full DOM implementation with jsdom
 - 🔧 Run custom JavaScript code within n8n workflows
 - 📝 Access to input items and HTML content
 - 🔄 Process multiple items in batch
+### HTML to PDF Converter
+- 📄 Convert HTML strings to PDF files
+- 🌐 Convert web pages (URLs) to PDF
+- ⚙️ Configurable page format (A4, A3, Letter, Legal, Tabloid)
+- 🎨 Support for custom orientations
+- 💾 Output as binary data or base64 string
+- 🚀 Lightweight - no browser required (uses PDFKit)
+- 📝 Extracts headings and paragraphs from HTML
 ## Installation
 ### Community Node Installation (Recommended)
@@ -28,7 +42,48 @@ A custom n8n node that allows you to run custom JavaScript scripts with **jsdom*
 5. Build: `npm run build`
 6. Restart n8n
-## Usage Examples
+## HTML to PDF Converter
+### Example 1: Convert HTML String to PDF
+Configure the node with:
+- **HTML Source**: HTML String
+- **HTML Content**: Your HTML code
+- **Output Format**: Binary Data
+- **File Name**: output.pdf
+### Example 2: Convert Web Page to PDF
+Configure the node with:
+- **HTML Source**: URL
+- **URL**: https://example.com
+- **Output Format**: Binary Data
+- **Page Format**: A4
+- **Landscape**: false
+### Example 3: Custom Margins and Settings
+```json
+{
+  "htmlSource": "string",
+  "htmlContent": "<html><body><h1>Invoice</h1><p>Total: $100</p></body></html>",
+  "outputFormat": "binary",
+  "fileName": "invoice.pdf",
+  "pageFormat": "Letter",
+  "margin": {
+    "top": "20mm",
+    "right": "15mm",
+    "bottom": "20mm",
+    "left": "15mm"
+  },
+  "printBackground": true,
+  "landscape": false
+}
+```
+The PDF will be available as binary data that can be saved to disk or sent via email in subsequent nodes.
+## Script Runner - Usage Examples
 ### Example 1: Extract Text with Cheerio
@@ -92,7 +147,50 @@ const $ = cheerio.load($item.json.html || html);
 // Extract data
 const title = $('h1').first().text();
-const description = $('meta[name="description"]').attr('content');
+conHTML to PDF Converter
+### Example 1: Convert HTML String to PDF
+Configure the node with:
+- **HTML Source**: HTML String
+- **HTML Content**: Your HTML code
+- **Output Format**: Binary Data
+- **File Name**: output.pdf
+### Example 2: Convert Web Page to PDF
+Configure the node with:
+- **HTML Source**: URL
+- **URL**: https://example.com
+- **Output Format**: Binary Data
+- **Page Format**: A4
+- **Landscape**: false
+### Example 3: Custom Margins and Settings
+```json
+{
+  "htmlSource": "string",
+  "htmlContent": "<html><body><h1>Invoice</h1><p>Total: $100</p></body></html>",
+  "outputFormat": "binary",
+  "fileName": "invoice.pdf",
+  "pageFormat": "Letter",
+  "margin": {
+    "top": "20mm",
+    "right": "15mm",
+    "bottom": "20mm",
+    "left": "15mm"
+  },
+  "printBackground": true,
+  "landscape": false
+}
+```
+The PDF will be available as binary data that can be saved to disk or sent via email in subsequent nodes.
+## Script Runner Usage Examples
+### Example 1: Extract Text with Cheerio'meta[name="description"]').attr('content');
 return {
   url,

package/dist/nodes/HtmlToPdfConverter/HtmlToPdfConverter.node.d.ts ADDED Viewed

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

package/dist/nodes/HtmlToPdfConverter/HtmlToPdfConverter.node.js ADDED Viewed

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlToPdfConverter = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const pdfkit_1 = __importDefault(require("pdfkit"));
+const html_to_text_1 = require("html-to-text");
+const jsdom_1 = require("jsdom");
+const axios_1 = __importDefault(require("axios"));
+class HtmlToPdfConverter {
+    constructor() {
+        this.description = {
+            displayName: 'HTML to PDF Converter',
+            name: 'htmlToPdfConverter',
+            icon: 'file:pdf.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Convert HTML content to PDF files',
+            defaults: {
+                name: 'HTML to PDF',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'HTML Source',
+                    name: 'htmlSource',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'HTML String',
+                            value: 'string',
+                        },
+                        {
+                            name: 'URL',
+                            value: 'url',
+                        },
+                    ],
+                    default: 'string',
+                    description: 'Source of the HTML content',
+                },
+                {
+                    displayName: 'HTML Content',
+                    name: 'htmlContent',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 10,
+                    },
+                    displayOptions: {
+                        show: {
+                            htmlSource: ['string'],
+                        },
+                    },
+                    default: '',
+                    placeholder: '<html><body><h1>Hello World</h1></body></html>',
+                    description: 'The HTML content to convert to PDF',
+                    required: true,
+                },
+                {
+                    displayName: 'URL',
+                    name: 'url',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            htmlSource: ['url'],
+                        },
+                    },
+                    default: '',
+                    placeholder: 'https://example.com',
+                    description: 'URL of the webpage to convert to PDF',
+                    required: true,
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormat',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Binary Data',
+                            value: 'binary',
+                            description: 'Return PDF as binary data (recommended)',
+                        },
+                        {
+                            name: 'Base64 String',
+                            value: 'base64',
+                            description: 'Return PDF as base64 encoded string',
+                        },
+                    ],
+                    default: 'binary',
+                    description: 'How to return the PDF data',
+                },
+                {
+                    displayName: 'File Name',
+                    name: 'fileName',
+                    type: 'string',
+                    default: 'output.pdf',
+                    description: 'Name for the output PDF file',
+                    required: true,
+                },
+                {
+                    displayName: 'Page Format',
+                    name: 'pageFormat',
+                    type: 'options',
+                    options: [
+                        { name: 'A4', value: 'A4' },
+                        { name: 'A3', value: 'A3' },
+                        { name: 'Letter', value: 'Letter' },
+                        { name: 'Legal', value: 'Legal' },
+                        { name: 'Tabloid', value: 'Tabloid' },
+                    ],
+                    default: 'A4',
+                    description: 'Paper format for the PDF',
+                },
+                {
+                    displayName: 'Margin',
+                    name: 'margin',
+                    type: 'json',
+                    default: '{"top": "10mm", "right": "10mm", "bottom": "10mm", "left": "10mm"}',
+                    description: 'Page margins (JSON format with top, right, bottom, left)',
+                },
+                {
+                    displayName: 'Print Background',
+                    name: 'printBackground',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to print background graphics',
+                },
+                {
+                    displayName: 'Landscape',
+                    name: 'landscape',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to use landscape orientation',
+                },
+                {
+                    displayName: 'Wait for Network Idle',
+                    name: 'waitForNetworkIdle',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to wait for network requests to finish before generating PDF',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const htmlSource = this.getNodeParameter('htmlSource', itemIndex);
+                const outputFormat = this.getNodeParameter('outputFormat', itemIndex);
+                const fileName = this.getNodeParameter('fileName', itemIndex);
+                const pageFormat = this.getNodeParameter('pageFormat', itemIndex);
+                const landscape = this.getNodeParameter('landscape', itemIndex);
+                let htmlContent = '';
+                if (htmlSource === 'url') {
+                    const url = this.getNodeParameter('url', itemIndex);
+                    if (!url) {
+                        throw new Error('URL is required when HTML Source is set to URL');
+                    }
+                    const response = await axios_1.default.get(url);
+                    htmlContent = response.data;
+                }
+                else {
+                    htmlContent = this.getNodeParameter('htmlContent', itemIndex);
+                    if (!htmlContent) {
+                        throw new Error('HTML Content is required when HTML Source is set to HTML String');
+                    }
+                }
+                // Parse HTML with JSDOM
+                const dom = new jsdom_1.JSDOM(htmlContent);
+                const document = dom.window.document;
+                // Extract text content
+                const textContent = (0, html_to_text_1.convert)(htmlContent, {
+                    wordwrap: 130,
+                    preserveNewlines: true,
+                });
+                // Create PDF
+                const pdfBuffer = await new Promise((resolve, reject) => {
+                    const chunks = [];
+                    // Define page sizes
+                    const pageSizes = {
+                        'A4': [595.28, 841.89],
+                        'A3': [841.89, 1190.55],
+                        'Letter': [612, 792],
+                        'Legal': [612, 1008],
+                        'Tabloid': [792, 1224],
+                    };
+                    const size = pageSizes[pageFormat] || pageSizes['A4'];
+                    const doc = new pdfkit_1.default({
+                        size: landscape ? [size[1], size[0]] : size,
+                        margin: 50,
+                    });
+                    doc.on('data', (chunk) => chunks.push(chunk));
+                    doc.on('end', () => resolve(Buffer.concat(chunks)));
+                    doc.on('error', reject);
+                    // Add title from HTML
+                    const title = document.querySelector('title')?.textContent || 'Document';
+                    doc.fontSize(20).text(title, { align: 'center' });
+                    doc.moveDown();
+                    // Add headings and paragraphs
+                    const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    const paragraphs = document.querySelectorAll('p');
+                    if (headings.length > 0 || paragraphs.length > 0) {
+                        headings.forEach((heading) => {
+                            const level = parseInt(heading.tagName.substring(1));
+                            const fontSize = 24 - (level * 2);
+                            doc.font('Helvetica-Bold').fontSize(fontSize).text(heading.textContent || '');
+                            doc.font('Helvetica');
+                            doc.moveDown(0.5);
+                        });
+                        paragraphs.forEach((para) => {
+                            doc.fontSize(12).text(para.textContent || '');
+                            doc.moveDown();
+                        });
+                    }
+                    else {
+                        // Fallback to plain text conversion
+                        doc.fontSize(12).text(textContent);
+                    }
+                    doc.end();
+                });
+                if (outputFormat === 'binary') {
+                    const binaryData = await this.helpers.prepareBinaryData(pdfBuffer, fileName, 'application/pdf');
+                    returnData.push({
+                        json: {
+                            success: true,
+                            fileName,
+                            size: pdfBuffer.length,
+                        },
+                        binary: {
+                            data: binaryData,
+                        },
+                        pairedItem: { item: itemIndex },
+                    });
+                }
+                else {
+                    const base64String = pdfBuffer.toString('base64');
+                    returnData.push({
+                        json: {
+                            success: true,
+                            fileName,
+                            size: pdfBuffer.length,
+                            pdfData: base64String,
+                        },
+                        pairedItem: { item: itemIndex },
+                    });
+                }
+            }
+            catch (err) {
+                const error = err;
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: error.message || 'PDF generation failed',
+                        },
+                        pairedItem: { item: itemIndex },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.HtmlToPdfConverter = HtmlToPdfConverter;

package/dist/nodes/HtmlToPdfConverter/pdf.svg ADDED Viewed

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+  <path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"/>
+  <polyline points="14 2 14 8 20 8"/>
+  <text x="7" y="17" font-size="6" font-weight="bold" fill="currentColor" font-family="Arial">PDF</text>
+</svg>

package/dist/nodes/LinkedInFetcher/LinkedInFetcher.node.js CHANGED Viewed

@@ -9,7 +9,7 @@ const axios_1 = __importDefault(require("axios"));
 function randomDelayMs(minSeconds = 45, maxSeconds = 90) {
     return Math.floor(Math.random() * (maxSeconds - minSeconds + 1) + minSeconds) * 1000;
 }
-async function fetchLinkedIn(accountId, url, totalLimit, apiKey, minDelaySec, maxDelaySec, startCursor = null, collected = [], seenIds = new Set(), consecutiveEmptyPages = 0, pageCount = 0) {
+async function fetchLinkedIn(DSN, accountId, url, totalLimit, apiKey, minDelaySec, maxDelaySec, startCursor = null, collected = [], seenIds = new Set(), consecutiveEmptyPages = 0, pageCount = 0) {
     const MAX_PAGES = 25;
     const MAX_CONSECUTIVE_EMPTY = 1;
     const PAGE_SIZE = 100;
@@ -34,7 +34,7 @@ async function fetchLinkedIn(accountId, url, totalLimit, apiKey, minDelaySec, ma
         });
         const config = {
             method: 'POST',
-            url: `https://api15.unipile.com:14554/api/v1/linkedin/search?${queryParams.toString()}`,
+            url: `https://${DSN}/api/v1/linkedin/search?${queryParams.toString()}`,
             headers: {
                 'X-API-KEY': apiKey,
                 'Accept': 'application/json',
@@ -129,7 +129,7 @@ async function fetchLinkedIn(accountId, url, totalLimit, apiKey, minDelaySec, ma
             this.logger.info(`Added ${addedThisPage} new items → total ${collected.length}/${totalLimit}. ` +
                 `Waiting ~${Math.round(delayMs / 1000)} seconds...`);
             await new Promise(resolve => setTimeout(resolve, delayMs));
-            return fetchLinkedIn.call(this, accountId, url, totalLimit, apiKey, minDelaySec, maxDelaySec, nextCursor, collected, seenIds, consecutiveEmptyPages, pageCount + 1);
+            return fetchLinkedIn.call(this, DSN, accountId, url, totalLimit, apiKey, minDelaySec, maxDelaySec, nextCursor, collected, seenIds, consecutiveEmptyPages, pageCount + 1);
         }
     }
     catch (err) {
@@ -175,6 +175,14 @@ class LinkedInFetcher {
             inputs: ['main'],
             outputs: ['main'],
             properties: [
+                {
+                    displayName: 'DSN',
+                    name: 'DSN',
+                    type: 'string',
+                    default: 'api15.unipile.com:14554',
+                    placeholder: 'e.g. api15.unipile.com:14554',
+                    description: 'Custom DNS address for the Unipile API',
+                },
                 {
                     displayName: 'Account ID',
                     name: 'accountId',
@@ -238,6 +246,7 @@ class LinkedInFetcher {
         const returnData = [];
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
             try {
+                const DSN = this.getNodeParameter('DSN', itemIndex, 'api15.unipile.com:14554');
                 const accountId = this.getNodeParameter('accountId', itemIndex);
                 const url = this.getNodeParameter('url', itemIndex)?.trim();
                 const totalLimit = this.getNodeParameter('total', itemIndex);
@@ -252,7 +261,7 @@ class LinkedInFetcher {
                 }
                 if (startCursor === '' || startCursor === 'null')
                     startCursor = null;
-                const result = await fetchLinkedIn.call(this, accountId, url, total, apiKey, minDelay, maxDelay, startCursor);
+                const result = await fetchLinkedIn.call(this, DSN, accountId, url, total, apiKey, minDelay, maxDelay, startCursor);
                 returnData.push({
                     json: {
                         result: result.items,

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-script-runner",
-  "version": "1.16.0",
+  "version": "1.16.2",
   "description": "Custom n8n nodes for script execution (jsdom, cheerio) and HTTP requests (axios, fetch)",
   "main": "index.js",
   "scripts": {
@@ -29,21 +29,26 @@
     "nodes": [
       "dist/nodes/ScriptRunner/ScriptRunner.node.js",
       "dist/nodes/HttpRequestRunner/HttpRequestRunner.node.js",
-      "dist/nodes/LinkedInFetcher/LinkedInFetcher.node.js"
+      "dist/nodes/LinkedInFetcher/LinkedInFetcher.node.js",
+      "dist/nodes/HtmlToPdfConverter/HtmlToPdfConverter.node.js"
     ]
   },
   "devDependencies": {
     "@types/jsdom": "^27.0.0",
     "@types/node": "^20.10.0",
+    "@types/pdfkit": "^0.13.0",
     "@types/user-agents": "^1.0.4",
     "gulp": "^4.0.2",
     "n8n-workflow": "^1.0.0",
     "typescript": "^5.3.0"
   },
   "dependencies": {
+    "@types/html-to-text": "^9.0.4",
     "axios": "^1.6.0",
     "cheerio": "^1.0.0-rc.12",
+    "html-to-text": "^9.0.5",
     "jsdom": "^23.0.0",
+    "pdfkit": "^0.15.0",
     "user-agents": "^1.1.669"
   },
   "author": "",