create-entity-app-server 0.0.4 → 0.1.13

package/dist-create/template/app/plugins/sms/providers/aws-sns.ts

@@ -0,0 +1,182 @@
+/**
+ * AWS SNS SMS 프로바이더 (국제 SMS)
+ *
+ * Go 엔티티서버 `internal/sms/client_aws_sns.go`에서 포팅
+ *
+ * 인증: AWS Signature V4 (직접 구현, SDK 미사용)
+ * URL: POST https://sns.{region}.amazonaws.com
+ * Content-Type: application/x-www-form-urlencoded; charset=utf-8
+ * MMS 미지원
+ */
+
+import { createHmac, createHash } from "node:crypto";
+import type { SmsClient, SendRequest, SendResult, SmsProviderConfig } from "../types/index.ts";
+
+const TIMEOUT_MS = 30_000;
+
+export class AWSSNSClient implements SmsClient {
+    private readonly region: string;
+    private readonly accessKey: string;
+    private readonly secretKey: string;
+    /** Transactional | Promotional */
+    private readonly smsType: string;
+
+    constructor(cfg: SmsProviderConfig) {
+        this.region = cfg.region ?? "ap-northeast-2";
+        this.accessKey = cfg.access_key ?? "";
+        this.secretKey = cfg.secret_key ?? "";
+        // api_key 필드를 SMS 타입으로 재활용 (Go 원본 동일)
+        this.smsType = cfg.api_key || "Transactional";
+    }
+
+    name(): string {
+        return "aws_sns";
+    }
+
+    async send(req: SendRequest): Promise<SendResult> {
+        if (req.type.toLowerCase() === "mms") {
+            throw new Error("AWS SNS does not support MMS");
+        }
+
+        const phoneNumber = normalizePhoneE164(req.receiver);
+        const host = `sns.${this.region}.amazonaws.com`;
+        const url = `https://${host}`;
+
+        const params = new URLSearchParams();
+        params.set("Action", "Publish");
+        params.set("Message", req.content);
+        params.set("PhoneNumber", phoneNumber);
+        params.set("Version", "2010-03-31");
+        params.set(
+            "MessageAttributes.entry.1.Name",
+            "AWS.SNS.SMS.SMSType",
+        );
+        params.set(
+            "MessageAttributes.entry.1.Value.DataType",
+            "String",
+        );
+        params.set(
+            "MessageAttributes.entry.1.Value.StringValue",
+            this.smsType,
+        );
+
+        if (req.sender) {
+            params.set(
+                "MessageAttributes.entry.2.Name",
+                "AWS.SNS.SMS.SenderID",
+            );
+            params.set(
+                "MessageAttributes.entry.2.Value.DataType",
+                "String",
+            );
+            params.set(
+                "MessageAttributes.entry.2.Value.StringValue",
+                req.sender,
+            );
+        }
+
+        const bodyStr = params.toString();
+        const now = new Date();
+        const amzDate = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+        const dateStamp = amzDate.slice(0, 8);
+
+        // AWS Signature V4
+        const contentType =
+            "application/x-www-form-urlencoded; charset=utf-8";
+        const payloadHash = sha256(bodyStr);
+
+        const canonicalRequest = [
+            "POST",
+            "/",
+            "",
+            `content-type:${contentType}`,
+            `host:${host}`,
+            `x-amz-date:${amzDate}`,
+            "",
+            "content-type;host;x-amz-date",
+            payloadHash,
+        ].join("\n");
+
+        const credentialScope = `${dateStamp}/${this.region}/sns/aws4_request`;
+        const stringToSign = [
+            "AWS4-HMAC-SHA256",
+            amzDate,
+            credentialScope,
+            sha256(canonicalRequest),
+        ].join("\n");
+
+        const signingKey = deriveSigningKey(
+            this.secretKey,
+            dateStamp,
+            this.region,
+            "sns",
+        );
+        const signature = hmac(signingKey, stringToSign).toString("hex");
+
+        const authorization = `AWS4-HMAC-SHA256 Credential=${this.accessKey}/${credentialScope}, SignedHeaders=content-type;host;x-amz-date, Signature=${signature}`;
+
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": contentType,
+                    Host: host,
+                    "X-Amz-Date": amzDate,
+                    Authorization: authorization,
+                },
+                body: bodyStr,
+                signal: controller.signal,
+            });
+
+            const text = await response.text();
+
+            if (!response.ok) {
+                throw new Error(
+                    `AWS SNS error: status=${response.status}, body=${text}`,
+                );
+            }
+
+            // XML에서 <MessageId>...</MessageId> 추출
+            const match = text.match(/<MessageId>([^<]+)<\/MessageId>/);
+            return {
+                provider_msg_id: match?.[1] ?? "",
+                status_code: String(response.status),
+            };
+        } finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+
+/** 한국 전화번호를 E.164 형식으로 정규화 */
+function normalizePhoneE164(phone: string): string {
+    if (phone.startsWith("+")) return phone;
+    const cleaned = phone.replace(/[^0-9]/g, "");
+    if (cleaned.startsWith("0")) {
+        return "+82" + cleaned.slice(1);
+    }
+    return "+" + cleaned;
+}
+
+function sha256(data: string): string {
+    return createHash("sha256").update(data, "utf-8").digest("hex");
+}
+
+function hmac(key: Buffer | string, data: string): Buffer {
+    return createHmac("sha256", key).update(data, "utf-8").digest();
+}
+
+function deriveSigningKey(
+    secret: string,
+    dateStamp: string,
+    region: string,
+    service: string,
+): Buffer {
+    const kDate = hmac(Buffer.from("AWS4" + secret, "utf-8"), dateStamp);
+    const kRegion = hmac(kDate, region);
+    const kService = hmac(kRegion, service);
+    return hmac(kService, "aws4_request");
+}

