feat: revamp to use AWS SES

Author: wackerow

.env.example

@@ -49,5 +49,10 @@ ANALYZE=false
 # environment variables set to make api requests
 USE_MOCK_DATA=true
 
+# AWS SES Configuration for Enterprise Contact Form
+# SES_ACCESS_KEY_ID=your_iam_access_key_id
+# SES_SECRET_ACCESS_KEY=your_iam_secret_access_key  
+# SES_REGION=us-east-1
+
 # Google Sheet ID for torch holders
 GOOGLE_SHEET_ID_TORCH_HOLDERS=

app/[locale]/enterprise/page.tsx

@@ -36,7 +36,6 @@ import Visa from "@/components/icons/enterprise/visa.svg"
 import Walmart from "@/components/icons/enterprise/walmart.svg"
 import WFP from "@/components/icons/enterprise/wfp.svg"
 import MainArticle from "@/components/MainArticle"
-import NetlifyFormsDetection from "@/components/NetlifyFormsDetection"
 import Translation from "@/components/Translation"
 import { ButtonLink } from "@/components/ui/buttons/Button"
 import { Card } from "@/components/ui/card"
@@ -287,7 +286,6 @@ const Page = async ({ params }: { params: { locale: Lang } }) => {
 
   return (
     <div className="mb-12 space-y-12 md:mb-20 md:space-y-20">
-      <NetlifyFormsDetection />
       <HubHero
         header={t("page-enterprise-hero-title")}
         description={t("page-enterprise-hero-subtitle")}

app/api/enterprise-contact/route.ts

@@ -1,39 +1,44 @@
 import { NextRequest, NextResponse } from "next/server"
+import { SendRawEmailCommand, SESClient } from "@aws-sdk/client-ses"
 
 const ENTERPRISE_EMAIL = "[email protected]"
+const SES_FROM_EMAIL = "[email protected]"
 const RATE_LIMIT_WINDOW_MS = 60 * 1000 // 1 minute
 const MAX_REQUESTS_PER_WINDOW = 3
 
-// Simple in-memory rate limiting (in production, use Redis or similar)
-const ipRequestHistory = new Map<string, number[]>()
+// Configure SES client
+const sesClient = new SESClient({
+  region: process.env.SES_REGION || "us-east-1",
+  credentials: {
+    accessKeyId: process.env.SES_ACCESS_KEY_ID!,
+    secretAccessKey: process.env.SES_SECRET_ACCESS_KEY!,
+  },
+})
 
-function getClientIP(request: NextRequest): string {
-  const forwarded = request.headers.get("x-forwarded-for")
-  const realIP = request.headers.get("x-real-ip")
+// Log the region being used for debugging
+console.log("Using AWS SES region:", process.env.SES_REGION || "us-east-1")
 
-  if (forwarded) return forwarded.split(",")[0].trim()
-  if (realIP) return realIP
-  return "unknown"
-}
+// Simple in-memory rate limiting (in production, use Redis or similar)
+const requestHistory = new Map<string, number[]>()
 
-function isRateLimited(ip: string): boolean {
+function isRateLimited(identifier: string): boolean {
   const now = Date.now()
-  const requests = ipRequestHistory.get(ip) || []
+  const requests = requestHistory.get(identifier) || []
 
   // Filter out requests outside the current window
   const recentRequests = requests.filter(
     (timestamp) => now - timestamp < RATE_LIMIT_WINDOW_MS
   )
 
   // Update the history
-  ipRequestHistory.set(ip, recentRequests)
+  requestHistory.set(identifier, recentRequests)
 
   // Check if we're over the limit
   if (recentRequests.length >= MAX_REQUESTS_PER_WINDOW) return true
 
   // Add this request
   recentRequests.push(now)
-  ipRequestHistory.set(ip, recentRequests)
+  requestHistory.set(identifier, recentRequests)
 
   return false
 }
@@ -53,12 +58,72 @@ function validateEmail(email: string): boolean {
   return emailRegex.test(email)
 }
 
+function createRawEmail(
+  fromEmail: string,
+  toEmail: string,
+  replyToEmail: string,
+  subject: string,
+  textBody: string
+): string {
+  const boundary = `----=_Part_${Date.now()}_${Math.random().toString(36)}`
+
+  return [
+    `From: ${fromEmail}`,
+    `To: ${toEmail}`,
+    `Reply-To: ${replyToEmail}`,
+    `Subject: ${subject}`,
+    `MIME-Version: 1.0`,
+    `Content-Type: multipart/alternative; boundary="${boundary}"`,
+    ``,
+    `--${boundary}`,
+    `Content-Type: text/plain; charset=UTF-8`,
+    `Content-Transfer-Encoding: 7bit`,
+    ``,
+    textBody,
+    ``,
+    `--${boundary}--`,
+  ].join("\r\n")
+}
+
+async function sendEmail(userEmail: string, message: string): Promise<void> {
+  const subject = "Enterprise Inquiry from ethereum.org"
+  const textBody = `
+New enterprise inquiry received:
+
+From: ${userEmail}
+Timestamp: ${new Date().toISOString()}
+
+Message:
+${message}
+
+---
+This message was sent via the enterprise contact form on ethereum.org/enterprise.
+Reply to this email to respond directly to the sender.
+  `.trim()
+
+  const rawEmail = createRawEmail(
+    SES_FROM_EMAIL,
+    ENTERPRISE_EMAIL,
+    userEmail,
+    subject,
+    textBody
+  )
+
+  const command = new SendRawEmailCommand({
+    RawMessage: {
+      Data: new TextEncoder().encode(rawEmail),
+    },
+  })
+
+  await sesClient.send(command)
+}
+
 export async function POST(request: NextRequest) {
   try {
-    const clientIP = getClientIP(request)
+    // Rate limiting based on a simple identifier (could be improved with real session tracking)
+    const userAgent = request.headers.get("user-agent") || "unknown"
 
-    // Rate limiting
-    if (isRateLimited(clientIP)) {
+    if (isRateLimited(userAgent)) {
       return NextResponse.json(
         { error: "Too many requests. Please try again later." },
         { status: 429 }
@@ -88,56 +153,15 @@ export async function POST(request: NextRequest) {
       )
     }
 
-    // Create email content
-    const emailSubject = "Enterprise Inquiry from ethereum.org"
-    const emailBody = `
-New enterprise inquiry received:
-
-From: ${sanitizedEmail}
-IP: ${clientIP}
-Timestamp: ${new Date().toISOString()}
-
-Message:
-${sanitizedMessage}
-
----
-This message was sent via the enterprise contact form on ethereum.org/enterprise.
-    `.trim()
-
-    // Submit to Netlify Forms
+    // Send email via AWS SES
     try {
-      const formData = new URLSearchParams()
-      formData.append("form-name", "enterprise-contact")
-      formData.append("email", sanitizedEmail)
-      formData.append("message", sanitizedMessage)
-      formData.append("subject", emailSubject)
-      formData.append("ip", clientIP)
-      formData.append("timestamp", new Date().toISOString())
-
-      const netlifyResponse = await fetch("/__forms.html", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-        },
-        body: formData.toString(),
-      })
-
-      if (!netlifyResponse.ok) {
-        throw new Error(`Netlify Forms error: ${netlifyResponse.status}`)
-      }
-    } catch (netlifyError) {
-      console.error("Netlify Forms submission failed:", netlifyError)
-      // Log the submission details for manual follow-up
-      console.log("Enterprise Contact Form Submission (Netlify failed):", {
-        to: ENTERPRISE_EMAIL,
-        subject: emailSubject,
-        body: emailBody,
-        from: sanitizedEmail,
-        ip: clientIP,
-        timestamp: new Date().toISOString(),
-      })
-      // Continue without throwing - we don't want to show user an error
-      // if Netlify is down but the form validation passed
+      await sendEmail(sanitizedEmail, sanitizedMessage)
+    } catch (emailError) {
+      console.error("AWS SES email sending failed:", emailError)
+      return NextResponse.json(
+        { error: "Failed to send message. Please try again later." },
+        { status: 500 }
+      )
     }
 
     return NextResponse.json(

package.json

@@ -30,6 +30,7 @@
     "test:e2e:report": "playwright show-report tests/e2e/__report__"
   },
   "dependencies": {
+    "@aws-sdk/client-ses": "^3.859.0",
     "@crowdin/crowdin-api-client": "^1.25.0",
     "@docsearch/react": "^3.5.2",
     "@hookform/resolvers": "^3.8.0",