@leolionart/n8n-nodes-pdf-extractor 1.0.0 → 1.2.0

package/dist/nodes/PdfExtractor/PdfExtractor.node.js

@@ -1,46 +1,38 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PdfExtractor = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const child_process_1 = require("child_process");
-const util_1 = require("util");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// unpdf provides a simple API for PDF text extraction with password support
+const unpdf_1 = require("unpdf");
+/**
+ * Parse page range string into array of page numbers
+ * Supports: "1-5", "1,3,5", "1-3,7,9-11", or empty for all pages
+ */
+function parsePageRange(pageRange, totalPages) {
+    if (!pageRange.trim()) {
+        // Return all pages
+        return Array.from({ length: totalPages }, (_, i) => i + 1);
+    }
+    const pages = new Set();
+    const parts = pageRange.split(',').map(p => p.trim());
+    for (const part of parts) {
+        if (part.includes('-')) {
+            const [start, end] = part.split('-').map(n => parseInt(n.trim(), 10));
+            if (!isNaN(start) && !isNaN(end)) {
+                for (let i = Math.max(1, start); i <= Math.min(totalPages, end); i++) {
+                    pages.add(i);
+                }
+            }
+        }
+        else {
+            const pageNum = parseInt(part, 10);
+            if (!isNaN(pageNum) && pageNum >= 1 && pageNum <= totalPages) {
+                pages.add(pageNum);
+            }
+        }
+    }
+    return Array.from(pages).sort((a, b) => a - b);
+}
 class PdfExtractor {
     constructor() {
         this.description = {
@@ -50,7 +42,7 @@ class PdfExtractor {
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"]}}',
-            description: 'Extract text from password-protected PDFs using qpdf and pdftotext. Requires qpdf and poppler-utils installed in the n8n container.',
+            description: 'Extract text from password-protected PDFs. No external dependencies required - works out of the box in n8n Docker.',
             defaults: {
                 name: 'PDF Extractor',
             },
@@ -69,12 +61,6 @@ class PdfExtractor {
                             description: 'Extract text content from PDF',
                             action: 'Extract text from PDF',
                         },
-                        {
-                            name: 'Decrypt Only',
-                            value: 'decrypt',
-                            description: 'Decrypt PDF and return as binary',
-                            action: 'Decrypt PDF file',
-                        },
                     ],
                     default: 'extractText',
                 },
@@ -105,18 +91,30 @@ class PdfExtractor {
                     default: {},
                     options: [
                         {
-                            displayName: 'Layout Mode',
-                            name: 'layout',
+                            displayName: 'Join Pages',
+                            name: 'joinPages',
                             type: 'boolean',
                             default: true,
-                            description: 'Whether to maintain the original physical layout of the text',
+                            description: 'Whether to join all pages into a single text output',
+                        },
+                        {
+                            displayName: 'Page Separator',
+                            name: 'pageSeparator',
+                            type: 'string',
+                            default: '\n\n--- Page {page} ---\n\n',
+                            description: 'Separator between pages when joining. Use {page} for page number.',
+                            displayOptions: {
+                                show: {
+                                    joinPages: [true],
+                                },
+                            },
                         },
                         {
                             displayName: 'Page Range',
                             name: 'pageRange',
                             type: 'string',
                             default: '',
-                            placeholder: '1-5',
+                            placeholder: '1-5 or 1,3,5',
                             description: 'Extract specific pages only (e.g., "1-5" or "1,3,5"). Leave empty for all pages.',
                         },
                         {
@@ -127,16 +125,16 @@ class PdfExtractor {
                             description: 'Name of the JSON property to store extracted text',
                         },
                         {
-                            displayName: 'Encoding',
-                            name: 'encoding',
-                            type: 'options',
-                            options: [
-                                { name: 'UTF-8', value: 'UTF-8' },
-                                { name: 'Latin1', value: 'Latin1' },
-                                { name: 'ASCII7', value: 'ASCII7' },
-                            ],
-                            default: 'UTF-8',
-                            description: 'Text encoding for output',
+                            displayName: 'Include Page Numbers',
+                            name: 'includePageNumbers',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to include page numbers in the output when not joining pages',
+                            displayOptions: {
+                                show: {
+                                    joinPages: [false],
+                                },
+                            },
                         },
                     ],
                 },
@@ -146,112 +144,98 @@ class PdfExtractor {
     async execute() {
         const items = this.getInputData();
         const returnData = [];
-        // Check if required tools are installed
-        try {
-            await execAsync('which qpdf');
-            await execAsync('which pdftotext');
-        }
-        catch {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Required tools not found. Please install qpdf and poppler-utils in your n8n container:\n' +
-                'docker exec -u root n8n apk add --no-cache qpdf poppler-utils');
-        }
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
             try {
-                const operation = this.getNodeParameter('operation', itemIndex);
                 const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex);
                 const password = this.getNodeParameter('password', itemIndex);
                 const options = this.getNodeParameter('options', itemIndex, {});
                 // Validate binary data exists
                 const binaryData = this.helpers.assertBinaryData(itemIndex, binaryPropertyName);
                 const buffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
-                // Create temp files with unique names
-                const tempDir = os.tmpdir();
-                const timestamp = Date.now();
-                const randomId = Math.random().toString(36).substring(7);
-                const inputPath = path.join(tempDir, `n8n_pdf_input_${timestamp}_${randomId}.pdf`);
-                const decryptedPath = path.join(tempDir, `n8n_pdf_decrypted_${timestamp}_${randomId}.pdf`);
-                // Write PDF to temp file
-                fs.writeFileSync(inputPath, buffer);
-                let pdfPath = inputPath;
+                // Convert buffer to Uint8Array
+                const pdfData = new Uint8Array(buffer);
+                // Get document info first to know total pages
+                let pdf;
                 try {
-                    // Decrypt if password provided
-                    if (password) {
-                        const qpdfCmd = `qpdf --decrypt --password="${password.replace(/"/g, '\\"')}" "${inputPath}" "${decryptedPath}"`;
-                        try {
-                            await execAsync(qpdfCmd);
-                            pdfPath = decryptedPath;
-                        }
-                        catch (error) {
-                            const errorMessage = error.message || String(error);
-                            if (errorMessage.includes('invalid password')) {
-                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid password for PDF file', { itemIndex });
-                            }
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to decrypt PDF: ${errorMessage}`, { itemIndex });
-                        }
-                    }
-                    if (operation === 'extractText') {
-                        // Build pdftotext command
-                        const pdftotextArgs = [];
-                        if (options.layout !== false) {
-                            pdftotextArgs.push('-layout');
-                        }
-                        if (options.encoding) {
-                            pdftotextArgs.push(`-enc ${options.encoding}`);
-                        }
-                        if (options.pageRange) {
-                            const pageMatch = options.pageRange.match(/^(\d+)(?:-(\d+))?$/);
-                            if (pageMatch) {
-                                pdftotextArgs.push(`-f ${pageMatch[1]}`);
-                                if (pageMatch[2]) {
-                                    pdftotextArgs.push(`-l ${pageMatch[2]}`);
-                                }
-                            }
+                    pdf = await (0, unpdf_1.getDocumentProxy)(pdfData, {
+                        password: password || undefined,
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error.message || String(error);
+                    if (errorMessage.toLowerCase().includes('password')) {
+                        if (password) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid password for PDF file', { itemIndex });
                         }
-                        const pdftotextCmd = `pdftotext ${pdftotextArgs.join(' ')} "${pdfPath}" -`;
-                        const { stdout, stderr } = await execAsync(pdftotextCmd, { maxBuffer: 50 * 1024 * 1024 });
-                        if (stderr && !stderr.includes('Syntax Warning')) {
-                            console.warn(`pdftotext warning: ${stderr}`);
+                        else {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This PDF is password-protected. Please provide the password.', { itemIndex });
                         }
-                        const outputProperty = options.outputProperty || 'text';
-                        returnData.push({
-                            json: {
-                                [outputProperty]: stdout,
-                                fileName: binaryData.fileName,
-                                mimeType: binaryData.mimeType,
-                                fileSize: buffer.length,
-                                encrypted: !!password,
-                            },
-                            pairedItem: { item: itemIndex },
-                        });
-                    }
-                    else if (operation === 'decrypt') {
-                        // Read decrypted PDF and return as binary
-                        const decryptedBuffer = fs.readFileSync(pdfPath);
-                        const newBinaryData = await this.helpers.prepareBinaryData(decryptedBuffer, binaryData.fileName?.replace('.pdf', '_decrypted.pdf') || 'decrypted.pdf', 'application/pdf');
-                        returnData.push({
-                            json: {
-                                fileName: binaryData.fileName,
-                                decrypted: true,
-                            },
-                            binary: {
-                                [binaryPropertyName]: newBinaryData,
-                            },
-                            pairedItem: { item: itemIndex },
-                        });
                     }
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load PDF: ${errorMessage}`, { itemIndex });
                 }
-                finally {
-                    // Cleanup temp files
+                const numPages = pdf.numPages;
+                const pagesToExtract = parsePageRange(options.pageRange || '', numPages);
+                // Extract text from selected pages
+                const pageTexts = [];
+                for (const pageNum of pagesToExtract) {
                     try {
-                        if (fs.existsSync(inputPath))
-                            fs.unlinkSync(inputPath);
-                        if (fs.existsSync(decryptedPath))
-                            fs.unlinkSync(decryptedPath);
+                        const page = await pdf.getPage(pageNum);
+                        const textContent = await page.getTextContent();
+                        // Join text items
+                        const pageText = textContent.items
+                            .filter((item) => typeof item === 'object' && item !== null && 'str' in item)
+                            .map((item) => item.str)
+                            .join(' ')
+                            .replace(/\s+/g, ' ')
+                            .trim();
+                        pageTexts.push({ page: pageNum, text: pageText });
                     }
-                    catch {
-                        // Ignore cleanup errors
+                    catch (pageError) {
+                        console.warn(`Failed to extract page ${pageNum}: ${pageError}`);
+                        pageTexts.push({ page: pageNum, text: '' });
                     }
                 }
+                const outputProperty = options.outputProperty || 'text';
+                const joinPages = options.joinPages !== false;
+                let outputData;
+                if (joinPages) {
+                    const separator = options.pageSeparator || '\n\n--- Page {page} ---\n\n';
+                    const fullText = pageTexts
+                        .map((p, index) => {
+                        if (index === 0) {
+                            return p.text;
+                        }
+                        return separator.replace('{page}', String(p.page)) + p.text;
+                    })
+                        .join('');
+                    outputData = {
+                        [outputProperty]: fullText,
+                        fileName: binaryData.fileName,
+                        mimeType: binaryData.mimeType,
+                        fileSize: buffer.length,
+                        totalPages: numPages,
+                        extractedPages: pagesToExtract.length,
+                        encrypted: !!password,
+                    };
+                }
+                else {
+                    const pagesOutput = options.includePageNumbers
+                        ? pageTexts
+                        : pageTexts.map(p => p.text);
+                    outputData = {
+                        [outputProperty]: pagesOutput,
+                        fileName: binaryData.fileName,
+                        mimeType: binaryData.mimeType,
+                        fileSize: buffer.length,
+                        totalPages: numPages,
+                        extractedPages: pagesToExtract.length,
+                        encrypted: !!password,
+                    };
+                }
+                returnData.push({
+                    json: outputData,
+                    pairedItem: { item: itemIndex },
+                });
             }
             catch (error) {
                 if (this.continueOnFail()) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leolionart/n8n-nodes-pdf-extractor",
-  "version": "1.0.0",
-  "description": "n8n community node to extract text from password-protected PDFs using qpdf and pdftotext",
+  "version": "1.2.0",
+  "description": "n8n community node to extract text from password-protected PDFs - no external dependencies required",
   "keywords": [
     "n8n-community-node-package",
     "n8n",
@@ -9,8 +9,7 @@
     "extract",
     "password",
     "decrypt",
-    "pdftotext",
-    "qpdf"
+    "text-extraction"
   ],
   "license": "MIT",
   "homepage": "https://github.com/pntai/n8n-nodes-pdf-extractor",
@@ -58,5 +57,8 @@
   },
   "peerDependencies": {
     "n8n-workflow": "*"
+  },
+  "dependencies": {
+    "unpdf": "^0.12.1"
   }
 }