package/dist-create/template/app/plugins/sms/providers/index.ts

@@ -0,0 +1,47 @@
+/**
+ * SMS 프로바이더 팩토리
+ *
+ * Go 엔티티서버 `internal/sms/client.go` NewClient에서 포팅
+ */
+
+import type { SmsClient, SmsProviderConfig } from "../types/index.ts";
+import { AligoClient } from "./aligo.ts";
+import { SolapiClient } from "./solapi.ts";
+import { PpurioClient } from "./ppurio.ts";
+import { NHNClient } from "./nhn.ts";
+import { AWSSNSClient } from "./aws-sns.ts";
+
+/**
+ * driver 이름에 따라 SmsClient 구현체를 생성한다.
+ */
+export function createSmsClient(cfg: SmsProviderConfig): SmsClient {
+    switch (cfg.driver) {
+        case "aligo":
+            return new AligoClient(cfg);
+        case "solapi":
+            return new SolapiClient(cfg);
+        case "ppurio":
+            return new PpurioClient(cfg);
+        case "nhn_cloud":
+            return new NHNClient(cfg);
+        case "aws_sns":
+            return new AWSSNSClient(cfg);
+        default:
+            throw new Error(`Unknown SMS provider driver: ${cfg.driver}`);
+    }
+}
+
+/**
+ * 메시지 내용과 이미지 유무로 메시지 타입을 자동 판정한다.
+ *
+ * Go 원본: DetermineMsgType(content string, threshold int, imageURL string) string
+ */
+export function determineMsgType(
+    content: string,
+    thresholdBytes: number,
+    imageUrl: string,
+): string {
+    if (imageUrl) return "mms";
+    if (Buffer.byteLength(content, "utf-8") > thresholdBytes) return "lms";
+    return "sms";
+}

package/dist-create/template/app/plugins/sms/providers/nhn.ts

