@postalsys/email-text-tools 2.1.16 → 2.2.0

package/lib/worker-pool.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const { Worker } = require('worker_threads');
+const path = require('path');
+const { EventEmitter } = require('events');
+
+class WorkerPool extends EventEmitter {
+    constructor(options = {}) {
+        super();
+
+        this.workerPath = options.workerPath || path.join(__dirname, 'juice-worker.js');
+        this.minWorkers = options.minWorkers || 2;
+        this.maxWorkers = options.maxWorkers || 4;
+        this.maxQueueSize = options.maxQueueSize || 100;
+        this.workerTimeout = options.workerTimeout || 10000;
+        this.idleTimeout = options.idleTimeout || 30000;
+
+        this.workers = [];
+        this.freeWorkers = [];
+        this.queue = [];
+        this.closing = false;
+
+        // Initialize minimum number of workers
+        this._initWorkers();
+    }
+
+    _initWorkers() {
+        for (let i = 0; i < this.minWorkers; i++) {
+            this._createWorker();
+        }
+    }
+
+    _createWorker() {
+        if (this.closing) return null;
+
+        const worker = new Worker(this.workerPath);
+        const workerInfo = {
+            worker,
+            busy: false,
+            lastUsed: Date.now(),
+            timeoutHandle: null,
+            currentTask: null
+        };
+
+        worker.on('message', msg => {
+            if (workerInfo.currentTask) {
+                const { resolve, reject, timeoutHandle } = workerInfo.currentTask;
+                clearTimeout(timeoutHandle);
+
+                if (msg.success) {
+                    resolve(msg.result);
+                } else {
+                    reject(new Error(msg.error));
+                }
+
+                workerInfo.currentTask = null;
+                workerInfo.busy = false;
+                workerInfo.lastUsed = Date.now();
+
+                // Add worker back to free list if not already there
+                if (!this.freeWorkers.includes(workerInfo)) {
+                    this.freeWorkers.push(workerInfo);
+                }
+
+                // Process next item in queue
+                this._processQueue();
+            }
+        });
+
+        worker.on('error', err => {
+            if (workerInfo.currentTask) {
+                const { reject, timeoutHandle } = workerInfo.currentTask;
+                clearTimeout(timeoutHandle);
+                reject(err);
+                workerInfo.currentTask = null;
+            }
+
+            // Remove failed worker
+            const index = this.workers.indexOf(workerInfo);
+            if (index > -1) {
+                this.workers.splice(index, 1);
+            }
+
+            const freeIndex = this.freeWorkers.indexOf(workerInfo);
+            if (freeIndex > -1) {
+                this.freeWorkers.splice(freeIndex, 1);
+            }
+
+            // Create replacement if below minimum
+            if (this.workers.length < this.minWorkers && !this.closing) {
+                this._createWorker();
+            }
+
+            // Process queue with remaining workers
+            this._processQueue();
+        });
+
+        worker.on('exit', () => {
+            // Clean up worker references
+            const index = this.workers.indexOf(workerInfo);
+            if (index > -1) {
+                this.workers.splice(index, 1);
+            }
+
+            const freeIndex = this.freeWorkers.indexOf(workerInfo);
+            if (freeIndex > -1) {
+                this.freeWorkers.splice(freeIndex, 1);
+            }
+        });
+
+        this.workers.push(workerInfo);
+        this.freeWorkers.push(workerInfo);
+
+        // Set up idle timeout for workers above minimum
+        if (this.workers.length > this.minWorkers) {
+            this._setupIdleTimeout(workerInfo);
+        }
+
+        return workerInfo;
+    }
+
+    _setupIdleTimeout(workerInfo) {
+        if (workerInfo.timeoutHandle) {
+            clearTimeout(workerInfo.timeoutHandle);
+        }
+
+        workerInfo.timeoutHandle = setTimeout(() => {
+            if (!workerInfo.busy && this.workers.length > this.minWorkers) {
+                this._removeWorker(workerInfo);
+            }
+        }, this.idleTimeout);
+    }
+
+    _removeWorker(workerInfo) {
+        const index = this.workers.indexOf(workerInfo);
+        if (index > -1) {
+            this.workers.splice(index, 1);
+        }
+
+        const freeIndex = this.freeWorkers.indexOf(workerInfo);
+        if (freeIndex > -1) {
+            this.freeWorkers.splice(freeIndex, 1);
+        }
+
+        if (workerInfo.timeoutHandle) {
+            clearTimeout(workerInfo.timeoutHandle);
+        }
+
+        workerInfo.worker.terminate();
+    }
+
+    async process(data, options = {}) {
+        if (this.closing) {
+            throw new Error('Worker pool is closing');
+        }
+
+        const timeout = options.timeout || this.workerTimeout;
+
+        return new Promise((resolve, reject) => {
+            const task = { data, resolve, reject, timeout };
+
+            // Try to get a free worker
+            const workerInfo = this.freeWorkers.shift();
+
+            if (workerInfo) {
+                this._executeTask(workerInfo, task);
+            } else if (this.workers.length < this.maxWorkers) {
+                // Create new worker if below max
+                const newWorker = this._createWorker();
+                if (newWorker) {
+                    this.freeWorkers.shift(); // Remove from free list
+                    this._executeTask(newWorker, task);
+                }
+            } else if (this.queue.length < this.maxQueueSize) {
+                // Queue the task
+                this.queue.push(task);
+            } else {
+                reject(new Error('Worker pool queue is full'));
+            }
+        });
+    }
+
+    _executeTask(workerInfo, task) {
+        workerInfo.busy = true;
+        workerInfo.lastUsed = Date.now();
+
+        // Clear idle timeout while working
+        if (workerInfo.timeoutHandle) {
+            clearTimeout(workerInfo.timeoutHandle);
+            workerInfo.timeoutHandle = null;
+        }
+
+        // Set up task timeout
+        const timeoutHandle = setTimeout(() => {
+            task.reject(new Error(`Worker task timed out after ${task.timeout}ms`));
+            workerInfo.currentTask = null;
+            workerInfo.busy = false;
+
+            // Terminate and replace the worker
+            this._removeWorker(workerInfo);
+            if (this.workers.length < this.minWorkers && !this.closing) {
+                this._createWorker();
+            }
+
+            this._processQueue();
+        }, task.timeout);
+
+        workerInfo.currentTask = { ...task, timeoutHandle };
+        workerInfo.worker.postMessage(task.data);
+    }
+
+    _processQueue() {
+        if (this.queue.length === 0) {
+            // Mark free workers and set up idle timeouts
+            this.workers.forEach(workerInfo => {
+                if (!workerInfo.busy && !this.freeWorkers.includes(workerInfo)) {
+                    this.freeWorkers.push(workerInfo);
+                    if (this.workers.length > this.minWorkers) {
+                        this._setupIdleTimeout(workerInfo);
+                    }
+                }
+            });
+            return;
+        }
+
+        const workerInfo = this.freeWorkers.shift();
+        if (workerInfo) {
+            const task = this.queue.shift();
+            if (task) {
+                this._executeTask(workerInfo, task);
+            }
+        }
+    }
+
+    async close() {
+        this.closing = true;
+
+        // Clear the queue
+        while (this.queue.length > 0) {
+            const task = this.queue.shift();
+            task.reject(new Error('Worker pool is closing'));
+        }
+
+        // Terminate all workers
+        const terminatePromises = this.workers.map(workerInfo => {
+            if (workerInfo.timeoutHandle) {
+                clearTimeout(workerInfo.timeoutHandle);
+            }
+            return workerInfo.worker.terminate();
+        });
+
+        await Promise.all(terminatePromises);
+
+        this.workers = [];
+        this.freeWorkers = [];
+    }
+
+    getStats() {
+        return {
+            totalWorkers: this.workers.length,
+            busyWorkers: this.workers.filter(w => w.busy).length,
+            freeWorkers: this.freeWorkers.length,
+            queuedTasks: this.queue.length,
+            minWorkers: this.minWorkers,
+            maxWorkers: this.maxWorkers
+        };
+    }
+}
+
+module.exports = WorkerPool;

