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

IMAP eMail Management for Wappler

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

exports.imapgetrawheaders = async function (options) {
    const IMAP_HOST = this.parseOptional(options.imap_host, '*', process.env.IMAP_HOST);
    const IMAP_PASSWORD = this.parseOptional(options.imap_password, '*', process.env.IMAP_PASSWORD);
    const IMAP_USER = this.parseOptional(options.imap_user, '*', process.env.IMAP_USER);
    const IMAP_PORT = this.parseOptional(options.imap_port, '*', process.env.IMAP_PORT);
    const imap_tlsstring = this.parseOptional(options.imap_tls, '*', process.env.IMAP_TLS).toLowerCase();
    const IMAP_TLS = (imap_tlsstring === 'true');

    const mailbox = this.parseOptional(options.mailbox, '*', 'INBOX');

    console.log(`Connecting to IMAP server... User: ${IMAP_USER}`);

    return new Promise((resolve, reject) => {
        const imap = new Imap({
            user: IMAP_USER,
            password: IMAP_PASSWORD,
            host: IMAP_HOST,
            port: IMAP_PORT,
            tls: IMAP_TLS,
            tlsOptions: {
                rejectUnauthorized: process.env.IMAP_CERTIFICATE_OVERRIDE === '1' ? false : true
            }

        });

        imap.once('error', (err) => {
            console.error(`IMAP Connection Error: ${err.message}`);
            return reject(`IMAP Error: ${err.message}`);
        });

        imap.once('ready', () => {
            console.log('IMAP connection established.');

            imap.openBox(mailbox, false, (err, box) => {
                if (err) {
                    console.error(`Error opening mailbox: ${err.message}`);
                    imap.end();
                    return reject(`Error opening mailbox: ${err.message}`);
                }

                console.log(`Mailbox "${mailbox}" opened. Total Messages: ${box.messages.total}`);

                if (box.messages.total === 0) {
                    imap.end();
                    console.warn('No messages found.');
                    return reject('No messages found.');
                }

                imap.search(['ALL'], (err, results) => {
                    if (err || results.length === 0) {
                        console.error('No messages available.');
                        imap.end();
                        return reject('No messages available.');
                    }

                    console.log(`Found ${results.length} messages. Fetching headers and body...`);

                    const fetch = imap.fetch([results[0]], { bodies: '', struct: true });

                    fetch.on('message', (msg, seqno) => {
                        console.log(`Processing message #${seqno}`);
                        let headerData = '';
                        let bodyData = '';
                        let internalDate = '';

                        msg.on('body', (stream, info) => {
                            stream.on('data', (chunk) => {
                                if (info.which === 'HEADER') {
                                    headerData += chunk.toString();
                                } else {
                                    bodyData += chunk.toString();
                                }
                            });

                            stream.on('end', async () => {
                                try {
                                    const parsed = await simpleParser(headerData + bodyData);
                                    console.log(`Parsed Message #${seqno}:`, parsed);

                                    resolve({
                                        id: seqno,
                                        headers: parsed.headers,
                                        subject: parsed.subject,
                                        from: parsed.from?.text,
                                        to: parsed.to?.text,
                                        date: parsed.date || internalDate,
                                        body: parsed.text, // Plain text version of the email
                                        htmlBody: parsed.html, // HTML version of the email
                                    });
                                } catch (error) {
                                    console.error(`Error parsing message: ${error.message}`);
                                    reject(`Error parsing message: ${error.message}`);
                                }
                            });
                        });

                        msg.on('attributes', (attrs) => {
                            internalDate = attrs.date?.toUTCString();
                            console.log(`Message #${seqno} internal date: ${internalDate}`);
                        });
                    });

                    fetch.once('error', (err) => {
                        console.error(`Fetch error: ${err.message}`);
                        reject(`Fetch error: ${err.message}`);
                    });

                    fetch.once('end', () => {
                        console.log('Fetching process completed. Closing IMAP connection.');
                        imap.end();
                    });
                });
            });
        });

        imap.once('end', () => {
            console.log('IMAP connection closed.');
        });

        imap.connect();
    });
};