@airhornjs/aws 5.0.1

package/dist/index.js

@@ -0,0 +1,184 @@
+// src/index.ts
+import { SESClient, SendEmailCommand } from "@aws-sdk/client-ses";
+import { PublishCommand, SNSClient } from "@aws-sdk/client-sns";
+import {
+  AirhornSendType
+} from "airhorn";
+var AirhornAws = class {
+  name = "aws";
+  capabilities;
+  snsClient;
+  sesClient;
+  constructor(options) {
+    if (!options.region) {
+      throw new Error("AirhornAws requires region");
+    }
+    this.capabilities = options.capabilities || [
+      AirhornSendType.SMS,
+      AirhornSendType.MobilePush,
+      AirhornSendType.Email
+    ];
+    const credentials = options.accessKeyId && options.secretAccessKey ? {
+      accessKeyId: options.accessKeyId,
+      secretAccessKey: options.secretAccessKey,
+      sessionToken: options.sessionToken
+    } : void 0;
+    if (this.capabilities.includes(AirhornSendType.SMS)) {
+      this.snsClient = new SNSClient({
+        region: options.region,
+        credentials
+      });
+    }
+    if (this.capabilities.includes(AirhornSendType.Email)) {
+      this.sesClient = new SESClient({
+        region: options.region,
+        credentials
+      });
+    }
+  }
+  async send(message, options) {
+    const result = {
+      success: false,
+      response: null,
+      errors: []
+    };
+    try {
+      if (message.type === AirhornSendType.SMS || message.type === AirhornSendType.MobilePush) {
+        return this.sendSMS(message, options);
+      }
+      if (message.type === AirhornSendType.Email) {
+        return this.sendEmail(message, options);
+      }
+      throw new Error(
+        `AirhornAws does not support message type: ${message.type}`
+      );
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      result.errors.push(err);
+      result.response = {
+        error: err.message,
+        details: error
+      };
+    }
+    return result;
+  }
+  async sendSMS(message, options) {
+    const result = {
+      success: false,
+      response: null,
+      errors: []
+    };
+    try {
+      if (!this.snsClient) {
+        throw new Error("SNS is not configured");
+      }
+      if (!message.from) {
+        throw new Error(
+          "From identifier is required for SMS/MobilePush messages"
+        );
+      }
+      let command;
+      if (message.type === AirhornSendType.MobilePush || message.to.startsWith("arn:")) {
+        command = new PublishCommand({
+          TargetArn: message.to,
+          Message: message.content,
+          MessageAttributes: options?.MessageAttributes,
+          MessageStructure: options?.MessageStructure,
+          ...options
+        });
+      } else {
+        command = new PublishCommand({
+          PhoneNumber: message.to,
+          Message: message.content,
+          MessageAttributes: {
+            "AWS.SNS.SMS.SenderID": {
+              DataType: "String",
+              StringValue: message.from
+            },
+            "AWS.SNS.SMS.SMSType": {
+              DataType: "String",
+              StringValue: options?.smsType || "Transactional"
+            },
+            ...options?.MessageAttributes
+          },
+          ...options
+        });
+      }
+      const response = await this.snsClient.send(command);
+      result.success = true;
+      result.response = {
+        messageId: response.MessageId,
+        sequenceNumber: response.SequenceNumber,
+        metadata: response.$metadata
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      result.errors.push(err);
+      result.response = {
+        error: err.message,
+        details: error
+      };
+    }
+    return result;
+  }
+  async sendEmail(message, options) {
+    const result = {
+      success: false,
+      response: null,
+      errors: []
+    };
+    try {
+      if (!this.sesClient) {
+        throw new Error("SES is not configured");
+      }
+      if (!message.from) {
+        throw new Error("From email address is required for email messages");
+      }
+      const command = new SendEmailCommand({
+        Source: message.from,
+        Destination: {
+          ToAddresses: [message.to],
+          CcAddresses: options?.ccAddresses,
+          BccAddresses: options?.bccAddresses
+        },
+        Message: {
+          Subject: {
+            Data: message.subject || "Notification",
+            Charset: "UTF-8"
+          },
+          Body: {
+            Text: {
+              Data: message.content,
+              Charset: "UTF-8"
+            },
+            Html: {
+              Data: message.content,
+              Charset: "UTF-8"
+            }
+          }
+        },
+        ReplyToAddresses: options?.replyToAddresses,
+        ReturnPath: options?.returnPath,
+        ConfigurationSetName: options?.configurationSetName,
+        Tags: options?.tags
+      });
+      const response = await this.sesClient.send(command);
+      result.success = true;
+      result.response = {
+        messageId: response.MessageId,
+        metadata: response.$metadata
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      result.errors.push(err);
+      result.response = {
+        error: err.message,
+        details: error
+      };
+    }
+    return result;
+  }
+};
+export {
+  AirhornAws
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@airhornjs/aws",
+  "version": "5.0.1",
+  "description": "AWS SNS and SES provider for Airhorn",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "airhorn",
+    "notifications",
+    "aws",
+    "sns",
+    "ses",
+    "sms",
+    "email",
+    "provider"
+  ],
+  "homepage": "https://github.com/jaredwray/airhorn/tree/main/packages/aws",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jaredwray/airhorn.git",
+    "directory": "packages/aws"
+  },
+  "bugs": {
+    "url": "https://github.com/jaredwray/airhorn/issues"
+  },
+  "license": "MIT",
+  "author": "Jared Wray <me@jaredwray.com>",
+  "dependencies": {
+    "@aws-sdk/client-ses": "^3.873.0",
+    "@aws-sdk/client-sns": "^3.873.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.2.2",
+    "@types/node": "^24.3.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "airhorn": "^5.0.1"
+  },
+  "scripts": {
+    "lint": "biome check --write --error-on-warnings",
+    "test": "pnpm lint && vitest run --coverage",
+    "test:ci": "biome check --error-on-warnings && vitest run --coverage",
+    "clean": "rimraf ./dist ./coverage ./node_modules ./package-lock.json ./pnpm-lock.yaml",
+    "build:publish": "pnpm build && pnpm publish --access public",
+    "build": "rimraf ./dist && tsup src/index.ts --format esm --dts --clean"
+  }
+}

