vesant-sdk 1.2.0 → 1.3.1

package/dist/scores/index.d.ts

@@ -0,0 +1,96 @@
+import { B as BaseClient, R as RequestOptions } from '../client-DzElM7u-.js';
+import { c as RiskLevel, T as Timestamp, U as UUID } from '../types-DZHongaK.js';
+
+/**
+ * Score and Workflow type definitions.
+ */
+
+interface CustomerScore {
+    customer_id: string;
+    overall_score: number;
+    risk_level: RiskLevel;
+    risk_category: string;
+    last_calculated: Timestamp;
+}
+interface ScoreFactor {
+    name: string;
+    value: number;
+    weight: number;
+    description?: string;
+}
+interface ScoreHistoryEntry {
+    score: number;
+    risk_level: RiskLevel;
+    calculated_at: Timestamp;
+}
+interface ScoreBreakdown extends CustomerScore {
+    factors: ScoreFactor[];
+    history: ScoreHistoryEntry[];
+    weights: Record<string, number>;
+    thresholds: Record<RiskLevel, number>;
+}
+type WorkflowStatus = 'pending' | 'in_progress' | 'awaiting_review' | 'completed' | 'failed' | 'cancelled';
+type WorkflowStepType = 'geolocation_verification' | 'kyc_submission' | 'risk_assessment' | 'decision' | 'manual_review' | 'edd_review';
+interface WorkflowStep {
+    id: UUID;
+    type: WorkflowStepType;
+    status: WorkflowStatus;
+    result?: Record<string, unknown>;
+    started_at?: Timestamp;
+    completed_at?: Timestamp;
+}
+interface Workflow {
+    id: UUID;
+    customer_id: string;
+    status: WorkflowStatus;
+    steps: WorkflowStep[];
+    metadata?: Record<string, unknown>;
+    created_at: Timestamp;
+    updated_at: Timestamp;
+}
+interface WorkflowFilters {
+    status?: WorkflowStatus;
+    customer_id?: string;
+    from_date?: string;
+    to_date?: string;
+    page?: number;
+    page_size?: number;
+}
+interface WorkflowListResponse {
+    data: Workflow[];
+    total: number;
+    page: number;
+    page_size: number;
+    total_pages: number;
+}
+
+/**
+ * Scores and Workflow API clients.
+ */
+
+declare class ScoresClient extends BaseClient {
+    /**
+     * Get the current risk score for a customer.
+     */
+    getScore(customerId: string, requestOptions?: RequestOptions): Promise<CustomerScore>;
+    /**
+     * Get a detailed score breakdown for a customer.
+     */
+    getScoreBreakdown(customerId: string, requestOptions?: RequestOptions): Promise<ScoreBreakdown>;
+}
+declare class WorkflowClient extends BaseClient {
+    /**
+     * Get the current workflow status for a customer.
+     */
+    getWorkflowStatus(customerId: string, requestOptions?: RequestOptions): Promise<Workflow>;
+    /**
+     * List workflows with optional filters.
+     */
+    listWorkflows(filters?: WorkflowFilters, requestOptions?: RequestOptions): Promise<WorkflowListResponse>;
+    /**
+     * Get a specific workflow by ID.
+     */
+    getWorkflow(workflowId: string, requestOptions?: RequestOptions): Promise<Workflow>;
+}
+
+export { type CustomerScore, type ScoreBreakdown, type ScoreFactor, type ScoreHistoryEntry, ScoresClient, type Workflow, WorkflowClient, type WorkflowFilters, type WorkflowListResponse, type WorkflowStatus, type WorkflowStep, type WorkflowStepType };

package/dist/scores/index.js

