@k-msg/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1015 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BulkOperationHandler: () => BulkOperationHandler,
+  CircuitBreaker: () => CircuitBreaker,
+  ErrorFactory: () => ErrorFactory,
+  ErrorRecovery: () => ErrorRecovery,
+  ErrorUtils: () => ErrorUtils,
+  GracefulDegradation: () => GracefulDegradation,
+  HealthMonitor: () => HealthMonitor,
+  KMessageError: () => KMessageError,
+  KMessageErrorCode: () => KMessageErrorCode,
+  MessageError: () => MessageError,
+  MockProvider: () => MockProvider,
+  PerformanceTest: () => PerformanceTest,
+  ProviderError: () => ProviderError,
+  RateLimiter: () => RateLimiter,
+  Result: () => Result,
+  RetryHandler: () => RetryHandler,
+  TemplateCategory: () => TemplateCategory,
+  TemplateError: () => TemplateError,
+  TestAssertions: () => TestAssertions,
+  TestData: () => TestData,
+  TestSetup: () => TestSetup
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var KMessageErrorCode = /* @__PURE__ */ ((KMessageErrorCode2) => {
+  KMessageErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  KMessageErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  KMessageErrorCode2["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+  KMessageErrorCode2["PROVIDER_NOT_FOUND"] = "PROVIDER_NOT_FOUND";
+  KMessageErrorCode2["PROVIDER_NOT_AVAILABLE"] = "PROVIDER_NOT_AVAILABLE";
+  KMessageErrorCode2["PROVIDER_AUTHENTICATION_FAILED"] = "PROVIDER_AUTHENTICATION_FAILED";
+  KMessageErrorCode2["PROVIDER_CONNECTION_FAILED"] = "PROVIDER_CONNECTION_FAILED";
+  KMessageErrorCode2["PROVIDER_RATE_LIMITED"] = "PROVIDER_RATE_LIMITED";
+  KMessageErrorCode2["PROVIDER_INSUFFICIENT_BALANCE"] = "PROVIDER_INSUFFICIENT_BALANCE";
+  KMessageErrorCode2["TEMPLATE_NOT_FOUND"] = "TEMPLATE_NOT_FOUND";
+  KMessageErrorCode2["TEMPLATE_VALIDATION_FAILED"] = "TEMPLATE_VALIDATION_FAILED";
+  KMessageErrorCode2["TEMPLATE_CREATION_FAILED"] = "TEMPLATE_CREATION_FAILED";
+  KMessageErrorCode2["TEMPLATE_MODIFICATION_FAILED"] = "TEMPLATE_MODIFICATION_FAILED";
+  KMessageErrorCode2["TEMPLATE_DELETION_FAILED"] = "TEMPLATE_DELETION_FAILED";
+  KMessageErrorCode2["MESSAGE_SEND_FAILED"] = "MESSAGE_SEND_FAILED";
+  KMessageErrorCode2["MESSAGE_INVALID_PHONE_NUMBER"] = "MESSAGE_INVALID_PHONE_NUMBER";
+  KMessageErrorCode2["MESSAGE_INVALID_VARIABLES"] = "MESSAGE_INVALID_VARIABLES";
+  KMessageErrorCode2["MESSAGE_QUOTA_EXCEEDED"] = "MESSAGE_QUOTA_EXCEEDED";
+  KMessageErrorCode2["MESSAGE_RESERVATION_FAILED"] = "MESSAGE_RESERVATION_FAILED";
+  KMessageErrorCode2["MESSAGE_CANCELLATION_FAILED"] = "MESSAGE_CANCELLATION_FAILED";
+  KMessageErrorCode2["NETWORK_TIMEOUT"] = "NETWORK_TIMEOUT";
+  KMessageErrorCode2["NETWORK_CONNECTION_FAILED"] = "NETWORK_CONNECTION_FAILED";
+  KMessageErrorCode2["NETWORK_SERVICE_UNAVAILABLE"] = "NETWORK_SERVICE_UNAVAILABLE";
+  KMessageErrorCode2["API_INVALID_REQUEST"] = "API_INVALID_REQUEST";
+  KMessageErrorCode2["API_UNAUTHORIZED"] = "API_UNAUTHORIZED";
+  KMessageErrorCode2["API_FORBIDDEN"] = "API_FORBIDDEN";
+  KMessageErrorCode2["API_NOT_FOUND"] = "API_NOT_FOUND";
+  KMessageErrorCode2["API_TOO_MANY_REQUESTS"] = "API_TOO_MANY_REQUESTS";
+  KMessageErrorCode2["API_INTERNAL_SERVER_ERROR"] = "API_INTERNAL_SERVER_ERROR";
+  return KMessageErrorCode2;
+})(KMessageErrorCode || {});
+var KMessageError = class _KMessageError extends Error {
+  code;
+  context;
+  retryable;
+  statusCode;
+  cause;
+  constructor(code, message, context = {}, options = {}) {
+    super(message);
+    this.name = "KMessageError";
+    this.code = code;
+    this.context = {
+      ...context,
+      timestamp: context.timestamp || /* @__PURE__ */ new Date()
+    };
+    this.retryable = options.retryable ?? this.isRetryableByDefault(code);
+    this.statusCode = options.statusCode;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _KMessageError);
+    }
+  }
+  isRetryableByDefault(code) {
+    const retryableCodes = [
+      "NETWORK_TIMEOUT" /* NETWORK_TIMEOUT */,
+      "NETWORK_CONNECTION_FAILED" /* NETWORK_CONNECTION_FAILED */,
+      "NETWORK_SERVICE_UNAVAILABLE" /* NETWORK_SERVICE_UNAVAILABLE */,
+      "PROVIDER_CONNECTION_FAILED" /* PROVIDER_CONNECTION_FAILED */,
+      "PROVIDER_RATE_LIMITED" /* PROVIDER_RATE_LIMITED */,
+      "API_TOO_MANY_REQUESTS" /* API_TOO_MANY_REQUESTS */,
+      "API_INTERNAL_SERVER_ERROR" /* API_INTERNAL_SERVER_ERROR */
+    ];
+    return retryableCodes.includes(code);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+      retryable: this.retryable,
+      statusCode: this.statusCode,
+      stack: this.stack
+    };
+  }
+};
+var ProviderError = class extends KMessageError {
+  constructor(providerId, code, message, context = {}, options = {}) {
+    super(code, message, { ...context, providerId }, options);
+    this.name = "ProviderError";
+  }
+};
+var TemplateError = class extends KMessageError {
+  constructor(templateCode, code, message, context = {}, options = {}) {
+    super(code, message, { ...context, templateCode }, options);
+    this.name = "TemplateError";
+  }
+};
+var MessageError = class extends KMessageError {
+  constructor(phoneNumber, code, message, context = {}, options = {}) {
+    super(code, message, { ...context, phoneNumber }, options);
+    this.name = "MessageError";
+  }
+};
+var ErrorFactory = {
+  providerNotFound: (providerId) => new ProviderError(
+    providerId,
+    "PROVIDER_NOT_FOUND" /* PROVIDER_NOT_FOUND */,
+    `Provider '${providerId}' not found`,
+    {},
+    { retryable: false, statusCode: 404 }
+  ),
+  providerNotAvailable: (providerId, reason) => new ProviderError(
+    providerId,
+    "PROVIDER_NOT_AVAILABLE" /* PROVIDER_NOT_AVAILABLE */,
+    `Provider '${providerId}' is not available${reason ? `: ${reason}` : ""}`,
+    {},
+    { retryable: true, statusCode: 503 }
+  ),
+  authenticationFailed: (providerId, details) => new ProviderError(
+    providerId,
+    "PROVIDER_AUTHENTICATION_FAILED" /* PROVIDER_AUTHENTICATION_FAILED */,
+    `Authentication failed for provider '${providerId}'${details ? `: ${details}` : ""}`,
+    {},
+    { retryable: false, statusCode: 401 }
+  ),
+  templateNotFound: (templateCode) => new TemplateError(
+    templateCode,
+    "TEMPLATE_NOT_FOUND" /* TEMPLATE_NOT_FOUND */,
+    `Template '${templateCode}' not found`,
+    {},
+    { retryable: false, statusCode: 404 }
+  ),
+  invalidPhoneNumber: (phoneNumber) => new MessageError(
+    phoneNumber,
+    "MESSAGE_INVALID_PHONE_NUMBER" /* MESSAGE_INVALID_PHONE_NUMBER */,
+    `Invalid phone number format: ${phoneNumber}`,
+    {},
+    { retryable: false, statusCode: 400 }
+  ),
+  networkTimeout: (providerId, timeout) => new KMessageError(
+    "NETWORK_TIMEOUT" /* NETWORK_TIMEOUT */,
+    `Network request timed out${timeout ? ` after ${timeout}ms` : ""}`,
+    { providerId },
+    { retryable: true, statusCode: 408 }
+  ),
+  rateLimited: (providerId, retryAfter) => new ProviderError(
+    providerId,
+    "PROVIDER_RATE_LIMITED" /* PROVIDER_RATE_LIMITED */,
+    `Rate limit exceeded for provider '${providerId}'${retryAfter ? `. Retry after ${retryAfter}s` : ""}`,
+    { retryAfter },
+    { retryable: true, statusCode: 429 }
+  ),
+  insufficientBalance: (providerId, balance) => new ProviderError(
+    providerId,
+    "PROVIDER_INSUFFICIENT_BALANCE" /* PROVIDER_INSUFFICIENT_BALANCE */,
+    `Insufficient balance for provider '${providerId}'${balance ? `. Current balance: ${balance}` : ""}`,
+    { balance },
+    { retryable: false, statusCode: 402 }
+  ),
+  fromHttpStatus: (statusCode, message, context = {}) => {
+    let code;
+    let retryable = false;
+    switch (statusCode) {
+      case 400:
+        code = "API_INVALID_REQUEST" /* API_INVALID_REQUEST */;
+        break;
+      case 401:
+        code = "API_UNAUTHORIZED" /* API_UNAUTHORIZED */;
+        break;
+      case 403:
+        code = "API_FORBIDDEN" /* API_FORBIDDEN */;
+        break;
+      case 404:
+        code = "API_NOT_FOUND" /* API_NOT_FOUND */;
+        break;
+      case 408:
+        code = "NETWORK_TIMEOUT" /* NETWORK_TIMEOUT */;
+        retryable = true;
+        break;
+      case 429:
+        code = "API_TOO_MANY_REQUESTS" /* API_TOO_MANY_REQUESTS */;
+        retryable = true;
+        break;
+      case 500:
+      case 502:
+      case 503:
+      case 504:
+        code = "API_INTERNAL_SERVER_ERROR" /* API_INTERNAL_SERVER_ERROR */;
+        retryable = true;
+        break;
+      default:
+        code = "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+        retryable = statusCode >= 500 && statusCode < 600;
+    }
+    return new KMessageError(code, message, context, { retryable, statusCode });
+  }
+};
+var Result = {
+  success: (data) => ({ success: true, data }),
+  failure: (error) => ({ success: false, error }),
+  fromPromise: async (promise) => {
+    try {
+      const data = await promise;
+      return Result.success(data);
+    } catch (error) {
+      if (error instanceof KMessageError) {
+        return Result.failure(error);
+      }
+      return Result.failure(new KMessageError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        error instanceof Error ? error.message : "Unknown error occurred",
+        {},
+        { cause: error instanceof Error ? error : void 0 }
+      ));
+    }
+  }
+};
+var ErrorUtils = {
+  isRetryable: (error) => {
+    if (error instanceof KMessageError) {
+      return error.retryable;
+    }
+    const retryableMessages = ["timeout", "ECONNRESET", "ECONNREFUSED", "ETIMEDOUT"];
+    return retryableMessages.some(
+      (msg) => error.message.toLowerCase().includes(msg.toLowerCase())
+    );
+  },
+  getStatusCode: (error) => {
+    if (error instanceof KMessageError && error.statusCode) {
+      return error.statusCode;
+    }
+    return 500;
+  },
+  formatErrorForClient: (error) => {
+    if (error instanceof KMessageError) {
+      return {
+        code: error.code,
+        message: error.message,
+        retryable: error.retryable,
+        context: error.context
+      };
+    }
+    return {
+      code: "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      message: error.message || "Unknown error occurred",
+      retryable: false,
+      context: {}
+    };
+  },
+  formatErrorForLogging: (error) => {
+    const baseInfo = {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+    if (error instanceof KMessageError) {
+      return {
+        ...baseInfo,
+        code: error.code,
+        context: error.context,
+        retryable: error.retryable,
+        statusCode: error.statusCode
+      };
+    }
+    return baseInfo;
+  }
+};
+
+// src/test-utils.ts
+var import_bun_test = require("bun:test");
+var MockProvider = class {
+  id;
+  name;
+  _healthy = true;
+  _issues = [];
+  _balance = "1000";
+  _templates = [];
+  _history = [];
+  constructor(id = "mock", name = "Mock Provider") {
+    this.id = id;
+    this.name = name;
+  }
+  // Health check simulation
+  async healthCheck() {
+    return {
+      healthy: this._healthy,
+      issues: [...this._issues],
+      data: {
+        balance: this._balance,
+        status: this._healthy ? "connected" : "disconnected",
+        code: this._healthy ? 200 : 500,
+        message: this._healthy ? "OK" : "Service unavailable"
+      }
+    };
+  }
+  // Test helpers
+  setHealthy(healthy, issues = []) {
+    this._healthy = healthy;
+    this._issues = issues;
+  }
+  setBalance(balance) {
+    this._balance = balance;
+  }
+  setTemplates(templates) {
+    this._templates = templates;
+  }
+  setHistory(history) {
+    this._history = history;
+  }
+  // Provider methods with mock implementations
+  async sendMessage(templateCode, phoneNumber, variables, options) {
+    if (!this._healthy) {
+      throw new MessageError(phoneNumber, "MESSAGE_SEND_FAILED" /* MESSAGE_SEND_FAILED */, "Provider is unhealthy");
+    }
+    if (phoneNumber === "01000000000") {
+      throw new MessageError(phoneNumber, "MESSAGE_INVALID_PHONE_NUMBER" /* MESSAGE_INVALID_PHONE_NUMBER */, "Invalid phone number");
+    }
+    return {
+      success: true,
+      messageId: `mock_${Date.now()}`,
+      status: "sent",
+      error: null
+    };
+  }
+  async getTemplates(page = 1, size = 15, filters) {
+    if (!this._healthy) {
+      throw new ProviderError(this.id, "PROVIDER_NOT_AVAILABLE" /* PROVIDER_NOT_AVAILABLE */, "Provider is unhealthy");
+    }
+    const start = (page - 1) * size;
+    const end = start + size;
+    const list = this._templates.slice(start, end);
+    return {
+      code: 200,
+      message: "Success",
+      totalCount: this._templates.length,
+      list
+    };
+  }
+  async createTemplate(name, content, category, buttons) {
+    if (!this._healthy) {
+      throw new TemplateError(name, "TEMPLATE_CREATION_FAILED" /* TEMPLATE_CREATION_FAILED */, "Provider is unhealthy");
+    }
+    if (name === "invalid_template") {
+      throw new TemplateError(name, "TEMPLATE_VALIDATION_FAILED" /* TEMPLATE_VALIDATION_FAILED */, "Template validation failed");
+    }
+    const templateCode = `mock_${name}_${Date.now()}`;
+    this._templates.push({
+      templateCode,
+      templateName: name,
+      templateContent: content,
+      status: "Y",
+      createDate: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      success: true,
+      templateCode,
+      status: "created",
+      error: null
+    };
+  }
+  async modifyTemplate(templateCode, name, content, buttons) {
+    if (!this._healthy) {
+      throw new TemplateError(templateCode, "TEMPLATE_MODIFICATION_FAILED" /* TEMPLATE_MODIFICATION_FAILED */, "Provider is unhealthy");
+    }
+    const template = this._templates.find((t) => t.templateCode === templateCode);
+    if (!template) {
+      throw new TemplateError(templateCode, "TEMPLATE_NOT_FOUND" /* TEMPLATE_NOT_FOUND */, "Template not found");
+    }
+    template.templateName = name;
+    template.templateContent = content;
+    return {
+      success: true,
+      templateCode,
+      status: "modified",
+      error: null
+    };
+  }
+  async deleteTemplate(templateCode) {
+    if (!this._healthy) {
+      throw new TemplateError(templateCode, "TEMPLATE_DELETION_FAILED" /* TEMPLATE_DELETION_FAILED */, "Provider is unhealthy");
+    }
+    const index = this._templates.findIndex((t) => t.templateCode === templateCode);
+    if (index === -1) {
+      return {
+        code: 404,
+        message: "Template not found"
+      };
+    }
+    this._templates.splice(index, 1);
+    return {
+      code: 200,
+      message: "Template deleted successfully"
+    };
+  }
+  async getHistory(page = 1, size = 15, filters) {
+    if (!this._healthy) {
+      throw new ProviderError(this.id, "PROVIDER_NOT_AVAILABLE" /* PROVIDER_NOT_AVAILABLE */, "Provider is unhealthy");
+    }
+    const start = (page - 1) * size;
+    const end = start + size;
+    const list = this._history.slice(start, end);
+    return {
+      code: 200,
+      message: "Success",
+      totalCount: this._history.length,
+      list
+    };
+  }
+  async cancelReservation(messageId) {
+    if (!this._healthy) {
+      throw new KMessageError("MESSAGE_CANCELLATION_FAILED" /* MESSAGE_CANCELLATION_FAILED */, "Provider is unhealthy");
+    }
+    return {
+      code: 200,
+      message: "Reservation cancelled successfully"
+    };
+  }
+};
+var TestAssertions = {
+  /**
+   * Assert that an error is a KMessageError with specific code
+   */
+  assertKMessageError: (error, expectedCode, expectedMessage) => {
+    (0, import_bun_test.expect)(error).toBeInstanceOf(KMessageError);
+    const kError = error;
+    (0, import_bun_test.expect)(kError.code).toBe(expectedCode);
+    if (expectedMessage) {
+      (0, import_bun_test.expect)(kError.message).toContain(expectedMessage);
+    }
+  },
+  /**
+   * Assert that an error is retryable
+   */
+  assertRetryable: (error, expected = true) => {
+    (0, import_bun_test.expect)(error.retryable).toBe(expected);
+  },
+  /**
+   * Assert that a health status is healthy
+   */
+  assertHealthy: (health, expected = true) => {
+    (0, import_bun_test.expect)(health.healthy).toBe(expected);
+    if (!expected) {
+      (0, import_bun_test.expect)(health.issues.length).toBeGreaterThan(0);
+    }
+  },
+  /**
+   * Assert that a provider result has expected structure
+   */
+  assertProviderResult: (result, expectSuccess = true) => {
+    (0, import_bun_test.expect)(result).toHaveProperty("success");
+    (0, import_bun_test.expect)(result.success).toBe(expectSuccess);
+    if (expectSuccess) {
+      (0, import_bun_test.expect)(result.error).toBeNull();
+    } else {
+      (0, import_bun_test.expect)(result.error).toBeDefined();
+    }
+  },
+  /**
+   * Assert that API response has expected structure
+   */
+  assertApiResponse: (response, expectedCode = 200) => {
+    (0, import_bun_test.expect)(response).toHaveProperty("code");
+    (0, import_bun_test.expect)(response).toHaveProperty("message");
+    (0, import_bun_test.expect)(response.code).toBe(expectedCode);
+  }
+};
+var TestData = {
+  createMockTemplate: (overrides = {}) => ({
+    templateCode: "mock_template_001",
+    templateName: "Mock Template",
+    templateContent: "[#{\uC11C\uBE44\uC2A4\uBA85}] \uC548\uB155\uD558\uC138\uC694, #{\uACE0\uAC1D\uBA85}\uB2D8!",
+    status: "Y",
+    createDate: "2024-01-01 12:00:00",
+    ...overrides
+  }),
+  createMockMessage: (overrides = {}) => ({
+    seqNo: 12345,
+    phone: "01012345678",
+    templateCode: "mock_template_001",
+    statusCode: "OK",
+    statusCodeName: "\uC131\uACF5",
+    requestDate: "2024-01-01 12:00:00",
+    sendDate: "2024-01-01 12:01:00",
+    receiveDate: "2024-01-01 12:01:30",
+    sendMessage: "[MyApp] \uC548\uB155\uD558\uC138\uC694, \uD64D\uAE38\uB3D9\uB2D8!",
+    ...overrides
+  }),
+  createMockVariables: (overrides = {}) => ({
+    \uC11C\uBE44\uC2A4\uBA85: "MyApp",
+    \uACE0\uAC1D\uBA85: "\uD64D\uAE38\uB3D9",
+    \uC778\uC99D\uCF54\uB4DC: "123456",
+    ...overrides
+  }),
+  generatePhoneNumber: (valid = true) => {
+    if (valid) {
+      const numbers = ["010", "011", "016", "017", "018", "019"];
+      const prefix = numbers[Math.floor(Math.random() * numbers.length)];
+      const suffix = Math.floor(Math.random() * 1e8).toString().padStart(8, "0");
+      return prefix + suffix;
+    } else {
+      return "01000000000";
+    }
+  }
+};
+var TestSetup = {
+  /**
+   * Create a test environment with mock providers
+   */
+  createTestEnvironment: () => {
+    const mockProviders = {
+      healthy: new MockProvider("healthy", "Healthy Provider"),
+      unhealthy: new MockProvider("unhealthy", "Unhealthy Provider"),
+      rateLimited: new MockProvider("ratelimited", "Rate Limited Provider")
+    };
+    mockProviders.unhealthy.setHealthy(false, ["Connection failed", "Authentication error"]);
+    mockProviders.rateLimited.setHealthy(true);
+    return {
+      providers: mockProviders,
+      cleanup: () => {
+      }
+    };
+  },
+  /**
+   * Create test data for various scenarios
+   */
+  createTestScenarios: () => ({
+    validMessage: {
+      templateCode: "valid_template",
+      phoneNumber: TestData.generatePhoneNumber(true),
+      variables: TestData.createMockVariables()
+    },
+    invalidMessage: {
+      templateCode: "invalid_template",
+      phoneNumber: TestData.generatePhoneNumber(false),
+      variables: {}
+    },
+    templates: [
+      TestData.createMockTemplate({ templateCode: "template_001", templateName: "Welcome Message" }),
+      TestData.createMockTemplate({ templateCode: "template_002", templateName: "OTP Message" }),
+      TestData.createMockTemplate({ templateCode: "template_003", templateName: "Notification" })
+    ],
+    history: [
+      TestData.createMockMessage({ seqNo: 1, templateCode: "template_001" }),
+      TestData.createMockMessage({ seqNo: 2, templateCode: "template_002" }),
+      TestData.createMockMessage({ seqNo: 3, templateCode: "template_003" })
+    ]
+  })
+};
+var PerformanceTest = {
+  /**
+   * Measure execution time of a function
+   */
+  measureTime: async (fn) => {
+    const start = performance.now();
+    const result = await fn();
+    const duration = performance.now() - start;
+    return { result, duration };
+  },
+  /**
+   * Run a function multiple times and get statistics
+   */
+  benchmark: async (fn, iterations = 10) => {
+    const results = [];
+    const durations = [];
+    for (let i = 0; i < iterations; i++) {
+      const { result, duration } = await PerformanceTest.measureTime(fn);
+      results.push(result);
+      durations.push(duration);
+    }
+    durations.sort((a, b) => a - b);
+    const statistics = {
+      min: durations[0],
+      max: durations[durations.length - 1],
+      average: durations.reduce((sum, d) => sum + d, 0) / durations.length,
+      median: durations[Math.floor(durations.length / 2)]
+    };
+    return { results, statistics };
+  }
+};
+
+// src/retry.ts
+var RetryHandler = class {
+  static defaultOptions = {
+    maxAttempts: 3,
+    initialDelay: 1e3,
+    maxDelay: 3e4,
+    backoffMultiplier: 2,
+    jitter: true,
+    retryCondition: (error) => ErrorUtils.isRetryable(error)
+  };
+  static async execute(operation, options = {}) {
+    const opts = { ...this.defaultOptions, ...options };
+    let lastError;
+    let delay = opts.initialDelay;
+    for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt === opts.maxAttempts || !opts.retryCondition(lastError, attempt)) {
+          throw lastError;
+        }
+        const actualDelay = opts.jitter ? delay + Math.random() * delay * 0.1 : delay;
+        opts.onRetry?.(lastError, attempt);
+        await new Promise((resolve) => setTimeout(resolve, actualDelay));
+        delay = Math.min(delay * opts.backoffMultiplier, opts.maxDelay);
+      }
+    }
+    throw lastError;
+  }
+  static createRetryableFunction(func, options = {}) {
+    return async (...args) => {
+      return this.execute(() => func(...args), options);
+    };
+  }
+};
+var CircuitBreaker = class {
+  constructor(options) {
+    this.options = options;
+  }
+  state = "CLOSED";
+  failureCount = 0;
+  lastFailureTime = 0;
+  nextAttemptTime = 0;
+  async execute(operation) {
+    const now = Date.now();
+    switch (this.state) {
+      case "OPEN":
+        if (now < this.nextAttemptTime) {
+          throw new KMessageError(
+            "NETWORK_SERVICE_UNAVAILABLE" /* NETWORK_SERVICE_UNAVAILABLE */,
+            "Circuit breaker is OPEN",
+            { state: this.state, nextAttemptTime: this.nextAttemptTime }
+          );
+        }
+        this.state = "HALF_OPEN";
+        this.options.onHalfOpen?.();
+        break;
+      case "HALF_OPEN":
+        break;
+      case "CLOSED":
+        break;
+    }
+    try {
+      const result = await Promise.race([
+        operation(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(
+            new KMessageError(
+              "NETWORK_TIMEOUT" /* NETWORK_TIMEOUT */,
+              "Circuit breaker timeout",
+              { timeout: this.options.timeout }
+            )
+          ), this.options.timeout)
+        )
+      ]);
+      if (this.state === "HALF_OPEN") {
+        this.state = "CLOSED";
+        this.failureCount = 0;
+        this.options.onClose?.();
+      }
+      return result;
+    } catch (error) {
+      this.recordFailure();
+      throw error;
+    }
+  }
+  recordFailure() {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+    if (this.failureCount >= this.options.failureThreshold) {
+      this.state = "OPEN";
+      this.nextAttemptTime = this.lastFailureTime + this.options.resetTimeout;
+      this.options.onOpen?.();
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  getFailureCount() {
+    return this.failureCount;
+  }
+  reset() {
+    this.state = "CLOSED";
+    this.failureCount = 0;
+    this.lastFailureTime = 0;
+    this.nextAttemptTime = 0;
+  }
+};
+var BulkOperationHandler = class {
+  static async execute(items, operation, options = {}) {
+    const opts = {
+      concurrency: 5,
+      retryOptions: {
+        maxAttempts: 3,
+        initialDelay: 1e3,
+        maxDelay: 1e4,
+        backoffMultiplier: 2,
+        jitter: true
+      },
+      failFast: false,
+      ...options
+    };
+    const startTime = Date.now();
+    const successful = [];
+    const failed = [];
+    let completed = 0;
+    const retryableOperation = RetryHandler.createRetryableFunction(
+      operation,
+      opts.retryOptions
+    );
+    const batches = this.createBatches(items, opts.concurrency);
+    for (const batch of batches) {
+      const batchPromises = batch.map(async (item) => {
+        try {
+          const result = await retryableOperation(item);
+          successful.push({ item, result });
+        } catch (error) {
+          failed.push({ item, error });
+          if (opts.failFast) {
+            throw new KMessageError(
+              "MESSAGE_SEND_FAILED" /* MESSAGE_SEND_FAILED */,
+              `Bulk operation failed fast after ${failed.length} failures`,
+              { totalItems: items.length, failedCount: failed.length }
+            );
+          }
+        } finally {
+          completed++;
+          opts.onProgress?.(completed, items.length, failed.length);
+        }
+      });
+      await Promise.allSettled(batchPromises);
+      if (opts.failFast && failed.length > 0) {
+        break;
+      }
+    }
+    const duration = Date.now() - startTime;
+    return {
+      successful,
+      failed,
+      summary: {
+        total: items.length,
+        successful: successful.length,
+        failed: failed.length,
+        duration
+      }
+    };
+  }
+  static createBatches(items, batchSize) {
+    const batches = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+      batches.push(items.slice(i, i + batchSize));
+    }
+    return batches;
+  }
+};
+var RateLimiter = class {
+  constructor(maxRequests, windowMs) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+  }
+  requests = [];
+  async acquire() {
+    const now = Date.now();
+    this.requests = this.requests.filter((time) => now - time < this.windowMs);
+    if (this.requests.length >= this.maxRequests) {
+      const oldestRequest = Math.min(...this.requests);
+      const waitTime = this.windowMs - (now - oldestRequest);
+      if (waitTime > 0) {
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        return this.acquire();
+      }
+    }
+    this.requests.push(now);
+  }
+  canMakeRequest() {
+    const now = Date.now();
+    this.requests = this.requests.filter((time) => now - time < this.windowMs);
+    return this.requests.length < this.maxRequests;
+  }
+  getRemainingRequests() {
+    const now = Date.now();
+    this.requests = this.requests.filter((time) => now - time < this.windowMs);
+    return Math.max(0, this.maxRequests - this.requests.length);
+  }
+};
+var HealthMonitor = class {
+  constructor(services, checkIntervalMs = 3e4) {
+    this.services = services;
+    this.checkInterval = checkIntervalMs;
+  }
+  healthStatus = /* @__PURE__ */ new Map();
+  lastCheck = /* @__PURE__ */ new Map();
+  checkInterval;
+  intervalId;
+  start() {
+    this.intervalId = setInterval(() => {
+      this.checkAllServices();
+    }, this.checkInterval);
+    this.checkAllServices();
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+  }
+  async checkAllServices() {
+    const checks = Array.from(this.services.entries()).map(
+      async ([serviceName, healthCheck]) => {
+        try {
+          const isHealthy = await healthCheck();
+          const wasHealthy = this.healthStatus.get(serviceName);
+          this.healthStatus.set(serviceName, isHealthy);
+          this.lastCheck.set(serviceName, Date.now());
+          if (wasHealthy !== void 0 && wasHealthy !== isHealthy) {
+            console.log(`Service ${serviceName} status changed: ${wasHealthy ? "healthy" : "unhealthy"} -> ${isHealthy ? "healthy" : "unhealthy"}`);
+          }
+        } catch (error) {
+          this.healthStatus.set(serviceName, false);
+          this.lastCheck.set(serviceName, Date.now());
+          console.error(`Health check failed for ${serviceName}:`, error);
+        }
+      }
+    );
+    await Promise.allSettled(checks);
+  }
+  getServiceHealth(serviceName) {
+    return this.healthStatus.get(serviceName);
+  }
+  getAllHealth() {
+    return Object.fromEntries(this.healthStatus);
+  }
+  isServiceHealthy(serviceName) {
+    return this.healthStatus.get(serviceName) === true;
+  }
+  getLastCheckTime(serviceName) {
+    return this.lastCheck.get(serviceName);
+  }
+};
+var GracefulDegradation = class {
+  fallbackStrategies = /* @__PURE__ */ new Map();
+  registerFallback(operationName, fallbackFunction) {
+    this.fallbackStrategies.set(operationName, fallbackFunction);
+  }
+  async executeWithFallback(operationName, primaryOperation, options = {}) {
+    const timeout = options.timeout || 1e4;
+    try {
+      const result = await Promise.race([
+        RetryHandler.execute(primaryOperation, options.retryOptions),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(
+            new KMessageError(
+              "NETWORK_TIMEOUT" /* NETWORK_TIMEOUT */,
+              `Operation ${operationName} timed out`,
+              { operationName, timeout }
+            )
+          ), timeout)
+        )
+      ]);
+      return result;
+    } catch (error) {
+      console.warn(`Primary operation ${operationName} failed, attempting fallback:`, error);
+      const fallback = this.fallbackStrategies.get(operationName);
+      if (fallback) {
+        try {
+          return await fallback();
+        } catch (fallbackError) {
+          throw new KMessageError(
+            "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+            `Both primary and fallback operations failed for ${operationName}`,
+            {
+              operationName,
+              primaryError: error.message,
+              fallbackError: fallbackError.message
+            },
+            { cause: error }
+          );
+        }
+      }
+      throw error;
+    }
+  }
+};
+var ErrorRecovery = {
+  /**
+   * Create a resilient function that combines multiple recovery patterns
+   */
+  createResilientFunction(func, options = {}) {
+    let circuitBreaker;
+    let rateLimiter;
+    if (options.circuitBreaker) {
+      circuitBreaker = new CircuitBreaker(options.circuitBreaker);
+    }
+    if (options.rateLimiter) {
+      rateLimiter = new RateLimiter(
+        options.rateLimiter.maxRequests,
+        options.rateLimiter.windowMs
+      );
+    }
+    return async (...args) => {
+      if (rateLimiter) {
+        await rateLimiter.acquire();
+      }
+      const operation = async () => {
+        const wrappedFunc = async () => {
+          if (options.timeout) {
+            return Promise.race([
+              func(...args),
+              new Promise(
+                (_, reject) => setTimeout(() => reject(
+                  new KMessageError(
+                    "NETWORK_TIMEOUT" /* NETWORK_TIMEOUT */,
+                    "Operation timed out",
+                    { timeout: options.timeout }
+                  )
+                ), options.timeout)
+              )
+            ]);
+          }
+          return func(...args);
+        };
+        if (circuitBreaker) {
+          return circuitBreaker.execute(wrappedFunc);
+        }
+        return wrappedFunc();
+      };
+      try {
+        return await RetryHandler.execute(operation, options.retryOptions);
+      } catch (error) {
+        if (options.fallback) {
+          console.warn("Primary operation failed, using fallback:", error);
+          return options.fallback(...args);
+        }
+        throw error;
+      }
+    };
+  }
+};
+
+// src/index.ts
+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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BulkOperationHandler,
+  CircuitBreaker,
+  ErrorFactory,
+  ErrorRecovery,
+  ErrorUtils,
+  GracefulDegradation,
+  HealthMonitor,
+  KMessageError,
+  KMessageErrorCode,
+  MessageError,
+  MockProvider,
+  PerformanceTest,
+  ProviderError,
+  RateLimiter,
+  Result,
+  RetryHandler,
+  TemplateCategory,
+  TemplateError,
+  TestAssertions,
+  TestData,
+  TestSetup
+});
+//# sourceMappingURL=index.cjs.map