@k-msg/template 0.1.0 → 0.1.2

package/dist/interpolator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Interpolates variables into a string using the #{key} syntax.
+ *
+ * @param text The string to interpolate
+ * @param vars A record of key-value pairs to replace
+ * @returns The interpolated string
+ */
+export declare function interpolate(text: string, vars: Record<string, any>): string;

package/dist/parser/button.parser.d.ts

@@ -0,0 +1,25 @@
+import type { TemplateButton } from "../types/template.types";
+export declare class ButtonParser {
+    /**
+     * 버튼 설정의 유효성을 검증합니다
+     */
+    static validateButtons(buttons: TemplateButton[]): {
+        isValid: boolean;
+        errors: string[];
+    };
+    private static validateButtonByType;
+    private static validateWebLinkButton;
+    private static validateAppLinkButton;
+    private static validateDeliveryButton;
+    private static validateBotKeywordButton;
+    private static validateMessageDeliveryButton;
+    private static isValidUrl;
+    /**
+     * 버튼을 JSON 문자열로 직렬화합니다 (카카오 API 형식)
+     */
+    static serializeButtons(buttons: TemplateButton[]): string;
+    /**
+     * JSON 문자열에서 버튼 배열로 역직렬화합니다
+     */
+    static deserializeButtons(buttonsJson: string): TemplateButton[];
+}

package/dist/parser/validator.d.ts

@@ -0,0 +1,24 @@
+import { type AlimTalkTemplate } from "../types/template.types";
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare class TemplateValidator {
+    /**
+     * 알림톡 템플릿의 전체적인 유효성을 검증합니다
+     */
+    static validate(template: AlimTalkTemplate): ValidationResult;
+    private static validateBasicFields;
+    private static validateContent;
+    private static containsProhibitedCharacters;
+    private static validateUrlsInContent;
+    private static validateByCategory;
+    private static validateAuthenticationTemplate;
+    private static validatePromotionTemplate;
+    private static validatePaymentTemplate;
+    /**
+     * 빠른 검증 - 기본적인 필수 필드만 검사
+     */
+    static quickValidate(template: Partial<AlimTalkTemplate>): ValidationResult;
+}

package/dist/parser/variable.parser.d.ts

@@ -0,0 +1,27 @@
+import type { TemplateVariable } from "../types/template.types";
+export declare class VariableParser {
+    private static readonly VARIABLE_PATTERN;
+    /**
+     * 템플릿 내용에서 변수를 추출합니다
+     */
+    static extractVariables(content: string): string[];
+    /**
+     * 템플릿 내용의 변수를 실제 값으로 치환합니다
+     */
+    static replaceVariables(content: string, variables: Record<string, string | number | Date>): string;
+    /**
+     * 변수 정의와 실제 제공된 값을 검증합니다
+     */
+    static validateVariables(variableDefinitions: TemplateVariable[], providedVariables: Record<string, any>): {
+        isValid: boolean;
+        errors: string[];
+    };
+    private static validateVariableType;
+    /**
+     * 템플릿에서 사용된 변수와 정의된 변수의 일치성을 검사합니다
+     */
+    static validateTemplateVariables(content: string, variableDefinitions: TemplateVariable[]): {
+        isValid: boolean;
+        errors: string[];
+    };
+}