@@ -0,0 +1,594 @@
+'use strict';
+
+// src/core/errors.ts
+var CGSError = class _CGSError extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "CGSError";
+    Object.setPrototypeOf(this, _CGSError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends CGSError {
+  constructor(message, originalError) {
+    super(message, "NETWORK_ERROR", void 0, { originalError });
+    this.originalError = originalError;
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends CGSError {
+  constructor(message, fields) {
+    super(message, "VALIDATION_ERROR", 400, { fields });
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var ServiceUnavailableError = class _ServiceUnavailableError extends CGSError {
+  constructor(message) {
+    super(`${message} is unavailable`, "SERVICE_UNAVAILABLE", 503, { service: message });
+    this.name = "ServiceUnavailableError";
+    Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends CGSError {
+  constructor(message = "Authentication failed") {
+    super(message, "AUTHENTICATION_ERROR", 401);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends CGSError {
+  constructor(retryAfter) {
+    super("Rate limit exceeded", "RATE_LIMIT_EXCEEDED", 429, { retryAfter });
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends CGSError {
+  constructor(timeout) {
+    super(`Request timeout after ${timeout}ms`, "TIMEOUT", 408, { timeout });
+    this.timeout = timeout;
+    this.name = "TimeoutError";
+    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() {
+  return {
+    debug(message, meta) {
+      console.log(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+    },
+    info(message, meta) {
+      console.info(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+    },
+    warn(message, meta) {
+      console.warn(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+    },
+    error(message, meta) {
+      console.error(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+    }
+  };
+}
+
+// src/core/version.ts
+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"]);
+    }
+    if (!config.tenantId?.trim()) {
+      throw new ValidationError("tenantId is required and must be a non-empty string", ["tenantId"]);
+    }
+    this.interceptors = config.interceptors || [];
+    this.logger = config.logger || createConsoleLogger();
+    this.config = {
+      ...config,
+      apiKey: config.apiKey || "",
+      headers: config.headers || {},
+      timeout: config.timeout || 1e4,
+      retries: config.retries || 3,
+      debug: config.debug || false,
+      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 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) {
+      if (requestOptions.signal.aborted) {
+        controller.abort();
+      } else {
+        requestOptions.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+    }
+    try {
+      let finalOptions = { ...options, headers };
+      for (const interceptor of this.interceptors) {
+        if (interceptor.onRequest) {
+          finalOptions = await interceptor.onRequest(url, finalOptions);
+        }
+      }
+      if (this.config.debug) {
+        this.logger.debug(`${finalOptions.method || "GET"} ${url}`, {
+          headers: finalOptions.headers,
+          body: finalOptions.body
+        });
+      }
+      const response = await fetch(url, {
+        ...finalOptions,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (this.rateLimitTracker) {
+        this.rateLimitTracker.updateFromHeaders(response.headers);
+      }
+      let data;
+      try {
+        data = await response.json();
+      } catch {
+        if (!response.ok) {
+          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 || {}, requestId);
+      }
+      this.circuitBreaker?.onSuccess();
+      let result = data;
+      for (const interceptor of this.interceptors) {
+        if (interceptor.onResponse) {
+          result = await interceptor.onResponse(url, result);
+        }
+      }
+      if (this.config.debug) {
+        this.logger.debug("Response:", { data: result });
+      }
+      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) {
+            await interceptor.onError(url, error);
+          }
+        }
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          if (requestOptions?.signal?.aborted) {
+            const abortError = new CGSError("Request aborted", "REQUEST_ABORTED");
+            abortError.requestId = requestId;
+            throw abortError;
+          }
+          this.circuitBreaker?.onFailure();
+          const timeoutError = new TimeoutError(this.config.timeout);
+          timeoutError.requestId = requestId;
+          throw timeoutError;
+        }
+        if (error instanceof CGSError) {
+          throw error;
+        }
+      }
+      const networkError = new NetworkError("Network request failed", error);
+      networkError.requestId = requestId;
+      this.circuitBreaker?.onFailure();
+      throw networkError;
+    }
+  }
+  /**
+   * Make an HTTP request with retry logic
+   */
+  async requestWithRetry(endpoint, options = {}, serviceURL, retries = this.config.retries, requestOptions) {
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await this.request(endpoint, options, serviceURL, requestOptions);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error("Unknown error");
+        if (requestOptions?.signal?.aborted) {
+          throw lastError;
+        }
+        if (lastError instanceof CGSError && lastError.statusCode && lastError.statusCode >= 400 && lastError.statusCode < 500 && lastError.statusCode !== 429) {
+          throw lastError;
+        }
+        if (attempt === retries) {
+          break;
+        }
+        let delay;
+        if (lastError instanceof RateLimitError && lastError.retryAfter) {
+          delay = lastError.retryAfter * 1e3;
+        } else {
+          delay = Math.min(1e3 * Math.pow(2, attempt) + Math.random() * 1e3, 1e4);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (this.config.debug) {
+          this.logger.debug(`Retry attempt ${attempt + 1}/${retries} after ${delay.toFixed(0)}ms`);
+        }
+      }
+    }
+    throw new NetworkError(`Request failed after ${retries} retries`, lastError);
+  }
+  /**
+   * Handle error responses from API
+   */
+  handleErrorResponse(status, data, requestId) {
+    const message = data.error || data.message || `HTTP ${status}`;
+    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);
+      }
+    };
+    const error = createError();
+    if (requestId) {
+      error.requestId = requestId;
+    }
+    throw error;
+  }
+  /**
+   * Build query string from parameters
+   */
+  buildQueryString(params) {
+    const query = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        if (Array.isArray(value)) {
+          value.forEach((item) => query.append(key, String(item)));
+        } else {
+          query.append(key, String(value));
+        }
+      }
+    });
+    const queryString = query.toString();
+    return queryString ? `?${queryString}` : "";
+  }
+  /**
+   * Update client configuration
+   */
+  updateConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config,
+      headers: {
+        ...this.config.headers,
+        ...config.headers || {}
+      }
+    };
+    if (config.logger) {
+      this.logger = config.logger;
+    }
+    if (config.interceptors) {
+      this.interceptors = config.interceptors;
+    }
+  }
+  /**
+   * Get current configuration (readonly)
+   */
+  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
+   */
+  async healthCheck() {
+    return this.request("/api/v1/health");
+  }
+};
+
+// src/scores/client.ts
+var ScoresClient = class extends BaseClient {
+  /**
+   * Get the current risk score for a customer.
+   */
+  async getScore(customerId, requestOptions) {
+    return this.requestWithRetry(
+      `/api/v1/scores/${encodeURIComponent(customerId)}`,
+      { method: "GET" },
+      void 0,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get a detailed score breakdown for a customer.
+   */
+  async getScoreBreakdown(customerId, requestOptions) {
+    return this.requestWithRetry(
+      `/api/v1/scores/${encodeURIComponent(customerId)}/breakdown`,
+      { method: "GET" },
+      void 0,
+      void 0,
+      requestOptions
+    );
+  }
+};
+var WorkflowClient = class extends BaseClient {
+  /**
+   * Get the current workflow status for a customer.
+   */
+  async getWorkflowStatus(customerId, requestOptions) {
+    return this.requestWithRetry(
+      `/api/v1/workflows/${encodeURIComponent(customerId)}/status`,
+      { method: "GET" },
+      void 0,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * List workflows with optional filters.
+   */
+  async listWorkflows(filters, requestOptions) {
+    const queryString = this.buildQueryString(filters || {});
+    return this.requestWithRetry(
+      `/api/v1/workflows${queryString}`,
+      { method: "GET" },
+      void 0,
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Get a specific workflow by ID.
+   */
+  async getWorkflow(workflowId, requestOptions) {
+    return this.requestWithRetry(
+      `/api/v1/workflows/${encodeURIComponent(workflowId)}`,
+      { method: "GET" },
+      void 0,
+      void 0,
+      requestOptions
+    );
+  }
+};
+
+exports.ScoresClient = ScoresClient;
+exports.WorkflowClient = WorkflowClient;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map