package/package.json

@@ -1,10 +1,16 @@
 {
     "name": "@postalsys/email-text-tools",
-    "version": "2.1.16",
+    "version": "2.2.0",
     "description": "Email text tools",
     "main": "index.js",
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1",
+        "test": "node --test test/*.test.js",
+        "test:coverage": "node --test --experimental-test-coverage test/*.test.js",
+        "test:watch": "node --test --watch test/*.test.js",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "format": "prettier --write .",
+        "format:check": "prettier --check .",
         "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
     },
     "repository": {
@@ -19,18 +25,21 @@
     },
     "homepage": "https://github.com/postalsys/email-text-tools#readme",
     "devDependencies": {
+        "@eslint/js": "^9.36.0",
+        "eslint": "^9.36.0",
         "eslint-config-nodemailer": "1.2.0",
-        "eslint-config-prettier": "9.1.0"
+        "eslint-config-prettier": "9.1.0",
+        "prettier": "^3.6.2"
     },
     "dependencies": {
-        "dompurify": "3.2.6",
+        "dompurify": "3.2.7",
         "he": "1.2.0",
         "html-to-text": "9.0.5",
-        "jsdom": "26.1.0",
-        "juice": "11.0.1",
+        "jsdom": "27.0.0",
+        "juice": "^11.0.2",
         "linkify-it": "5.0.0",
         "moment-timezone": "0.6.0",
         "node-html-parser": "7.0.1",
-        "tlds": "1.259.0"
+        "tlds": "1.260.0"
     }
 }

