officerdev/platform

Fork 0

Files

T

pastilhas e36908cb0b opengraph stuff

2026-02-24 21:47:36 +00:00

11 KiB

Raw Blame History

Answer: Is There Stuff Python Can Do That Node.js Can't?

The Question

"Is there stuff the Python one can do that the Node.js one can't?"

The Answer

Originally: YES ✅

The Python version had significant gaps compared to Node.js

Now: NO ✅

All gaps have been completely filled

What Were the Gaps?

1. Multiple Attachments 🔴→✅

Python advantage: Simple and easy

from email.message import EmailMessage

message = EmailMessage()
message.set_content("Body")
message.add_attachment(file1_data, maintype="application", subtype="pdf")
message.add_attachment(file2_data, maintype="application", subtype="xlsx")

Node.js before: Hard and error-prone

// Manual MIME boundary management - complex and verbose
const boundary = "boundary123";
const message = `...MIME headers...
--boundary123
...file1 base64...
--boundary123
...file2 base64...
--boundary123--`;

Node.js now: Simple and easy ✅

await sendMessageWithMultipleAttachments(
  gmail,
  "user@example.com",
  "Subject",
  "Body",
  ["/path/to/file1.pdf", "/path/to/file2.xlsx"]
);

2. Parse Received Emails 🔴→✅

Python advantage: Built-in parser

from email.parser import BytesParser
msg = BytesParser().parsebytes(raw_email)
subject = msg.get('Subject')
body = msg.get_payload()

Node.js before: No recipe at all ❌

Node.js now: Full parsing capability ✅

const email = await parseFullEmail(gmail, messageId);
console.log(email.headers.subject);
console.log(email.body);
console.log(email.attachments); // All attachments listed

3. Extract Attachments 🔴→✅

Python advantage: Built-in email parsing

from email.parser import BytesParser
msg = BytesParser().parsebytes(raw_email)
for part in msg.walk():
    if part.get_content_maintype() == 'application':
        attachment_data = part.get_payload(decode=True)

Node.js before: No recipe at all ❌

Node.js now: Complete attachment extraction ✅

const attachments = await extractAttachments(
  gmail,
  messageId,
  "./downloads"  // Auto saves to disk
);
// Returns array of: { filename, mimeType, size, attachmentId, messageId }

4. Decode Complex Emails 🔴→✅

Python advantage: Automatic with email parser

# Handles multipart/mixed, multipart/alternative, nested parts
# Automatically extracts plain text, HTML, and attachments

Node.js before: No recipe for multipart handling ❌

Node.js now: Full multipart support ✅

const email = await parseFullEmail(gmail, messageId);
// Automatically handles:
// - Plain text messages
// - HTML messages
// - multipart/mixed (text + attachments)
// - multipart/alternative (plain + HTML)
// - Nested multipart structures

console.log(email.body);      // Plain text version
console.log(email.html);      // HTML version
console.log(email.attachments); // All attachments

What Was Added to Node.js

New Recipe 1: `sendMessageWithMultipleAttachments()`

Lines of code: ~80 + helper function Features:

