@zerosls/clm-sdk 1.1.7 → 1.1.8

package/dist/core/api-client.js

@@ -6,7 +6,8 @@ export class ApiClient {
         var _a, _b;
         this.token = null;
         this.baseUrl = config.baseUrl;
-        this.fallbackBaseUrl = config.fallbackBaseUrl || "http://216.250.117.119/ZeroServicesQA/api/v1";
+        this.fallbackBaseUrl =
+            config.fallbackBaseUrl || "http://216.250.117.119/ZeroServicesQA/api/v1";
         this.organization = config.organization;
         this.token = config.token || null;
         this.eventEmitter = eventEmitter;
@@ -56,8 +57,187 @@ export class ApiClient {
             }
         }
     }
+    /*private async request<T>(
+      method: string,
+      endpoint: string,
+      data?: any,
+      params?: Record<string, any>,
+      options: RequestOptions = {}
+    ): Promise<T> {
+      // ✅ Primer intento con baseUrl normal
+      const primaryUrl = buildUrl(this.baseUrl, endpoint, params);
+      
+      const base: HeadersInit = buildHeaders(this.token, {
+        "X-Organization": this.organization,
+        ...(options.headers || {}),
+      });
+  
+      const headers = new Headers(base);
+  
+      // ✅ Obtener token legacy
+      const legacyToken =
+        (window as any).__LEGACY_TOKEN__ ||
+        sessionStorage.getItem("legacy_token") ||
+        null;
+  
+      if (legacyToken) {
+        headers.set("Authorization", `Bearer ${legacyToken}`);
+        if (this.debug) {
+          console.log("🔐 Using legacy token for:", endpoint);
+        }
+      } else if (this.token) {
+        if (this.debug) {
+          console.log("🔐 Using v1 token for:", endpoint);
+        }
+      } else {
+        console.warn("⚠️ No token available for endpoint:", endpoint);
+      }
+  
+      const useCache = this.cacheEnabled && options.useCache !== false;
+      if (useCache && method === "GET") {
+        const cacheKey = generateCacheKey(method, primaryUrl, data);
+        const cachedData = this.cache.get<T>(cacheKey);
+        if (cachedData) {
+          if (this.debug) {
+            console.log(`[SDK-Cache] Hit: ${cacheKey}`);
+          }
+          return cachedData;
+        }
+      }
+  
+      this.eventEmitter.emit("beforeRequest", {
+        url: primaryUrl,
+        method,
+        data,
+      });
+  
+      try {
+        const fetchOptions: RequestInit = {
+          method,
+          headers,
+          credentials: "include",
+        };
+  
+        if (data && method !== "GET") {
+          fetchOptions.body = JSON.stringify(data);
+          if (this.debug) {
+            console.log(`📤 ${method} Body:`, data);
+          }
+        }
+  
+        if (this.debug) {
+          console.log(`🌐 ${method} ${primaryUrl}`);
+        }
+  
+        // ✅ Primer intento
+        const response = await fetch(primaryUrl, fetchOptions);
+  
+        // ✅ Si es 404, intentar con fallback URL
+        if (response.status === 404) {
+          console.warn(`⚠️ 404 en ${primaryUrl}, intentando con fallback...`);
+          
+          const fallbackUrl = buildUrl(this.fallbackBaseUrl, endpoint, params);
+          
+          if (this.debug) {
+            console.log(`🔄 Retry: ${method} ${fallbackUrl}`);
+          }
+  
+          // ✅ Segundo intento con fallback
+          const fallbackResponse = await fetch(fallbackUrl, fetchOptions);
+          
+          if (!fallbackResponse.ok) {
+            let errorData;
+            try {
+              errorData = await fallbackResponse.json();
+            } catch {
+              errorData = { message: fallbackResponse.statusText };
+            }
+  
+            console.error(`❌ Fallback también falló ${fallbackResponse.status}:`, errorData);
+  
+            if (fallbackResponse.status === 401) {
+              this.eventEmitter.emit("authError", {
+                statusCode: 401,
+                message: errorData.message || "Authentication required",
+              });
+            }
+  
+            return errorData as T;
+          }
+  
+          // ✅ Fallback exitoso
+          const fallbackData = await parseResponse<T>(fallbackResponse);
+          
+          console.log(`✅ Fallback exitoso para: ${endpoint}`);
+          
+          this.eventEmitter.emit("afterRequest", {
+            url: fallbackUrl,
+            method,
+            response: fallbackData,
+          });
+  
+          return fallbackData;
+        }
+  
+        // ✅ Otros errores (no 404)
+        if (!response.ok) {
+          let errorData;
+          try {
+            errorData = await response.json();
+          } catch {
+            errorData = { message: response.statusText };
+          }
+  
+          console.error(`❌ ${method} ${response.status}:`, errorData);
+  
+          if (response.status === 401) {
+            this.eventEmitter.emit("authError", {
+              statusCode: 401,
+              message: errorData.message || "Authentication required",
+            });
+          }
+  
+          return errorData as T;
+        }
+  
+        // ✅ Respuesta exitosa del primer intento
+        const responseData = await parseResponse<T>(response);
+  
+        if (useCache && method === "GET") {
+          const cacheKey = generateCacheKey(method, primaryUrl, data);
+          const cacheTime = options.cacheTime || undefined;
+          this.cache.set(cacheKey, responseData, cacheTime);
+  
+          if (this.debug) {
+            console.log(`[SDK-Cache] Set: ${cacheKey}`);
+          }
+        }
+  
+        this.eventEmitter.emit("afterRequest", {
+          url: primaryUrl,
+          method,
+          response: responseData,
+        });
+  
+        return responseData;
+      } catch (error) {
+        this.eventEmitter.emit("requestError", {
+          url: primaryUrl,
+          method,
+          error,
+        });
+  
+        if (error instanceof ApiError) {
+          throw error;
+        }
+  
+        throw new ApiError((error as Error).message || "Network error", 0, {
+          originalError: error,
+        });
+      }
+    }*/
+    // core/api-client.ts
     async request(method, endpoint, data, params, options = {}) {
-        // ✅ Primer intento con baseUrl normal
         const primaryUrl = buildUrl(this.baseUrl, endpoint, params);
         const base = buildHeaders(this.token, {
             "X-Organization": this.organization,
@@ -124,6 +304,11 @@ export class ApiClient {
                 }
                 // ✅ Segundo intento con fallback
                 const fallbackResponse = await fetch(fallbackUrl, fetchOptions);
+                // ✅ Manejar 204 No Content
+                if (fallbackResponse.status === 204) {
+                    console.log(`✅ Fallback exitoso (204 No Content): ${endpoint}`);
+                    return {}; // Retornar objeto vacío
+                }
                 if (!fallbackResponse.ok) {
                     let errorData;
                     try {
@@ -132,7 +317,7 @@ export class ApiClient {
                     catch (_a) {
                         errorData = { message: fallbackResponse.statusText };
                     }
-                    console.error(`❌ Fallback también falló ${fallbackResponse.status}:`, errorData);
+                    console.error(`❌ Fallback falló ${fallbackResponse.status}:`, errorData);
                     if (fallbackResponse.status === 401) {
                         this.eventEmitter.emit("authError", {
                             statusCode: 401,
@@ -141,9 +326,9 @@ export class ApiClient {
                     }
                     return errorData;
                 }
-                // ✅ Fallback exitoso
+                // ✅ Fallback exitoso con contenido
                 const fallbackData = await parseResponse(fallbackResponse);
-                console.log(`✅ Fallback exitoso para: ${endpoint}`);
+                console.log(`✅ Fallback exitoso: ${endpoint}`);
                 this.eventEmitter.emit("afterRequest", {
                     url: fallbackUrl,
                     method,
@@ -151,6 +336,11 @@ export class ApiClient {
                 });
                 return fallbackData;
             }
+            // ✅ Manejar 204 No Content en primer intento
+            if (response.status === 204) {
+                console.log(`✅ Request exitoso (204 No Content): ${endpoint}`);
+                return {}; // Retornar objeto vacío
+            }
             // ✅ Otros errores (no 404)
             if (!response.ok) {
                 let errorData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerosls/clm-sdk",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "SDK for ZeroCLM API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/api-client.ts

@@ -24,7 +24,8 @@ export class ApiClient {
 
   constructor(config: SdkConfig, eventEmitter: EventEmitter) {
     this.baseUrl = config.baseUrl;
-    this.fallbackBaseUrl = config.fallbackBaseUrl || "http://216.250.117.119/ZeroServicesQA/api/v1";
+    this.fallbackBaseUrl =
+      config.fallbackBaseUrl || "http://216.250.117.119/ZeroServicesQA/api/v1";
     this.organization = config.organization;
     this.token = config.token || null;
     this.eventEmitter = eventEmitter;
@@ -125,7 +126,7 @@ export class ApiClient {
     }
   }
 
-  private async request<T>(
+  /*private async request<T>(
     method: string,
     endpoint: string,
     data?: any,
@@ -299,9 +300,204 @@ export class ApiClient {
         throw error;
       }
 
+      throw new ApiError((error as Error).message || "Network error", 0, {
+        originalError: error,
+      });
+    }
+  }*/
+
+  // core/api-client.ts
+  private async request<T>(
+    method: string,
+    endpoint: string,
+    data?: any,
+    params?: Record<string, any>,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    const primaryUrl = buildUrl(this.baseUrl, endpoint, params);
+
+    const base: HeadersInit = buildHeaders(this.token, {
+      "X-Organization": this.organization,
+      ...(options.headers || {}),
+    });
+
+    const headers = new Headers(base);
+
+    // ✅ Obtener token legacy
+    const legacyToken =
+      (window as any).__LEGACY_TOKEN__ ||
+      sessionStorage.getItem("legacy_token") ||
+      null;
+
+    if (legacyToken) {
+      headers.set("Authorization", `Bearer ${legacyToken}`);
+      if (this.debug) {
+        console.log("🔐 Using legacy token for:", endpoint);
+      }
+    } else if (this.token) {
+      if (this.debug) {
+        console.log("🔐 Using v1 token for:", endpoint);
+      }
+    } else {
+      console.warn("⚠️ No token available for endpoint:", endpoint);
+    }
+
+    const useCache = this.cacheEnabled && options.useCache !== false;
+    if (useCache && method === "GET") {
+      const cacheKey = generateCacheKey(method, primaryUrl, data);
+      const cachedData = this.cache.get<T>(cacheKey);
+      if (cachedData) {
+        if (this.debug) {
+          console.log(`[SDK-Cache] Hit: ${cacheKey}`);
+        }
+        return cachedData;
+      }
+    }
+
+    this.eventEmitter.emit("beforeRequest", {
+      url: primaryUrl,
+      method,
+      data,
+    });
+
+    try {
+      const fetchOptions: RequestInit = {
+        method,
+        headers,
+        credentials: "include",
+      };
+
+      if (data && method !== "GET") {
+        fetchOptions.body = JSON.stringify(data);
+        if (this.debug) {
+          console.log(`📤 ${method} Body:`, data);
+        }
+      }
+
+      if (this.debug) {
+        console.log(`🌐 ${method} ${primaryUrl}`);
+      }
+
+      // ✅ Primer intento
+      const response = await fetch(primaryUrl, fetchOptions);
+
+      // ✅ Si es 404, intentar con fallback URL
+      if (response.status === 404) {
+        console.warn(`⚠️ 404 en ${primaryUrl}, intentando con fallback...`);
+
+        const fallbackUrl = buildUrl(this.fallbackBaseUrl, endpoint, params);
+
+        if (this.debug) {
+          console.log(`🔄 Retry: ${method} ${fallbackUrl}`);
+        }
+
+        // ✅ Segundo intento con fallback
+        const fallbackResponse = await fetch(fallbackUrl, fetchOptions);
+
+        // ✅ Manejar 204 No Content
+        if (fallbackResponse.status === 204) {
+          console.log(`✅ Fallback exitoso (204 No Content): ${endpoint}`);
+          return {} as T; // Retornar objeto vacío
+        }
+
+        if (!fallbackResponse.ok) {
+          let errorData;
+          try {
+            errorData = await fallbackResponse.json();
+          } catch {
+            errorData = { message: fallbackResponse.statusText };
+          }
+
+          console.error(
+            `❌ Fallback falló ${fallbackResponse.status}:`,
+            errorData
+          );
+
+          if (fallbackResponse.status === 401) {
+            this.eventEmitter.emit("authError", {
+              statusCode: 401,
+              message: errorData.message || "Authentication required",
+            });
+          }
+
+          return errorData as T;
+        }
+
+        // ✅ Fallback exitoso con contenido
+        const fallbackData = await parseResponse<T>(fallbackResponse);
+
+        console.log(`✅ Fallback exitoso: ${endpoint}`);
+
+        this.eventEmitter.emit("afterRequest", {
+          url: fallbackUrl,
+          method,
+          response: fallbackData,
+        });
+
+        return fallbackData;
+      }
+
+      // ✅ Manejar 204 No Content en primer intento
+      if (response.status === 204) {
+        console.log(`✅ Request exitoso (204 No Content): ${endpoint}`);
+        return {} as T; // Retornar objeto vacío
+      }
+
+      // ✅ Otros errores (no 404)
+      if (!response.ok) {
+        let errorData;
+        try {
+          errorData = await response.json();
+        } catch {
+          errorData = { message: response.statusText };
+        }
+
+        console.error(`❌ ${method} ${response.status}:`, errorData);
+
+        if (response.status === 401) {
+          this.eventEmitter.emit("authError", {
+            statusCode: 401,
+            message: errorData.message || "Authentication required",
+          });
+        }
+
+        return errorData as T;
+      }
+
+      // ✅ Respuesta exitosa del primer intento
+      const responseData = await parseResponse<T>(response);
+
+      if (useCache && method === "GET") {
+        const cacheKey = generateCacheKey(method, primaryUrl, data);
+        const cacheTime = options.cacheTime || undefined;
+        this.cache.set(cacheKey, responseData, cacheTime);
+
+        if (this.debug) {
+          console.log(`[SDK-Cache] Set: ${cacheKey}`);
+        }
+      }
+
+      this.eventEmitter.emit("afterRequest", {
+        url: primaryUrl,
+        method,
+        response: responseData,
+      });
+
+      return responseData;
+    } catch (error) {
+      this.eventEmitter.emit("requestError", {
+        url: primaryUrl,
+        method,
+        error,
+      });
+
+      if (error instanceof ApiError) {
+        throw error;
+      }
+
       throw new ApiError((error as Error).message || "Network error", 0, {
         originalError: error,
       });
     }
   }
-}
+}