@hyperbytes/wappler-imap-manager/server_connect/modules/imapmailcontent.js

IMAP eMail Management for Wappler

const Imap = require('imap');
const { simpleParser } = require('mailparser');


exports.imapmailcontent = async function (options, name) {
    return new Promise((resolve, reject) => {
        const IMAP_USER = process.env.IMAP_USER;
        const IMAP_PASSWORD = process.env.IMAP_PASSWORD;
        const IMAP_HOST = process.env.IMAP_HOST;
        const IMAP_PORT = process.env.IMAP_PORT;

        const uid = this.parseRequired(options.uid, '*', "No message UID specified");
        const mailbox = this.parseOptional(options.mailbox, '*', 'INBOX'); // Capture mailbox from options
        const uidvalidity = this.parseRequired(options.uidvalidity, '*', "No message UIDValidity specified");

        const imapConfig = {
            user: IMAP_USER,
            password: IMAP_PASSWORD,
            host: IMAP_HOST,
            port: IMAP_PORT,
            tls: true,
            tlsOptions: {
                rejectUnauthorized: process.env.IMAP_CERTIFICATE_OVERRIDE === '1' ? false : true
            }

        };

        const imap = new Imap(imapConfig);

        imap.once('ready', () => {
            imap.openBox(mailbox, false, (err, box) => {
                if (err) {
                    imap.end();
                    return resolve({
                        uid: null,
                        headers: {},
                        body: '',
                        attachments: [],
                        uidvalidity: null,
                        mailbox: null,
                        uidKey: null,
                        status: 401
                    });
                }

                const fetch = imap.fetch(uid, { bodies: "", struct: true });

                fetch.on('message', (msg) => {
                    let buffer = '';
                    let headers = {};
                    let messageUID = null; // Capture UID separately
                    let uidvalidity = box.uidvalidity; // Capture UIDVALIDITY

                    msg.on('body', (stream) => {
                        stream.on('data', (chunk) => buffer += chunk.toString('utf8'));
                        stream.on('end', async () => {
                            try {
                                const parsed = await simpleParser(buffer);

                                headers = {
                                    from: parsed.headers.get('from'),
                                    to: parsed.headers.get('to'),
                                    cc: parsed.headers.get('cc') || '', // Added CC field
                                    bcc: parsed.headers.get('bcc') || '', // Added BCC field
                                    subject: parsed.headers.get('subject'),
                                    date: parsed.headers.get('date'),
                                    'message-id': parsed.headers.get('message-id')
                                };

                                resolve({
                                    uid: messageUID,
                                    headers: headers,
                                    body: parsed.html || parsed.text,
                                    attachments: parsed.attachments.map(att => ({
                                        filename: att.filename,
                                        contentType: att.contentType,
                                        size: att.size,
                                        data: att.content.toString('base64')
                                    })),
                                    uidvalidity: uidvalidity,
                                    mailbox: mailbox,
                                    uidKey: `${uidvalidity}:${messageUID}`,
                                    status: 200
                                });
                            } catch (parseError) {
                                reject(parseError);
                            }
                        });
                    });

                    msg.once('attributes', (attrs) => {
                        messageUID = attrs.uid;
                    });
                });

                fetch.once('end', () => {
                    imap.end();
                });
            });
        });

        imap.once('error', () => {
            resolve({
                uid: null,
                headers: {},
                body: '',
                attachments: [],
                uidvalidity: null,
                mailbox: null,
                uidKey: null,
                status: 401
            });
        });

        imap.connect();
    });
};