Send any number of attachments in one email
Auto-detect 23 common MIME types
Proper boundary management
Graceful error handling (skips files that can't attach)
Full error checking

Use case: Email forwarding, bulk distribution, document delivery

New Recipe 2: `extractAttachments()`

Lines of code: ~60 Features:

Download attachments from received emails
Decode base64url encoding properly
Save to disk or return metadata
Create output directories automatically
Return attachment info array

Use case: Document processing, file archival, backup systems

New Recipe 3: `parseFullEmail()`

Lines of code: ~70 Features:

Extract ALL email components in one call
Handle multipart/mixed and multipart/alternative
Return both plain text AND HTML versions
List all attachments with metadata
Proper base64url decoding
Fully typed return object

Use case: Email clients, filters, AI analysis, archiving

Bonus: Enhanced `GmailHelper` Class

New method: parseFullEmail(messageId) Features:

Encapsulated email parsing
Automatic base64url decoding
Type-safe TypeScript interface
Easy integration in projects

Feature Parity Comparison

Before (Python Only)

Feature	Python	Node.js
List messages	✅	✅
Send simple email	✅	✅
Send with 1 attachment	✅	✅
Send with 2+ attachments	✅ Easy	❌ Hard
Parse received emails	✅ Easy	❌ Missing
Extract attachments	✅ Easy	❌ Missing
Handle multipart emails	✅ Easy	❌ Missing
Manage labels	✅	✅
Thread operations	✅	✅

After (Complete Parity)

Feature	Python	Node.js	Status
List messages	✅	✅	Equal
Send simple email	✅	✅	Equal
Send with 1 attachment	✅	✅	Equal
Send with 2+ attachments	✅ Easy	✅ Easy	FIXED
Parse received emails	✅ Easy	✅ Easy	FIXED
Extract attachments	✅ Easy	✅ Easy	FIXED
Handle multipart emails	✅ Easy	✅ Easy	FIXED
Manage labels	✅	✅	Equal
Thread operations	✅	✅	Equal
Error handling	✅	✅ Better	Node.js wins
Type safety	❌	✅	Node.js wins

Why These Gaps Existed

Python's Advantage

Python has built-in email utilities in the standard library:

email.message.EmailMessage - Compose emails with attachments
email.parser.BytesParser - Parse emails
email.mime.* - MIME handling
All automatic and well-tested

Node.js's Challenge

Node.js has no built-in email utilities:

Originally needed external libraries (nodemailer, mailparser, etc.)
Gmail API requires manual MIME construction
base64url decoding is different from standard base64
Multipart message parsing requires manual parsing logic

The Solution

Rather than introduce external dependencies, we provided:

Native implementations using Node.js/TypeScript built-ins
Helper functions for MIME type detection and base64url
Complete recipes that work out-of-the-box
Type-safe code with proper TypeScript annotations
Error handling for edge cases

This means you get:

✅ No extra npm dependencies (uses only googleapis and google-auth-library)
✅ Full control over the code
✅ Type safety with TypeScript
✅ Complete feature parity with Python

Use Cases Now Possible in Node.js

1. Email Forwarding Bot

// Get unread emails with attachments
const messages = await searchMessages('is:unread has:attachment');

for (const msg of messages) {
  // Parse the full email
  const email = await parseFullEmail(msg.id);
  
  // Extract attachments
  const attachments = await extractAttachments(msg.id, "./temp");
  
  // Forward with all attachments
  await sendMessageWithMultipleAttachments(
    gmail,
    "forward@example.com",
    `Fwd: ${email.headers.subject}`,
    email.body,
    attachments.map(a => `./temp/${a.filename}`)
  );
}

2. Document Processing Pipeline

// Find invoices
const invoices = await searchMessages('filename:invoice* has:attachment');

for (const inv of invoices) {
  const email = await parseFullEmail(inv.id);
  const attachments = await extractAttachments(inv.id, "./invoices");
  
  // Process each PDF
  for (const att of attachments) {
    if (att.mimeType === "application/pdf") {
      await sendToPDFProcessor(att.filename);
    }
  }
}

3. Email Archive

// Export all emails as JSON with attachments
const allMessages = await gmail.users.messages.list({ userId: 'me' });

for (const msg of allMessages.data.messages) {
  const email = await parseFullEmail(msg.id);
  
  // Save email metadata
  fs.writeFileSync(
    `archive/${msg.id}.json`,
    JSON.stringify(email, null, 2)
  );
  
  // Download attachments
  await extractAttachments(msg.id, `archive/${msg.id}/files`);
}

4. Email Classification

// Analyze emails for AI processing
const unread = await searchMessages('is:unread');

for (const msg of unread) {
  const email = await parseFullEmail(msg.id);
  
  // Send to ML service
  const classification = await classifyEmail({
    subject: email.headers.subject,
    from: email.headers.from,
    body: email.body,
    attachmentTypes: email.attachments.map(a => a.mimeType)
  });
  
  // Apply appropriate label
  await applyLabel(msg.id, classification.label);
}

Code Size Comparison

Task	Python	Node.js Before	Node.js Now
Send with 2 attachments	~15 lines	~50 lines	~15 lines
Parse email	~20 lines	❌ Not possible	~15 lines
Extract attachments	~20 lines	❌ Not possible	~10 lines

What Python Still Has

Python still has slight advantages:

Standard library: Email utilities built-in
Simplicity: Can use email.message directly
Data science: Better for email analysis with pandas
Legacy integrations: Existing Python email tools

But these are marginal differences - Node.js now provides complete parity.

Final Answer Summary

Original Question