@k-msg/channel 0.1.0 → 0.1.2

package/dist/kakao/channel.d.ts

@@ -0,0 +1,25 @@
+import { type Channel, type ChannelCreateRequest, ChannelStatus, ChannelType } from "../types/channel.types";
+export declare class KakaoChannelManager {
+    private channels;
+    createChannel(request: ChannelCreateRequest): Promise<Channel>;
+    private validateKakaoChannelRequest;
+    private isValidPlusFriendId;
+    private initiateBusinessVerification;
+    completeVerification(channelId: string, approved: boolean, rejectionReason?: string): Promise<void>;
+    getChannel(channelId: string): Promise<Channel | null>;
+    updateChannel(channelId: string, updates: Partial<Channel>): Promise<Channel>;
+    deleteChannel(channelId: string): Promise<boolean>;
+    listChannels(filters?: {
+        status?: ChannelStatus;
+        type?: ChannelType;
+        verified?: boolean;
+    }): Promise<Channel[]>;
+    suspendChannel(channelId: string, reason: string): Promise<void>;
+    reactivateChannel(channelId: string): Promise<void>;
+    checkChannelHealth(channelId: string): Promise<{
+        isHealthy: boolean;
+        issues: string[];
+        recommendations: string[];
+    }>;
+    private generateChannelId;
+}

package/dist/kakao/sender-number.d.ts

@@ -0,0 +1,31 @@
+import { type SenderNumber, type SenderNumberCategory, type SenderNumberCreateRequest, SenderNumberStatus } from "../types/channel.types";
+export declare class KakaoSenderNumberManager {
+    private senderNumbers;
+    private verificationCodes;
+    addSenderNumber(channelId: string, request: SenderNumberCreateRequest): Promise<SenderNumber>;
+    private validatePhoneNumber;
+    private findSenderNumberByPhone;
+    private initiateVerification;
+    private sendVerificationSMS;
+    verifySenderNumber(senderNumberId: string, code: string): Promise<boolean>;
+    resendVerificationCode(senderNumberId: string): Promise<void>;
+    getSenderNumber(senderNumberId: string): Promise<SenderNumber | null>;
+    listSenderNumbers(filters?: {
+        channelId?: string;
+        status?: SenderNumberStatus;
+        category?: SenderNumberCategory;
+        verified?: boolean;
+    }): Promise<SenderNumber[]>;
+    updateSenderNumber(senderNumberId: string, updates: Partial<SenderNumber>): Promise<SenderNumber>;
+    deleteSenderNumber(senderNumberId: string): Promise<boolean>;
+    private isSenderNumberInUse;
+    blockSenderNumber(senderNumberId: string, reason: string): Promise<void>;
+    unblockSenderNumber(senderNumberId: string): Promise<void>;
+    validateSenderNumberForSending(senderNumberId: string): Promise<{
+        isValid: boolean;
+        errors: string[];
+    }>;
+    private generateSenderNumberId;
+    private generateVerificationCode;
+    cleanup(): void;
+}

