@5minds/node-red-contrib-processcube-tools 1.2.0-develop-d19f89-mg68thdf → 1.2.0-develop-59ef22-mg9d9ja5

package/src/email-sender/email-sender.ts

@@ -0,0 +1,210 @@
+import { NodeInitializer, Node, NodeMessage } from 'node-red';
+import nodemailer from 'nodemailer';
+import { EmailSenderNodeProperties } from '../interfaces/EmailSenderNodeProperties';
+
+interface EmailSenderNodeMessage extends NodeMessage {}
+
+// Dependency injection interface
+interface Dependencies {
+    nodemailer: typeof nodemailer;
+}
+
+// Default dependencies - production values
+const defaultDependencies: Dependencies = {
+    nodemailer: nodemailer,
+};
+
+const EmailSenderNode: NodeInitializer = (RED, dependencies: Dependencies = defaultDependencies) => {
+    function EmailSender(this: Node, config: EmailSenderNodeProperties) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        const validateRequiredProperties = (cfg: EmailSenderNodeProperties): string | null => {
+            const requiredFields = [
+                { name: 'sender', value: cfg.sender },
+                { name: 'address', value: cfg.address },
+                { name: 'to', value: cfg.to },
+                { name: 'subject', value: cfg.subject },
+                { name: 'htmlContent', value: cfg.htmlContent },
+                { name: 'host', value: cfg.host },
+                { name: 'port', value: cfg.port },
+                { name: 'user', value: cfg.user },
+                { name: 'password', value: cfg.password },
+                { name: 'secure', value: cfg.secure },
+                { name: 'rejectUnauthorized', value: cfg.rejectUnauthorized },
+            ];
+
+            for (const field of requiredFields) {
+                if (field.value === undefined || field.value === null || field.value === '') {
+                    return `Required property '${field.name}' is missing`;
+                }
+            }
+
+            return null;
+        };
+
+        const validationError = validateRequiredProperties(config);
+        if (validationError) {
+            node.status({ fill: 'red', shape: 'dot', text: 'configuration error' });
+            setImmediate(() => {
+                node.error(validationError);
+            });
+            return; // Stop initialization if config is invalid
+        }
+
+        const safeEvaluatePropertyAttachment = (cfg: EmailSenderNodeProperties, n: Node, m: NodeMessage) => {
+            if (cfg.attachments && cfg.attachments.trim() !== '') {
+                try {
+                    return RED.util.evaluateNodeProperty(cfg.attachments, cfg.attachmentsType, n, m);
+                } catch (e: any) {
+                    n.error('Failed to evaluate attachments property: ' + e.message, m);
+                    return null;
+                }
+            }
+            return null;
+        };
+
+        (node as any).on('input', async (msg: EmailSenderNodeMessage, send: Function, done: Function) => {
+            send =
+                send ||
+                function () {
+                    node.send.apply(node, arguments as any);
+                };
+            done =
+                done ||
+                function (err?: Error) {
+                    if (err) node.error(err, msg);
+                };
+
+            try {
+                // Retrieve and evaluate all configuration values
+                const sender = String(RED.util.evaluateNodeProperty(config.sender, config.senderType, node, msg));
+                const address = String(RED.util.evaluateNodeProperty(config.address, config.addressType, node, msg));
+                const to = String(RED.util.evaluateNodeProperty(config.to, config.toType, node, msg) || '');
+                const cc = String(RED.util.evaluateNodeProperty(config.cc, config.ccType, node, msg) || '');
+                const bcc = String(RED.util.evaluateNodeProperty(config.bcc, config.bccType, node, msg) || '');
+                const replyTo = String(
+                    RED.util.evaluateNodeProperty(config.replyTo, config.replyToType, node, msg) || '',
+                );
+                const subject = String(
+                    RED.util.evaluateNodeProperty(config.subject, config.subjectType, node, msg) ||
+                        msg.topic ||
+                        'Message from Node-RED',
+                );
+                const htmlContent = String(
+                    RED.util.evaluateNodeProperty(config.htmlContent, config.htmlContentType, node, msg),
+                );
+                const attachments = safeEvaluatePropertyAttachment(config, node, msg);
+
+                // SMTP Configuration
+                const host = String(RED.util.evaluateNodeProperty(config.host, config.hostType, node, msg));
+                const port = Number(RED.util.evaluateNodeProperty(config.port, config.portType, node, msg));
+                const user = String(RED.util.evaluateNodeProperty(config.user, config.userType, node, msg));
+                const password = String(RED.util.evaluateNodeProperty(config.password, config.passwordType, node, msg));
+                const secure = Boolean(RED.util.evaluateNodeProperty(config.secure, config.secureType, node, msg));
+                const rejectUnauthorized = Boolean(
+                    RED.util.evaluateNodeProperty(config.rejectUnauthorized, config.rejectUnauthorizedType, node, msg),
+                );
+
+                // Process attachments
+                let processedAttachments: any[] = [];
+                let parsedAttachments = attachments;
+                if (typeof parsedAttachments === 'string' && parsedAttachments.trim().startsWith('[')) {
+                    try {
+                        parsedAttachments = JSON.parse(parsedAttachments);
+                    } catch (e) {
+                        throw new Error('Failed to parse attachments JSON: ' + (e as Error).message);
+                    }
+                }
+
+                if (parsedAttachments) {
+                    const attachmentArray = Array.isArray(parsedAttachments) ? parsedAttachments : [parsedAttachments];
+                    for (const attachment of attachmentArray) {
+                        if (typeof attachment === 'object' && attachment !== null) {
+                            if (attachment.filename && attachment.content !== undefined) {
+                                processedAttachments.push({
+                                    filename: attachment.filename,
+                                    content: attachment.content,
+                                });
+                            } else {
+                                throw new Error(
+                                    `Attachment object is missing 'filename' or 'content' property. Got: ${JSON.stringify(attachment)}`,
+                                );
+                            }
+                        } else {
+                            throw new Error(`Invalid attachment format. Expected object, got: ${typeof attachment}`);
+                        }
+                    }
+                }
+
+                // Create and send email
+                const transporter = dependencies.nodemailer.createTransport({
+                    host,
+                    port,
+                    secure,
+                    auth: { user, pass: password },
+                    tls: { rejectUnauthorized },
+                });
+
+                const mailOptions = {
+                    from: { name: sender, address: address },
+                    to,
+                    cc,
+                    bcc,
+                    replyTo,
+                    subject,
+                    html: Buffer.from(htmlContent, 'utf-8'),
+                    attachments: processedAttachments,
+                };
+
+                transporter.sendMail(mailOptions, (error, info) => {
+                    if (error) {
+                        node.status({ fill: 'red', shape: 'dot', text: 'error sending' });
+                        if (
+                            error.message &&
+                            error.message.includes('SSL routines') &&
+                            error.message.includes('wrong version number')
+                        ) {
+                            done(
+                                new Error(
+                                    'SSL/TLS connection failed: Wrong version number. This usually means the wrong port or security settings are used. For SMTP: use port 587 with secure=false (STARTTLS) or port 465 with secure=true (SSL/TLS).',
+                                ),
+                            );
+                        } else {
+                            done(error);
+                        }
+                    } else {
+                        node.log('Email sent: ' + info.response);
+                        (msg as any).payload = info;
+
+                        if (info.accepted && info.accepted.length > 0) {
+                            node.status({ fill: 'green', shape: 'dot', text: 'sent' });
+                            send(msg);
+                            done();
+                        } else if (info.rejected && info.rejected.length > 0) {
+                            done(new Error('Email rejected: ' + info.rejected.join(', ')));
+                            node.status({ fill: 'red', shape: 'dot', text: 'rejected' });
+                        } else if (info.pending && info.pending.length > 0) {
+                            done(new Error('Email pending: ' + info.pending.join(', ')));
+                            node.status({ fill: 'yellow', shape: 'dot', text: 'pending' });
+                        } else {
+                            done(new Error('Unknown error while sending email.'));
+                            node.status({ fill: 'red', shape: 'dot', text: 'unknown error' });
+                        }
+                    }
+                });
+            } catch (error) {
+                done(error instanceof Error ? error : new Error(String(error)));
+                node.status({ fill: 'red', shape: 'dot', text: 'error' });
+            }
+        });
+    }
+
+    RED.nodes.registerType('email-sender', EmailSender, {
+        credentials: {
+            password: { type: 'password' },
+        },
+    });
+};
+
+export = EmailSenderNode;

