SendGrid Inbound Parse webhook alternative: migrate to GhostParse

// GhostParse's email.received data as the fields of SendGrid's Inbound Parse POST (its "parsed" format), so a
// handler written for SendGrid keeps working while you migrate. Pass it `event.data` from a verified webhook.
// Attachments come back as { attachment1: { filename, type, content }, … } in place of the uploaded files.
const who = (a) => (a.name ? `${a.name} <${a.address}>` : a.address);
const headerName = (k) => k.replace(/(^|-)([a-z])/g, (m) => m.toUpperCase());

export function toSendGrid(data) {
  const auth = data.authentication ?? {};
  const files = Object.fromEntries(data.attachments.map((a, i) => [`attachment${i + 1}`,
    { filename: a.filename ?? "attachment", type: a.content_type, content: Buffer.from(a.content ?? "", "base64") }]));
  return {
    headers: Object.entries(data.headers ?? {}).map(([k, v]) => `${headerName(k)}: ${v}`).join("\n"),
    from: data.from ? who(data.from) : "",
    to: data.to.map(who).join(", "),
    cc: (data.cc ?? []).map(who).join(", "),
    subject: data.subject ?? "",
    text: data.text ?? "",
    html: data.html ?? "",
    sender_ip: data.envelope?.client_ip ?? "",
    envelope: JSON.stringify({ to: data.envelope?.rcpt_to ?? data.to.map((a) => a.address), from: data.envelope?.mail_from ?? data.from?.address ?? "" }),
    SPF: auth.spf?.result ?? "none",
    dkim: `{${(auth.dkim ?? []).filter((d) => d.domain).map((d) => `@${d.domain} : ${d.result}`).join(", ")}}`,
    spam_score: data.spam ? String(data.spam.score) : "",
    spam_report: "",
    charsets: JSON.stringify({ to: "UTF-8", from: "UTF-8", subject: "UTF-8", text: "UTF-8", html: "UTF-8" }), // GhostParse sends text as UTF-8
    attachments: String(data.attachments.length),
    "attachment-info": JSON.stringify(Object.fromEntries(data.attachments.map((a, i) => [`attachment${i + 1}`,
      { filename: a.filename ?? "attachment", name: a.filename ?? "attachment", type: a.content_type, ...(a.content_id ? { "content-id": a.content_id } : {}) }]))),
    files,
  };
}

"""GhostParse's email.received data as the fields of SendGrid's Inbound Parse POST (its "parsed" format), so a
handler written for SendGrid keeps working while you migrate. Pass it event["data"] from a verified webhook.
Attachments come back as {"attachment1": {"filename", "type", "content"}, ...} in place of the uploaded files."""
import base64
import json
import re


def _json(value):
    return json.dumps(value, separators=(",", ":"))  # compact, as SendGrid sends it


def _who(a):
    return f'{a["name"]} <{a["address"]}>' if a.get("name") else a["address"]


def _header_name(k):
    return re.sub(r"(^|-)([a-z])", lambda m: m.group(0).upper(), k)


def to_sendgrid(data: dict) -> dict:
    auth = data.get("authentication") or {}
    env = data.get("envelope") or {}
    attachments = data["attachments"]
    names = {f"attachment{i + 1}": a for i, a in enumerate(attachments)}
    return {
        "headers": "\n".join(f"{_header_name(k)}: {v}" for k, v in (data.get("headers") or {}).items()),
        "from": _who(data["from"]) if data.get("from") else "",
        "to": ", ".join(_who(a) for a in data["to"]),
        "cc": ", ".join(_who(a) for a in data.get("cc") or []),
        "subject": data.get("subject") or "",
        "text": data.get("text") or "",
        "html": data.get("html") or "",
        "sender_ip": env.get("client_ip") or "",
        "envelope": _json({"to": env.get("rcpt_to") or [a["address"] for a in data["to"]],
                                "from": env.get("mail_from") or (data.get("from") or {}).get("address", "")}),
        "SPF": (auth.get("spf") or {}).get("result", "none"),
        "dkim": "{" + ", ".join(f'@{d["domain"]} : {d["result"]}' for d in auth.get("dkim") or [] if d.get("domain")) + "}",
        "spam_score": str(data["spam"]["score"]) if data.get("spam") else "",
        "spam_report": "",
        # GhostParse sends text as UTF-8
        "charsets": _json({k: "UTF-8" for k in ("to", "from", "subject", "text", "html")}),
        "attachments": str(len(attachments)),
        "attachment-info": _json({k: {"filename": a.get("filename") or "attachment", "name": a.get("filename") or "attachment",
                                           "type": a["content_type"], **({"content-id": a["content_id"]} if a.get("content_id") else {})}
                                       for k, a in names.items()}),
        "files": {k: {"filename": a.get("filename") or "attachment", "type": a["content_type"],
                      "content": base64.b64decode(a.get("content") or "")} for k, a in names.items()},
    }

import express from "express";
import { verifyWebhook } from "@wildye/email-parser";
import { toSendGrid } from "./sendgrid.mjs";
import { handleParse } from "./your-sendgrid-handler.js"; // what used to read req.body and req.files

const app = express();
app.post("/webhooks/ghostparse", express.raw({ type: "application/json", limit: "40mb" }), async (req, res) => {
  let event;
  try {
    event = verifyWebhook(req.body, req.headers, process.env.GHOSTPARSE_WEBHOOK_SECRET);
  } catch {
    return res.sendStatus(400);
  }
  if (event.type === "email.received") {
    const fields = toSendGrid(event.data); // from, to, subject, text, html, envelope, attachment-info, …
    await handleParse(fields, fields.files); // files.attachment1 = { filename, type, content: Buffer }
  }
  res.sendStatus(200);
});

import os
from flask import Flask, request
from email_parser import verify_webhook, WebhookVerificationError
from sendgrid import to_sendgrid
from your_sendgrid_handler import handle_parse  # what used to read request.form and request.files

app = Flask(__name__)

@app.post("/webhooks/ghostparse")
def ghostparse():
    try:
        event = verify_webhook(request.get_data(), request.headers, os.environ["GHOSTPARSE_WEBHOOK_SECRET"])
    except WebhookVerificationError:
        return "", 400
    if event.type == "email.received":
        fields = to_sendgrid(event.data)  # from, to, subject, text, html, envelope, attachment-info, ...
        handle_parse(fields, fields["files"])  # files["attachment1"] = {"filename", "type", "content": bytes}
    return "", 200