vesant-sdk 1.2.0 → 1.3.0

package/dist/kyc/index.mjs

@@ -54,6 +54,146 @@ var TimeoutError = class _TimeoutError extends CGSError {
     Object.setPrototypeOf(this, _TimeoutError.prototype);
   }
 };
+var CircuitBreakerOpenError = class _CircuitBreakerOpenError extends CGSError {
+  constructor() {
+    super("Circuit breaker is open \u2014 requests are temporarily blocked", "CIRCUIT_BREAKER_OPEN", 503);
+    this.name = "CircuitBreakerOpenError";
+    Object.setPrototypeOf(this, _CircuitBreakerOpenError.prototype);
+  }
+};
+
+// src/core/circuit-breaker.ts
+var CircuitBreaker = class {
+  constructor(config = {}) {
+    this.state = "closed";
+    this.failures = 0;
+    this.successes = 0;
+    this.lastFailureTime = null;
+    this.failureThreshold = config.failureThreshold ?? 5;
+    this.resetTimeout = config.resetTimeout ?? 3e4;
+    this.successThreshold = config.successThreshold ?? 1;
+  }
+  /**
+   * Check if a request can proceed through the circuit breaker.
+   */
+  canExecute() {
+    if (this.state === "closed") {
+      return true;
+    }
+    if (this.state === "open") {
+      const now = Date.now();
+      if (this.lastFailureTime && now - this.lastFailureTime >= this.resetTimeout) {
+        this.state = "half-open";
+        this.successes = 0;
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Record a successful request.
+   */
+  onSuccess() {
+    if (this.state === "half-open") {
+      this.successes++;
+      if (this.successes >= this.successThreshold) {
+        this.state = "closed";
+        this.failures = 0;
+        this.successes = 0;
+        this.lastFailureTime = null;
+      }
+    } else if (this.state === "closed") {
+      this.failures = 0;
+    }
+  }
+  /**
+   * Record a failed request.
+   */
+  onFailure() {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+    if (this.state === "half-open") {
+      this.state = "open";
+      this.successes = 0;
+    } else if (this.state === "closed" && this.failures >= this.failureThreshold) {
+      this.state = "open";
+    }
+  }
+  /**
+   * Get current circuit breaker status.
+   */
+  getStatus() {
+    return {
+      state: this.state,
+      failures: this.failures,
+      successes: this.successes,
+      lastFailureTime: this.lastFailureTime,
+      nextRetryTime: this.state === "open" && this.lastFailureTime ? this.lastFailureTime + this.resetTimeout : null
+    };
+  }
+  /**
+   * Reset the circuit breaker to its initial closed state.
+   */
+  reset() {
+    this.state = "closed";
+    this.failures = 0;
+    this.successes = 0;
+    this.lastFailureTime = null;
+  }
+};
+
+// src/core/rate-limiter.ts
+var RateLimitTracker = class {
+  constructor() {
+    this.limit = null;
+    this.remaining = null;
+    this.reset = null;
+    this.retryAfter = null;
+  }
+  /**
+   * Extract rate limit information from response headers.
+   */
+  updateFromHeaders(headers) {
+    const limit = headers.get("x-ratelimit-limit");
+    const remaining = headers.get("x-ratelimit-remaining");
+    const reset = headers.get("x-ratelimit-reset");
+    const retryAfter = headers.get("retry-after");
+    if (limit !== null) this.limit = parseInt(limit, 10);
+    if (remaining !== null) this.remaining = parseInt(remaining, 10);
+    if (reset !== null) this.reset = parseInt(reset, 10);
+    if (retryAfter !== null) this.retryAfter = parseInt(retryAfter, 10);
+  }
+  /**
+   * Check if the rate limit has been exceeded based on tracked headers.
+   */
+  isLimitExceeded() {
+    if (this.remaining !== null && this.remaining <= 0) {
+      if (this.reset !== null) {
+        const now = Math.floor(Date.now() / 1e3);
+        if (now >= this.reset) {
+          this.remaining = null;
+          this.reset = null;
+          this.retryAfter = null;
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get current rate limit status.
+   */
+  getStatus() {
+    return {
+      limit: this.limit,
+      remaining: this.remaining,
+      reset: this.reset,
+      retryAfter: this.retryAfter
+    };
+  }
+};
 
 // src/core/logger.ts
 function createConsoleLogger() {
@@ -74,11 +214,25 @@ function createConsoleLogger() {
 }
 
 // src/core/version.ts
-var SDK_VERSION = "1.2.0";
+var SDK_VERSION = "1.3.0";
+
+// src/shared/browser-utils.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
 
 // src/core/client.ts
 var BaseClient = class {
   constructor(config) {
+    this.circuitBreaker = null;
+    this.rateLimitTracker = null;
     if (!config.baseURL?.trim()) {
       throw new ValidationError("baseURL is required and must be a non-empty string", ["baseURL"]);
     }
@@ -88,8 +242,7 @@ var BaseClient = class {
     this.interceptors = config.interceptors || [];
     this.logger = config.logger || createConsoleLogger();
     this.config = {
-      baseURL: config.baseURL,
-      tenantId: config.tenantId,
+      ...config,
       apiKey: config.apiKey || "",
       headers: config.headers || {},
       timeout: config.timeout || 1e4,
@@ -98,22 +251,49 @@ var BaseClient = class {
       interceptors: this.interceptors,
       logger: this.logger
     };
+    if (config.circuitBreaker) {
+      this.circuitBreaker = new CircuitBreaker(config.circuitBreaker);
+    }
+    if (config.enableRateLimitTracking) {
+      this.rateLimitTracker = new RateLimitTracker();
+    }
   }
   /**
    * Make an HTTP request with timeout and error handling
    */
   async request(endpoint, options = {}, serviceURL, requestOptions) {
-    const url = `${serviceURL || this.config.baseURL}${endpoint}`;
+    const requestId = generateUUID();
+    if (this.circuitBreaker && !this.circuitBreaker.canExecute()) {
+      const error = new CircuitBreakerOpenError();
+      error.requestId = requestId;
+      throw error;
+    }
+    if (this.rateLimitTracker && this.rateLimitTracker.isLimitExceeded()) {
+      const status = this.rateLimitTracker.getStatus();
+      const error = new RateLimitError(status.retryAfter ?? void 0);
+      error.requestId = requestId;
+      throw error;
+    }
+    const baseURL = this.config.environment === "sandbox" && this.config.sandboxBaseURL ? this.config.sandboxBaseURL : serviceURL || this.config.baseURL;
+    const url = `${serviceURL || baseURL}${endpoint}`;
     const headers = {
       "Content-Type": "application/json",
       "X-Tenant-ID": this.config.tenantId,
       "X-SDK-Version": `vesant-sdk-ts/${SDK_VERSION}`,
+      "X-Request-ID": requestId,
       ...this.config.headers,
       ...options.headers || {}
     };
     if (this.config.apiKey) {
       headers["Authorization"] = `Bearer ${this.config.apiKey}`;
     }
+    if (this.config.environment === "sandbox") {
+      headers["X-Sandbox"] = "true";
+    }
+    const method = (options.method || "GET").toUpperCase();
+    if (["POST", "PUT", "PATCH"].includes(method)) {
+      headers["Idempotency-Key"] = requestOptions?.idempotencyKey || generateUUID();
+    }
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
     if (requestOptions?.signal) {
@@ -141,6 +321,9 @@ var BaseClient = class {
         signal: controller.signal
       });
       clearTimeout(timeoutId);
+      if (this.rateLimitTracker) {
+        this.rateLimitTracker.updateFromHeaders(response.headers);
+      }
       let data;
       try {
         data = await response.json();
@@ -149,13 +332,15 @@ var BaseClient = class {
           this.handleErrorResponse(response.status, {
             error: `HTTP ${response.status}`,
             message: response.statusText
-          });
+          }, requestId);
         }
+        this.circuitBreaker?.onSuccess();
         return void 0;
       }
       if (!response.ok) {
-        this.handleErrorResponse(response.status, data || {});
+        this.handleErrorResponse(response.status, data || {}, requestId);
       }
+      this.circuitBreaker?.onSuccess();
       let result = data;
       for (const interceptor of this.interceptors) {
         if (interceptor.onResponse) {
@@ -168,6 +353,14 @@ var BaseClient = class {
       return result;
     } catch (error) {
       clearTimeout(timeoutId);
+      if (error instanceof CGSError && error.statusCode && error.statusCode >= 500) {
+        this.circuitBreaker?.onFailure();
+      } else if (error instanceof NetworkError || error instanceof TimeoutError) {
+        this.circuitBreaker?.onFailure();
+      }
+      if (error instanceof CGSError && !error.requestId) {
+        error.requestId = requestId;
+      }
       if (error instanceof Error) {
         for (const interceptor of this.interceptors) {
           if (interceptor.onError) {
@@ -178,15 +371,23 @@ var BaseClient = class {
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           if (requestOptions?.signal?.aborted) {
-            throw new CGSError("Request aborted", "REQUEST_ABORTED");
+            const abortError = new CGSError("Request aborted", "REQUEST_ABORTED");
+            abortError.requestId = requestId;
+            throw abortError;
           }
-          throw new TimeoutError(this.config.timeout);
+          this.circuitBreaker?.onFailure();
+          const timeoutError = new TimeoutError(this.config.timeout);
+          timeoutError.requestId = requestId;
+          throw timeoutError;
         }
         if (error instanceof CGSError) {
           throw error;
         }
       }
-      throw new NetworkError("Network request failed", error);
+      const networkError = new NetworkError("Network request failed", error);
+      networkError.requestId = requestId;
+      this.circuitBreaker?.onFailure();
+      throw networkError;
     }
   }
   /**
@@ -225,29 +426,36 @@ var BaseClient = class {
   /**
    * Handle error responses from API
    */
-  handleErrorResponse(status, data) {
+  handleErrorResponse(status, data, requestId) {
     const message = data.error || data.message || `HTTP ${status}`;
-    switch (status) {
-      case 400:
-        throw new CGSError(message, "BAD_REQUEST", 400, data);
-      case 401:
-        throw new AuthenticationError(message);
-      case 403:
-        throw new CGSError(message, "FORBIDDEN", 403, data);
-      case 404:
-        throw new CGSError(message, "NOT_FOUND", 404, data);
-      case 429: {
-        const retryAfter = data.retry_after || data.retryAfter;
-        throw new RateLimitError(retryAfter);
+    const createError = () => {
+      switch (status) {
+        case 400:
+          return new CGSError(message, "BAD_REQUEST", 400, data);
+        case 401:
+          return new AuthenticationError(message);
+        case 403:
+          return new CGSError(message, "FORBIDDEN", 403, data);
+        case 404:
+          return new CGSError(message, "NOT_FOUND", 404, data);
+        case 429: {
+          const retryAfter = data.retry_after || data.retryAfter;
+          return new RateLimitError(retryAfter);
+        }
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+          return new ServiceUnavailableError(message);
+        default:
+          return new CGSError(message, "UNKNOWN_ERROR", status, data);
       }
-      case 500:
-      case 502:
-      case 503:
-      case 504:
-        throw new ServiceUnavailableError(message);
-      default:
-        throw new CGSError(message, "UNKNOWN_ERROR", status, data);
+    };
+    const error = createError();
+    if (requestId) {
+      error.requestId = requestId;
     }
+    throw error;
   }
   /**
    * Build query string from parameters
@@ -291,6 +499,18 @@ var BaseClient = class {
   getConfig() {
     return { ...this.config };
   }
+  /**
+   * Get rate limit status from tracked response headers.
+   */
+  getRateLimitStatus() {
+    return this.rateLimitTracker?.getStatus() ?? null;
+  }
+  /**
+   * Get circuit breaker status.
+   */
+  getCircuitBreakerStatus() {
+    return this.circuitBreaker?.getStatus() ?? null;
+  }
   /**
    * Health check endpoint
    */