@wraps.dev/cli 0.1.0

package/dist/lambda/event-processor/index.ts

@@ -0,0 +1,165 @@
+import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
+import type { SQSEvent } from "aws-lambda";
+
+const dynamodb = new DynamoDBClient({});
+
+/**
+ * Lambda handler for processing SES events from SQS (via EventBridge)
+ * Stores all SES events in DynamoDB:
+ * - Send: Email sent from SES
+ * - Delivery: Email delivered to recipient
+ * - Open: Email opened by recipient
+ * - Click: Link clicked in email
+ * - Bounce: Email bounced (permanent or transient)
+ * - Complaint: Recipient marked email as spam
+ * - Reject: Email rejected before sending
+ * - Rendering Failure: Template rendering failed
+ * - DeliveryDelay: Temporary delivery delay
+ * - Subscription: Recipient unsubscribed/changed preferences
+ */
+export async function handler(event: SQSEvent) {
+  console.log("Processing SES event from SQS:", JSON.stringify(event, null, 2));
+
+  const tableName = process.env.TABLE_NAME;
+  if (!tableName) {
+    throw new Error("TABLE_NAME environment variable not set");
+  }
+
+  for (const record of event.Records) {
+    try {
+      // Parse the SQS message body (which contains the EventBridge event)
+      const eventBridgeEvent = JSON.parse(record.body);
+
+      // The actual SES event is in the 'detail' field of the EventBridge event
+      const message = eventBridgeEvent.detail;
+      const eventType = message.eventType || message.notificationType;
+
+      // Extract email details
+      const mail = message.mail;
+      const messageId = mail.messageId;
+      const mailTimestamp = new Date(mail.timestamp).getTime();
+      const from = mail.source;
+      const to = mail.destination;
+      const subject = mail.commonHeaders?.subject || "";
+
+      // Extract additional data and event-specific timestamp based on event type
+      let additionalData: Record<string, unknown> = {};
+      let eventTimestamp = mailTimestamp; // Default to mail timestamp
+
+      if (eventType === "Send" && message.send) {
+        // Send event uses mail timestamp
+        additionalData = {
+          tags: mail.tags || {},
+        };
+      } else if (eventType === "Delivery" && message.delivery) {
+        eventTimestamp = new Date(message.delivery.timestamp).getTime();
+        additionalData = {
+          timestamp: message.delivery.timestamp,
+          processingTimeMillis: message.delivery.processingTimeMillis,
+          recipients: message.delivery.recipients,
+          smtpResponse: message.delivery.smtpResponse,
+          remoteMtaIp: message.delivery.remoteMtaIp,
+        };
+      } else if (eventType === "Open" && message.open) {
+        eventTimestamp = new Date(message.open.timestamp).getTime();
+        additionalData = {
+          timestamp: message.open.timestamp,
+          userAgent: message.open.userAgent,
+          ipAddress: message.open.ipAddress,
+        };
+      } else if (eventType === "Click" && message.click) {
+        eventTimestamp = new Date(message.click.timestamp).getTime();
+        additionalData = {
+          timestamp: message.click.timestamp,
+          link: message.click.link,
+          linkTags: message.click.linkTags || {},
+          userAgent: message.click.userAgent,
+          ipAddress: message.click.ipAddress,
+        };
+      } else if (eventType === "Bounce" && message.bounce) {
+        eventTimestamp = new Date(message.bounce.timestamp).getTime();
+        additionalData = {
+          bounceType: message.bounce.bounceType,
+          bounceSubType: message.bounce.bounceSubType,
+          bouncedRecipients: message.bounce.bouncedRecipients,
+          timestamp: message.bounce.timestamp,
+          feedbackId: message.bounce.feedbackId,
+        };
+      } else if (eventType === "Complaint" && message.complaint) {
+        eventTimestamp = new Date(message.complaint.timestamp).getTime();
+        additionalData = {
+          complainedRecipients: message.complaint.complainedRecipients,
+          timestamp: message.complaint.timestamp,
+          feedbackId: message.complaint.feedbackId,
+          complaintFeedbackType: message.complaint.complaintFeedbackType,
+          userAgent: message.complaint.userAgent,
+        };
+      } else if (eventType === "Reject" && message.reject) {
+        // Reject doesn't have a specific timestamp, use mail timestamp
+        additionalData = {
+          reason: message.reject.reason,
+        };
+      } else if (eventType === "Rendering Failure" && message.failure) {
+        // Rendering failure doesn't have a specific timestamp, use mail timestamp
+        additionalData = {
+          errorMessage: message.failure.errorMessage,
+          templateName: message.failure.templateName,
+        };
+      } else if (eventType === "DeliveryDelay" && message.deliveryDelay) {
+        eventTimestamp = new Date(message.deliveryDelay.timestamp).getTime();
+        additionalData = {
+          timestamp: message.deliveryDelay.timestamp,
+          delayType: message.deliveryDelay.delayType,
+          expirationTime: message.deliveryDelay.expirationTime,
+          delayedRecipients: message.deliveryDelay.delayedRecipients,
+        };
+      } else if (eventType === "Subscription" && message.subscription) {
+        eventTimestamp = new Date(message.subscription.timestamp).getTime();
+        additionalData = {
+          contactList: message.subscription.contactList,
+          timestamp: message.subscription.timestamp,
+          source: message.subscription.source,
+          newTopicPreferences: message.subscription.newTopicPreferences,
+          oldTopicPreferences: message.subscription.oldTopicPreferences,
+        };
+      }
+
+      // Store event in DynamoDB
+      // Use eventTimestamp as sort key to ensure each event type creates a unique record
+      await dynamodb.send(
+        new PutItemCommand({
+          TableName: tableName,
+          Item: {
+            messageId: { S: messageId },
+            sentAt: { N: eventTimestamp.toString() },
+            accountId: { S: process.env.AWS_ACCOUNT_ID || "unknown" },
+            from: { S: from },
+            to: { SS: to },
+            subject: { S: subject },
+            eventType: { S: eventType },
+            eventData: { S: JSON.stringify(message) },
+            additionalData: { S: JSON.stringify(additionalData) },
+            createdAt: { N: Date.now().toString() },
+            expiresAt: {
+              N: (Date.now() + 90 * 24 * 60 * 60 * 1000).toString(),
+            }, // 90 days TTL
+          },
+        })
+      );
+
+      console.log(
+        `Stored ${eventType} event for message ${messageId}`,
+        additionalData
+      );
+    } catch (error) {
+      console.error("Error processing record:", error);
+      console.error("Record:", JSON.stringify(record, null, 2));
+      // Don't throw - continue processing other records
+    }
+  }
+
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: "Events processed successfully" }),
+  };
+}