package/test/comprehensive.test.js

@@ -0,0 +1,347 @@
+'use strict';
+
+const { describe, it, before: _before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const mimeHtml = require('../lib/mime-html');
+const textToHtml = require('../lib/text-to-html');
+const _fs = require('fs');
+const path = require('path');
+const { Worker } = require('worker_threads');
+
+describe('Comprehensive Test Suite', () => {
+    describe('text-to-html conversion', () => {
+        it('should convert plain text to HTML', () => {
+            const text = 'Hello World\nThis is a test';
+            const html = textToHtml(text);
+
+            assert.ok(html.includes('Hello World'));
+            assert.ok(html.includes('<br'));
+            assert.ok(html.includes('This is a test'));
+        });
+
+        it('should handle quoted text', () => {
+            const text = 'Normal text\n> Quoted text\n> More quoted\nNormal again';
+            const html = textToHtml(text);
+
+            assert.ok(html.includes('blockquote'));
+            assert.ok(html.includes('Quoted text'));
+            assert.ok(html.includes('Normal again'));
+        });
+
+        it('should linkify URLs', () => {
+            const text = 'Visit https://example.com for more info';
+            const html = textToHtml(text);
+
+            assert.ok(html.includes('<a'));
+            assert.ok(html.includes('href='));
+            assert.ok(html.includes('https://example.com'));
+        });
+
+        it('should handle email addresses', () => {
+            const text = 'Contact me at test@example.com';
+            const html = textToHtml(text);
+
+            assert.ok(html.includes('mailto:'));
+            assert.ok(html.includes('test@example.com'));
+        });
+
+        it('should escape HTML entities', () => {
+            const text = 'Test <script>alert("xss")</script> & special chars';
+            const html = textToHtml(text);
+
+            assert.ok(!html.includes('<script>'));
+            assert.ok(html.includes('&lt;script'));
+            assert.ok(html.includes('&amp;'));
+        });
+
+        it('should handle empty text', () => {
+            const html = textToHtml('');
+            assert.ok(typeof html === 'string');
+        });
+
+        it('should handle null/undefined', () => {
+            const html1 = textToHtml(null);
+            const html2 = textToHtml(undefined);
+            const html3 = textToHtml('');
+
+            // textToHtml returns minimal HTML for empty input
+            assert.ok(typeof html1 === 'string');
+            assert.ok(typeof html2 === 'string');
+            assert.ok(typeof html3 === 'string');
+            // Should return consistent output for all empty inputs
+            assert.equal(html1, html2);
+            assert.equal(html2, html3);
+        });
+    });
+
+    describe('juice-worker.js', () => {
+        it('should process HTML in worker thread', async () => {
+            const worker = new Worker(path.join(__dirname, '../lib/juice-worker.js'));
+
+            const html = '<style>p { color: red; }</style><p>Test</p>';
+
+            const result = await new Promise((resolve, reject) => {
+                worker.on('message', msg => {
+                    worker.terminate();
+                    if (msg.success) {
+                        resolve(msg.result);
+                    } else {
+                        reject(new Error(msg.error));
+                    }
+                });
+
+                worker.on('error', reject);
+                worker.postMessage(html);
+            });
+
+            assert.ok(result.includes('style='));
+            assert.ok(result.includes('Test'));
+        });
+
+        it('should handle worker errors gracefully', async () => {
+            const worker = new Worker(path.join(__dirname, '../lib/juice-worker.js'));
+
+            // Send invalid data that should cause an error
+            const invalidData = null;
+
+            try {
+                await new Promise((resolve, reject) => {
+                    worker.on('message', msg => {
+                        worker.terminate();
+                        if (msg.success) {
+                            resolve(msg.result);
+                        } else {
+                            reject(new Error(msg.error));
+                        }
+                    });
+
+                    worker.on('error', reject);
+                    worker.postMessage(invalidData);
+                });
+
+                // If we get here without error, that's also OK
+                assert.ok(true);
+            } catch (err) {
+                // Expected to error
+                assert.ok(err);
+            }
+        });
+    });
+
+    describe('mime-html with text input', () => {
+        it('should properly convert text to HTML with default styles', () => {
+            const input = {
+                text: 'Hello\nWorld\n\nThis is a test'
+            };
+
+            const result = mimeHtml.sync(input);
+
+            assert.ok(result.includes('Hello'));
+            assert.ok(result.includes('World'));
+            assert.ok(result.includes('font-family')); // Default styles applied
+        });
+
+        it('should handle quoted text in text mode', () => {
+            const input = {
+                text: 'Reply:\n> Original message\n> Second line\n\nMy response'
+            };
+
+            const result = mimeHtml.sync(input);
+
+            assert.ok(result.includes('blockquote'));
+            assert.ok(result.includes('Original message'));
+        });
+    });
+
+    describe('error recovery and edge cases', () => {
+        it('should handle circular references in DOM', () => {
+            // This tests the DOM walking logic
+            const input = {
+                html: '<div><p>Test</p></div>'
+            };
+
+            const result = mimeHtml.sync(input);
+            assert.ok(result.includes('Test'));
+        });
+
+        it('should handle very long attribute values', () => {
+            const longValue = 'x'.repeat(10000);
+            const input = {
+                html: `<div data-test="${longValue}">Content</div>`
+            };
+
+            const result = mimeHtml.sync(input);
+            assert.ok(result.includes('Content'));
+        });
+
+        it('should handle style tags in body', () => {
+            const input = {
+                html: `
+                    <body>
+                        <style>p { color: red; }</style>
+                        <p>Test</p>
+                        <style>div { color: blue; }</style>
+                        <div>More</div>
+                    </body>
+                `
+            };
+
+            const result = mimeHtml.sync(input);
+            assert.ok(result.includes('Test'));
+            assert.ok(result.includes('More'));
+            // Style tags in body should be removed
+            assert.ok(!result.includes('<style'));
+        });
+
+        it('should handle CDATA sections', () => {
+            const input = {
+                html: '<div><![CDATA[Some text]]></div>'
+            };
+
+            const result = mimeHtml.sync(input);
+            assert.ok(typeof result === 'string');
+        });
+
+        it('should handle XML namespaces', () => {
+            const input = {
+                html: '<html xmlns="http://www.w3.org/1999/xhtml"><body><p>Test</p></body></html>'
+            };
+
+            const result = mimeHtml.sync(input);
+            assert.ok(result.includes('Test'));
+        });
+    });
+
+    describe('async version configuration', () => {
+        it('should respect timeout configuration', async () => {
+            const input = {
+                html: '<p>Quick test</p>'
+            };
+
+            const start = Date.now();
+            const result = await mimeHtml.async(input, {
+                timeout: 100,
+                useWorkerPool: false
+            });
+            const elapsed = Date.now() - start;
+
+            assert.ok(result.includes('Quick test'));
+            // Should complete without timing out
+            assert.ok(elapsed < 200);
+        });
+
+        it('should respect logErrors configuration', async () => {
+            const input = {
+                html: null
+            };
+
+            // Capture console.warn
+            const originalWarn = console.warn;
+            let warnCalled = false;
+            console.warn = () => {
+                warnCalled = true;
+            };
+
+            await mimeHtml.async(input, {
+                logErrors: false,
+                fallbackOnError: true
+            });
+
+            console.warn = originalWarn;
+            assert.ok(!warnCalled, 'Should not log errors when logErrors is false');
+        });
+
+        it('should respect fallbackOnError configuration', async () => {
+            const input = {
+                html: '<p>Test</p>'
+            };
+
+            // With fallback
+            const result1 = await mimeHtml.async(input, {
+                fallbackOnError: true,
+                logErrors: false
+            });
+            assert.ok(typeof result1 === 'string');
+        });
+    });
+
+    describe('worker pool configuration', () => {
+        it('should respect min/max worker settings', async () => {
+            const input = {
+                html: '<p>Pool config test</p>'
+            };
+
+            // First close any existing pool
+            await mimeHtml.closeWorkerPool();
+
+            // Process with custom pool settings
+            await mimeHtml.async(input, {
+                useWorkerPool: true,
+                minWorkers: 1,
+                maxWorkers: 2
+            });
+
+            const stats = mimeHtml.getWorkerPoolStats();
+            assert.ok(stats);
+            assert.equal(stats.minWorkers, 1);
+            assert.equal(stats.maxWorkers, 2);
+        });
+    });
+
+    describe('concurrent stress test', () => {
+        it('should handle rapid concurrent requests without deadlock', async () => {
+            const promises = [];
+
+            // Fire off 50 concurrent requests rapidly
+            for (let i = 0; i < 50; i++) {
+                promises.push(
+                    mimeHtml.async(
+                        {
+                            html: `<p>Stress test ${i}</p>`
+                        },
+                        {
+                            useWorkerPool: true,
+                            timeout: 5000
+                        }
+                    )
+                );
+            }
+
+            const results = await Promise.all(promises);
+
+            assert.equal(results.length, 50);
+            results.forEach((result, i) => {
+                assert.ok(result.includes(`Stress test ${i}`));
+            });
+        });
+    });
+
+    describe('memory leak prevention', () => {
+        it('should clean up workers after timeout', async () => {
+            const input = {
+                html: '<p>Timeout test</p>'
+            };
+
+            try {
+                // This should timeout and clean up the worker
+                await mimeHtml.async(input, {
+                    timeout: 1,
+                    useWorkerPool: false,
+                    fallbackOnError: false,
+                    logErrors: false
+                });
+            } catch (err) {
+                assert.ok(err.message.includes('timed out'));
+            }
+
+            // Worker should be cleaned up, no leak
+            const memAfter = process.memoryUsage();
+            assert.ok(memAfter.heapUsed < 500 * 1024 * 1024); // Less than 500MB
+        });
+    });
+
+    // Clean up
+    after(async () => {
+        await mimeHtml.closeWorkerPool();
+    });
+});