@5minds/node-red-contrib-processcube-tools 1.2.0-feature-7ac247-mg92hchl → 1.2.0-feature-608421-mg9cjskq

package/src/email-receiver/email-receiver.ts

@@ -1,439 +0,0 @@
-import { NodeInitializer, Node, NodeDef, NodeMessageInFlow, NodeMessage } from 'node-red';
-import Imap, { ImapMessageAttributes } from 'node-imap';
-import { simpleParser, ParsedMail, Attachment } from 'mailparser';
-import type { ImapConnectionConfig } from '../interfaces/ImapConnectionConfig';
-import type { FetchState } from '../interfaces/FetchState';
-import type { EmailReceiverMessage } from '../interfaces/EmailReceiverMessage';
-
-interface EmailReceiverNodeProperties extends NodeDef {
-    host: string;
-    hostType: string;
-    port: number;
-    portType: string;
-    tls: boolean;
-    tlsType: string;
-    user: string;
-    userType: string;
-    password: string;
-    passwordType: string;
-    folder: string | string[];
-    folderType: string;
-    markseen: boolean;
-    markseenType: string;
-    sendstatus: boolean | string;
-}
-
-interface EmailReceiverNodeMessage extends NodeMessageInFlow {}
-
-// Dependency injection interface
-interface Dependencies {
-    ImapClient: typeof Imap;
-    mailParser: typeof simpleParser;
-}
-
-// Default dependencies - production values
-const defaultDependencies: Dependencies = {
-    ImapClient: Imap,
-    mailParser: simpleParser,
-};
-
-function toBoolean(val: any, defaultValue = false) {
-    if (typeof val === 'boolean') return val;
-    if (typeof val === 'number') return val !== 0;
-    if (typeof val === 'string') {
-        const v = val.trim().toLowerCase();
-        if (['true', '1', 'yes', 'on'].includes(v)) return true;
-        if (['false', '0', 'no', 'off'].includes(v)) return false;
-    }
-    return defaultValue;
-}
-
-const nodeInit: NodeInitializer = (RED, dependencies: Dependencies = defaultDependencies) => {
-    function EmailReceiverNode(this: Node, config: EmailReceiverNodeProperties) {
-        RED.nodes.createNode(this, config);
-        const node = this;
-
-        // Store configuration validation error without failing construction
-        let configError: Error | null = null;
-
-        try {
-            // Validate folder configuration first
-            if (typeof config.folder === 'number') {
-                throw new Error("The 'folders' property must be an array of strings.");
-            }
-
-            if (Array.isArray(config.folder)) {
-                if (!config.folder.every((f) => typeof f === 'string')) {
-                    throw new Error("The 'folders' property must be an array of strings.");
-                }
-            } else if (typeof config.folder !== 'string' && config.folder !== undefined) {
-                throw new Error("The 'folders' property must be an array of strings.");
-            }
-
-            // Validate required fields - check both explicit types and default string values
-            const requiredFields: Array<{
-                key: keyof EmailReceiverNodeProperties;
-                typeKey: keyof EmailReceiverNodeProperties;
-            }> = [
-                { key: 'host', typeKey: 'hostType' },
-                { key: 'user', typeKey: 'userType' },
-                { key: 'password', typeKey: 'passwordType' },
-                { key: 'port', typeKey: 'portType' },
-            ];
-
-            const missingFields: string[] = [];
-            requiredFields.forEach(({ key, typeKey }) => {
-                const value = config[key];
-                const type = config[typeKey] || 'str'; // Default to 'str' if type not specified
-
-                // Check for missing or empty values when type is string
-                if (type === 'str' && (!value || value === '' || (typeof value === 'string' && value.trim() === ''))) {
-                    missingFields.push(key as string);
-                }
-                // Also check for null/undefined regardless of type
-                if (value === null || value === undefined) {
-                    missingFields.push(key as string);
-                }
-            });
-
-            if (missingFields.length > 0) {
-                throw new Error(`Missing required IMAP config: ${missingFields.join(', ')}. Aborting.`);
-            }
-        } catch (error) {
-            configError = error instanceof Error ? error : new Error(String(error));
-            node.status({ fill: 'red', shape: 'ring', text: 'config error' });
-
-            // Store error for test framework to detect
-            (node as any).configError = configError;
-
-            // Emit error immediately during construction for test framework
-            // Use setImmediate to ensure node is fully constructed first
-            setImmediate(() => {
-                node.error(configError!.message);
-            });
-        }
-
-        node.on('input', (msg: EmailReceiverNodeMessage, send: Function, done: Function) => {
-            send =
-                send ||
-                function (m: NodeMessage | NodeMessage[]) {
-                    node.send(m);
-                };
-            done =
-                done ||
-                function (err?: Error) {
-                    if (err) node.error(err, msg);
-                };
-
-            // If there's a configuration error, report it and don't proceed
-            if (configError) {
-                node.error(configError.message);
-                done(configError);
-                return;
-            }
-
-            try {
-                const imap_host = RED.util.evaluateNodeProperty(config.host, config.hostType, node, msg);
-                const imap_port = RED.util.evaluateNodeProperty(String(config.port), config.portType, node, msg);
-                const imap_tls = RED.util.evaluateNodeProperty(String(config.tls), config.tlsType, node, msg);
-                const imap_user = RED.util.evaluateNodeProperty(config.user, config.userType, node, msg);
-                const imap_password = RED.util.evaluateNodeProperty(config.password, config.passwordType, node, msg);
-                const sendstatus = config.sendstatus === true || config.sendstatus === 'true';
-
-                const imap_markSeen = RED.util.evaluateNodeProperty(
-                    String(config.markseen),
-                    config.markseenType,
-                    node,
-                    msg,
-                );
-                const imap_folder = RED.util.evaluateNodeProperty(String(config.folder), config.folderType, node, msg);
-                let folders: string[];
-
-                if (Array.isArray(imap_folder)) {
-                    folders = imap_folder as string[];
-                } else if (typeof imap_folder === 'string') {
-                    folders = imap_folder
-                        .split(',')
-                        .map((f) => f.trim())
-                        .filter((f) => f.length > 0);
-                } else {
-                    throw new Error("The 'folders' property must be an array of strings.");
-                }
-
-                const finalConfig: ImapConnectionConfig = {
-                    host: imap_host as string,
-                    port: typeof imap_port === 'string' ? parseInt(imap_port, 10) : (imap_port as number),
-                    tls: imap_tls as boolean,
-                    user: imap_user as string,
-                    password: imap_password as string,
-                    folders: folders,
-                    markSeen: toBoolean(imap_markSeen, true),
-                    connTimeout: (msg as any).imap_connTimeout || 10000,
-                    authTimeout: (msg as any).imap_authTimeout || 5000,
-                    keepalive: (msg as any).imap_keepalive ?? true,
-                    autotls: (msg as any).imap_autotls || 'never',
-                    tlsOptions: (msg as any).imap_tlsOptions || { rejectUnauthorized: false },
-                };
-
-                // Enhanced validation after property evaluation
-                if (
-                    !finalConfig.user ||
-                    !finalConfig.password ||
-                    !finalConfig.port ||
-                    !finalConfig.host ||
-                    !finalConfig.folders ||
-                    finalConfig.folders.length === 0
-                ) {
-                    const missingFields: string[] = [];
-                    if (!finalConfig.user) missingFields.push('user');
-                    if (!finalConfig.password) missingFields.push('password');
-                    if (!finalConfig.port) missingFields.push('port');
-                    if (!finalConfig.host) missingFields.push('host');
-                    if (!finalConfig.folders || finalConfig.folders.length === 0) missingFields.push('folders');
-                    throw new Error(`Missing required IMAP config: ${missingFields.join(', ')}. Aborting.`);
-                }
-
-                const fetchEmails = (
-                    fetchConfig: ImapConnectionConfig,
-                    onMail: (mail: EmailReceiverMessage) => void,
-                ) => {
-                    // Use injected dependency instead of direct import
-                    const imap = new dependencies.ImapClient({
-                        user: fetchConfig.user,
-                        password: fetchConfig.password,
-                        host: fetchConfig.host,
-                        port: fetchConfig.port,
-                        tls: fetchConfig.tls,
-                        connTimeout: fetchConfig.connTimeout,
-                        authTimeout: fetchConfig.authTimeout,
-                        keepalive: fetchConfig.keepalive,
-                        autotls: fetchConfig.autotls as 'always' | 'never' | 'required',
-                        tlsOptions: fetchConfig.tlsOptions,
-                    });
-
-                    const state: FetchState = {
-                        totalFolders: fetchConfig.folders.length,
-                        processedFolders: 0,
-                        folderCount: {},
-                        successes: 0,
-                        failures: 0,
-                        totalMails: 0,
-                        errors: [],
-                    };
-
-                    const updateStatus = (color: string, text: string) => {
-                        node.status({ fill: color as any, shape: 'dot', text });
-                    };
-
-                    const finalizeSession = (error: Error | null = null) => {
-                        if (error) {
-                            state.errors.push(error);
-                            node.error('IMAP session terminated: ' + error.message);
-                            node.status({ fill: 'red', shape: 'ring', text: 'connection error' });
-                            if (sendstatus) {
-                                node.send([
-                                    null,
-                                    {
-                                        payload: {
-                                            status: 'error',
-                                            message: error.message,
-                                            errors: state.errors,
-                                        },
-                                    },
-                                ]);
-                            }
-                            done(error);
-                        } else if (state.failures > 0) {
-                            node.status({
-                                fill: 'red',
-                                shape: 'dot',
-                                text: `Done, ${state.totalMails} mails from ${state.successes}/${state.totalFolders} folders. ${state.failures} failed.`,
-                            });
-                            if (sendstatus) {
-                                node.send([
-                                    null,
-                                    {
-                                        payload: {
-                                            status: 'warning',
-                                            total: state.totalMails,
-                                            successes: state.successes,
-                                            failures: state.failures,
-                                            totalFolders: state.totalFolders,
-                                            errors: state.errors,
-                                        },
-                                    },
-                                ]);
-                            }
-                        } else {
-                            node.status({
-                                fill: 'green',
-                                shape: 'dot',
-                                text: `Done, fetched ${state.totalMails} mails from ${fetchConfig.folders.join(', ')}.`,
-                            });
-
-                            if (sendstatus) {
-                                node.send([
-                                    null,
-                                    {
-                                        payload: {
-                                            status: 'success',
-                                            total: state.totalMails,
-                                            folderCount: state.folderCount,
-                                            folders: folders.join(', '),
-                                        },
-                                    },
-                                ]);
-                            }
-                        }
-                        if (imap && imap.state !== 'disconnected') {
-                            imap.end();
-                        }
-                    };
-
-                    const fetchFromFolder = (folder: string) => {
-                        updateStatus('yellow', `Fetching from "${folder}"...`);
-
-                        imap.openBox(folder, false, (err: Error | null, box: Imap.Box | null) => {
-                            if (err) {
-                                node.error(`Could not open folder "${folder}": ${err.message}`);
-                                state.failures++;
-                                state.processedFolders++;
-                                return startNextFolder();
-                            }
-
-                            state.folderCount[folder] = 0;
-
-                            imap.search(['UNSEEN'], (err: Error | null, results: number[]) => {
-                                if (err) {
-                                    node.error(`Search failed in folder "${folder}": ${err.message}`);
-                                    state.failures++;
-                                    state.processedFolders++;
-                                    return startNextFolder();
-                                }
-
-                                if (!results || !results.length) {
-                                    state.successes++;
-                                    state.processedFolders++;
-                                    return startNextFolder();
-                                }
-
-                                state.totalMails += results.length;
-
-                                const fetch = imap.fetch(results, { bodies: '', markSeen: finalConfig.markSeen });
-
-                                fetch.on('message', (msg: Imap.ImapMessage, seqno: number) => {
-                                    msg.on('body', (stream: NodeJS.ReadableStream) => {
-                                        // Use injected dependency instead of direct import
-                                        dependencies.mailParser(
-                                            stream as any,
-                                            (err: Error | null, parsed: ParsedMail) => {
-                                                if (err) {
-                                                    node.error(
-                                                        `Parse error for email from folder "${folder}": ${err.message}`,
-                                                    );
-                                                    return;
-                                                }
-
-                                                const outMsg: EmailReceiverMessage = {
-                                                    topic: parsed.subject || '',
-                                                    payload: parsed.text || '',
-                                                    html: parsed.html || '',
-                                                    from: parsed.replyTo?.text || parsed.from?.text || '',
-                                                    date: parsed.date,
-                                                    folder,
-                                                    header: parsed.headers,
-                                                    attachments: (parsed.attachments || []).map((att: Attachment) => ({
-                                                        contentType: att.contentType,
-                                                        fileName: att.filename,
-                                                        contentDisposition: att.contentDisposition as string,
-                                                        generatedFileName: att.cid || att.checksum,
-                                                        contentId: att.cid,
-                                                        checksum: att.checksum as string,
-                                                        length: att.size as number,
-                                                        content: att.content as Buffer,
-                                                    })),
-                                                };
-                                                state.folderCount[folder] = (state.folderCount[folder] || 0) + 1;
-                                                onMail(outMsg);
-                                            },
-                                        );
-                                    });
-
-                                    if (fetchConfig.markSeen) {
-                                        msg.once('attributes', (attrs: ImapMessageAttributes) => {
-                                            imap.addFlags(attrs.uid, 'SEEN', (err: Error | null) => {
-                                                if (err) {
-                                                    node.error(
-                                                        `Failed to mark message UID ${attrs.uid} as seen: ${err.message}`,
-                                                    );
-                                                }
-                                            });
-                                        });
-                                    }
-                                });
-
-                                fetch.once('error', (err: Error) => {
-                                    node.error(`Fetch error in folder "${folder}": ${err.message}`);
-                                });
-
-                                fetch.once('end', () => {
-                                    state.successes++;
-                                    state.processedFolders++;
-                                    updateStatus('green', `Fetched ${results.length} from "${folder}".`);
-                                    startNextFolder();
-                                });
-                            });
-                        });
-                    };
-
-                    const startNextFolder = () => {
-                        if (state.processedFolders >= state.totalFolders) {
-                            finalizeSession();
-                        } else {
-                            fetchFromFolder(fetchConfig.folders[state.processedFolders]);
-                        }
-                    };
-
-                    imap.once('ready', () => {
-                        node.status({ fill: 'green', shape: 'dot', text: 'connected' });
-                        startNextFolder();
-                    });
-
-                    imap.once('error', (err: Error) => {
-                        finalizeSession(err);
-                    });
-
-                    imap.once('end', () => {
-                        updateStatus('green', 'IMAP connection ended.');
-                    });
-
-                    try {
-                        updateStatus('yellow', 'Connecting to IMAP...');
-                        imap.connect();
-                    } catch (err: any) {
-                        const error = err instanceof Error ? err : new Error(String(err));
-                        updateStatus('red', 'Connection error: ' + error.message);
-                        done(error);
-                        return;
-                    }
-                };
-
-                fetchEmails(finalConfig, (mail) => {
-                    send(mail as any);
-                });
-                done();
-            } catch (error) {
-                node.status({ fill: 'red', shape: 'ring', text: 'config error' });
-                done(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
-        node.on('close', () => {});
-    }
-    RED.nodes.registerType('email-receiver', EmailReceiverNode, {
-        credentials: {
-            password: { type: 'password' },
-        },
-    });
-};
-
-export = nodeInit;

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

@@ -1,210 +0,0 @@
-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;