sms-verification-api 0.9.1 → 0.9.7

package/src/{index.js → index.ts}

@@ -3,6 +3,6 @@
  * This file is used by Cloudflare Workers and Wrangler.
  */
 
-import app from "./verify-phone-server.js";
+import app from "./verify-phone-server";
 
 export default app; 

package/src/sns.ts

@@ -0,0 +1,265 @@
+/**
+ * AWS SNS HTTP API Client for Cloudflare Workers
+ */
+
+interface SNSClientOptions {
+  accessKeyId?: string;
+  secretAccessKey?: string;
+  region?: string;
+}
+
+interface SNSResponse {
+  MessageId?: string;
+  TopicArn?: string;
+  SubscriptionArn?: string;
+  raw?: string;
+}
+
+type SendSMSCallback = (
+  err: { err: Error; "err.stack"?: string } | undefined,
+  messageId?: string,
+) => void;
+
+class SNSClient {
+  accessKeyId?: string;
+  secretAccessKey?: string;
+  region: string;
+  endpoint: string;
+
+  constructor(options: SNSClientOptions = {}) {
+    this.accessKeyId = options.accessKeyId;
+    this.secretAccessKey = options.secretAccessKey;
+    this.region = options.region || "us-east-1";
+    this.endpoint = `https://sns.${this.region}.amazonaws.com`;
+  }
+
+  stringToUint8Array(str: string): Uint8Array {
+    return new TextEncoder().encode(str);
+  }
+
+  arrayBufferToHex(buffer: ArrayBuffer | Uint8Array): string {
+    return Array.from(new Uint8Array(buffer as ArrayBuffer))
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  }
+
+  async sign(
+    method: string,
+    url: string,
+    headers: Record<string, string>,
+    payload: string,
+  ): Promise<Record<string, string>> {
+    const now = new Date();
+    const amzDate = now.toISOString().replace(/[:\-]|\.\d{3}/g, "");
+    const dateStamp = amzDate.substring(0, 8);
+
+    const canonicalUri = "/";
+    const canonicalQuerystring = url.split("?")[1] || "";
+
+    headers["host"] = `sns.${this.region}.amazonaws.com`;
+    headers["x-amz-date"] = amzDate;
+
+    const payloadHash = await crypto.subtle
+      .digest("SHA-256", this.stringToUint8Array(payload))
+      .then((buffer) => this.arrayBufferToHex(buffer));
+    headers["x-amz-content-sha256"] = payloadHash;
+
+    const sortedHeaders = Object.keys(headers)
+      .sort()
+      .map((key) => `${key.toLowerCase()}:${headers[key]}`)
+      .join("\n");
+
+    const signedHeaders = Object.keys(headers)
+      .sort()
+      .map((key) => key.toLowerCase())
+      .join(";");
+
+    const canonicalRequest = [
+      method,
+      canonicalUri,
+      canonicalQuerystring,
+      sortedHeaders,
+      "",
+      signedHeaders,
+      payloadHash,
+    ].join("\n");
+
+    const algorithm = "AWS4-HMAC-SHA256";
+    const credentialScope = `${dateStamp}/${this.region}/sns/aws4_request`;
+
+    const canonicalRequestHash = await crypto.subtle
+      .digest("SHA-256", this.stringToUint8Array(canonicalRequest))
+      .then((buffer) => this.arrayBufferToHex(buffer));
+
+    const stringToSign = [
+      algorithm,
+      amzDate,
+      credentialScope,
+      canonicalRequestHash,
+    ].join("\n");
+
+    const kDate = await crypto.subtle
+      .importKey(
+        "raw",
+        this.stringToUint8Array(`AWS4${this.secretAccessKey}`),
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"],
+      )
+      .then((key) =>
+        crypto.subtle.sign("HMAC", key, this.stringToUint8Array(dateStamp)),
+      );
+
+    const kRegion = await crypto.subtle
+      .importKey("raw", kDate, { name: "HMAC", hash: "SHA-256" }, false, [
+        "sign",
+      ])
+      .then((key) =>
+        crypto.subtle.sign("HMAC", key, this.stringToUint8Array(this.region)),
+      );
+
+    const kService = await crypto.subtle
+      .importKey("raw", kRegion, { name: "HMAC", hash: "SHA-256" }, false, [
+        "sign",
+      ])
+      .then((key) =>
+        crypto.subtle.sign("HMAC", key, this.stringToUint8Array("sns")),
+      );
+
+    const kSigning = await crypto.subtle
+      .importKey("raw", kService, { name: "HMAC", hash: "SHA-256" }, false, [
+        "sign",
+      ])
+      .then((key) =>
+        crypto.subtle.sign(
+          "HMAC",
+          key,
+          this.stringToUint8Array("aws4_request"),
+        ),
+      );
+
+    const signature = await crypto.subtle
+      .importKey("raw", kSigning, { name: "HMAC", hash: "SHA-256" }, false, [
+        "sign",
+      ])
+      .then((key) =>
+        crypto.subtle.sign("HMAC", key, this.stringToUint8Array(stringToSign)),
+      )
+      .then((buffer) => this.arrayBufferToHex(buffer));
+
+    headers["authorization"] =
+      `${algorithm} Credential=${this.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+
+    return headers;
+  }
+
+  async makeRequest(
+    action: string,
+    params: Record<string, string> = {},
+  ): Promise<SNSResponse> {
+    const queryParams = new URLSearchParams({
+      Action: action,
+      Version: "2010-03-31",
+      ...params,
+    });
+
+    const url = `${this.endpoint}/?${queryParams.toString()}`;
+    const payload = "";
+    const headers: Record<string, string> = {
+      "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+    };
+
+    const signedHeaders = await this.sign("GET", url, headers, payload);
+
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: signedHeaders,
+      });
+
+      const text = await response.text();
+
+      if (!response.ok) {
+        throw new Error(`SNS API Error: ${response.status} - ${text}`);
+      }
+
+      return this.parseXMLResponse(text);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`SNS Request failed: ${message}`);
+    }
+  }
+
+  parseXMLResponse(xmlText: string): SNSResponse {
+    const messageIdMatch = xmlText.match(/<MessageId>([^<]+)<\/MessageId>/);
+    const topicArnMatch = xmlText.match(/<TopicArn>([^<]+)<\/TopicArn>/);
+    const subscriptionArnMatch = xmlText.match(
+      /<SubscriptionArn>([^<]+)<\/SubscriptionArn>/,
+    );
+
+    if (messageIdMatch) {
+      return { MessageId: messageIdMatch[1] };
+    }
+
+    if (topicArnMatch) {
+      return { TopicArn: topicArnMatch[1] };
+    }
+
+    if (subscriptionArnMatch) {
+      return { SubscriptionArn: subscriptionArnMatch[1] };
+    }
+
+    return { raw: xmlText };
+  }
+}
+
+let defaultClient: SNSClient | null = null;
+
+export function createClient(options: SNSClientOptions = {}): SNSClient {
+  defaultClient = new SNSClient(options);
+  return defaultClient;
+}
+
+export function sendSMS(
+  textmessage: string,
+  phone: string,
+  senderid: string,
+  SMSType: string,
+  callback: SendSMSCallback,
+  client: SNSClient | null = null,
+): void {
+  const snsClient = client || defaultClient;
+
+  if (!snsClient) {
+    return callback({
+      err: new Error("SNS client not initialized. Call createClient() first."),
+    });
+  }
+
+  const params: Record<string, string> = {
+    Message: textmessage,
+    PhoneNumber: phone,
+    "MessageAttributes.entry.1.Name": "AWS.SNS.SMS.SenderID",
+    "MessageAttributes.entry.1.Value.DataType": "String",
+    "MessageAttributes.entry.1.Value.StringValue": senderid,
+    "MessageAttributes.entry.2.Name": "AWS.SNS.SMS.SMSType",
+    "MessageAttributes.entry.2.Value.DataType": "String",
+    "MessageAttributes.entry.2.Value.StringValue": SMSType,
+  };
+
+  snsClient
+    .makeRequest("Publish", params)
+    .then((response) => {
+      callback(undefined, response.MessageId);
+    })
+    .catch((error: Error) => {
+      callback({ err: error, "err.stack": error.stack });
+    });
+}
+
+export { SNSClient };
+
+export default {
+  createClient,
+  sendSMS,
+};