package/dist/management/crud.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Channel CRUD Operations
+ * 채널 생성, 조회, 수정, 삭제 통합 관리
+ */
+import { EventEmitter } from "events";
+import { type Channel, type ChannelCreateRequest, type ChannelFilters, type SenderNumber, type SenderNumberCreateRequest, type SenderNumberFilters } from "../types/channel.types";
+export interface PaginationOptions {
+    page: number;
+    limit: number;
+    sortBy?: string;
+    sortOrder?: "asc" | "desc";
+}
+export interface PaginatedResult<T> {
+    data: T[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+export interface ChannelCRUDOptions {
+    enableAuditLog: boolean;
+    enableEventEmission: boolean;
+    defaultPageSize: number;
+    maxPageSize: number;
+    enableSoftDelete: boolean;
+    autoCleanup: boolean;
+    cleanupInterval: number;
+}
+export interface AuditLogEntry {
+    id: string;
+    entityType: "channel" | "senderNumber";
+    entityId: string;
+    action: "create" | "read" | "update" | "delete" | "verify" | "suspend" | "activate";
+    userId?: string;
+    timestamp: Date;
+    changes?: {
+        before: any;
+        after: any;
+    };
+    metadata?: Record<string, any>;
+}
+export declare class ChannelCRUD extends EventEmitter {
+    private options;
+    private channels;
+    private senderNumbers;
+    private auditLogs;
+    private cleanupTimer?;
+    private defaultOptions;
+    constructor(options?: Partial<ChannelCRUDOptions>);
+    createChannel(request: ChannelCreateRequest, userId?: string): Promise<Channel>;
+    getChannel(channelId: string, userId?: string): Promise<Channel | null>;
+    updateChannel(channelId: string, updates: Partial<Omit<Channel, "id" | "createdAt" | "updatedAt">>, userId?: string): Promise<Channel>;
+    deleteChannel(channelId: string, userId?: string): Promise<boolean>;
+    listChannels(filters?: ChannelFilters, pagination?: PaginationOptions): Promise<PaginatedResult<Channel>>;
+    createSenderNumber(channelId: string, request: SenderNumberCreateRequest, userId?: string): Promise<SenderNumber>;
+    getSenderNumber(senderNumberId: string, userId?: string): Promise<SenderNumber | null>;
+    updateSenderNumber(senderNumberId: string, updates: Partial<Omit<SenderNumber, "id" | "phoneNumber" | "createdAt" | "updatedAt">>, userId?: string): Promise<SenderNumber>;
+    deleteSenderNumber(senderNumberId: string, userId?: string): Promise<boolean>;
+    listSenderNumbers(filters?: SenderNumberFilters, pagination?: PaginationOptions): Promise<PaginatedResult<SenderNumber>>;
+    getAuditLogs(entityType?: "channel" | "senderNumber", entityId?: string, limit?: number): AuditLogEntry[];
+    getStatistics(): {
+        channels: {
+            total: number;
+            byStatus: Record<string, number>;
+            byType: Record<string, number>;
+            byProvider: Record<string, number>;
+        };
+        senderNumbers: {
+            total: number;
+            byStatus: Record<string, number>;
+            byCategory: Record<string, number>;
+        };
+    };
+    cleanup(): {
+        deletedChannels: number;
+        expiredAuditLogs: number;
+    };
+    destroy(): void;
+    private addAuditLog;
+    private getDefaultLimits;
+    private getDefaultFeatures;
+    private startAutoCleanup;
+    private generateChannelId;
+    private generateSenderNumberId;
+    private generateAuditLogId;
+}

package/dist/management/permissions.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Permission Management System
+ * 채널 및 발신번호 액세스 권한 관리
+ */
+import { EventEmitter } from "events";
+export interface User {
+    id: string;
+    email: string;
+    name: string;
+    roles: Role[];
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Role {
+    id: string;
+    name: string;
+    permissions: Permission[];
+    description?: string;
+    isSystem: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Permission {
+    id: string;
+    resource: ResourceType;
+    action: ActionType;
+    scope: PermissionScope;
+    conditions?: PermissionCondition[];
+}
+export declare enum ResourceType {
+    CHANNEL = "channel",
+    SENDER_NUMBER = "senderNumber",
+    TEMPLATE = "template",
+    MESSAGE = "message",
+    USER = "user",
+    ROLE = "role",
+    AUDIT_LOG = "auditLog",
+    ANALYTICS = "analytics"
+}
+export declare enum ActionType {
+    CREATE = "create",
+    READ = "read",
+    UPDATE = "update",
+    DELETE = "delete",
+    VERIFY = "verify",
+    SUSPEND = "suspend",
+    ACTIVATE = "activate",
+    SEND = "send",
+    MANAGE = "manage"
+}
+export declare enum PermissionScope {
+    GLOBAL = "global",
+    ORGANIZATION = "organization",
+    TEAM = "team",
+    PERSONAL = "personal"
+}
+export interface PermissionCondition {
+    field: string;
+    operator: "equals" | "not_equals" | "in" | "not_in" | "contains" | "starts_with";
+    value: any;
+}
+export interface AccessContext {
+    userId: string;
+    organizationId?: string;
+    teamId?: string;
+    resourceOwnerId?: string;
+    metadata?: Record<string, any>;
+}
+export interface PermissionCheck {
+    userId: string;
+    resource: ResourceType;
+    action: ActionType;
+    resourceId?: string;
+    context?: AccessContext;
+}
+export interface PermissionResult {
+    granted: boolean;
+    reason?: string;
+    matchedPermissions: Permission[];
+    deniedReasons: string[];
+}
+export declare class PermissionManager extends EventEmitter {
+    private users;
+    private roles;
+    private userRoleCache;
+    private permissionCache;
+    private cacheExpiry;
+    private readonly CACHE_DURATION;
+    constructor();
+    createUser(userData: Omit<User, "id" | "createdAt" | "updatedAt">): Promise<User>;
+    getUser(userId: string): Promise<User | null>;
+    updateUser(userId: string, updates: Partial<User>): Promise<User>;
+    deleteUser(userId: string): Promise<boolean>;
+    createRole(roleData: Omit<Role, "id" | "createdAt" | "updatedAt">): Promise<Role>;
+    getRole(roleId: string): Promise<Role | null>;
+    updateRole(roleId: string, updates: Partial<Role>): Promise<Role>;
+    deleteRole(roleId: string): Promise<boolean>;
+    assignRoleToUser(userId: string, roleId: string): Promise<void>;
+    removeRoleFromUser(userId: string, roleId: string): Promise<void>;
+    checkPermission(check: PermissionCheck): Promise<PermissionResult>;
+    hasPermission(userId: string, resource: ResourceType, action: ActionType, resourceId?: string, context?: AccessContext): Promise<boolean>;
+    requirePermission(userId: string, resource: ResourceType, action: ActionType, resourceId?: string, context?: AccessContext): Promise<void>;
+    getUserPermissions(userId: string): Promise<Permission[]>;
+    getUserRoles(userId: string): Promise<Role[]>;
+    listUsers(filters?: {
+        isActive?: boolean;
+        roleId?: string;
+    }): User[];
+    listRoles(): Role[];
+    private performPermissionCheck;
+    private doesPermissionMatch;
+    private checkConditions;
+    private evaluateCondition;
+    private initializeSystemRoles;
+    private updateUserRoleCache;
+    private clearUserPermissionCache;
+    private clearRolePermissionCache;
+    private getCacheKey;
+    private getFromCache;
+    private setCache;
+    private generateUserId;
+    private generateRoleId;
+}

package/dist/services/channel.service.d.ts

@@ -0,0 +1,22 @@
+import type { ChannelConfig, ChannelVerificationResult } from "../types/channel.types";
+import { SenderNumberStatus } from "../types/channel.types";
+export interface ServiceSenderNumber {
+    phoneNumber: string;
+    name?: string;
+    verifiedAt?: Date;
+    status: SenderNumberStatus;
+    channelId: string;
+}
+export declare class ChannelService {
+    private channels;
+    private senderNumbers;
+    createChannel(channel: Omit<ChannelConfig, "id" | "createdAt" | "updatedAt">): Promise<ChannelConfig>;
+    getChannel(channelId: string): Promise<ChannelConfig | null>;
+    listChannels(providerId?: string): Promise<ChannelConfig[]>;
+    updateChannel(channelId: string, updates: Partial<ChannelConfig>): Promise<ChannelConfig>;
+    deleteChannel(channelId: string): Promise<void>;
+    addSenderNumber(channelId: string, phoneNumber: string, name?: string): Promise<ServiceSenderNumber>;
+    verifySenderNumber(phoneNumber: string): Promise<ChannelVerificationResult>;
+    getSenderNumbers(channelId?: string): Promise<ServiceSenderNumber[]>;
+    private generateChannelId;
+}

package/dist/types/channel.types.d.ts

@@ -0,0 +1,228 @@
+import { z } from "zod";
+export interface Channel {
+    id: string;
+    name: string;
+    provider: string;
+    type: ChannelType;
+    status: ChannelStatus;
+    profileKey: string;
+    senderNumbers: SenderNumber[];
+    metadata: ChannelMetadata;
+    verification: ChannelVerification;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare enum ChannelType {
+    KAKAO_ALIMTALK = "KAKAO_ALIMTALK",
+    KAKAO_FRIENDTALK = "KAKAO_FRIENDTALK",
+    SMS = "SMS",
+    LMS = "LMS",
+    MMS = "MMS"
+}
+export declare enum ChannelStatus {
+    PENDING = "PENDING",// 등록 대기
+    VERIFYING = "VERIFYING",// 검증 중
+    ACTIVE = "ACTIVE",// 활성화
+    SUSPENDED = "SUSPENDED",// 일시 정지
+    BLOCKED = "BLOCKED",// 차단됨
+    DELETED = "DELETED"
+}
+export interface SenderNumber {
+    id: string;
+    phoneNumber: string;
+    status: SenderNumberStatus;
+    verificationCode?: string;
+    verifiedAt?: Date;
+    category: SenderNumberCategory;
+    metadata: {
+        businessName?: string;
+        businessRegistrationNumber?: string;
+        contactPerson?: string;
+        contactEmail?: string;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare enum SenderNumberStatus {
+    PENDING = "PENDING",// 등록 대기
+    VERIFYING = "VERIFYING",// 인증 중
+    VERIFIED = "VERIFIED",// 인증 완료
+    REJECTED = "REJECTED",// 반려됨
+    BLOCKED = "BLOCKED"
+}
+export declare enum SenderNumberCategory {
+    BUSINESS = "BUSINESS",// 사업자
+    PERSONAL = "PERSONAL",// 개인
+    GOVERNMENT = "GOVERNMENT",// 관공서
+    NON_PROFIT = "NON_PROFIT"
+}
+export interface ChannelMetadata {
+    businessInfo?: {
+        name: string;
+        registrationNumber: string;
+        category: string;
+        contactPerson: string;
+        contactEmail: string;
+        contactPhone: string;
+    };
+    kakaoInfo?: {
+        plusFriendId: string;
+        brandName: string;
+        logoUrl?: string;
+        description?: string;
+    };
+    limits: {
+        dailyMessageLimit: number;
+        monthlyMessageLimit: number;
+        rateLimit: number;
+    };
+    features: {
+        supportsBulkSending: boolean;
+        supportsScheduling: boolean;
+        supportsButtons: boolean;
+        maxButtonCount: number;
+    };
+}
+export interface ChannelVerification {
+    status: VerificationStatus;
+    documents: VerificationDocument[];
+    verifiedAt?: Date;
+    rejectedAt?: Date;
+    rejectionReason?: string;
+    verifiedBy?: string;
+}
+export declare enum VerificationStatus {
+    NOT_REQUIRED = "NOT_REQUIRED",
+    PENDING = "PENDING",
+    UNDER_REVIEW = "UNDER_REVIEW",
+    VERIFIED = "VERIFIED",
+    REJECTED = "REJECTED"
+}
+export interface VerificationDocument {
+    id: string;
+    type: DocumentType;
+    fileName: string;
+    fileUrl: string;
+    uploadedAt: Date;
+    status: DocumentStatus;
+}
+export declare enum DocumentType {
+    BUSINESS_REGISTRATION = "BUSINESS_REGISTRATION",
+    BUSINESS_LICENSE = "BUSINESS_LICENSE",
+    ID_CARD = "ID_CARD",
+    AUTHORIZATION_LETTER = "AUTHORIZATION_LETTER",
+    OTHER = "OTHER"
+}
+export declare enum DocumentStatus {
+    UPLOADED = "UPLOADED",
+    VERIFIED = "VERIFIED",
+    REJECTED = "REJECTED"
+}
+export interface ChannelCreateRequest {
+    name: string;
+    type: ChannelType;
+    provider: string;
+    profileKey: string;
+    businessInfo?: {
+        name: string;
+        registrationNumber: string;
+        category: string;
+        contactPerson: string;
+        contactEmail: string;
+        contactPhone: string;
+    };
+    kakaoInfo?: {
+        plusFriendId: string;
+        brandName: string;
+        logoUrl?: string;
+        description?: string;
+    };
+}
+export interface SenderNumberCreateRequest {
+    phoneNumber: string;
+    category: SenderNumberCategory;
+    businessInfo?: {
+        businessName: string;
+        businessRegistrationNumber: string;
+        contactPerson: string;
+        contactEmail: string;
+    };
+}
+export interface ChannelFilters {
+    provider?: string;
+    type?: ChannelType;
+    status?: ChannelStatus;
+    verified?: boolean;
+    createdAfter?: Date;
+    createdBefore?: Date;
+}
+export interface SenderNumberFilters {
+    channelId?: string;
+    status?: SenderNumberStatus;
+    category?: SenderNumberCategory;
+    verified?: boolean;
+}
+export declare const ChannelCreateRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<typeof ChannelType>;
+    provider: z.ZodString;
+    profileKey: z.ZodString;
+    businessInfo: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        registrationNumber: z.ZodString;
+        category: z.ZodString;
+        contactPerson: z.ZodString;
+        contactEmail: z.ZodString;
+        contactPhone: z.ZodString;
+    }, z.core.$strip>>;
+    kakaoInfo: z.ZodOptional<z.ZodObject<{
+        plusFriendId: z.ZodString;
+        brandName: z.ZodString;
+        logoUrl: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SenderNumberCreateRequestSchema: z.ZodObject<{
+    phoneNumber: z.ZodString;
+    category: z.ZodEnum<typeof SenderNumberCategory>;
+    businessInfo: z.ZodOptional<z.ZodObject<{
+        businessName: z.ZodString;
+        businessRegistrationNumber: z.ZodString;
+        contactPerson: z.ZodString;
+        contactEmail: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ChannelFiltersSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<typeof ChannelType>>;
+    status: z.ZodOptional<z.ZodEnum<typeof ChannelStatus>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    createdAfter: z.ZodOptional<z.ZodDate>;
+    createdBefore: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export declare const SenderNumberFiltersSchema: z.ZodObject<{
+    channelId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<typeof SenderNumberStatus>>;
+    category: z.ZodOptional<z.ZodEnum<typeof SenderNumberCategory>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ChannelCreateRequestType = z.infer<typeof ChannelCreateRequestSchema>;
+export type SenderNumberCreateRequestType = z.infer<typeof SenderNumberCreateRequestSchema>;
+export type ChannelFiltersType = z.infer<typeof ChannelFiltersSchema>;
+export type SenderNumberFiltersType = z.infer<typeof SenderNumberFiltersSchema>;
+export interface ChannelConfig {
+    id: string;
+    name: string;
+    type: "alimtalk" | "sms" | "lms" | "friendtalk";
+    providerId: string;
+    active: boolean;
+    settings: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ChannelVerificationResult {
+    success: boolean;
+    status: string;
+    verificationCode?: string;
+    error?: string;
+}

package/dist/verification/business.verify.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Business Verification System
+ * 사업자 정보 및 서류 검증 시스템
+ */
+import { EventEmitter } from "events";
+import { DocumentType, type VerificationDocument, VerificationStatus } from "../types/channel.types";
+export interface BusinessInfo {
+    businessName: string;
+    businessRegistrationNumber: string;
+    businessType: "corporation" | "individual" | "partnership" | "other";
+    industry: string;
+    establishedDate: Date;
+    address: {
+        street: string;
+        city: string;
+        state: string;
+        postalCode: string;
+        country: string;
+    };
+    contactInfo: {
+        phoneNumber: string;
+        email: string;
+        website?: string;
+    };
+    representatives: Array<{
+        name: string;
+        position: string;
+        phoneNumber: string;
+        email: string;
+    }>;
+}
+export interface VerificationRequest {
+    id: string;
+    channelId: string;
+    businessInfo: BusinessInfo;
+    documents: VerificationDocument[];
+    status: VerificationStatus;
+    submittedAt: Date;
+    reviewedAt?: Date;
+    reviewedBy?: string;
+    reviewNotes?: string;
+    autoVerificationResults?: AutoVerificationResult[];
+}
+export interface AutoVerificationResult {
+    checkType: "business_registry" | "document_validation" | "address_verification" | "phone_verification";
+    status: "passed" | "failed" | "warning";
+    score: number;
+    details: string;
+    metadata?: Record<string, any>;
+}
+export interface DocumentValidationResult {
+    isValid: boolean;
+    confidence: number;
+    extractedData?: Record<string, any>;
+    issues: Array<{
+        type: "format" | "content" | "quality" | "authenticity";
+        severity: "low" | "medium" | "high" | "critical";
+        message: string;
+    }>;
+}
+export interface BusinessVerifierOptions {
+    enableAutoVerification: boolean;
+    requiredDocuments: DocumentType[];
+    autoApprovalThreshold: number;
+    requireManualReview: boolean;
+    documentRetentionDays: number;
+    enableExternalAPIs: boolean;
+    externalAPIConfig?: {
+        businessRegistryAPI?: string;
+        addressVerificationAPI?: string;
+        documentOCRAPI?: string;
+    };
+}
+export declare class BusinessVerifier extends EventEmitter {
+    private options;
+    private verificationRequests;
+    private documentValidators;
+    private defaultOptions;
+    constructor(options?: Partial<BusinessVerifierOptions>);
+    /**
+     * Submit business verification request
+     */
+    submitVerification(channelId: string, businessInfo: BusinessInfo, documents: VerificationDocument[]): Promise<VerificationRequest>;
+    /**
+     * Get verification request by ID
+     */
+    getVerificationRequest(requestId: string): VerificationRequest | null;
+    /**
+     * Get verification request by channel ID
+     */
+    getVerificationByChannelId(channelId: string): VerificationRequest | null;
+    /**
+     * Manually approve verification
+     */
+    approveVerification(requestId: string, reviewerId: string, notes?: string): Promise<VerificationRequest>;
+    /**
+     * Manually reject verification
+     */
+    rejectVerification(requestId: string, reviewerId: string, reason: string): Promise<VerificationRequest>;
+    /**
+     * Update verification request with additional documents
+     */
+    addDocument(requestId: string, document: VerificationDocument): Promise<VerificationRequest>;
+    /**
+     * List verification requests with filters
+     */
+    listVerificationRequests(filters?: {
+        status?: VerificationStatus;
+        channelId?: string;
+        submittedAfter?: Date;
+        submittedBefore?: Date;
+    }): VerificationRequest[];
+    /**
+     * Get verification statistics
+     */
+    getVerificationStats(): {
+        total: number;
+        byStatus: Record<string, number>;
+        averageProcessingTime: number;
+        autoApprovalRate: number;
+    };
+    private processAutoVerification;
+    private validateRequiredDocuments;
+    private verifyBusinessRegistration;
+    private calculateBusinessRegistrationScore;
+    private validateDocument;
+    private verifyAddress;
+    private verifyPhoneNumber;
+    private initializeDocumentValidators;
+    private generateRequestId;
+}