@@ -0,0 +1,82 @@
+/**
+ * NHN Cloud SMS 프로바이더
+ *
+ * Go 엔티티서버 `internal/sms/client_nhn.go`에서 포팅
+ *
+ * 인증: X-Secret-Key 헤더
+ * URL: POST https://api-sms.cloud.toast.com/sms/v3.0/appKeys/{appKey}/sender/sms (SMS)
+ *      POST https://api-sms.cloud.toast.com/sms/v3.0/appKeys/{appKey}/sender/mms (LMS/MMS)
+ */
+
+import type { SmsClient, SendRequest, SendResult, SmsProviderConfig } from "../types/index.ts";
+
+const NHN_BASE_URL = "https://api-sms.cloud.toast.com/sms/v3.0/appKeys";
+const TIMEOUT_MS = 30_000;
+
+export class NHNClient implements SmsClient {
+    private readonly appKey: string;
+    private readonly secretKey: string;
+
+    constructor(cfg: SmsProviderConfig) {
+        this.appKey = cfg.app_key ?? "";
+        this.secretKey = cfg.secret_key ?? "";
+    }
+
+    name(): string {
+        return "nhn_cloud";
+    }
+
+    async send(req: SendRequest): Promise<SendResult> {
+        const isSms = req.type.toLowerCase() === "sms";
+        const endpoint = isSms ? "sms" : "mms";
+        const url = `${NHN_BASE_URL}/${this.appKey}/sender/${endpoint}`;
+
+        const body: Record<string, unknown> = {
+            sendNo: req.sender,
+            recipientList: [{ recipientNo: req.receiver }],
+            body: req.content,
+        };
+
+        if (!isSms && req.subject) body.title = req.subject;
+        if (!isSms && req.image_url) {
+            body.attachFileList = [{ fileUrl: req.image_url }];
+        }
+
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json;charset=UTF-8",
+                    "X-Secret-Key": this.secretKey,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+
+            const result = (await response.json()) as {
+                header: {
+                    isSuccessful: boolean;
+                    resultCode: number;
+                    resultMessage: string;
+                };
+                body?: { data?: { requestId?: string } };
+            };
+
+            if (!result.header.isSuccessful) {
+                throw new Error(
+                    `NHN error: code=${result.header.resultCode}, message=${result.header.resultMessage}`,
+                );
+            }
+
+            return {
+                provider_msg_id: result.body?.data?.requestId ?? "",
+                status_code: String(result.header.resultCode),
+            };
+        } finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist-create/template/app/plugins/sms/providers/ppurio.ts

@@ -0,0 +1,76 @@
+/**
+ * 뿌리오(Ppurio) SMS 프로바이더
+ *
+ * Go 엔티티서버 `internal/sms/client_ppurio.go`에서 포팅
+ *
+ * 인증: Bearer Token
+ * URL: POST https://api.ppurio.com/v1/message
+ * Content-Type: application/json
+ */
+
+import type { SmsClient, SendRequest, SendResult, SmsProviderConfig } from "../types/index.ts";
+
+const PPURIO_API_URL = "https://api.ppurio.com/v1/message";
+const TIMEOUT_MS = 30_000;
+
+export class PpurioClient implements SmsClient {
+    private readonly apiKey: string;
+    private readonly account: string;
+
+    constructor(cfg: SmsProviderConfig) {
+        this.apiKey = cfg.api_key ?? "";
+        this.account = cfg.account ?? "";
+    }
+
+    name(): string {
+        return "ppurio";
+    }
+
+    async send(req: SendRequest): Promise<SendResult> {
+        const body: Record<string, unknown> = {
+            account: this.account,
+            messageType: req.type.toUpperCase(),
+            content: req.content,
+            from: req.sender,
+            duplicateFlag: "N",
+            targetCount: 1,
+            targets: [{ to: req.receiver }],
+        };
+
+        if (req.subject) body.subject = req.subject;
+        if (req.image_url) body.fileUrl = req.image_url;
+
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+        try {
+            const response = await fetch(PPURIO_API_URL, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(
+                    `Ppurio error: status=${response.status}, body=${text}`,
+                );
+            }
+
+            const result = (await response.json()) as {
+                code?: string;
+                requestId?: string;
+            };
+            return {
+                provider_msg_id: result.requestId ?? "",
+                status_code: result.code ?? String(response.status),
+            };
+        } finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist-create/template/app/plugins/sms/providers/solapi.ts

@@ -0,0 +1,83 @@
+/**
+ * Solapi(CoolSMS) SMS 프로바이더
+ *
+ * Go 엔티티서버 `internal/sms/client_solapi.go`에서 포팅
+ *
+ * 인증: HMAC-SHA256
+ *   Authorization: HMAC-SHA256 apiKey={key}, date={ISO8601}, salt={random}, signature={hmac(date+salt)}
+ * URL: POST https://api.solapi.com/messages/v4/send
+ * Content-Type: application/json
+ */
+
+import { buildSolapiAuthorization } from "../../providers/solapi-auth.ts";
+import type {
+    SmsClient,
+    SendRequest,
+    SendResult,
+    SmsProviderConfig,
+} from "../types/index.ts";
+
+const SOLAPI_API_URL = "https://api.solapi.com/messages/v4/send";
+const TIMEOUT_MS = 30_000;
+
+export class SolapiClient implements SmsClient {
+    private readonly apiKey: string;
+    private readonly apiSecret: string;
+
+    constructor(cfg: SmsProviderConfig) {
+        this.apiKey = cfg.api_key ?? "";
+        this.apiSecret = cfg.api_secret ?? "";
+    }
+
+    name(): string {
+        return "solapi";
+    }
+
+    async send(req: SendRequest): Promise<SendResult> {
+        const { authorization } = buildSolapiAuthorization(
+            this.apiKey,
+            this.apiSecret,
+        );
+
+        const body: Record<string, unknown> = {
+            message: {
+                to: req.receiver,
+                from: req.sender,
+                text: req.content,
+                type: req.type.toUpperCase(),
+                ...(req.subject ? { subject: req.subject } : {}),
+                ...(req.image_url ? { imageUrl: req.image_url } : {}),
+            },
+        };
+
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+        try {
+            const response = await fetch(SOLAPI_API_URL, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: authorization,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(
+                    `Solapi error: status=${response.status}, body=${text}`,
+                );
+            }
+
+            const result = (await response.json()) as { groupId?: string };
+            return {
+                provider_msg_id: result.groupId ?? "",
+                status_code: String(response.status),
+            };
+        } finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist-create/template/app/plugins/sms/routes.ts

@@ -0,0 +1,23 @@
+/**
+ * SMS 라우트 테이블
+ * 등록 경로: /api/v1/sms/*
+ */
+
+import type { FastifyInstance } from "fastify";
+import * as h from "./handlers.ts";
+
+/** SMS 라우트를 등록한다 */
+export default async function smsRoutes(app: FastifyInstance) {
+    // POST /api/v1/sms/send — SMS/LMS/MMS 발송 큐 등록
+    app.post("/send", h.handleSend);
+
+    // GET /api/v1/sms/status/:seq — 발송 상태 조회
+    app.get("/status/:seq", h.handleStatus);
+
+    // 인증번호 라우트 (인증 불필요)
+    // POST /api/v1/sms/verification/send — 인증번호 발송
+    app.post("/verification/send", h.handleVerificationSend);
+
+    // POST /api/v1/sms/verification/verify — 인증번호 검증
+    app.post("/verification/verify", h.handleVerificationVerify);
+}