package/dist/registry/template.registry.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Template Registry - Manages templates across providers and categories
+ */
+import { EventEmitter } from "events";
+import type { AlimTalkTemplate, TemplateCategory, TemplateStatus } from "../types/template.types";
+export interface TemplateSearchFilters {
+    provider?: string;
+    category?: TemplateCategory;
+    status?: TemplateStatus;
+    nameContains?: string;
+    codeContains?: string;
+    createdAfter?: Date;
+    createdBefore?: Date;
+    usageMin?: number;
+    usageMax?: number;
+}
+export interface TemplateSearchOptions {
+    page?: number;
+    limit?: number;
+    sortBy?: "name" | "code" | "createdAt" | "updatedAt" | "usage";
+    sortOrder?: "asc" | "desc";
+}
+export interface TemplateSearchResult {
+    templates: AlimTalkTemplate[];
+    total: number;
+    page: number;
+    limit: number;
+    hasMore: boolean;
+}
+export interface TemplateVersion {
+    version: number;
+    template: AlimTalkTemplate;
+    changes: string[];
+    createdAt: Date;
+    createdBy?: string;
+}
+export interface TemplateHistory {
+    templateId: string;
+    versions: TemplateVersion[];
+    currentVersion: number;
+}
+export interface TemplateUsageStats {
+    templateId: string;
+    totalSent: number;
+    totalDelivered: number;
+    totalFailed: number;
+    deliveryRate: number;
+    failureRate: number;
+    lastUsed?: Date;
+    usageByDay: Array<{
+        date: string;
+        sent: number;
+        delivered: number;
+        failed: number;
+    }>;
+}
+export interface TemplateRegistryOptions {
+    enableVersioning: boolean;
+    maxVersionsPerTemplate: number;
+    enableUsageTracking: boolean;
+    enableAutoBackup: boolean;
+    backupInterval: number;
+    enableValidationOnRegister: boolean;
+}
+export declare class TemplateRegistry extends EventEmitter {
+    private options;
+    private templates;
+    private templatesByCode;
+    private templatesByProvider;
+    private templatesByCategory;
+    private templateHistories;
+    private usageStats;
+    private backupTimer?;
+    private defaultOptions;
+    constructor(options?: Partial<TemplateRegistryOptions>);
+    /**
+     * Register a new template
+     */
+    register(template: AlimTalkTemplate): Promise<void>;
+    /**
+     * Update an existing template
+     */
+    update(templateId: string, updates: Partial<AlimTalkTemplate>): Promise<AlimTalkTemplate>;
+    /**
+     * Get template by ID
+     */
+    get(templateId: string): AlimTalkTemplate | null;
+    /**
+     * Get template by code and provider
+     */
+    getByCode(code: string, provider: string): AlimTalkTemplate | null;
+    /**
+     * Search templates with filters and pagination
+     */
+    search(filters?: TemplateSearchFilters, options?: TemplateSearchOptions): TemplateSearchResult;
+    /**
+     * Get templates by provider
+     */
+    getByProvider(provider: string): AlimTalkTemplate[];
+    /**
+     * Get templates by category
+     */
+    getByCategory(category: TemplateCategory): AlimTalkTemplate[];
+    /**
+     * Delete template
+     */
+    delete(templateId: string): Promise<boolean>;
+    /**
+     * Get template version history
+     */
+    getHistory(templateId: string): TemplateHistory | null;
+    /**
+     * Get specific template version
+     */
+    getVersion(templateId: string, version: number): AlimTalkTemplate | null;
+    /**
+     * Restore template to a specific version
+     */
+    restoreVersion(templateId: string, version: number): Promise<AlimTalkTemplate>;
+    /**
+     * Get template usage statistics
+     */
+    getUsageStats(templateId: string): TemplateUsageStats | null;
+    /**
+     * Update template usage statistics
+     */
+    updateUsageStats(templateId: string, stats: {
+        sent?: number;
+        delivered?: number;
+        failed?: number;
+    }): void;
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        totalTemplates: number;
+        byProvider: Record<string, number>;
+        byCategory: Record<string, number>;
+        byStatus: Record<string, number>;
+    };
+    /**
+     * Export templates to JSON
+     */
+    export(filters?: TemplateSearchFilters): string;
+    /**
+     * Import templates from JSON
+     */
+    import(jsonData: string, options?: {
+        overwrite?: boolean;
+    }): Promise<{
+        imported: number;
+        skipped: number;
+        errors: string[];
+    }>;
+    /**
+     * Clear all templates (use with caution!)
+     */
+    clear(): void;
+    /**
+     * Stop the registry and cleanup
+     */
+    destroy(): void;
+    private updateIndexes;
+    private initializeVersionHistory;
+    private addVersionToHistory;
+    private initializeUsageStats;
+    private startAutoBackup;
+}

