Trying to use Haraka as the Mail Server in our new project

[shemeerfr]

Trying to use Haraka as the Mail Server in our new project ,We are trying to make our own plugin and no way we could find a solution to access the mail properties like Body and the attachments , Can any one please help us to find an existing plugin which we could get the mail properties like , Receivers, Body , Attachment etc.. Or the sample code snippet that can be used to access this properties

Below is a sample code which we are writing our plugin

var util=require('util');

exports.register = function () {
    this.logdebug("Initializing Parse Message Plugin ....");
    this.register_hook('attachment', 'process_attachments');
};

exports.hook_data = function (next, connection) {
    this.logdebug("inside hook_data ....");

    // Enable mail body parsing - should be enabled in hook_data
    connection.transaction.parse_body = true;

    next();
}

exports.hook_data_post = function (next, connection) {
    this.logdebug("inside hook_data_post ....");

    const transaction = connection.transaction;

    this.logdebug('length is ', transaction.body.children?.length);

    // Extract text and attachments from the email parts
    if (transaction.body.children?.length) {
        for (const part of transaction.body.children) {
            //this.logdebug('part is', util.inspect(part));
            if (part.ct === 'text/plain') {
                // This part is the plain text body
                this.loginfo('Body text:', part.bodytext);
            } else if (part.ct.includes('application/octet-stream')) {
                // This part is the attachment
                const attachment = {
                    filename: part.ct,
                    content: part.body_text_encoded, // or part.body, depending on how it's stored
                    contentType: part.ct
                };
                this.process_attachments(connection, [attachment]);
            }
        }
    }

    next();
}

exports.process_attachments = function (connection, attachments) {
    for (const attachment of attachments) {
        this.loginfo(`Received attachment: ${attachment.filename}, Size: ${attachment.content.length}`);
        // Process the attachment here
    }
}

exports.hook_queue = function (next, connection) {
    this.logdebug("inside hook_queue ....");

    // Enable mail body parsing - should be enabled in hook_data
    connection.transaction.parse_body = true;

    // get a decoded copy of a header, e.g. From
    var from_header = connection.transaction.header.get_decoded('From');
    this.loginfo('from is', from_header);
    
    // get a header that doesn't need to be decoded:
    var msg_id = connection.transaction.header.get('Message-ID');
    this.loginfo('msg_id is', msg_id);
    
    // get multiple headers, e.g. Received:
    var received = connection.transaction.rcpt_to;
    this.loginfo('received is', received);

    next();
}

exports.shutdown = function () {
    this.loginfo("Shutting Parse Message Plugin.");
};

[fusionbeam]

have you figured out a way to do this properly?
I noticed that body parts may be 2 levels deep when dealing with attachments ...

[RagedPanda]

A few things in the sample stop it from working:

1. There is no attachment hook, so this.register_hook('attachment', ...) never fires. Attachments are delivered through transaction.attachment_hooks(), registered in hook_data.
2. parse_body has to be set in hook_data or earlier. Setting it in hook_queue is too late: the body has already been received. (attachment_hooks() turns it on for you.)
3. The body is a tree, not a flat list. A message with an attachment is usually multipart/mixed → (multipart/alternative → text/plain + text/html) + attachment, so the text parts are two levels down. That's the nesting @fusionbeam noticed. Walk children recursively.
4. part.ct includes parameters, e.g. text/plain; charset="utf-8", so part.ct === 'text/plain' rarely matches. Compare the start of the string instead.
5. Attachment content isn't in the body tree. Attachment parts have an empty bodytext; their bytes arrive only on the stream passed to the attachment hook.

Something like this collects all of it:

exports.hook_data = function (next, connection) {
    const txn = connection.transaction
    txn.parse_body = true
    txn.notes.attachments = []

    txn.attachment_hooks((ct, filename, body, stream) => {
        stream.connection = connection // backpressure while we read
        const chunks = []
        stream.on('data', (chunk) => chunks.push(chunk))
        stream.on('end', () => {
            const content = Buffer.concat(chunks)
            txn.notes.attachments.push({ filename, contentType: ct, size: content.length, content })
        })
    })
    next()
}

function collectText(part, found = { text: [], html: [] }) {
    const ct = (part.ct || '').toLowerCase()
    if (ct.startsWith('text/plain')) found.text.push(part.bodytext)
    if (ct.startsWith('text/html')) found.html.push(part.bodytext)
    for (const child of part.children) collectText(child, found)
    return found
}

exports.hook_data_post = function (next, connection) {
    const txn = connection.transaction
    const { text, html } = collectText(txn.body)

    this.loginfo(connection, `from: ${txn.mail_from.address()}`)
    this.loginfo(connection, `to: ${txn.rcpt_to.map((rcpt) => rcpt.address()).join(', ')}`)
    this.loginfo(connection, `subject: ${txn.header.get_decoded('Subject')}`)
    this.loginfo(connection, `text parts: ${text.length}, html parts: ${html.length}`)
    for (const att of txn.notes.attachments) {
        this.loginfo(connection, `attachment: ${att.filename} (${att.contentType}, ${att.size} bytes)`)
    }
    next()
}

• transaction.mail_from and transaction.rcpt_to are the envelope sender and recipients (Address objects; .address() gives user@host). For the header versions use transaction.header.get_decoded('To') etc.
• By hook_data_post the whole message has been parsed and every attachment stream has ended, so it's the place to read everything together, or to next(DENY, ...) based on what you found.
• Buffering attachments in memory is fine for small ones. For large ones, pipe stream to a file instead; the attachment_hooks example in docs/Transaction.md does exactly that.