@k-msg/provider 0.1.0 → 0.1.2

package/dist/interfaces/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./plugin";
+export * from "./services";
+export interface NotificationRequest {
+    phoneNumber: string;
+    message: string;
+    templateCode?: string;
+    variables?: Record<string, string>;
+}
+export interface NotificationResponse {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+    code?: string;
+}

package/dist/interfaces/plugin.d.ts

@@ -0,0 +1,122 @@
+import type { EventEmitter } from "events";
+export interface ProviderPlugin {
+    readonly metadata: ProviderMetadata;
+    readonly capabilities: ProviderCapabilities;
+    initialize(context: PluginContext): Promise<void>;
+    destroy(): Promise<void>;
+    middleware?: ProviderMiddleware[];
+    getImplementation(): ProviderImplementation;
+}
+export interface ProviderMetadata {
+    name: string;
+    version: string;
+    author: string;
+    description: string;
+    homepage?: string;
+    repository?: string;
+}
+export interface ProviderCapabilities {
+    messaging: {
+        single: boolean;
+        bulk: boolean;
+        maxBulkSize?: number;
+        maxMessageLength?: number;
+        variableSupport?: boolean;
+        maxVariables?: number;
+    };
+    scheduling?: {
+        supported: boolean;
+        maxAdvanceDays?: number;
+        minAdvanceMinutes?: number;
+        modifiable?: boolean;
+        cancellable?: boolean;
+    };
+    templating?: {
+        supported: boolean;
+        crud: boolean;
+        validation: boolean;
+        buttonTypes?: string[];
+        maxButtons?: number;
+        reviewRequired?: boolean;
+        reviewTime?: string;
+    };
+    resending?: {
+        supported: boolean;
+        fallbackTypes?: string[];
+        customContent?: boolean;
+    };
+    webhooks?: {
+        delivery: boolean;
+        status: boolean;
+    };
+    rateLimit?: {
+        messagesPerSecond?: number;
+        messagesPerMinute?: number;
+        messagesPerHour?: number;
+        messagesPerDay?: number;
+    };
+}
+export interface PluginContext {
+    config: ProviderConfig;
+    logger: Logger;
+    metrics: MetricsCollector;
+    storage: PluginStorage;
+    eventBus: EventEmitter;
+}
+export interface ProviderConfig {
+    apiUrl: string;
+    apiKey?: string;
+    secretKey?: string;
+    userId?: string;
+    senderKey?: string;
+    plusFriendId?: string;
+    headers?: Record<string, string>;
+    customFields?: Record<string, any>;
+    timeout?: number;
+    retryConfig?: RetryConfig;
+    logLevel?: string;
+}
+export interface RetryConfig {
+    maxRetries: number;
+    retryDelay: number;
+    retryableErrors?: string[];
+    retryableStatusCodes?: number[];
+}
+export interface Logger {
+    info(message: string, ...args: any[]): void;
+    error(message: string, error?: any): void;
+    debug(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+}
+export interface MetricsCollector {
+    increment(metric: string, labels?: Record<string, string>): void;
+    histogram(metric: string, value: number, labels?: Record<string, string>): void;
+    gauge(metric: string, value: number, labels?: Record<string, string>): void;
+}
+export interface PluginStorage {
+    get(key: string): Promise<any>;
+    set(key: string, value: any, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+import type { AnalyticsService, BalanceService, HistoryService, MessagingService, SchedulingService, TemplatingService, WebhookService } from "./services";
+export interface ProviderImplementation {
+    messaging: MessagingService;
+    scheduling?: SchedulingService;
+    templating?: TemplatingService;
+    analytics?: AnalyticsService;
+    webhooks?: WebhookService;
+    balance?: BalanceService;
+    history?: HistoryService;
+}
+export interface ProviderMiddleware {
+    name: string;
+    pre?: (context: MiddlewareContext) => Promise<void>;
+    post?: (context: MiddlewareContext) => Promise<void>;
+    error?: (error: Error, context: MiddlewareContext) => Promise<void>;
+}
+export interface MiddlewareContext {
+    request: any;
+    response?: any;
+    metadata: Record<string, any>;
+    startTime: number;
+}

package/dist/interfaces/services.d.ts

@@ -0,0 +1,222 @@
+export interface MessagingService {
+    sendMessage(params: SendMessageParams): Promise<SendMessageResult>;
+    sendBulk(params: BulkMessageParams): Promise<BulkMessageResult>;
+    getDeliveryStatus?(messageId: string): Promise<DeliveryStatus>;
+}
+export interface SchedulingService {
+    schedule(params: ScheduleMessageParams): Promise<ScheduleResult>;
+    cancelSchedule(params: CancelScheduleParams): Promise<void>;
+    modifySchedule?(params: ModifyScheduleParams): Promise<ScheduleResult>;
+}
+export interface TemplatingService {
+    createTemplate(params: TemplateParams): Promise<Template>;
+    updateTemplate(templateId: string, params: TemplateParams): Promise<Template>;
+    deleteTemplate(templateId: string): Promise<void>;
+    getTemplate(templateId: string): Promise<Template>;
+    listTemplates(params?: ListTemplatesParams): Promise<TemplateList>;
+    validateTemplate(params: TemplateParams): Promise<ValidationResult>;
+}
+export interface AnalyticsService {
+    getStats(params: AnalyticsParams): Promise<AnalyticsData>;
+    getDeliveryReport(messageId: string): Promise<DeliveryReport>;
+}
+export interface WebhookService {
+    registerWebhook(params: WebhookParams): Promise<WebhookRegistration>;
+    updateWebhook(webhookId: string, params: WebhookParams): Promise<WebhookRegistration>;
+    deleteWebhook(webhookId: string): Promise<void>;
+    listWebhooks(): Promise<WebhookRegistration[]>;
+}
+export interface BalanceService {
+    getBalance(): Promise<BalanceInfo>;
+    getRate?(): Promise<RateInfo>;
+}
+export interface HistoryService {
+    getHistory(params: HistoryParams): Promise<HistoryList>;
+    getMessageDetail(messageId: string): Promise<MessageDetail>;
+}
+export interface SendMessageParams {
+    to: string;
+    templateId?: string;
+    message?: string;
+    variables?: Record<string, string>;
+    resend?: ResendConfig;
+}
+export interface BulkMessageParams {
+    templateId: string;
+    messages: Array<{
+        to: string;
+        variables?: Record<string, string>;
+    }>;
+    resend?: ResendConfig;
+}
+export interface ResendConfig {
+    from: string;
+    content?: string;
+    title?: string;
+}
+export interface SendMessageResult {
+    messageId: string;
+    status: "SUCCESS" | "FAILED" | "PENDING";
+    statusCode?: string;
+    remainingBalance?: number;
+    creditsUsed?: number;
+}
+export interface BulkMessageResult {
+    messageIds: string[];
+    successCount: number;
+    failureCount: number;
+    results: Array<{
+        status: "SUCCESS" | "FAILED";
+        statusCode?: string;
+        messageId?: string;
+    }>;
+    remainingBalance?: number;
+    creditsUsed?: number;
+}
+export interface ScheduleMessageParams {
+    templateId: string;
+    messages: Array<{
+        to: string;
+        variables?: Record<string, string>;
+    }>;
+    scheduledAt: Date;
+    resend?: ResendConfig;
+}
+export interface ScheduleResult {
+    scheduleId: string;
+    scheduledAt: Date;
+    messageCount: number;
+}
+export interface CancelScheduleParams {
+    scheduleId: string;
+}
+export interface ModifyScheduleParams {
+    scheduleId: string;
+    scheduledAt?: Date;
+    messages?: Array<{
+        to: string;
+        variables?: Record<string, string>;
+    }>;
+}
+export interface TemplateParams {
+    name: string;
+    content: string;
+    variables?: string[];
+    buttons?: TemplateButton[];
+}
+export interface TemplateButton {
+    type: string;
+    name: string;
+    linkMobile?: string;
+    linkPc?: string;
+    linkIos?: string;
+    linkAndroid?: string;
+}
+export interface Template {
+    id: string;
+    name: string;
+    content: string;
+    status: "ACTIVE" | "PENDING" | "REJECTED";
+    variables: string[];
+    buttons?: TemplateButton[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ListTemplatesParams {
+    page?: number;
+    pageSize?: number;
+    templateCode?: string;
+    templateName?: string;
+    status?: string;
+}
+export interface TemplateList {
+    items: Template[];
+    totalCount: number;
+    currentPage: number;
+    totalPages: number;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+}
+export interface DeliveryStatus {
+    messageId: string;
+    status: "PENDING" | "SENT" | "DELIVERED" | "FAILED" | "EXPIRED";
+    sentAt?: Date;
+    deliveredAt?: Date;
+    failureReason?: string;
+}
+export interface AnalyticsParams {
+    startDate: Date;
+    endDate: Date;
+    templateIds?: string[];
+    metrics?: string[];
+}
+export interface AnalyticsData {
+    sent: number;
+    delivered: number;
+    failed: number;
+    deliveryRate: number;
+    templateStats?: Record<string, any>;
+}
+export interface DeliveryReport {
+    messageId: string;
+    templateId?: string;
+    recipient: string;
+    status: string;
+    sentAt: Date;
+    deliveredAt?: Date;
+    events: Array<{
+        timestamp: Date;
+        event: string;
+        description?: string;
+    }>;
+}
+export interface WebhookParams {
+    url: string;
+    events: string[];
+    secretKey?: string;
+}
+export interface WebhookRegistration {
+    id: string;
+    url: string;
+    events: string[];
+    isActive: boolean;
+    createdAt: Date;
+}
+export interface BalanceInfo {
+    amount: number;
+    currency: string;
+    lastUpdated: Date;
+}
+export interface RateInfo {
+    messageRate: number;
+    currency: string;
+    unit: string;
+}
+export interface HistoryParams {
+    startDate?: Date;
+    endDate?: Date;
+    phoneNumber?: string;
+    templateId?: string;
+    status?: string;
+    page?: number;
+    pageSize?: number;
+}
+export interface HistoryList {
+    items: MessageDetail[];
+    totalCount: number;
+    currentPage: number;
+    totalPages: number;
+}
+export interface MessageDetail {
+    messageId: string;
+    phoneNumber: string;
+    templateId?: string;
+    content: string;
+    status: string;
+    sentAt: Date;
+    deliveredAt?: Date;
+    failureReason?: string;
+    creditsUsed: number;
+}

package/dist/iwinv/contracts/account.contract.d.ts

@@ -0,0 +1,11 @@
+/**
+ * IWINV Account Contract Implementation
+ */
+import type { AccountContract, AccountProfile, Balance } from "../../contracts/provider.contract";
+import type { IWINVConfig } from "../types/iwinv";
+export declare class IWINVAccountContract implements AccountContract {
+    private config;
+    constructor(config: IWINVConfig);
+    getBalance(): Promise<Balance>;
+    getProfile(): Promise<AccountProfile>;
+}

package/dist/iwinv/contracts/analytics.contract.d.ts

@@ -0,0 +1,16 @@
+/**
+ * IWINV Analytics Contract Implementation
+ */
+import { type AnalyticsContract, type DateRange, type DeliveryReport, type TemplateStats, type UsageStats } from "../../contracts/provider.contract";
+import type { IWINVConfig } from "../types/iwinv";
+export declare class IWINVAnalyticsContract implements AnalyticsContract {
+    private config;
+    constructor(config: IWINVConfig);
+    getUsage(period: DateRange): Promise<UsageStats>;
+    getTemplateStats(templateId: string, period: DateRange): Promise<TemplateStats>;
+    getDeliveryReport(messageId: string): Promise<DeliveryReport>;
+    private groupByTemplate;
+    private groupByDay;
+    private groupByHour;
+    private mapStatus;
+}

package/dist/iwinv/contracts/channel.contract.d.ts

@@ -0,0 +1,15 @@
+/**
+ * IWINV Channel Contract Implementation
+ */
+import type { Channel, ChannelContract, ChannelRequest, SenderNumber } from "../../contracts/provider.contract";
+import type { IWINVConfig } from "../types/iwinv";
+export declare class IWINVChannelContract implements ChannelContract {
+    private config;
+    constructor(config: IWINVConfig);
+    register(channel: ChannelRequest): Promise<Channel>;
+    list(): Promise<Channel[]>;
+    private getDefaultChannel;
+    addSenderNumber(channelId: string, number: string): Promise<SenderNumber>;
+    verifySenderNumber(number: string, verificationCode: string): Promise<boolean>;
+    private mapPlusFriendStatus;
+}

package/dist/iwinv/contracts/messaging.contract.d.ts

@@ -0,0 +1,14 @@
+/**
+ * IWINV Messaging Contract Implementation
+ */
+import { MessageStatus, type MessagingContract, type ProviderBulkResult, type ProviderMessageRequest, type ProviderMessageResult, type ScheduleResult } from "../../contracts/provider.contract";
+import type { IWINVConfig } from "../types/iwinv";
+export declare class IWINVMessagingContract implements MessagingContract {
+    private config;
+    constructor(config: IWINVConfig);
+    send(message: ProviderMessageRequest): Promise<ProviderMessageResult>;
+    sendBulk(messages: ProviderMessageRequest[]): Promise<ProviderBulkResult>;
+    schedule(message: ProviderMessageRequest, scheduledAt: Date): Promise<ScheduleResult>;
+    cancel(messageId: string): Promise<void>;
+    getStatus(messageId: string): Promise<MessageStatus>;
+}

package/dist/iwinv/contracts/sms.contract.d.ts

@@ -0,0 +1,33 @@
+import { type BulkSMSResult, type ScheduleResult, type SMSAccountContract, type SMSAccountProfile, type SMSBalance, type SMSContract, type SMSResult, type SMSSenderNumber, type SMSSendRequest, SMSStatus } from "../../contracts/sms.contract";
+import type { IWINVConfig } from "../types/iwinv";
+export declare class IWINVSMSContract implements SMSContract {
+    private config;
+    constructor(config: IWINVConfig);
+    send(request: SMSSendRequest): Promise<SMSResult>;
+    sendBulk(requests: SMSSendRequest[]): Promise<BulkSMSResult>;
+    schedule(request: SMSSendRequest, scheduledAt: Date): Promise<ScheduleResult>;
+    cancel(messageId: string): Promise<void>;
+    getStatus(messageId: string): Promise<SMSStatus>;
+    private determineMessageType;
+    private getDefaultSenderNumber;
+    private formatDate;
+    private mapIWINVStatusToDeliveryStatus;
+    private mapIWINVStatusToSMSStatus;
+    private isRetryableError;
+    private formatDateForHistory;
+    private generateMessageId;
+    private generateRequestId;
+    private generateScheduleId;
+    private makeRequest;
+}
+export declare class IWINVSMSAccountContract implements SMSAccountContract {
+    private config;
+    constructor(config: IWINVConfig);
+    getBalance(): Promise<SMSBalance>;
+    getProfile(): Promise<SMSAccountProfile>;
+    getSenderNumbers(): Promise<SMSSenderNumber[]>;
+    addSenderNumber(phoneNumber: string): Promise<SMSSenderNumber>;
+    verifySenderNumber(phoneNumber: string, verificationCode: string): Promise<boolean>;
+    private mapSenderStatus;
+    private makeRequest;
+}

package/dist/iwinv/contracts/template.contract.d.ts

@@ -0,0 +1,18 @@
+/**
+ * IWINV Template Contract Implementation
+ */
+import { type ProviderTemplate, type SyncResult, type TemplateContract, type TemplateCreateRequest, type TemplateCreateResult, type TemplateFilters, type TemplateUpdateRequest, type TemplateUpdateResult } from "../../contracts/provider.contract";
+import type { IWINVConfig } from "../types/iwinv";
+export declare class IWINVTemplateContract implements TemplateContract {
+    private config;
+    constructor(config: IWINVConfig);
+    create(template: TemplateCreateRequest): Promise<TemplateCreateResult>;
+    update(templateId: string, template: TemplateUpdateRequest): Promise<TemplateUpdateResult>;
+    delete(templateId: string): Promise<void>;
+    get(templateId: string): Promise<ProviderTemplate>;
+    list(filters?: TemplateFilters): Promise<ProviderTemplate[]>;
+    sync(): Promise<SyncResult>;
+    private mapIWINVTemplateStatus;
+    private applyFilters;
+    private mapIWINVStatus;
+}

package/dist/iwinv/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * IWINV Provider 패키지 진입점
+ */
+export { IWINVProvider as default, IWINVProvider } from "./provider";
+export * from "./types/iwinv";

package/dist/iwinv/provider-multi.d.ts

@@ -0,0 +1,116 @@
+/**
+ * IWINV Multi Provider - New Adapter Pattern Implementation
+ * 새 어댑터 패턴을 사용한 IWINV 다중 프로바이더 구현
+ */
+import { IWINVProvider } from "./provider";
+import { IWINVSMSProvider } from "./provider-sms";
+import type { IWINVConfig } from "./types/iwinv";
+/**
+ * AlimTalk과 SMS를 모두 지원하는 통합 IWINV 프로바이더
+ */
+export declare class IWINVMultiProvider {
+    private alimtalkProvider;
+    private smsProvider;
+    private config;
+    constructor(config: IWINVConfig);
+    get id(): string;
+    get name(): string;
+    get version(): string;
+    get type(): "messaging";
+    /**
+     * AlimTalk 프로바이더 인스턴스 반환
+     */
+    getAlimTalkProvider(): IWINVProvider;
+    /**
+     * SMS 프로바이더 인스턴스 반환
+     */
+    getSMSProvider(): IWINVSMSProvider;
+    /**
+     * 채널 타입에 따른 자동 라우팅 전송
+     */
+    send(request: any & {
+        channel?: "alimtalk" | "sms" | "auto";
+    }): Promise<any>;
+    /**
+     * AlimTalk 전송 (템플릿 기반)
+     */
+    sendAlimTalk(templateId: string, to: string, variables: Record<string, string>, options?: {
+        scheduledAt?: Date;
+        senderNumber?: string;
+        priority?: "high" | "normal" | "low";
+    }): Promise<any>;
+    /**
+     * SMS 전송 (직접 메시지)
+     */
+    sendSMS(phoneNumber: string, message: string, options?: {
+        senderNumber?: string;
+        scheduledAt?: Date;
+        priority?: "high" | "normal" | "low";
+    }): Promise<any>;
+    /**
+     * LMS 전송 (긴 메시지)
+     */
+    sendLMS(phoneNumber: string, subject: string, message: string, options?: {
+        senderNumber?: string;
+        scheduledAt?: Date;
+        priority?: "high" | "normal" | "low";
+    }): Promise<any>;
+    /**
+     * 폴백 전송 (AlimTalk 실패 시 SMS로 자동 전환)
+     */
+    sendWithFallback(request: {
+        templateCode: string;
+        phoneNumber: string;
+        variables: Record<string, string>;
+        fallbackMessage?: string;
+        options?: {
+            scheduledAt?: Date;
+            senderNumber?: string;
+            priority?: "high" | "normal" | "low";
+        };
+    }): Promise<any & {
+        channel: "alimtalk" | "sms";
+    }>;
+    /**
+     * 대량 전송 (채널 자동 선택)
+     */
+    sendBulk(requests: Array<any & {
+        channel?: "alimtalk" | "sms" | "auto";
+    }>, options?: {
+        batchSize?: number;
+        concurrency?: number;
+    }): Promise<any[]>;
+    /**
+     * 헬스체크 (두 프로바이더 모두 확인)
+     */
+    healthCheck(): Promise<{
+        healthy: boolean;
+        issues: string[];
+        data: {
+            alimtalk: import("@k-msg/core").ProviderHealthStatus | null;
+            sms: import("@k-msg/core").ProviderHealthStatus | null;
+        };
+    }>;
+    /**
+     * 지원 기능 목록
+     */
+    getSupportedFeatures(): string[];
+    /**
+     * 설정 정보
+     */
+    getCapabilities(): {
+        channels: string[];
+        maxRecipientsPerRequest: number;
+        maxRequestsPerSecond: number;
+        supportsBulk: boolean;
+        supportsScheduling: boolean;
+        supportsTemplating: boolean;
+        supportsAutoFallback: boolean;
+        supportsWebhooks: boolean;
+    };
+}
+/**
+ * Multi Provider 팩토리 함수들
+ */
+export declare const createIWINVMultiProvider: (config: IWINVConfig) => IWINVMultiProvider;
+export declare const createDefaultIWINVMultiProvider: () => IWINVMultiProvider;

package/dist/iwinv/provider-sms.d.ts

@@ -0,0 +1,55 @@
+/**
+ * IWINV SMS Provider - New Adapter Pattern Implementation
+ * 새 어댑터 패턴을 사용한 IWINV SMS 프로바이더 구현
+ */
+import { IWINVProvider } from "./provider";
+import type { IWINVConfig } from "./types/iwinv";
+/**
+ * SMS 특화 IWINV 프로바이더
+ * 새 어댑터 패턴 기반으로 SMS 기능에 최적화
+ */
+export declare class IWINVSMSProvider extends IWINVProvider {
+    constructor(config: IWINVConfig);
+    /**
+     * SMS 전송 (표준 인터페이스 사용)
+     */
+    sendSMS(phoneNumber: string, message: string, options?: {
+        senderNumber?: string;
+        scheduledAt?: Date;
+        priority?: "high" | "normal" | "low";
+    }): Promise<any>;
+    /**
+     * LMS 전송 (긴 문자 메시지)
+     */
+    sendLMS(phoneNumber: string, subject: string, message: string, options?: {
+        senderNumber?: string;
+        scheduledAt?: Date;
+        priority?: "high" | "normal" | "low";
+    }): Promise<any>;
+    /**
+     * 대량 SMS 전송
+     */
+    sendBulkSMS(recipients: Array<{
+        phoneNumber: string;
+        message: string;
+        variables?: Record<string, string>;
+    }>, options?: {
+        senderNumber?: string;
+        scheduledAt?: Date;
+        batchSize?: number;
+    }): Promise<(PromiseRejectedResult | PromiseFulfilledResult<any>)[]>;
+    /**
+     * SMS/LMS 자동 판별 전송
+     */
+    sendMessage(phoneNumber: string, message: string, options?: {
+        senderNumber?: string;
+        scheduledAt?: Date;
+        subject?: string;
+        priority?: "high" | "normal" | "low";
+    }): Promise<any>;
+}
+/**
+ * SMS Provider 팩토리 함수들
+ */
+export declare const createIWINVSMSProvider: (config: IWINVConfig) => IWINVSMSProvider;
+export declare const createDefaultIWINVSMSProvider: () => IWINVSMSProvider;

package/dist/iwinv/provider.d.ts

@@ -0,0 +1,42 @@
+import { type SendOptions, type StandardRequest, UniversalProvider } from "@k-msg/core";
+import type { IWINVConfig } from "./types/iwinv";
+export declare class IWINVProvider extends UniversalProvider {
+    private static readonly directSmsTemplates;
+    private readonly iwinvConfig;
+    constructor(config: IWINVConfig);
+    send(params: SendOptions | StandardRequest | any): Promise<any>;
+    private isStandardRequest;
+    private isSmsChannelRequest;
+    private resolveSmsBaseUrl;
+    private isLongMessage;
+    private resolveSmsMessageType;
+    private extractMessageText;
+    private formatSmsReserveDate;
+    private normalizePhoneNumber;
+    private buildSmsSecretHeader;
+    private buildLmsTitle;
+    private mapSmsResponseMessage;
+    private mapSmsErrorCode;
+    private isSmsRetryableCode;
+    private normalizeCode;
+    private extractProviderCode;
+    private isIpRestrictionResult;
+    private getIpRetryCount;
+    private getIpRetryDelayMs;
+    private wait;
+    private emitIpRestrictionAlert;
+    private addIpRetryMetadata;
+    private sendWithIpRetry;
+    private sendSmsRequestOnce;
+}
+export declare const createIWINVProvider: (config: IWINVConfig) => IWINVProvider;
+export declare const createDefaultIWINVProvider: () => IWINVProvider;
+export declare class IWINVProviderFactory {
+    static create(config: IWINVConfig): IWINVProvider;
+    static createDefault(): IWINVProvider;
+    static getInstance(): {
+        createProvider: (config: IWINVConfig) => IWINVProvider;
+        initialize: () => void;
+    };
+}
+export declare function initializeIWINV(): void;