package/dist/service.d.ts

@@ -0,0 +1,14 @@
+import { KMsgError, type Result, type Template, type TemplateProvider } from "@k-msg/core";
+export declare class TemplateService {
+    private readonly provider;
+    constructor(provider: TemplateProvider);
+    create(template: Omit<Template, "id" | "status" | "createdAt" | "updatedAt">): Promise<Result<Template, KMsgError>>;
+    update(code: string, template: Partial<Omit<Template, "id" | "code" | "status" | "createdAt" | "updatedAt">>): Promise<Result<Template, KMsgError>>;
+    delete(code: string): Promise<Result<void, KMsgError>>;
+    get(code: string): Promise<Result<Template, KMsgError>>;
+    list(params?: {
+        status?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<Result<Template[], KMsgError>>;
+}

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

@@ -0,0 +1,10 @@
+import type { AlimTalkTemplate } from "../types/template.types";
+export declare class TemplateService {
+    private templates;
+    createTemplate(template: Omit<AlimTalkTemplate, "id" | "metadata">): Promise<AlimTalkTemplate>;
+    getTemplate(templateId: string): Promise<AlimTalkTemplate | null>;
+    updateTemplate(templateId: string, updates: Partial<AlimTalkTemplate>): Promise<AlimTalkTemplate>;
+    deleteTemplate(templateId: string): Promise<void>;
+    renderTemplate(templateId: string, variables: Record<string, any>): Promise<string>;
+    private generateTemplateId;
+}

package/dist/types/template.types.d.ts

@@ -0,0 +1,150 @@
+import { z } from "zod";
+export declare enum TemplateType {
+    ALIMTALK = "ALIMTALK",
+    SMS = "SMS",
+    LMS = "LMS",
+    MMS = "MMS",
+    RCS = "RCS"
+}
+export declare enum TemplateCategory {
+    AUTHENTICATION = "AUTHENTICATION",// 인증
+    NOTIFICATION = "NOTIFICATION",// 알림
+    PROMOTION = "PROMOTION",// 프로모션
+    INFORMATION = "INFORMATION",// 정보성
+    RESERVATION = "RESERVATION",// 예약
+    SHIPPING = "SHIPPING",// 배송
+    PAYMENT = "PAYMENT"
+}
+export declare enum TemplateStatus {
+    DRAFT = "DRAFT",// 초안
+    PENDING = "PENDING",// 검수 중
+    APPROVED = "APPROVED",// 승인됨
+    REJECTED = "REJECTED",// 반려됨
+    DISABLED = "DISABLED"
+}
+export interface TemplateVariable {
+    name: string;
+    type: "string" | "number" | "date" | "custom";
+    required: boolean;
+    maxLength?: number;
+    format?: string;
+    description?: string;
+    example?: string;
+}
+export interface TemplateButton {
+    type: "WL" | "AL" | "DS" | "BK" | "MD";
+    name: string;
+    linkMobile?: string;
+    linkPc?: string;
+    linkIos?: string;
+    linkAndroid?: string;
+    schemeIos?: string;
+    schemeAndroid?: string;
+}
+export interface AlimTalkTemplate {
+    id: string;
+    code: string;
+    name: string;
+    content: string;
+    variables?: TemplateVariable[];
+    buttons?: TemplateButton[];
+    category: TemplateCategory;
+    status: TemplateStatus;
+    provider: string;
+    metadata: {
+        createdAt: Date;
+        updatedAt: Date;
+        approvedAt?: Date;
+        rejectedAt?: Date;
+        rejectionReason?: string;
+        usage: {
+            sent: number;
+            delivered: number;
+            failed: number;
+        };
+    };
+}
+export declare const TemplateVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        date: "date";
+        custom: "custom";
+    }>;
+    required: z.ZodBoolean;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    example: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TemplateButtonSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        WL: "WL";
+        AL: "AL";
+        DS: "DS";
+        BK: "BK";
+        MD: "MD";
+    }>;
+    name: z.ZodString;
+    linkMobile: z.ZodOptional<z.ZodString>;
+    linkPc: z.ZodOptional<z.ZodString>;
+    linkIos: z.ZodOptional<z.ZodString>;
+    linkAndroid: z.ZodOptional<z.ZodString>;
+    schemeIos: z.ZodOptional<z.ZodString>;
+    schemeAndroid: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AlimTalkTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodString;
+    content: z.ZodString;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            date: "date";
+            custom: "custom";
+        }>;
+        required: z.ZodBoolean;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        example: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    buttons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            WL: "WL";
+            AL: "AL";
+            DS: "DS";
+            BK: "BK";
+            MD: "MD";
+        }>;
+        name: z.ZodString;
+        linkMobile: z.ZodOptional<z.ZodString>;
+        linkPc: z.ZodOptional<z.ZodString>;
+        linkIos: z.ZodOptional<z.ZodString>;
+        linkAndroid: z.ZodOptional<z.ZodString>;
+        schemeIos: z.ZodOptional<z.ZodString>;
+        schemeAndroid: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    category: z.ZodEnum<typeof TemplateCategory>;
+    status: z.ZodEnum<typeof TemplateStatus>;
+    provider: z.ZodString;
+    metadata: z.ZodObject<{
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        approvedAt: z.ZodOptional<z.ZodDate>;
+        rejectedAt: z.ZodOptional<z.ZodDate>;
+        rejectionReason: z.ZodOptional<z.ZodString>;
+        usage: z.ZodObject<{
+            sent: z.ZodNumber;
+            delivered: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AlimTalkTemplateType = z.infer<typeof AlimTalkTemplateSchema>;
+export type TemplateVariableType = z.infer<typeof TemplateVariableSchema>;
+export type TemplateButtonType = z.infer<typeof TemplateButtonSchema>;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@k-msg/template",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "packageManager": "bun@1.3.8",
   "description": "AlimTalk template engine for parsing, building and managing templates",
   "type": "module",
   "main": "dist/index.js",
@@ -17,19 +18,24 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "bun run build:esm && bun run build:cjs && bun run build:types",
+    "build:esm": "bun build ./src/index.ts --outdir ./dist --format esm --minify --sourcemap --entry-naming '[name].mjs' --external 'bun:test'",
+    "build:cjs": "bun build ./src/index.ts --outdir ./dist --format cjs --minify --sourcemap --entry-naming '[name].js' --external 'bun:test'",
+    "build:types": "tsc",
     "dev": "tsc --watch",
     "test": "bun test",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "pack": "bun pm pack",
+    "publish": "bun publish --access public"
   },
   "dependencies": {
-    "zod": "catalog:"
+    "@k-msg/core": "0.1.1",
+    "zod": "^4.0.14"
   },
   "devDependencies": {
-    "typescript": "catalog:",
-    "@types/bun": "catalog:",
-    "@types/node": "catalog:",
-    "tsup": "^8.5.0"
+    "typescript": "^5.7.2",
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0"
   },
   "keywords": [
     "alimtalk",
@@ -44,12 +50,12 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/k-otp/k-message.git"
+    "url": "git+https://github.com/k-otp/k-msg.git"
   },
-  "homepage": "https://github.com/k-otp/k-message",
+  "homepage": "https://github.com/k-otp/k-msg",
   "bugs": {
-    "url": "https://github.com/k-otp/k-message/issues"
+    "url": "https://github.com/k-otp/k-msg/issues"
   },
   "author": "imjlk",
   "license": "MIT"
-}
+}