vesant-sdk 1.4.4 → 1.5.0

package/dist/geolocation/index.js

@@ -1,46 +1,46 @@
 'use strict';
 
 // src/core/errors.ts
-var CGSError = class _CGSError extends Error {
+var VesantError = class _VesantError 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);
+    this.name = "VesantError";
+    Object.setPrototypeOf(this, _VesantError.prototype);
   }
 };
-var NetworkError = class _NetworkError extends CGSError {
+var NetworkError = class _NetworkError extends VesantError {
   constructor(message, originalError) {
-    super(message, "NETWORK_ERROR", void 0, { originalError });
+    super(message, "NETWORK_ERROR");
     this.originalError = originalError;
     this.name = "NetworkError";
     Object.setPrototypeOf(this, _NetworkError.prototype);
   }
 };
-var ValidationError = class _ValidationError extends CGSError {
+var ValidationError = class _ValidationError extends VesantError {
   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 });
+var ServiceUnavailableError = class _ServiceUnavailableError extends VesantError {
+  constructor(message = "Service unavailable") {
+    super(message, "SERVICE_UNAVAILABLE", 503);
     this.name = "ServiceUnavailableError";
     Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
   }
 };
-var AuthenticationError = class _AuthenticationError extends CGSError {
+var AuthenticationError = class _AuthenticationError extends VesantError {
   constructor(message = "Authentication failed") {
     super(message, "AUTHENTICATION_ERROR", 401);
     this.name = "AuthenticationError";
     Object.setPrototypeOf(this, _AuthenticationError.prototype);
   }
 };
-var RateLimitError = class _RateLimitError extends CGSError {
+var RateLimitError = class _RateLimitError extends VesantError {
   constructor(retryAfter) {
     super("Rate limit exceeded", "RATE_LIMIT_EXCEEDED", 429, { retryAfter });
     this.retryAfter = retryAfter;
@@ -48,7 +48,7 @@ var RateLimitError = class _RateLimitError extends CGSError {
     Object.setPrototypeOf(this, _RateLimitError.prototype);
   }
 };
-var TimeoutError = class _TimeoutError extends CGSError {
+var TimeoutError = class _TimeoutError extends VesantError {
   constructor(timeout) {
     super(`Request timeout after ${timeout}ms`, "TIMEOUT", 408, { timeout });
     this.timeout = timeout;
@@ -56,7 +56,7 @@ var TimeoutError = class _TimeoutError extends CGSError {
     Object.setPrototypeOf(this, _TimeoutError.prototype);
   }
 };
-var CircuitBreakerOpenError = class _CircuitBreakerOpenError extends CGSError {
+var CircuitBreakerOpenError = class _CircuitBreakerOpenError extends VesantError {
   constructor() {
     super("Circuit breaker is open \u2014 requests are temporarily blocked", "CIRCUIT_BREAKER_OPEN", 503);
     this.name = "CircuitBreakerOpenError";
@@ -201,22 +201,22 @@ var RateLimitTracker = class {
 function createConsoleLogger() {
   return {
     debug(message, meta) {
-      console.log(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+      console.log(`[Vesant SDK] ${message}`, meta !== void 0 ? meta : "");
     },
     info(message, meta) {
-      console.info(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+      console.info(`[Vesant SDK] ${message}`, meta !== void 0 ? meta : "");
     },
     warn(message, meta) {
-      console.warn(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+      console.warn(`[Vesant SDK] ${message}`, meta !== void 0 ? meta : "");
     },
     error(message, meta) {
-      console.error(`[CGS SDK] ${message}`, meta !== void 0 ? meta : "");
+      console.error(`[Vesant SDK] ${message}`, meta !== void 0 ? meta : "");
     }
   };
 }
 
 // src/core/version.ts
-var SDK_VERSION = "1.4.4";
+var SDK_VERSION = "1.5.0";
 
 // src/shared/browser-utils.ts
 function generateUUID() {
@@ -233,7 +233,7 @@ function generateDeviceId() {
   if (typeof window === "undefined" || typeof localStorage === "undefined") {
     return generateUUID();
   }
-  const storageKey = "cgs_device_id";
+  const storageKey = "vesant_device_id";
   let deviceId = localStorage.getItem(storageKey);
   if (!deviceId) {
     deviceId = generateUUID();
@@ -300,9 +300,20 @@ var BaseClient = class {
     }
     this.interceptors = config.interceptors || [];
     this.logger = config.logger || createConsoleLogger();
+    let environment = config.environment;
+    const apiKey = config.apiKey || "";
+    if (apiKey.startsWith("pk_test_")) {
+      if (environment === "production") {
+        this.logger.warn('Sandbox API key (pk_test_*) used with environment: "production" \u2014 overriding to "sandbox"');
+      }
+      environment = "sandbox";
+    } else if (apiKey.startsWith("pk_live_") && environment === "sandbox") {
+      this.logger.warn('Production API key (pk_live_*) used with environment: "sandbox" \u2014 sandbox isolation will still be applied for backward compatibility');
+    }
     this.config = {
       ...config,
-      apiKey: config.apiKey || "",
+      apiKey,
+      environment,
       headers: config.headers || {},
       timeout: config.timeout || 1e4,
       retries: config.retries || 3,
@@ -369,10 +380,7 @@ var BaseClient = class {
         }
       }
       if (this.config.debug) {
-        this.logger.debug(`${finalOptions.method || "GET"} ${url}`, {
-          headers: finalOptions.headers,
-          body: finalOptions.body
-        });
+        this.logger.debug(`${finalOptions.method || "GET"} ${endpoint}`);
       }
       const response = await fetch(url, {
         ...finalOptions,
@@ -406,17 +414,17 @@ var BaseClient = class {
         }
       }
       if (this.config.debug) {
-        this.logger.debug("Response:", { data: result });
+        this.logger.debug(`Response: ${response.status}`);
       }
       return result;
     } catch (error) {
       clearTimeout(timeoutId);
-      if (error instanceof CGSError && error.statusCode && error.statusCode >= 500) {
+      if (error instanceof VesantError && 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) {
+      if (error instanceof VesantError && !error.requestId) {
         error.requestId = requestId;
       }
       if (error instanceof Error) {
@@ -429,7 +437,7 @@ var BaseClient = class {
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           if (requestOptions?.signal?.aborted) {
-            const abortError = new CGSError("Request aborted", "REQUEST_ABORTED");
+            const abortError = new VesantError("Request aborted", "REQUEST_ABORTED");
             abortError.requestId = requestId;
             throw abortError;
           }
@@ -438,7 +446,7 @@ var BaseClient = class {
           timeoutError.requestId = requestId;
           throw timeoutError;
         }
-        if (error instanceof CGSError) {
+        if (error instanceof VesantError) {
           throw error;
         }
       }
@@ -461,7 +469,7 @@ var BaseClient = class {
         if (requestOptions?.signal?.aborted) {
           throw lastError;
         }
-        if (lastError instanceof CGSError && lastError.statusCode && lastError.statusCode >= 400 && lastError.statusCode < 500 && lastError.statusCode !== 429) {
+        if (lastError instanceof VesantError && lastError.statusCode && lastError.statusCode >= 400 && lastError.statusCode < 500 && lastError.statusCode !== 429) {
           throw lastError;
         }
         if (attempt === retries) {
@@ -489,13 +497,13 @@ var BaseClient = class {
     const createError = () => {
       switch (status) {
         case 400:
-          return new CGSError(message, "BAD_REQUEST", 400, data);
+          return new VesantError(message, "BAD_REQUEST", 400);
         case 401:
           return new AuthenticationError(message);
         case 403:
-          return new CGSError(message, "FORBIDDEN", 403, data);
+          return new VesantError(message, "FORBIDDEN", 403);
         case 404:
-          return new CGSError(message, "NOT_FOUND", 404, data);
+          return new VesantError(message, "NOT_FOUND", 404);
         case 429: {
           const retryAfter = data.retry_after || data.retryAfter;
           return new RateLimitError(retryAfter);
@@ -506,7 +514,7 @@ var BaseClient = class {
         case 504:
           return new ServiceUnavailableError(message);
         default:
-          return new CGSError(message, "UNKNOWN_ERROR", status, data);
+          return new VesantError(message, "UNKNOWN_ERROR", status);
       }
     };
     const error = createError();