package/{processcube-html-to-text/processcube-html-to-text.html → src/html-to-text/html-to-text.html}

@@ -1,5 +1,5 @@
 <script type="text/javascript">
-    RED.nodes.registerType('processcube-html-to-text', {
+    RED.nodes.registerType('html-to-text', {
         category: 'ProcessCube Tools',
         color: '#02AFD6',
         defaults: {
@@ -9,12 +9,12 @@
         outputs: 1,
         icon: 'font-awesome/fa-sign-in',
         label: function () {
-            return this.name || 'processcube-html-to-text';
+            return this.name || 'html-to-text';
         },
     });
 </script>
 
-<script type="text/html" data-template-name="processcube-html-to-text">
+<script type="text/html" data-template-name="html-to-text">
     <div class="form-row">
         <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
         <input type="text" id="node-input-name" placeholder="Name" />

package/src/html-to-text/html-to-text.ts

@@ -0,0 +1,53 @@
+import { NodeInitializer, Node, NodeDef, NodeMessage } from 'node-red';
+const { compile } = require('html-to-text');
+
+interface HtmlToTextNodeProperties extends NodeDef {
+    // Add your custom properties here if needed
+}
+
+interface HtmlToTextNodeMessage extends NodeMessage {
+    payload: string;
+}
+
+const HtmlToTextNode: NodeInitializer = function (RED) {
+    function HtmlToText(this: Node, config: HtmlToTextNodeProperties) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        const options = {
+            wordwrap: 130,
+        };
+
+        const compiledConvert = compile(options);
+
+        (node as any).on('input', (msg: HtmlToTextNodeMessage, send?: Function, done?: Function) => {
+            // Provide default functions if not available (for older Node-RED versions)
+            send =
+                send ||
+                function (m: NodeMessage | NodeMessage[]) {
+                    node.send(m);
+                };
+            done =
+                done ||
+                function (err?: Error) {
+                    if (err) node.error(err, msg);
+                };
+
+            try {
+                if (typeof msg.payload !== 'string') {
+                    throw new Error('Payload is not a string!');
+                }
+
+                msg.payload = compiledConvert(msg.payload);
+                send(msg);
+                done();
+            } catch (error) {
+                done(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+
+    RED.nodes.registerType('html-to-text', HtmlToText);
+};
+
+export = HtmlToTextNode;

package/src/index.ts

@@ -0,0 +1,12 @@
+// Importiere die Registrierungsfunktion für deine Nodes.
+import registerEmailReceiverNode from './email-receiver/email-receiver';
+import registerEmailSenderNode from './email-sender/email-sender';
+import registerHtmlToTextNode from './html-to-text/html-to-text';
+
+// Exportiere eine Funktion, die alle Nodes registriert.
+export = function (RED: any) {
+    // Rufe die Registrierungsfunktionen für jede Node auf.
+    registerEmailReceiverNode(RED);
+    registerEmailSenderNode(RED);
+    registerHtmlToTextNode(RED);
+};

package/src/interfaces/EmailReceiverMessage.ts

@@ -0,0 +1,22 @@
+import type { ParsedMail } from 'mailparser';
+
+// Custom type for the output message
+export interface EmailReceiverMessage {
+    topic: string | undefined;
+    payload: string | undefined;
+    html: string | boolean | undefined;
+    from: string | undefined;
+    date: Date | undefined;
+    folder: string;
+    header: ParsedMail['headers'];
+    attachments: Array<{
+        contentType: string;
+        fileName: string | undefined;
+        contentDisposition: string;
+        generatedFileName: string | undefined;
+        contentId: string | undefined;
+        checksum: string;
+        length: number;
+        content: Buffer;
+    }>;
+}

package/src/interfaces/EmailSenderNodeProperties.ts

@@ -0,0 +1,37 @@
+import { NodeDef } from 'node-red';
+
+export interface EmailSenderNodeProperties extends NodeDef {
+    // Mail configuration properties
+    sender: string;
+    senderType: string;
+    address: string;
+    addressType: string;
+    to: string;
+    toType: string;
+    cc: string;
+    ccType: string;
+    bcc: string;
+    bccType: string;
+    replyTo: string;
+    replyToType: string;
+    subject: string;
+    subjectType: string;
+    htmlContent: string;
+    htmlContentType: string;
+    attachments: string;
+    attachmentsType: string;
+
+    // SMTP configuration properties
+    host: string;
+    hostType: string;
+    port: string;
+    portType: string;
+    user: string;
+    userType: string;
+    password: string;
+    passwordType: string;
+    secure: string;
+    secureType: string;
+    rejectUnauthorized: string;
+    rejectUnauthorizedType: string;
+}

package/src/interfaces/FetchState.ts

@@ -0,0 +1,9 @@
+export interface FetchState {
+    totalFolders: number;
+    processedFolders: number;
+    successes: number;
+    failures: number;
+    totalMails: number;
+    errors: Error[];
+    folderCount: { [folder: string]: number };
+}

package/src/interfaces/ImapConnectionConfig.ts

@@ -0,0 +1,14 @@
+export interface ImapConnectionConfig {
+    host: string;
+    port: number;
+    tls: boolean;
+    user: string;
+    password: string;
+    folders: string[];
+    markSeen: boolean;
+    connTimeout: number;
+    authTimeout: number;
+    keepalive: boolean;
+    autotls: string;
+    tlsOptions: { rejectUnauthorized: boolean };
+}

package/src/test/framework/advanced-test-patterns.ts

@@ -0,0 +1,224 @@
+// ============================================================================
+// ADVANCED TEST PATTERNS FOR NODE-RED CUSTOM NODES
+// ============================================================================
+
+import type { TestScenario } from './types';
+
+// ============================================================================
+// ERROR RESILIENCE PATTERNS
+// ============================================================================
+
+export class ErrorResilienceTestBuilder {
+    private scenarios: TestScenario[] = [];
+
+    addNetworkErrorScenario(name: string, config: any): this {
+        return this.addScenario({
+            name: `${name} - network error`,
+            config: { ...config, host: 'unreachable.invalid.test' },
+            input: { payload: 'test' },
+            expectedError: /network|connection|timeout/i,
+            timeout: 3000,
+        });
+    }
+
+    addMalformedInputScenario(name: string, config: any): this {
+        const malformedInputs = [
+            null,
+            undefined,
+            { payload: null },
+            { payload: '' },
+            { payload: { malformed: true, circular: null } },
+            'not-an-object',
+        ];
+
+        malformedInputs.forEach((input, index) => {
+            this.addScenario({
+                name: `${name} - malformed input ${index + 1}`,
+                config,
+                input,
+                timeout: 2000,
+            });
+        });
+
+        return this;
+    }
+
+    addResourceExhaustionScenario(name: string, config: any): this {
+        return this.addScenario({
+            name: `${name} - resource exhaustion`,
+            config,
+            input: {
+                payload: 'x'.repeat(10 * 1024 * 1024), // 10MB payload
+                largeArray: Array.from({ length: 100000 }, (_, i) => ({ id: i, data: 'test' })),
+            },
+            timeout: 5000,
+        });
+    }
+
+    addRapidFireScenario(name: string, config: any, messageCount: number = 1000): this {
+        return this.addScenario({
+            name: `${name} - rapid fire messages`,
+            config,
+            input: Array.from({ length: messageCount }, (_, i) => ({
+                payload: `rapid-message-${i}`,
+                sequence: i,
+            })),
+            timeout: Math.max(5000, messageCount * 5),
+        });
+    }
+
+    private addScenario(scenario: TestScenario): this {
+        this.scenarios.push(scenario);
+        return this;
+    }
+
+    getScenarios(): TestScenario[] {
+        return [...this.scenarios];
+    }
+}
+// ============================================================================
+// EDGE CASE PATTERNS
+// ============================================================================
+
+export class EdgeCaseTestBuilder {
+    private scenarios: TestScenario[] = [];
+
+    addEmptyDataScenarios(name: string, config: any): this {
+        const emptyDataCases = [
+            { name: 'empty object', data: {} },
+            { name: 'empty array', data: [] },
+            { name: 'empty string', data: '' },
+            { name: 'null payload', data: null },
+            { name: 'undefined payload', data: undefined },
+            { name: 'zero value', data: 0 },
+            { name: 'false value', data: false },
+        ];
+
+        emptyDataCases.forEach((testCase) => {
+            this.scenarios.push({
+                name: `${name} - ${testCase.name}`,
+                config,
+                input: { payload: testCase.data },
+                timeout: 2000,
+            });
+        });
+
+        return this;
+    }
+
+    addSpecialCharacterScenarios(name: string, config: any): this {
+        const specialCases = [
+            { name: 'unicode characters', data: '🚀💡🌟' },
+            { name: 'newlines and tabs', data: 'line1\nline2\tindented' },
+            { name: 'special symbols', data: '!@#$%^&*()_+-=[]{}|;:,.<>?' },
+            { name: 'very long string', data: 'a'.repeat(10000) },
+            { name: 'mixed encoding', data: 'Ñiño café résumé 北京' },
+        ];
+
+        specialCases.forEach((testCase) => {
+            this.scenarios.push({
+                name: `${name} - ${testCase.name}`,
+                config,
+                input: { payload: testCase.data },
+                timeout: 3000,
+            });
+        });
+
+        return this;
+    }
+
+    addLargeDataScenarios(name: string, config: any): this {
+        const largeCases = [
+            {
+                name: 'large object',
+                data: Object.fromEntries(Array.from({ length: 1000 }, (_, i) => [`key${i}`, `value${i}`])),
+            },
+            {
+                name: 'deeply nested object',
+                data: Array.from({ length: 100 }, () => ({})).reduce((acc, _, i) => ({ [`level${i}`]: acc }), {
+                    deepest: true,
+                }),
+            },
+            {
+                name: 'large array',
+                data: Array.from({ length: 10000 }, (_, i) => ({ id: i, data: `item${i}` })),
+            },
+        ];
+
+        largeCases.forEach((testCase) => {
+            this.scenarios.push({
+                name: `${name} - ${testCase.name}`,
+                config,
+                input: { payload: testCase.data },
+                timeout: 5000,
+            });
+        });
+
+        return this;
+    }
+
+    getScenarios(): TestScenario[] {
+        return [...this.scenarios];
+    }
+}
+
+// ============================================================================
+// SECURITY TESTING PATTERNS
+// ============================================================================
+
+export class SecurityTestBuilder {
+    private scenarios: TestScenario[] = [];
+
+    addInjectionTestScenarios(name: string, config: any): this {
+        const injectionPayloads = [
+            { name: 'SQL injection', payload: "'; DROP TABLE users; --" },
+            { name: 'XSS attempt', payload: '<script>alert("xss")</script>' },
+            { name: 'Command injection', payload: '; rm -rf / ;' },
+            { name: 'Path traversal', payload: '../../../etc/passwd' },
+            { name: 'JSON injection', payload: '{"__proto__":{"isAdmin":true}}' },
+        ];
+
+        injectionPayloads.forEach((attack) => {
+            this.scenarios.push({
+                name: `${name} - ${attack.name}`,
+                config,
+                input: { payload: attack.payload },
+                timeout: 2000,
+            });
+        });
+
+        return this;
+    }
+
+    addOversizedPayloadScenarios(name: string, config: any): this {
+        const oversizedCases = [
+            { name: '1MB payload', size: 1024 * 1024 },
+            { name: '10MB payload', size: 10 * 1024 * 1024 },
+            { name: 'deeply nested payload', depth: 1000 },
+        ];
+
+        oversizedCases.forEach((testCase) => {
+            let payload;
+            if (testCase.size) {
+                payload = 'x'.repeat(testCase.size);
+            } else if (testCase.depth) {
+                payload = Array.from({ length: testCase.depth }, () => ({})).reduce((acc) => ({ nested: acc }), {
+                    bottom: true,
+                });
+            }
+
+            this.scenarios.push({
+                name: `${name} - ${testCase.name}`,
+                config,
+                input: { payload },
+                timeout: 10000,
+            });
+        });
+
+        return this;
+    }
+
+    getScenarios(): TestScenario[] {
+        return [...this.scenarios];
+    }
+}

package/src/test/framework/generic-node-test-suite.ts

@@ -0,0 +1,58 @@
+import { expect } from 'chai';
+import { TestScenarioBuilder } from './test-scenario-builder';
+import { NodeTestRunner } from './node-test-runner';
+import { NodeAssertions } from './node-assertions';
+import type { TestScenario } from './types';
+
+/**
+ * Generic test suite generator for Node-RED custom nodes
+ */
+export function createNodeTestSuite(nodeName: string, nodeConstructor: Function, testConfigs: Record<string, any>) {
+    describe(`${nodeName} - Generic Test Suite`, function () {
+        this.timeout(10000);
+
+        describe('Node Registration', function () {
+            it('should register without errors', async function () {
+                const scenario: TestScenario = {
+                    name: 'registration',
+                    config: testConfigs.valid || testConfigs.minimal || {},
+                };
+
+                const context = await NodeTestRunner.runScenario(nodeConstructor, scenario);
+                expect(context.nodeInstance).to.exist;
+                expect(context.mockRED.nodes.lastRegisteredType).to.exist;
+                expect(context.mockRED.nodes.lastRegisteredConstructor).to.be.a('function');
+            });
+        });
+
+        describe('Configuration Validation', function () {
+            const validationTests = new TestScenarioBuilder();
+
+            if (testConfigs.valid) {
+                validationTests.addValidScenario('valid config', testConfigs.valid);
+            }
+
+            if (testConfigs.minimal) {
+                validationTests.addValidScenario('minimal config', testConfigs.minimal);
+            }
+
+            if (testConfigs.invalid) {
+                validationTests.addErrorScenario('invalid config', testConfigs.invalid, /error|invalid|missing/i);
+            }
+
+            validationTests.getScenarios().forEach((scenario) => {
+                it(`should handle ${scenario.name}`, async function () {
+                    const context = await NodeTestRunner.runScenario(nodeConstructor, scenario);
+
+                    expect(context.nodeInstance).to.exist;
+
+                    if (scenario.expectedError) {
+                        NodeAssertions.expectError(context, scenario.expectedError);
+                    } else {
+                        NodeAssertions.expectNoErrors(context);
+                    }
+                });
+            });
+        });
+    });
+}

package/src/test/framework/index.ts

@@ -0,0 +1,17 @@
+// Main exports for the Node-RED test framework
+
+// Unit Testing Framework
+export { TestScenarioBuilder } from './test-scenario-builder';
+export { NodeTestRunner } from './node-test-runner';
+export { NodeAssertions } from './node-assertions';
+export { createNodeTestSuite } from './generic-node-test-suite';
+
+// Integration Testing Framework
+export { IntegrationTestRunner } from './integration-test-runner';
+export { IntegrationAssertions } from './integration-assertions';
+export { IntegrationScenarioBuilder } from './integration-scenario-builder';
+
+export { ErrorResilienceTestBuilder, EdgeCaseTestBuilder, SecurityTestBuilder } from './advanced-test-patterns';
+
+// Types
+export * from './types';