@zerosls/clm-sdk 2.1.1 → 2.1.3

package/dist/config/config.js

@@ -6,7 +6,7 @@ function normalizeUrl(url) {
 //  if (fromWindow) return normalizeUrl(String(fromWindow));
 //}
 export const DEFAULT_CONFIG = {
-    baseUrl: "https://zero-api-qa.onrender.com/api/v1", //resolveDefaultBaseUrl(), 
+    baseUrl: "https://zero-api-production.up.railway.app/ZeroApiQA/api/v1", //resolveDefaultBaseUrl(), 
     organization: "default-org",
     cache: { enabled: true, ttl: 60000 },
     debug: true,

package/dist/core/api-client.js

@@ -55,27 +55,168 @@ export class ApiClient {
             }
         }
     }
+    /*private async request<T>(
+      method: string,
+      endpoint: string,
+      data?: any,
+      params?: Record<string, any>,
+      options: RequestOptions = {}
+    ): Promise<T> {
+      const url = buildUrl(this.baseUrl, endpoint, params);
+  
+      const base: HeadersInit = buildHeaders(this.token, {
+        "X-Organization": this.organization,
+        ...(options.headers || {}),
+      });
+  
+      const headers = new Headers(base);
+  
+      const legacyPattern = /(^|\/)legacy(\/|$)/i;
+      const isLegacyEndpoint = legacyPattern.test(endpoint);
+      const isLegacyLogin = /(^|\/)legacy\/login$/i.test(endpoint);
+  
+      if (isLegacyEndpoint && !isLegacyLogin) {
+        const legacyToken =
+          (typeof window !== "undefined" && (window as any).__LEGACY_TOKEN__) ||
+          (typeof sessionStorage !== "undefined" &&
+            sessionStorage.getItem("legacy_token")) ||
+          null;
+  
+        if (legacyToken) {
+          headers.set("Authorization", `Bearer ${legacyToken}`);
+        }
+      }
+  
+      if (!isLegacyEndpoint && !this.token) {
+        headers.delete("Authorization");
+      }
+  
+      const useCache = this.cacheEnabled && options.useCache !== false;
+      if (useCache && method === "GET") {
+        const cacheKey = generateCacheKey(method, url, 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,
+        method,
+        data,
+      });
+  
+      try {
+        const fetchOptions: RequestInit = {
+          method,
+          headers,
+          credentials: this.credentials,
+        };
+  
+        if (data && method !== "GET") {
+          fetchOptions.body = JSON.stringify(data);
+          console.log(`📤 ${method} Body:`, data);
+        }
+  
+        console.log(`🌐 ${method} ${url}`, fetchOptions);
+  
+        const response = await fetch(url, fetchOptions);
+  
+        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;
+        }
+  
+        const responseData = await parseResponse<T>(response);
+  
+        if (useCache && method === "GET") {
+          const cacheKey = generateCacheKey(method, url, 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,
+          method,
+          response: responseData,
+        });
+  
+        return responseData;
+      } catch (error) {
+        this.eventEmitter.emit("requestError", {
+          url,
+          method,
+          error,
+        });
+  
+        if (error instanceof ApiError) {
+          throw error;
+        }
+  
+        throw new ApiError((error as Error).message || "Network error", 0, {
+          originalError: error,
+        });
+      }
+    }*/
     async request(method, endpoint, data, params, options = {}) {
         const url = buildUrl(this.baseUrl, endpoint, params);
-        const base = buildHeaders(this.token, {
-            "X-Organization": this.organization,
-            ...(options.headers || {}),
-        });
-        const headers = new Headers(base);
-        const legacyPattern = /(^|\/)legacy(\/|$)/i;
-        const isLegacyEndpoint = legacyPattern.test(endpoint);
-        const isLegacyLogin = /(^|\/)legacy\/login$/i.test(endpoint);
+        // ✅ Detecta si es legacy
+        const isLegacyEndpoint = endpoint.includes("/legacy/");
+        const isLegacyLogin = endpoint.endsWith("/legacy/login");
+        // ✅ Elige el token correcto según el endpoint
+        let token = null;
         if (isLegacyEndpoint && !isLegacyLogin) {
-            const legacyToken = (typeof window !== "undefined" && window.__LEGACY_TOKEN__) ||
+            // Usa token legacy para endpoints legacy
+            token =
                 (typeof sessionStorage !== "undefined" &&
                     sessionStorage.getItem("legacy_token")) ||
-                null;
-            if (legacyToken) {
-                headers.set("Authorization", `Bearer ${legacyToken}`);
-            }
+                    (typeof window !== "undefined" && window.__LEGACY_TOKEN__) ||
+                    null;
+        }
+        else if (!isLegacyEndpoint) {
+            // Usa token nuevo para endpoints modernos
+            token =
+                (typeof sessionStorage !== "undefined" &&
+                    sessionStorage.getItem("auth_token")) ||
+                    (typeof window !== "undefined" && window.__AUTH_TOKEN__) ||
+                    null;
         }
-        if (!isLegacyEndpoint && !this.token) {
-            headers.delete("Authorization");
+        // ✅ Construye headers con el token correcto
+        const base = buildHeaders(token, {
+            "X-Organization": this.organization,
+            ...(options.headers || {}),
+        });
+        const headers = new Headers(base);
+        // ✅ Log para debug
+        if (this.debug) {
+            console.log("🔍 Request:", {
+                endpoint,
+                isLegacy: isLegacyEndpoint,
+                hasToken: !!token,
+                tokenType: isLegacyEndpoint ? "legacy" : "new",
+            });
         }
         const useCache = this.cacheEnabled && options.useCache !== false;
         if (useCache && method === "GET") {
@@ -101,9 +242,8 @@ export class ApiClient {
             };
             if (data && method !== "GET") {
                 fetchOptions.body = JSON.stringify(data);
-                console.log(`📤 ${method} Body:`, data);
             }
-            console.log(`🌐 ${method} ${url}`, fetchOptions);
+            console.log(`🌐 ${method} ${url}`);
             const response = await fetch(url, fetchOptions);
             if (!response.ok) {
                 let errorData;
@@ -120,7 +260,7 @@ export class ApiClient {
                         message: errorData.message || "Authentication required",
                     });
                 }
-                return errorData;
+                throw new ApiError(errorData.message || response.statusText, response.status, errorData);
             }
             const responseData = await parseResponse(response);
             if (useCache && method === "GET") {
@@ -139,6 +279,7 @@ export class ApiClient {
             return responseData;
         }
         catch (error) {
+            console.error(`💥 Request failed:`, { method, url, error });
             this.eventEmitter.emit("requestError", {
                 url,
                 method,

package/dist/modules/v1/auth/auth-api.js

@@ -2,9 +2,55 @@ export class AuthApi {
     constructor(apiClient) {
         this.apiClient = apiClient;
     }
+    /*async login(
+      credentials: LoginCredentials,
+      mode: LoginMode = "new"
+    ): Promise<{ ok: boolean }> {
+      const path = mode === "legacy" ? "/legacy/login" : "/auth/login";
+  
+      const response = await fetch(`${this.apiClient["baseUrl"]}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Organization": this.apiClient["organization"] || "default-org",
+        },
+        credentials: "include",
+        body: JSON.stringify({
+          email: credentials.email,
+          password: credentials.password,
+        }),
+      });
+  
+      if (!response.ok) {
+        if (response.status === 401) throw new Error("Invalid credentials");
+        throw new Error(`Login failed: ${response.status}`);
+      }
+  
+      const data: any = await response.json().catch(() => null);
+  
+      // ✅ Si es legacy, guarda Bearer token para siguientes llamadas legacy
+      if (mode === "legacy") {
+        const legacyToken = data?.dataResult?.token || data?.token;
+  
+        if (legacyToken) {
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.setItem("legacy_token", legacyToken);
+          }
+          if (typeof window !== "undefined") {
+            (window as any).__LEGACY_TOKEN__ = legacyToken;
+          }
+        }
+      }
+  
+      // ✅ Nuevo: cookie HttpOnly, no guardes token en memoria del SDK
+      this.apiClient.setToken(null);
+  
+      return { ok: true };
+    }*/
     async login(credentials, mode = "new") {
         var _a;
         const path = mode === "legacy" ? "/legacy/login" : "/auth/login";
+        console.log(`🔐 Login attempt (${mode}):`, credentials.email);
         const response = await fetch(`${this.apiClient["baseUrl"]}${path}`, {
             method: "POST",
             headers: {
@@ -23,8 +69,8 @@ export class AuthApi {
             throw new Error(`Login failed: ${response.status}`);
         }
         const data = await response.json().catch(() => null);
-        // ✅ Si es legacy, guarda Bearer token para siguientes llamadas legacy
         if (mode === "legacy") {
+            // ✅ Token LEGACY (del sistema viejo)
             const legacyToken = ((_a = data === null || data === void 0 ? void 0 : data.dataResult) === null || _a === void 0 ? void 0 : _a.token) || (data === null || data === void 0 ? void 0 : data.token);
             if (legacyToken) {
                 if (typeof sessionStorage !== "undefined") {
@@ -33,9 +79,28 @@ export class AuthApi {
                 if (typeof window !== "undefined") {
                     window.__LEGACY_TOKEN__ = legacyToken;
                 }
+                console.log("✅ Legacy token saved");
+            }
+            else {
+                console.warn("⚠️ No legacy token received");
+            }
+        }
+        else {
+            // ✅ Token NUEVO (del sistema moderno)
+            const newToken = data === null || data === void 0 ? void 0 : data.token;
+            if (newToken) {
+                if (typeof sessionStorage !== "undefined") {
+                    sessionStorage.setItem("auth_token", newToken);
+                }
+                if (typeof window !== "undefined") {
+                    window.__AUTH_TOKEN__ = newToken;
+                }
+                console.log("✅ Auth token saved");
+            }
+            else {
+                console.warn("⚠️ No auth token received");
             }
         }
-        // ✅ Nuevo: cookie HttpOnly, no guardes token en memoria del SDK
         this.apiClient.setToken(null);
         return { ok: true };
     }
@@ -45,18 +110,39 @@ export class AuthApi {
             this.apiClient.setToken(response.token);
         return response;
     }
+    /*async logout(): Promise<void> {
+      try {
+        await this.apiClient.post<void>("/auth/logout");
+      } finally {
+        // limpia token nuevo
+        this.apiClient.setToken(null);
+  
+        // limpia legacy token
+        if (typeof sessionStorage !== "undefined") {
+          sessionStorage.removeItem("legacy_token");
+        }
+        if (typeof window !== "undefined") {
+          delete (window as any).__LEGACY_TOKEN__;
+        }
+      }
+    }*/
     async logout() {
         try {
             await this.apiClient.post("/auth/logout");
+            console.log("✅ Logout successful");
+        }
+        catch (error) {
+            console.error("❌ Logout error:", error);
         }
         finally {
-            // limpia token nuevo
+            // ✅ Limpia AMBOS tokens (nuevo y legacy)
             this.apiClient.setToken(null);
-            // limpia legacy token
             if (typeof sessionStorage !== "undefined") {
+                sessionStorage.removeItem("auth_token"); // ✅ Agrega esto
                 sessionStorage.removeItem("legacy_token");
             }
             if (typeof window !== "undefined") {
+                delete window.__AUTH_TOKEN__; // ✅ Agrega esto
                 delete window.__LEGACY_TOKEN__;
             }
         }

package/package.json

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

package/src/config/config.ts

@@ -10,7 +10,7 @@ function normalizeUrl(url: string) {
 //}
 
 export const DEFAULT_CONFIG: Partial<SdkConfig> = {
-  baseUrl: "https://zero-api-qa.onrender.com/api/v1", //resolveDefaultBaseUrl(), 
+  baseUrl: "https://zero-api-production.up.railway.app/ZeroApiQA/api/v1", //resolveDefaultBaseUrl(), 
   organization: "default-org",
   cache: { enabled: true, ttl: 60000 },
   debug: true,

package/src/core/api-client.ts

@@ -122,7 +122,7 @@ export class ApiClient {
     }
   }
 
-  private async request<T>(
+  /*private async request<T>(
     method: string,
     endpoint: string,
     data?: any,
@@ -242,6 +242,151 @@ export class ApiClient {
         throw error;
       }
 
+      throw new ApiError((error as Error).message || "Network error", 0, {
+        originalError: error,
+      });
+    }
+  }*/
+
+  private async request<T>(
+    method: string,
+    endpoint: string,
+    data?: any,
+    params?: Record<string, any>,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    const url = buildUrl(this.baseUrl, endpoint, params);
+
+    // ✅ Detecta si es legacy
+    const isLegacyEndpoint = endpoint.includes("/legacy/");
+    const isLegacyLogin = endpoint.endsWith("/legacy/login");
+
+    // ✅ Elige el token correcto según el endpoint
+    let token: string | null = null;
+
+    if (isLegacyEndpoint && !isLegacyLogin) {
+      // Usa token legacy para endpoints legacy
+      token =
+        (typeof sessionStorage !== "undefined" &&
+          sessionStorage.getItem("legacy_token")) ||
+        (typeof window !== "undefined" && (window as any).__LEGACY_TOKEN__) ||
+        null;
+    } else if (!isLegacyEndpoint) {
+      // Usa token nuevo para endpoints modernos
+      token =
+        (typeof sessionStorage !== "undefined" &&
+          sessionStorage.getItem("auth_token")) ||
+        (typeof window !== "undefined" && (window as any).__AUTH_TOKEN__) ||
+        null;
+    }
+
+    // ✅ Construye headers con el token correcto
+    const base: HeadersInit = buildHeaders(token, {
+      "X-Organization": this.organization,
+      ...(options.headers || {}),
+    });
+
+    const headers = new Headers(base);
+
+    // ✅ Log para debug
+    if (this.debug) {
+      console.log("🔍 Request:", {
+        endpoint,
+        isLegacy: isLegacyEndpoint,
+        hasToken: !!token,
+        tokenType: isLegacyEndpoint ? "legacy" : "new",
+      });
+    }
+
+    const useCache = this.cacheEnabled && options.useCache !== false;
+    if (useCache && method === "GET") {
+      const cacheKey = generateCacheKey(method, url, 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,
+      method,
+      data,
+    });
+
+    try {
+      const fetchOptions: RequestInit = {
+        method,
+        headers,
+        credentials: this.credentials,
+      };
+
+      if (data && method !== "GET") {
+        fetchOptions.body = JSON.stringify(data);
+      }
+
+      console.log(`🌐 ${method} ${url}`);
+
+      const response = await fetch(url, fetchOptions);
+
+      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",
+          });
+        }
+
+        throw new ApiError(
+          errorData.message || response.statusText,
+          response.status,
+          errorData
+        );
+      }
+
+      const responseData = await parseResponse<T>(response);
+
+      if (useCache && method === "GET") {
+        const cacheKey = generateCacheKey(method, url, 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,
+        method,
+        response: responseData,
+      });
+
+      return responseData;
+    } catch (error) {
+      console.error(`💥 Request failed:`, { method, url, error });
+
+      this.eventEmitter.emit("requestError", {
+        url,
+        method,
+        error,
+      });
+
+      if (error instanceof ApiError) {
+        throw error;
+      }
+
       throw new ApiError((error as Error).message || "Network error", 0, {
         originalError: error,
       });

package/src/modules/v1/auth/auth-api.ts

@@ -10,7 +10,7 @@ export class AuthApi {
     this.apiClient = apiClient;
   }
 
-  async login(
+  /*async login(
     credentials: LoginCredentials,
     mode: LoginMode = "new"
   ): Promise<{ ok: boolean }> {
@@ -53,6 +53,71 @@ export class AuthApi {
     // ✅ Nuevo: cookie HttpOnly, no guardes token en memoria del SDK
     this.apiClient.setToken(null);
 
+    return { ok: true };
+  }*/
+
+  async login(
+    credentials: LoginCredentials,
+    mode: LoginMode = "new"
+  ): Promise<{ ok: boolean }> {
+    const path = mode === "legacy" ? "/legacy/login" : "/auth/login";
+
+    console.log(`🔐 Login attempt (${mode}):`, credentials.email);
+
+    const response = await fetch(`${this.apiClient["baseUrl"]}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Organization": this.apiClient["organization"] || "default-org",
+      },
+      credentials: "include",
+      body: JSON.stringify({
+        email: credentials.email,
+        password: credentials.password,
+      }),
+    });
+
+    if (!response.ok) {
+      if (response.status === 401) throw new Error("Invalid credentials");
+      throw new Error(`Login failed: ${response.status}`);
+    }
+
+    const data: any = await response.json().catch(() => null);
+
+    if (mode === "legacy") {
+      // ✅ Token LEGACY (del sistema viejo)
+      const legacyToken = data?.dataResult?.token || data?.token;
+
+      if (legacyToken) {
+        if (typeof sessionStorage !== "undefined") {
+          sessionStorage.setItem("legacy_token", legacyToken);
+        }
+        if (typeof window !== "undefined") {
+          (window as any).__LEGACY_TOKEN__ = legacyToken;
+        }
+        console.log("✅ Legacy token saved");
+      } else {
+        console.warn("⚠️ No legacy token received");
+      }
+    } else {
+      // ✅ Token NUEVO (del sistema moderno)
+      const newToken = data?.token;
+
+      if (newToken) {
+        if (typeof sessionStorage !== "undefined") {
+          sessionStorage.setItem("auth_token", newToken);
+        }
+        if (typeof window !== "undefined") {
+          (window as any).__AUTH_TOKEN__ = newToken;
+        }
+        console.log("✅ Auth token saved");
+      } else {
+        console.warn("⚠️ No auth token received");
+      }
+    }
+
+    this.apiClient.setToken(null);
+
     return { ok: true };
   }
 
@@ -66,7 +131,7 @@ export class AuthApi {
     return response;
   }
 
-  async logout(): Promise<void> {
+  /*async logout(): Promise<void> {
     try {
       await this.apiClient.post<void>("/auth/logout");
     } finally {
@@ -81,6 +146,28 @@ export class AuthApi {
         delete (window as any).__LEGACY_TOKEN__;
       }
     }
+  }*/
+
+  async logout(): Promise<void> {
+    try {
+      await this.apiClient.post<void>("/auth/logout");
+      console.log("✅ Logout successful");
+    } catch (error) {
+      console.error("❌ Logout error:", error);
+    } finally {
+      // ✅ Limpia AMBOS tokens (nuevo y legacy)
+      this.apiClient.setToken(null);
+
+      if (typeof sessionStorage !== "undefined") {
+        sessionStorage.removeItem("auth_token"); // ✅ Agrega esto
+        sessionStorage.removeItem("legacy_token");
+      }
+
+      if (typeof window !== "undefined") {
+        delete (window as any).__AUTH_TOKEN__; // ✅ Agrega esto
+        delete (window as any).__LEGACY_TOKEN__;
+      }
+    }
   }
 
   //isAuthenticated(): boolean {
@@ -89,7 +176,7 @@ export class AuthApi {
   //    (typeof sessionStorage !== "undefined" &&
   //      !!sessionStorage.getItem("legacy_token")) ||
   //    (typeof window !== "undefined" && !!(window as any).__LEGACY_TOKEN__);
-//
+  //
   //  return hasToken || hasLegacy;
   //}