package/src/index.ts

@@ -0,0 +1,244 @@
+import { SESClient, SendEmailCommand } from "@aws-sdk/client-ses";
+import { PublishCommand, SNSClient } from "@aws-sdk/client-sns";
+import {
+	type AirhornProvider,
+	type AirhornProviderMessage,
+	type AirhornProviderSendResult,
+	AirhornSendType,
+} from "airhorn";
+
+export type AirhornAwsOptions = {
+	region: string;
+	accessKeyId?: string;
+	secretAccessKey?: string;
+	sessionToken?: string;
+	capabilities?: AirhornSendType[];
+};
+
+export class AirhornAws implements AirhornProvider {
+	public name = "aws";
+	public capabilities: AirhornSendType[];
+
+	private snsClient?: SNSClient;
+	private sesClient?: SESClient;
+
+	constructor(options: AirhornAwsOptions) {
+		if (!options.region) {
+			throw new Error("AirhornAws requires region");
+		}
+
+		// Set capabilities from options or default to SMS, MobilePush, and Email
+		this.capabilities = options.capabilities || [
+			AirhornSendType.SMS,
+			AirhornSendType.MobilePush,
+			AirhornSendType.Email,
+		];
+
+		const credentials =
+			options.accessKeyId && options.secretAccessKey
+				? {
+						accessKeyId: options.accessKeyId,
+						secretAccessKey: options.secretAccessKey,
+						sessionToken: options.sessionToken,
+					}
+				: undefined;
+
+		// Configure SNS if SMS capability is enabled
+		if (this.capabilities.includes(AirhornSendType.SMS)) {
+			this.snsClient = new SNSClient({
+				region: options.region,
+				credentials,
+			});
+		}
+
+		// Configure SES if Email capability is enabled
+		if (this.capabilities.includes(AirhornSendType.Email)) {
+			this.sesClient = new SESClient({
+				region: options.region,
+				credentials,
+			});
+		}
+	}
+
+	async send(
+		message: AirhornProviderMessage,
+		// biome-ignore lint/suspicious/noExplicitAny: expected
+		options?: any,
+	): Promise<AirhornProviderSendResult> {
+		const result: AirhornProviderSendResult = {
+			success: false,
+			response: null,
+			errors: [],
+		};
+
+		try {
+			if (
+				message.type === AirhornSendType.SMS ||
+				message.type === AirhornSendType.MobilePush
+			) {
+				return this.sendSMS(message, options);
+			}
+
+			if (message.type === AirhornSendType.Email) {
+				return this.sendEmail(message, options);
+			}
+
+			throw new Error(
+				`AirhornAws does not support message type: ${message.type}`,
+			);
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			result.errors.push(err);
+			result.response = {
+				error: err.message,
+				details: error,
+			};
+		}
+
+		return result;
+	}
+
+	private async sendSMS(
+		message: AirhornProviderMessage,
+		// biome-ignore lint/suspicious/noExplicitAny: expected
+		options?: any,
+	): Promise<AirhornProviderSendResult> {
+		const result: AirhornProviderSendResult = {
+			success: false,
+			response: null,
+			errors: [],
+		};
+
+		try {
+			if (!this.snsClient) {
+				throw new Error("SNS is not configured");
+			}
+
+			if (!message.from) {
+				throw new Error(
+					"From identifier is required for SMS/MobilePush messages",
+				);
+			}
+
+			// Build command based on message type and destination
+			let command: PublishCommand;
+			if (
+				message.type === AirhornSendType.MobilePush ||
+				message.to.startsWith("arn:")
+			) {
+				// Mobile push to endpoint ARN or topic ARN
+				command = new PublishCommand({
+					TargetArn: message.to,
+					Message: message.content,
+					MessageAttributes: options?.MessageAttributes,
+					MessageStructure: options?.MessageStructure,
+					...options,
+				});
+			} else {
+				// Regular SMS to phone number
+				command = new PublishCommand({
+					PhoneNumber: message.to,
+					Message: message.content,
+					MessageAttributes: {
+						"AWS.SNS.SMS.SenderID": {
+							DataType: "String",
+							StringValue: message.from,
+						},
+						"AWS.SNS.SMS.SMSType": {
+							DataType: "String",
+							StringValue: options?.smsType || "Transactional",
+						},
+						...options?.MessageAttributes,
+					},
+					...options,
+				});
+			}
+
+			const response = await this.snsClient.send(command);
+
+			result.success = true;
+			result.response = {
+				messageId: response.MessageId,
+				sequenceNumber: response.SequenceNumber,
+				metadata: response.$metadata,
+			};
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			result.errors.push(err);
+			result.response = {
+				error: err.message,
+				details: error,
+			};
+		}
+
+		return result;
+	}
+
+	private async sendEmail(
+		message: AirhornProviderMessage,
+		// biome-ignore lint/suspicious/noExplicitAny: expected
+		options?: any,
+	): Promise<AirhornProviderSendResult> {
+		const result: AirhornProviderSendResult = {
+			success: false,
+			response: null,
+			errors: [],
+		};
+
+		try {
+			if (!this.sesClient) {
+				throw new Error("SES is not configured");
+			}
+
+			if (!message.from) {
+				throw new Error("From email address is required for email messages");
+			}
+
+			const command = new SendEmailCommand({
+				Source: message.from,
+				Destination: {
+					ToAddresses: [message.to],
+					CcAddresses: options?.ccAddresses,
+					BccAddresses: options?.bccAddresses,
+				},
+				Message: {
+					Subject: {
+						Data: message.subject || "Notification",
+						Charset: "UTF-8",
+					},
+					Body: {
+						Text: {
+							Data: message.content,
+							Charset: "UTF-8",
+						},
+						Html: {
+							Data: message.content,
+							Charset: "UTF-8",
+						},
+					},
+				},
+				ReplyToAddresses: options?.replyToAddresses,
+				ReturnPath: options?.returnPath,
+				ConfigurationSetName: options?.configurationSetName,
+				Tags: options?.tags,
+			});
+
+			const response = await this.sesClient.send(command);
+
+			result.success = true;
+			result.response = {
+				messageId: response.MessageId,
+				metadata: response.$metadata,
+			};
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			result.errors.push(err);
+			result.response = {
+				error: err.message,
+				details: error,
+			};
+		}
+
+		return result;
+	}
+}