@k-msg/template 0.1.0

package/dist/index.js

@@ -0,0 +1,1279 @@
+// src/parser/variable.parser.ts
+var VariableParser = class {
+  static VARIABLE_PATTERN = /#{([^}]+)}/g;
+  /**
+   * 템플릿 내용에서 변수를 추출합니다
+   */
+  static extractVariables(content) {
+    const variables = [];
+    const matches = content.matchAll(this.VARIABLE_PATTERN);
+    for (const match of matches) {
+      const variableName = match[1].trim();
+      if (variableName && !variables.includes(variableName)) {
+        variables.push(variableName);
+      }
+    }
+    return variables;
+  }
+  /**
+   * 템플릿 내용의 변수를 실제 값으로 치환합니다
+   */
+  static replaceVariables(content, variables) {
+    return content.replace(this.VARIABLE_PATTERN, (match, variableName) => {
+      const value = variables[variableName.trim()];
+      if (value === void 0 || value === null) {
+        return match;
+      }
+      if (value instanceof Date) {
+        return value.toISOString();
+      }
+      return String(value);
+    });
+  }
+  /**
+   * 변수 정의와 실제 제공된 값을 검증합니다
+   */
+  static validateVariables(variableDefinitions, providedVariables) {
+    const errors = [];
+    for (const definition of variableDefinitions) {
+      const value = providedVariables[definition.name];
+      if (definition.required && (value === void 0 || value === null)) {
+        errors.push(`Required variable '${definition.name}' is missing`);
+        continue;
+      }
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (!this.validateVariableType(value, definition.type)) {
+        errors.push(`Variable '${definition.name}' has invalid type. Expected: ${definition.type}`);
+      }
+      if (definition.maxLength && String(value).length > definition.maxLength) {
+        errors.push(`Variable '${definition.name}' exceeds maximum length of ${definition.maxLength}`);
+      }
+      if (definition.format && !new RegExp(definition.format).test(String(value))) {
+        errors.push(`Variable '${definition.name}' does not match required format: ${definition.format}`);
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  static validateVariableType(value, expectedType) {
+    switch (expectedType) {
+      case "string":
+        return typeof value === "string";
+      case "number":
+        return typeof value === "number" && !isNaN(value);
+      case "date":
+        return value instanceof Date || !isNaN(Date.parse(value));
+      case "custom":
+        return true;
+      // 커스텀 타입은 별도 검증 로직 필요
+      default:
+        return false;
+    }
+  }
+  /**
+   * 템플릿에서 사용된 변수와 정의된 변수의 일치성을 검사합니다
+   */
+  static validateTemplateVariables(content, variableDefinitions) {
+    const usedVariables = this.extractVariables(content);
+    const definedVariables = variableDefinitions.map((v) => v.name);
+    const errors = [];
+    for (const usedVar of usedVariables) {
+      if (!definedVariables.includes(usedVar)) {
+        errors.push(`Variable '${usedVar}' is used in template but not defined`);
+      }
+    }
+    for (const definition of variableDefinitions) {
+      if (definition.required && !usedVariables.includes(definition.name)) {
+        errors.push(`Required variable '${definition.name}' is defined but not used in template`);
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+};
+
+// src/types/template.types.ts
+import { z } from "zod";
+var TemplateType = /* @__PURE__ */ ((TemplateType2) => {
+  TemplateType2["ALIMTALK"] = "ALIMTALK";
+  TemplateType2["SMS"] = "SMS";
+  TemplateType2["LMS"] = "LMS";
+  TemplateType2["MMS"] = "MMS";
+  TemplateType2["RCS"] = "RCS";
+  return TemplateType2;
+})(TemplateType || {});
+var TemplateCategory = /* @__PURE__ */ ((TemplateCategory2) => {
+  TemplateCategory2["AUTHENTICATION"] = "AUTHENTICATION";
+  TemplateCategory2["NOTIFICATION"] = "NOTIFICATION";
+  TemplateCategory2["PROMOTION"] = "PROMOTION";
+  TemplateCategory2["INFORMATION"] = "INFORMATION";
+  TemplateCategory2["RESERVATION"] = "RESERVATION";
+  TemplateCategory2["SHIPPING"] = "SHIPPING";
+  TemplateCategory2["PAYMENT"] = "PAYMENT";
+  return TemplateCategory2;
+})(TemplateCategory || {});
+var TemplateStatus = /* @__PURE__ */ ((TemplateStatus2) => {
+  TemplateStatus2["DRAFT"] = "DRAFT";
+  TemplateStatus2["PENDING"] = "PENDING";
+  TemplateStatus2["APPROVED"] = "APPROVED";
+  TemplateStatus2["REJECTED"] = "REJECTED";
+  TemplateStatus2["DISABLED"] = "DISABLED";
+  return TemplateStatus2;
+})(TemplateStatus || {});
+var TemplateVariableSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["string", "number", "date", "custom"]),
+  required: z.boolean(),
+  maxLength: z.number().optional(),
+  format: z.string().optional(),
+  description: z.string().optional(),
+  example: z.string().optional()
+});
+var TemplateButtonSchema = z.object({
+  type: z.enum(["WL", "AL", "DS", "BK", "MD"]),
+  name: z.string().min(1),
+  linkMobile: z.string().url().optional(),
+  linkPc: z.string().url().optional(),
+  linkIos: z.string().url().optional(),
+  linkAndroid: z.string().url().optional(),
+  schemeIos: z.string().optional(),
+  schemeAndroid: z.string().optional()
+});
+var AlimTalkTemplateSchema = z.object({
+  id: z.string(),
+  code: z.string(),
+  name: z.string().min(1),
+  content: z.string().min(1),
+  variables: z.array(TemplateVariableSchema),
+  buttons: z.array(TemplateButtonSchema).optional(),
+  category: z.nativeEnum(TemplateCategory),
+  status: z.nativeEnum(TemplateStatus),
+  provider: z.string(),
+  metadata: z.object({
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    approvedAt: z.date().optional(),
+    rejectedAt: z.date().optional(),
+    rejectionReason: z.string().optional(),
+    usage: z.object({
+      sent: z.number().min(0),
+      delivered: z.number().min(0),
+      failed: z.number().min(0)
+    })
+  })
+});
+
+// src/parser/button.parser.ts
+var ButtonParser = class {
+  /**
+   * 버튼 설정의 유효성을 검증합니다
+   */
+  static validateButtons(buttons) {
+    const errors = [];
+    if (buttons.length > 5) {
+      errors.push("Maximum 5 buttons are allowed");
+    }
+    for (let i = 0; i < buttons.length; i++) {
+      const button = buttons[i];
+      const buttonIndex = i + 1;
+      if (!button.name || button.name.trim().length === 0) {
+        errors.push(`Button ${buttonIndex}: name is required`);
+      } else if (button.name.length > 14) {
+        errors.push(`Button ${buttonIndex}: name cannot exceed 14 characters`);
+      }
+      this.validateButtonByType(button, buttonIndex, errors);
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  static validateButtonByType(button, buttonIndex, errors) {
+    switch (button.type) {
+      case "WL":
+        this.validateWebLinkButton(button, buttonIndex, errors);
+        break;
+      case "AL":
+        this.validateAppLinkButton(button, buttonIndex, errors);
+        break;
+      case "DS":
+        this.validateDeliveryButton(button, buttonIndex, errors);
+        break;
+      case "BK":
+        this.validateBotKeywordButton(button, buttonIndex, errors);
+        break;
+      case "MD":
+        this.validateMessageDeliveryButton(button, buttonIndex, errors);
+        break;
+      default:
+        errors.push(`Button ${buttonIndex}: invalid button type '${button.type}'`);
+    }
+  }
+  static validateWebLinkButton(button, buttonIndex, errors) {
+    if (!button.linkMobile && !button.linkPc) {
+      errors.push(`Button ${buttonIndex}: web link button must have at least mobile or PC link`);
+    }
+    if (button.linkMobile && !this.isValidUrl(button.linkMobile)) {
+      errors.push(`Button ${buttonIndex}: invalid mobile link URL`);
+    }
+    if (button.linkPc && !this.isValidUrl(button.linkPc)) {
+      errors.push(`Button ${buttonIndex}: invalid PC link URL`);
+    }
+  }
+  static validateAppLinkButton(button, buttonIndex, errors) {
+    const hasAnyLink = button.linkIos || button.linkAndroid || button.schemeIos || button.schemeAndroid;
+    if (!hasAnyLink) {
+      errors.push(`Button ${buttonIndex}: app link button must have at least one app link or scheme`);
+    }
+    if (button.linkIos && !this.isValidUrl(button.linkIos)) {
+      errors.push(`Button ${buttonIndex}: invalid iOS link URL`);
+    }
+    if (button.linkAndroid && !this.isValidUrl(button.linkAndroid)) {
+      errors.push(`Button ${buttonIndex}: invalid Android link URL`);
+    }
+  }
+  static validateDeliveryButton(button, buttonIndex, errors) {
+  }
+  static validateBotKeywordButton(button, buttonIndex, errors) {
+  }
+  static validateMessageDeliveryButton(button, buttonIndex, errors) {
+  }
+  static isValidUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 버튼을 JSON 문자열로 직렬화합니다 (카카오 API 형식)
+   */
+  static serializeButtons(buttons) {
+    const serializedButtons = buttons.map((button) => ({
+      name: button.name,
+      type: button.type,
+      url_mobile: button.linkMobile,
+      url_pc: button.linkPc,
+      scheme_ios: button.schemeIos,
+      scheme_android: button.schemeAndroid
+    }));
+    return JSON.stringify(serializedButtons);
+  }
+  /**
+   * JSON 문자열에서 버튼 배열로 역직렬화합니다
+   */
+  static deserializeButtons(buttonsJson) {
+    try {
+      const parsed = JSON.parse(buttonsJson);
+      return parsed.map((button) => ({
+        name: button.name,
+        type: button.type,
+        linkMobile: button.url_mobile,
+        linkPc: button.url_pc,
+        linkIos: button.url_ios,
+        linkAndroid: button.url_android,
+        schemeIos: button.scheme_ios,
+        schemeAndroid: button.scheme_android
+      }));
+    } catch (error) {
+      throw new Error(`Failed to parse buttons JSON: ${error}`);
+    }
+  }
+};
+
+// src/parser/validator.ts
+var TemplateValidator = class {
+  /**
+   * 알림톡 템플릿의 전체적인 유효성을 검증합니다
+   */
+  static validate(template) {
+    const errors = [];
+    const warnings = [];
+    this.validateBasicFields(template, errors);
+    this.validateContent(template, errors, warnings);
+    const variableValidation = VariableParser.validateTemplateVariables(
+      template.content,
+      template.variables
+    );
+    errors.push(...variableValidation.errors);
+    if (template.buttons && template.buttons.length > 0) {
+      const buttonValidation = ButtonParser.validateButtons(template.buttons);
+      errors.push(...buttonValidation.errors);
+    }
+    this.validateByCategory(template, errors, warnings);
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  static validateBasicFields(template, errors) {
+    if (!template.name || template.name.trim().length === 0) {
+      errors.push("Template name is required");
+    }
+    if (!template.code || template.code.trim().length === 0) {
+      errors.push("Template code is required");
+    }
+    if (!template.provider || template.provider.trim().length === 0) {
+      errors.push("Provider is required");
+    }
+  }
+  static validateContent(template, errors, warnings) {
+    if (!template.content || template.content.trim().length === 0) {
+      errors.push("Template content is required");
+      return;
+    }
+    const content = template.content;
+    if (content.length > 1e3) {
+      errors.push("Template content cannot exceed 1000 characters");
+    }
+    if (this.containsProhibitedCharacters(content)) {
+      errors.push("Template content contains prohibited characters");
+    }
+    const lineBreaks = (content.match(/\n/g) || []).length;
+    if (lineBreaks > 20) {
+      warnings.push("Template content has many line breaks, which may affect readability");
+    }
+    this.validateUrlsInContent(content, warnings);
+  }
+  static containsProhibitedCharacters(content) {
+    const prohibitedChars = /[<>]/;
+    return prohibitedChars.test(content);
+  }
+  static validateUrlsInContent(content, warnings) {
+    const urlPattern = /https?:\/\/[^\s]+/g;
+    const urls = content.match(urlPattern) || [];
+    for (const url of urls) {
+      try {
+        new URL(url);
+      } catch {
+        warnings.push(`Invalid URL found in content: ${url}`);
+      }
+    }
+  }
+  static validateByCategory(template, errors, warnings) {
+    switch (template.category) {
+      case "AUTHENTICATION" /* AUTHENTICATION */:
+        this.validateAuthenticationTemplate(template, errors, warnings);
+        break;
+      case "PROMOTION" /* PROMOTION */:
+        this.validatePromotionTemplate(template, errors, warnings);
+        break;
+      case "PAYMENT" /* PAYMENT */:
+        this.validatePaymentTemplate(template, errors, warnings);
+        break;
+    }
+  }
+  static validateAuthenticationTemplate(template, errors, warnings) {
+    const hasAuthCode = template.variables.some(
+      (v) => v.name.includes("\uC778\uC99D") || v.name.includes("\uCF54\uB4DC") || v.name.includes("\uBC88\uD638")
+    );
+    if (!hasAuthCode) {
+      warnings.push("Authentication template should include an authentication code variable");
+    }
+    if (template.buttons && template.buttons.length > 0) {
+      warnings.push("Authentication templates typically should not have buttons");
+    }
+  }
+  static validatePromotionTemplate(template, errors, warnings) {
+    if (!template.buttons || template.buttons.length === 0) {
+      warnings.push("Promotion templates typically should have action buttons");
+    }
+  }
+  static validatePaymentTemplate(template, errors, warnings) {
+    const hasAmountVariable = template.variables.some(
+      (v) => v.name.includes("\uAE08\uC561") || v.name.includes("\uAC00\uACA9") || v.name.includes("\uC6D0")
+    );
+    if (!hasAmountVariable) {
+      warnings.push("Payment template should include an amount variable");
+    }
+  }
+  /**
+   * 빠른 검증 - 기본적인 필수 필드만 검사
+   */
+  static quickValidate(template) {
+    const errors = [];
+    if (!template.name) errors.push("Name is required");
+    if (!template.content) errors.push("Content is required");
+    if (!template.category) errors.push("Category is required");
+    if (!template.provider) errors.push("Provider is required");
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings: []
+    };
+  }
+};
+
+// src/services/template.service.ts
+var TemplateService = class {
+  templates = /* @__PURE__ */ new Map();
+  async createTemplate(template) {
+    const variables = VariableParser.extractVariables(template.content);
+    const newTemplate = {
+      ...template,
+      id: this.generateTemplateId(),
+      variables: variables.map((name) => ({
+        name,
+        type: "string",
+        required: true
+      })),
+      metadata: {
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date(),
+        usage: { sent: 0, delivered: 0, failed: 0 }
+      }
+    };
+    const validation = TemplateValidator.validate(newTemplate);
+    if (!validation.isValid) {
+      throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
+    }
+    this.templates.set(newTemplate.id, newTemplate);
+    return newTemplate;
+  }
+  async getTemplate(templateId) {
+    return this.templates.get(templateId) || null;
+  }
+  async updateTemplate(templateId, updates) {
+    const template = this.templates.get(templateId);
+    if (!template) {
+      throw new Error(`Template ${templateId} not found`);
+    }
+    const updatedTemplate = {
+      ...template,
+      ...updates,
+      metadata: {
+        ...template.metadata,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    };
+    this.templates.set(templateId, updatedTemplate);
+    return updatedTemplate;
+  }
+  async deleteTemplate(templateId) {
+    this.templates.delete(templateId);
+  }
+  async renderTemplate(templateId, variables) {
+    const template = this.templates.get(templateId);
+    if (!template) {
+      throw new Error(`Template ${templateId} not found`);
+    }
+    const validation = VariableParser.validateVariables(template.variables, variables);
+    if (!validation.isValid) {
+      throw new Error(`Variable validation failed: ${validation.errors.join(", ")}`);
+    }
+    return VariableParser.replaceVariables(template.content, variables);
+  }
+  generateTemplateId() {
+    return `tpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+};
+
+// src/builder/template.builder.ts
+var TemplateBuilder = class _TemplateBuilder {
+  template = {
+    variables: [],
+    buttons: [],
+    status: "DRAFT" /* DRAFT */,
+    metadata: {
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      usage: { sent: 0, delivered: 0, failed: 0 }
+    }
+  };
+  /**
+   * Set template name
+   */
+  name(name) {
+    this.template.name = name;
+    return this;
+  }
+  /**
+   * Set template code (provider specific)
+   */
+  code(code) {
+    this.template.code = code;
+    return this;
+  }
+  /**
+   * Set template content with variables
+   */
+  content(content) {
+    this.template.content = content;
+    const extractedVariables = VariableParser.extractVariables(content);
+    const existingVariableNames = (this.template.variables || []).map((v) => v.name);
+    for (const varName of extractedVariables) {
+      if (!existingVariableNames.includes(varName)) {
+        this.variable(varName, "string", true);
+      }
+    }
+    return this;
+  }
+  /**
+   * Set template category
+   */
+  category(category) {
+    this.template.category = category;
+    return this;
+  }
+  /**
+   * Set template provider
+   */
+  provider(provider) {
+    this.template.provider = provider;
+    return this;
+  }
+  /**
+   * Set template status
+   */
+  status(status) {
+    this.template.status = status;
+    return this;
+  }
+  /**
+   * Add a variable definition
+   */
+  variable(name, type = "string", required = true, options = {}) {
+    if (!this.template.variables) {
+      this.template.variables = [];
+    }
+    this.template.variables = this.template.variables.filter((v) => v.name !== name);
+    const variable = {
+      name,
+      type,
+      required,
+      ...options
+    };
+    this.template.variables.push(variable);
+    return this;
+  }
+  /**
+   * Add multiple variables at once
+   */
+  variables(variables) {
+    for (const variable of variables) {
+      this.variable(
+        variable.name,
+        variable.type || "string",
+        variable.required ?? true,
+        {
+          maxLength: variable.maxLength,
+          format: variable.format,
+          description: variable.description,
+          example: variable.example
+        }
+      );
+    }
+    return this;
+  }
+  /**
+   * Add a web link button
+   */
+  webLinkButton(name, mobileUrl, pcUrl) {
+    return this.button({
+      type: "WL",
+      name,
+      linkMobile: mobileUrl,
+      linkPc: pcUrl
+    });
+  }
+  /**
+   * Add an app link button
+   */
+  appLinkButton(name, options) {
+    return this.button({
+      type: "AL",
+      name,
+      linkIos: options.iosUrl,
+      linkAndroid: options.androidUrl,
+      schemeIos: options.iosScheme,
+      schemeAndroid: options.androidScheme
+    });
+  }
+  /**
+   * Add a delivery tracking button
+   */
+  deliveryButton(name) {
+    return this.button({
+      type: "DS",
+      name
+    });
+  }
+  /**
+   * Add a bot keyword button
+   */
+  botKeywordButton(name) {
+    return this.button({
+      type: "BK",
+      name
+    });
+  }
+  /**
+   * Add a message delivery button
+   */
+  messageDeliveryButton(name) {
+    return this.button({
+      type: "MD",
+      name
+    });
+  }
+  /**
+   * Add a custom button
+   */
+  button(button) {
+    if (!this.template.buttons) {
+      this.template.buttons = [];
+    }
+    if (this.template.buttons.length >= 5) {
+      throw new Error("Maximum 5 buttons are allowed per template");
+    }
+    this.template.buttons.push(button);
+    return this;
+  }
+  /**
+   * Clear all buttons
+   */
+  clearButtons() {
+    this.template.buttons = [];
+    return this;
+  }
+  /**
+   * Set template metadata
+   */
+  metadata(metadata) {
+    this.template.metadata = {
+      ...this.template.metadata,
+      ...metadata,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    return this;
+  }
+  /**
+   * Validate the current template
+   */
+  validate() {
+    const quickValidation = TemplateValidator.quickValidate(this.template);
+    if (!quickValidation.isValid) {
+      return quickValidation;
+    }
+    try {
+      const fullTemplate = this.build();
+      return TemplateValidator.validate(fullTemplate);
+    } catch (error) {
+      return {
+        isValid: false,
+        errors: [error instanceof Error ? error.message : "Unknown validation error"],
+        warnings: []
+      };
+    }
+  }
+  /**
+   * Preview the template with sample variables
+   */
+  preview(sampleVariables = {}) {
+    if (!this.template.content) {
+      throw new Error("Template content is required for preview");
+    }
+    const variables = { ...this.generateSampleVariables(), ...sampleVariables };
+    return VariableParser.replaceVariables(this.template.content, variables);
+  }
+  /**
+   * Generate sample variables based on variable definitions
+   */
+  generateSampleVariables() {
+    const samples = {};
+    for (const variable of this.template.variables || []) {
+      if (variable.example) {
+        samples[variable.name] = variable.example;
+      } else {
+        switch (variable.type) {
+          case "string":
+            samples[variable.name] = variable.name.includes("name") || variable.name.includes("\uC774\uB984") ? "\uD64D\uAE38\uB3D9" : variable.name.includes("code") || variable.name.includes("\uCF54\uB4DC") ? "123456" : `\uC0D8\uD50C${variable.name}`;
+            break;
+          case "number":
+            samples[variable.name] = variable.name.includes("amount") || variable.name.includes("\uAE08\uC561") ? 1e4 : variable.name.includes("count") || variable.name.includes("\uAC1C\uC218") ? 1 : 123;
+            break;
+          case "date":
+            samples[variable.name] = /* @__PURE__ */ new Date();
+            break;
+          default:
+            samples[variable.name] = `\uC0D8\uD50C\uAC12`;
+        }
+      }
+    }
+    return samples;
+  }
+  /**
+   * Clone the current builder
+   */
+  clone() {
+    const cloned = new _TemplateBuilder();
+    cloned.template = JSON.parse(JSON.stringify(this.template));
+    return cloned;
+  }
+  /**
+   * Reset the builder to start fresh
+   */
+  reset() {
+    this.template = {
+      variables: [],
+      buttons: [],
+      status: "DRAFT" /* DRAFT */,
+      metadata: {
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date(),
+        usage: { sent: 0, delivered: 0, failed: 0 }
+      }
+    };
+    return this;
+  }
+  /**
+   * Build the final template
+   */
+  build() {
+    if (!this.template.name) throw new Error("Template name is required");
+    if (!this.template.code) throw new Error("Template code is required");
+    if (!this.template.content) throw new Error("Template content is required");
+    if (!this.template.category) throw new Error("Template category is required");
+    if (!this.template.provider) throw new Error("Template provider is required");
+    const template = {
+      id: this.template.id || this.generateTemplateId(),
+      name: this.template.name,
+      code: this.template.code,
+      content: this.template.content,
+      variables: this.template.variables || [],
+      buttons: this.template.buttons,
+      category: this.template.category,
+      status: this.template.status || "DRAFT" /* DRAFT */,
+      provider: this.template.provider,
+      metadata: {
+        ...this.template.metadata,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    };
+    const validation = TemplateValidator.validate(template);
+    if (!validation.isValid) {
+      throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
+    }
+    return template;
+  }
+  generateTemplateId() {
+    return `tpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+};
+var TemplateBuilders = {
+  /**
+   * Create an authentication template builder
+   */
+  authentication(name, provider) {
+    return new TemplateBuilder().name(name).category("AUTHENTICATION" /* AUTHENTICATION */).provider(provider).variable("code", "string", true, {
+      maxLength: 10,
+      description: "Authentication code",
+      example: "123456"
+    });
+  },
+  /**
+   * Create a notification template builder
+   */
+  notification(name, provider) {
+    return new TemplateBuilder().name(name).category("NOTIFICATION" /* NOTIFICATION */).provider(provider).variable("name", "string", true, {
+      description: "Recipient name",
+      example: "\uD64D\uAE38\uB3D9"
+    });
+  },
+  /**
+   * Create a promotion template builder
+   */
+  promotion(name, provider) {
+    return new TemplateBuilder().name(name).category("PROMOTION" /* PROMOTION */).provider(provider).variable("name", "string", true, {
+      description: "Customer name",
+      example: "\uD64D\uAE38\uB3D9"
+    }).variable("discount", "number", false, {
+      description: "Discount percentage",
+      example: "20"
+    });
+  },
+  /**
+   * Create a payment template builder
+   */
+  payment(name, provider) {
+    return new TemplateBuilder().name(name).category("PAYMENT" /* PAYMENT */).provider(provider).variable("name", "string", true, {
+      description: "Customer name",
+      example: "\uD64D\uAE38\uB3D9"
+    }).variable("amount", "number", true, {
+      description: "Payment amount",
+      example: "10000"
+    });
+  }
+};
+
+// src/registry/template.registry.ts
+import { EventEmitter } from "events";
+var TemplateRegistry = class extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.options = { ...this.defaultOptions, ...options };
+    if (this.options.enableAutoBackup) {
+      this.startAutoBackup();
+    }
+  }
+  templates = /* @__PURE__ */ new Map();
+  templatesByCode = /* @__PURE__ */ new Map();
+  templatesByProvider = /* @__PURE__ */ new Map();
+  templatesByCategory = /* @__PURE__ */ new Map();
+  templateHistories = /* @__PURE__ */ new Map();
+  usageStats = /* @__PURE__ */ new Map();
+  backupTimer;
+  defaultOptions = {
+    enableVersioning: true,
+    maxVersionsPerTemplate: 10,
+    enableUsageTracking: true,
+    enableAutoBackup: false,
+    backupInterval: 36e5,
+    // 1 hour
+    enableValidationOnRegister: true
+  };
+  /**
+   * Register a new template
+   */
+  async register(template) {
+    if (this.options.enableValidationOnRegister) {
+      const validation = TemplateValidator.validate(template);
+      if (!validation.isValid) {
+        throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
+      }
+    }
+    const existingTemplate = this.getByCode(template.code, template.provider);
+    if (existingTemplate && existingTemplate.id !== template.id) {
+      throw new Error(`Template with code '${template.code}' already exists for provider '${template.provider}'`);
+    }
+    this.templates.set(template.id, template);
+    this.templatesByCode.set(`${template.provider}:${template.code}`, template);
+    this.updateIndexes(template);
+    if (this.options.enableVersioning) {
+      this.initializeVersionHistory(template);
+    }
+    if (this.options.enableUsageTracking) {
+      this.initializeUsageStats(template);
+    }
+    this.emit("template:registered", { template });
+  }
+  /**
+   * Update an existing template
+   */
+  async update(templateId, updates) {
+    const existing = this.templates.get(templateId);
+    if (!existing) {
+      throw new Error(`Template ${templateId} not found`);
+    }
+    const updatedTemplate = {
+      ...existing,
+      ...updates,
+      id: templateId,
+      // Ensure ID doesn't change
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    };
+    if (this.options.enableValidationOnRegister) {
+      const validation = TemplateValidator.validate(updatedTemplate);
+      if (!validation.isValid) {
+        throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
+      }
+    }
+    if (this.options.enableVersioning) {
+      this.addVersionToHistory(existing, updatedTemplate);
+    }
+    this.templates.set(templateId, updatedTemplate);
+    this.templatesByCode.set(`${updatedTemplate.provider}:${updatedTemplate.code}`, updatedTemplate);
+    this.updateIndexes(updatedTemplate);
+    this.emit("template:updated", {
+      oldTemplate: existing,
+      newTemplate: updatedTemplate
+    });
+    return updatedTemplate;
+  }
+  /**
+   * Get template by ID
+   */
+  get(templateId) {
+    return this.templates.get(templateId) || null;
+  }
+  /**
+   * Get template by code and provider
+   */
+  getByCode(code, provider) {
+    return this.templatesByCode.get(`${provider}:${code}`) || null;
+  }
+  /**
+   * Search templates with filters and pagination
+   */
+  search(filters = {}, options = {}) {
+    let templates = Array.from(this.templates.values());
+    if (filters.provider) {
+      templates = templates.filter((t) => t.provider === filters.provider);
+    }
+    if (filters.category) {
+      templates = templates.filter((t) => t.category === filters.category);
+    }
+    if (filters.status) {
+      templates = templates.filter((t) => t.status === filters.status);
+    }
+    if (filters.nameContains) {
+      const searchTerm = filters.nameContains.toLowerCase();
+      templates = templates.filter((t) => t.name.toLowerCase().includes(searchTerm));
+    }
+    if (filters.codeContains) {
+      const searchTerm = filters.codeContains.toLowerCase();
+      templates = templates.filter((t) => t.code.toLowerCase().includes(searchTerm));
+    }
+    if (filters.createdAfter) {
+      templates = templates.filter((t) => t.metadata.createdAt >= filters.createdAfter);
+    }
+    if (filters.createdBefore) {
+      templates = templates.filter((t) => t.metadata.createdAt <= filters.createdBefore);
+    }
+    if (filters.usageMin !== void 0) {
+      templates = templates.filter((t) => t.metadata.usage.sent >= filters.usageMin);
+    }
+    if (filters.usageMax !== void 0) {
+      templates = templates.filter((t) => t.metadata.usage.sent <= filters.usageMax);
+    }
+    const sortBy = options.sortBy || "createdAt";
+    const sortOrder = options.sortOrder || "desc";
+    templates.sort((a, b) => {
+      let aValue, bValue;
+      switch (sortBy) {
+        case "name":
+          aValue = a.name;
+          bValue = b.name;
+          break;
+        case "code":
+          aValue = a.code;
+          bValue = b.code;
+          break;
+        case "createdAt":
+          aValue = a.metadata.createdAt.getTime();
+          bValue = b.metadata.createdAt.getTime();
+          break;
+        case "updatedAt":
+          aValue = a.metadata.updatedAt.getTime();
+          bValue = b.metadata.updatedAt.getTime();
+          break;
+        case "usage":
+          aValue = a.metadata.usage.sent;
+          bValue = b.metadata.usage.sent;
+          break;
+        default:
+          aValue = a.metadata.createdAt.getTime();
+          bValue = b.metadata.createdAt.getTime();
+      }
+      if (sortOrder === "asc") {
+        return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
+      } else {
+        return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
+      }
+    });
+    const page = options.page || 1;
+    const limit = options.limit || 20;
+    const start = (page - 1) * limit;
+    const end = start + limit;
+    const paginatedTemplates = templates.slice(start, end);
+    return {
+      templates: paginatedTemplates,
+      total: templates.length,
+      page,
+      limit,
+      hasMore: end < templates.length
+    };
+  }
+  /**
+   * Get templates by provider
+   */
+  getByProvider(provider) {
+    const templateIds = this.templatesByProvider.get(provider) || /* @__PURE__ */ new Set();
+    return Array.from(templateIds).map((id) => this.templates.get(id)).filter((template) => template !== void 0);
+  }
+  /**
+   * Get templates by category
+   */
+  getByCategory(category) {
+    const templateIds = this.templatesByCategory.get(category) || /* @__PURE__ */ new Set();
+    return Array.from(templateIds).map((id) => this.templates.get(id)).filter((template) => template !== void 0);
+  }
+  /**
+   * Delete template
+   */
+  async delete(templateId) {
+    const template = this.templates.get(templateId);
+    if (!template) {
+      return false;
+    }
+    this.templates.delete(templateId);
+    this.templatesByCode.delete(`${template.provider}:${template.code}`);
+    const providerSet = this.templatesByProvider.get(template.provider);
+    if (providerSet) {
+      providerSet.delete(templateId);
+      if (providerSet.size === 0) {
+        this.templatesByProvider.delete(template.provider);
+      }
+    }
+    const categorySet = this.templatesByCategory.get(template.category);
+    if (categorySet) {
+      categorySet.delete(templateId);
+      if (categorySet.size === 0) {
+        this.templatesByCategory.delete(template.category);
+      }
+    }
+    this.templateHistories.delete(templateId);
+    this.usageStats.delete(templateId);
+    this.emit("template:deleted", { template });
+    return true;
+  }
+  /**
+   * Get template version history
+   */
+  getHistory(templateId) {
+    return this.templateHistories.get(templateId) || null;
+  }
+  /**
+   * Get specific template version
+   */
+  getVersion(templateId, version) {
+    const history = this.templateHistories.get(templateId);
+    if (!history) return null;
+    const versionEntry = history.versions.find((v) => v.version === version);
+    return versionEntry ? versionEntry.template : null;
+  }
+  /**
+   * Restore template to a specific version
+   */
+  async restoreVersion(templateId, version) {
+    const versionTemplate = this.getVersion(templateId, version);
+    if (!versionTemplate) {
+      throw new Error(`Version ${version} not found for template ${templateId}`);
+    }
+    return this.update(templateId, {
+      ...versionTemplate,
+      metadata: {
+        ...versionTemplate.metadata,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  /**
+   * Get template usage statistics
+   */
+  getUsageStats(templateId) {
+    return this.usageStats.get(templateId) || null;
+  }
+  /**
+   * Update template usage statistics
+   */
+  updateUsageStats(templateId, stats) {
+    const template = this.templates.get(templateId);
+    if (!template) return;
+    if (stats.sent) template.metadata.usage.sent += stats.sent;
+    if (stats.delivered) template.metadata.usage.delivered += stats.delivered;
+    if (stats.failed) template.metadata.usage.failed += stats.failed;
+    if (this.options.enableUsageTracking) {
+      const usageStats = this.usageStats.get(templateId);
+      if (usageStats) {
+        if (stats.sent) usageStats.totalSent += stats.sent;
+        if (stats.delivered) usageStats.totalDelivered += stats.delivered;
+        if (stats.failed) usageStats.totalFailed += stats.failed;
+        usageStats.deliveryRate = usageStats.totalSent > 0 ? usageStats.totalDelivered / usageStats.totalSent * 100 : 0;
+        usageStats.failureRate = usageStats.totalSent > 0 ? usageStats.totalFailed / usageStats.totalSent * 100 : 0;
+        usageStats.lastUsed = /* @__PURE__ */ new Date();
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        let todayStats = usageStats.usageByDay.find((d) => d.date === today);
+        if (!todayStats) {
+          todayStats = { date: today, sent: 0, delivered: 0, failed: 0 };
+          usageStats.usageByDay.push(todayStats);
+          usageStats.usageByDay = usageStats.usageByDay.sort((a, b) => b.date.localeCompare(a.date)).slice(0, 30);
+        }
+        if (stats.sent) todayStats.sent += stats.sent;
+        if (stats.delivered) todayStats.delivered += stats.delivered;
+        if (stats.failed) todayStats.failed += stats.failed;
+      }
+    }
+    this.emit("usage:updated", { templateId, stats });
+  }
+  /**
+   * Get registry statistics
+   */
+  getStats() {
+    const templates = Array.from(this.templates.values());
+    const byProvider = {};
+    const byCategory = {};
+    const byStatus = {};
+    for (const template of templates) {
+      byProvider[template.provider] = (byProvider[template.provider] || 0) + 1;
+      byCategory[template.category] = (byCategory[template.category] || 0) + 1;
+      byStatus[template.status] = (byStatus[template.status] || 0) + 1;
+    }
+    return {
+      totalTemplates: templates.length,
+      byProvider,
+      byCategory,
+      byStatus
+    };
+  }
+  /**
+   * Export templates to JSON
+   */
+  export(filters) {
+    const result = this.search(filters, { limit: 1e4 });
+    return JSON.stringify({
+      templates: result.templates,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      total: result.total
+    }, null, 2);
+  }
+  /**
+   * Import templates from JSON
+   */
+  async import(jsonData, options = {}) {
+    const result = { imported: 0, skipped: 0, errors: [] };
+    try {
+      const data = JSON.parse(jsonData);
+      const templates = data.templates || [];
+      for (const templateData of templates) {
+        try {
+          const existingTemplate = this.get(templateData.id);
+          if (existingTemplate && !options.overwrite) {
+            result.skipped++;
+            continue;
+          }
+          await this.register(templateData);
+          result.imported++;
+        } catch (error) {
+          result.errors.push(`Template ${templateData.id}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      }
+    } catch (error) {
+      result.errors.push(`Invalid JSON format: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return result;
+  }
+  /**
+   * Clear all templates (use with caution!)
+   */
+  clear() {
+    this.templates.clear();
+    this.templatesByCode.clear();
+    this.templatesByProvider.clear();
+    this.templatesByCategory.clear();
+    this.templateHistories.clear();
+    this.usageStats.clear();
+    this.emit("registry:cleared");
+  }
+  /**
+   * Stop the registry and cleanup
+   */
+  destroy() {
+    if (this.backupTimer) {
+      clearInterval(this.backupTimer);
+      this.backupTimer = void 0;
+    }
+    this.removeAllListeners();
+    this.emit("registry:destroyed");
+  }
+  updateIndexes(template) {
+    if (!this.templatesByProvider.has(template.provider)) {
+      this.templatesByProvider.set(template.provider, /* @__PURE__ */ new Set());
+    }
+    this.templatesByProvider.get(template.provider).add(template.id);
+    if (!this.templatesByCategory.has(template.category)) {
+      this.templatesByCategory.set(template.category, /* @__PURE__ */ new Set());
+    }
+    this.templatesByCategory.get(template.category).add(template.id);
+  }
+  initializeVersionHistory(template) {
+    const history = {
+      templateId: template.id,
+      versions: [{
+        version: 1,
+        template: JSON.parse(JSON.stringify(template)),
+        changes: ["Initial version"],
+        createdAt: /* @__PURE__ */ new Date()
+      }],
+      currentVersion: 1
+    };
+    this.templateHistories.set(template.id, history);
+  }
+  addVersionToHistory(oldTemplate, newTemplate) {
+    const history = this.templateHistories.get(newTemplate.id);
+    if (!history) return;
+    const changes = [];
+    if (oldTemplate.name !== newTemplate.name) changes.push("Name changed");
+    if (oldTemplate.content !== newTemplate.content) changes.push("Content changed");
+    if (oldTemplate.category !== newTemplate.category) changes.push("Category changed");
+    if (oldTemplate.status !== newTemplate.status) changes.push("Status changed");
+    if (JSON.stringify(oldTemplate.variables) !== JSON.stringify(newTemplate.variables)) {
+      changes.push("Variables changed");
+    }
+    if (JSON.stringify(oldTemplate.buttons) !== JSON.stringify(newTemplate.buttons)) {
+      changes.push("Buttons changed");
+    }
+    if (changes.length === 0) return;
+    const newVersion = {
+      version: history.currentVersion + 1,
+      template: JSON.parse(JSON.stringify(newTemplate)),
+      changes,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    history.versions.push(newVersion);
+    history.currentVersion = newVersion.version;
+    if (history.versions.length > this.options.maxVersionsPerTemplate) {
+      history.versions = history.versions.slice(-this.options.maxVersionsPerTemplate);
+    }
+  }
+  initializeUsageStats(template) {
+    const stats = {
+      templateId: template.id,
+      totalSent: template.metadata.usage.sent,
+      totalDelivered: template.metadata.usage.delivered,
+      totalFailed: template.metadata.usage.failed,
+      deliveryRate: 0,
+      failureRate: 0,
+      usageByDay: []
+    };
+    if (stats.totalSent > 0) {
+      stats.deliveryRate = stats.totalDelivered / stats.totalSent * 100;
+      stats.failureRate = stats.totalFailed / stats.totalSent * 100;
+    }
+    this.usageStats.set(template.id, stats);
+  }
+  startAutoBackup() {
+    this.backupTimer = setInterval(() => {
+      this.emit("backup:requested", {
+        data: this.export(),
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }, this.options.backupInterval);
+  }
+};
+export {
+  ButtonParser,
+  TemplateBuilder,
+  TemplateBuilders,
+  TemplateCategory,
+  TemplateRegistry,
+  TemplateService,
+  TemplateStatus,
+  TemplateType,
+  TemplateValidator,
+  VariableParser
+};
+//# sourceMappingURL=index.js.map