package/dist/lambda/event-processor/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "wraps-email-event-processor",
+  "version": "1.0.0",
+  "description": "Lambda function to process SES events",
+  "type": "module",
+  "main": "index.ts",
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.490.0"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.130"
+  }
+}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@wraps.dev/cli",
+  "version": "0.1.0",
+  "description": "CLI for deploying Wraps email infrastructure to your AWS account",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "bin": {
+    "wraps": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wraps-team/wraps.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://wraps.dev",
+  "bugs": {
+    "url": "https://github.com/wraps-team/wraps/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "pnpm build:console && tsup",
+    "build:console": "pnpm --filter @wraps/console build",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "aws",
+    "ses",
+    "email",
+    "infrastructure",
+    "cli"
+  ],
+  "author": "Wraps",
+  "license": "MIT",
+  "dependencies": {
+    "@aws-sdk/client-cloudformation": "^3.490.0",
+    "@aws-sdk/client-cloudwatch": "^3.490.0",
+    "@aws-sdk/client-dynamodb": "^3.490.0",
+    "@aws-sdk/client-iam": "3.925.0",
+    "@aws-sdk/client-lambda": "3.925.0",
+    "@aws-sdk/client-route-53": "3.925.0",
+    "@aws-sdk/client-ses": "^3.490.0",
+    "@aws-sdk/client-sesv2": "3.925.0",
+    "@aws-sdk/client-sns": "^3.490.0",
+    "@aws-sdk/client-sts": "^3.490.0",
+    "@aws-sdk/util-dynamodb": "3.927.0",
+    "@clack/prompts": "^0.11.0",
+    "@pulumi/aws": "^6.20.0",
+    "@pulumi/pulumi": "^3.100.0",
+    "args": "^5.0.3",
+    "cosmiconfig": "^9.0.0",
+    "esbuild": "^0.19.0",
+    "express": "^4.21.2",
+    "get-port": "^7.1.0",
+    "http-terminator": "^3.2.0",
+    "open": "^10.1.0",
+    "picocolors": "^1.1.1",
+    "tabtab": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/args": "5.0.4",
+    "@types/express": "^5.0.0",
+    "@types/node": "^20.11.0",
+    "@vitest/coverage-v8": "4.0.7",
+    "aws-sdk-client-mock": "4.1.0",
+    "aws-sdk-client-mock-vitest": "7.0.1",
+    "eslint": "^8.56.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.7"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}