@zerosls/clm-sdk 1.1.9 → 2.0.0

package/src/core/api-client.ts

@@ -1,4 +1,3 @@
-// core/api-client.ts
 import { SdkConfig, SdkEventType, SdkEvents } from "../types/sdk";
 import { PaginatedResponse, RequestOptions } from "../types/common";
 import { EventEmitter } from "./event-emitter";
@@ -13,7 +12,6 @@ import {
 
 export class ApiClient {
   private baseUrl: string;
-  private fallbackBaseUrl: string; // ✅ URL de respaldo
   private organization: string;
   private token: string | null = null;
   private eventEmitter: EventEmitter;
@@ -24,8 +22,6 @@ 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.organization = config.organization;
     this.token = config.token || null;
     this.eventEmitter = eventEmitter;
@@ -126,185 +122,6 @@ 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,
-      });
-    }
-  }*/
   private async request<T>(
     method: string,
     endpoint: string,
@@ -312,49 +129,38 @@ export class ApiClient {
     params?: Record<string, any>,
     options: RequestOptions = {}
   ): Promise<T> {
-    const primaryUrl = buildUrl(this.baseUrl, endpoint, params);
+    const url = buildUrl(this.baseUrl, endpoint, params);
 
-    const baseHeaders: HeadersInit = buildHeaders(this.token, {
+    const base: HeadersInit = buildHeaders(this.token, {
       "X-Organization": this.organization,
       ...(options.headers || {}),
     });
 
-    // ✅ Función helper para debug de headers
-    const headersToObject = (headers: Headers): Record<string, string> => {
-      const obj: Record<string, string> = {};
-      headers.forEach((value, key) => {
-        obj[key] = value;
-      });
-      return obj;
-    };
+    const headers = new Headers(base);
 
-    const createHeaders = (): Headers => {
-      const headers = new Headers(baseHeaders);
+    const legacyPattern = /(^|\/)legacy(\/|$)/i;
+    const isLegacyEndpoint = legacyPattern.test(endpoint);
+    const isLegacyLogin = /(^|\/)legacy\/login$/i.test(endpoint);
 
+    if (isLegacyEndpoint && !isLegacyLogin) {
       const legacyToken =
-        (window as any).__LEGACY_TOKEN__ ||
-        sessionStorage.getItem("legacy_token") ||
+        (typeof window !== "undefined" && (window as any).__LEGACY_TOKEN__) ||
+        (typeof sessionStorage !== "undefined" &&
+          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);
       }
+    }
 
-      return headers;
-    };
+    if (!isLegacyEndpoint && !this.token) {
+      headers.delete("Authorization");
+    }
 
     const useCache = this.cacheEnabled && options.useCache !== false;
     if (useCache && method === "GET") {
-      const cacheKey = generateCacheKey(method, primaryUrl, data);
+      const cacheKey = generateCacheKey(method, url, data);
       const cachedData = this.cache.get<T>(cacheKey);
       if (cachedData) {
         if (this.debug) {
@@ -365,105 +171,25 @@ export class ApiClient {
     }
 
     this.eventEmitter.emit("beforeRequest", {
-      url: primaryUrl,
+      url,
       method,
       data,
     });
 
     try {
-      let body: string | undefined;
-      if (data && method !== "GET") {
-        body = JSON.stringify(data);
-        if (this.debug) {
-          console.log(`📤 ${method} Body:`, data);
-        }
-      }
-
-      // ✅ Primer intento
-      const headers1 = createHeaders();
-      const fetchOptions1: RequestInit = {
+      const fetchOptions: RequestInit = {
         method,
-        headers: headers1,
-        credentials: "include",
-        ...(body && { body }),
+        headers,
+        credentials: this.credentials,
       };
 
-      if (this.debug) {
-        console.log(`🌐 ${method} ${primaryUrl}`);
-        console.log("📋 Headers:", headersToObject(headers1)); // ✅ CORREGIDO
-      }
-
-      const response = await fetch(primaryUrl, fetchOptions1);
-
-      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
-        const headers2 = createHeaders();
-        const fetchOptions2: RequestInit = {
-          method,
-          headers: headers2,
-          credentials: "include",
-          ...(body && { body }),
-        };
-
-        if (this.debug) {
-          console.log("📋 Fallback Headers:", headersToObject(headers2)); // ✅ CORREGIDO
-        }
-
-        const fallbackResponse = await fetch(fallbackUrl, fetchOptions2);
-
-        if (fallbackResponse.status === 204) {
-          console.log(`✅ Fallback exitoso (204 No Content): ${endpoint}`);
-          return {} as T;
-        }
-
-        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;
-        }
-
-        const fallbackData = await parseResponse<T>(fallbackResponse);
-
-        console.log(`✅ Fallback exitoso: ${endpoint}`);
-
-        this.eventEmitter.emit("afterRequest", {
-          url: fallbackUrl,
-          method,
-          response: fallbackData,
-        });
-
-        return fallbackData;
+      if (data && method !== "GET") {
+        fetchOptions.body = JSON.stringify(data);
+        console.log(`📤 ${method} Body:`, data);
       }
 
-      if (response.status === 204) {
-        console.log(`✅ Request exitoso (204 No Content): ${endpoint}`);
-        return {} as T;
-      }
+      console.log(`🌐 ${method} ${url}`, fetchOptions);
+      const response = await fetch(url, fetchOptions);
 
       if (!response.ok) {
         let errorData;
@@ -488,7 +214,7 @@ export class ApiClient {
       const responseData = await parseResponse<T>(response);
 
       if (useCache && method === "GET") {
-        const cacheKey = generateCacheKey(method, primaryUrl, data);
+        const cacheKey = generateCacheKey(method, url, data);
         const cacheTime = options.cacheTime || undefined;
         this.cache.set(cacheKey, responseData, cacheTime);
 
@@ -498,7 +224,7 @@ export class ApiClient {
       }
 
       this.eventEmitter.emit("afterRequest", {
-        url: primaryUrl,
+        url,
         method,
         response: responseData,
       });
@@ -506,7 +232,7 @@ export class ApiClient {
       return responseData;
     } catch (error) {
       this.eventEmitter.emit("requestError", {
-        url: primaryUrl,
+        url,
         method,
         error,
       });

package/src/index.ts

@@ -15,14 +15,12 @@ import { LogsApi } from "./modules/v1/_logs/logs-api";
 // Legacy
 import { AreasApi } from "./modules/legacy/areas/areas-api";
 import { ClassificationTypesApi } from "./modules/legacy/classificationtypes/classificationtypes-api";
-import { LegacyApiClient } from "./core/legacy-api-client";
 
 /**
  * Main SDK for consuming CLM API
  */
 export class ClmSdk {
   private apiClient: ApiClient;
-  private legacyClient: LegacyApiClient;
   private eventEmitter: EventEmitter;
   private cacheInstance: Cache;
 
@@ -47,10 +45,6 @@ export class ClmSdk {
     this.cacheInstance = new Cache(fullConfig.cache?.ttl);
     this.apiClient = new ApiClient(fullConfig, this.eventEmitter);
 
-    this.legacyClient = new LegacyApiClient(
-      "http://216.250.117.119/ZeroServicesQA/api/v1"
-    );
-
     // Initialize modules v1
     this.auth = new AuthApi(this.apiClient);
     this.users = new UsersApi(this.apiClient);
@@ -63,13 +57,6 @@ export class ClmSdk {
     this.classificationTypes = new ClassificationTypesApi(this.apiClient);
   }
 
-  async legacyLogin(userName: string, password: string) {
-    return await this.legacyClient.login(userName, password);
-  }
-
-  legacyLogout(): void {
-    this.legacyClient.logout();
-  }
 
   /**
    * Access to events system
@@ -100,6 +87,5 @@ export * from "./modules/v1/notifications/types";
 export * from "./modules/v1/_logs/types";
 
 // Export legacy types
-export * from "./core/legacy-api-client";
 export * from "./modules/legacy/areas/types";
 export * from "./modules/legacy/classificationtypes/types";

package/src/modules/legacy/classificationtypes/classificationtypes-api.ts

@@ -10,7 +10,7 @@ import {
 
 export class ClassificationTypesApi {
   private apiClient: ApiClient;
-  private readonly basePath = "/catalog/clasificationtype";
+  private readonly basePath = "/legacy/catalog/clasificationtype";
 
   constructor(apiClient: ApiClient) {
     this.apiClient = apiClient;

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

@@ -1,7 +1,8 @@
-// auth-api.ts
-import { ApiClient } from "../../../core/api-client"; 
+import { ApiClient } from "../../../core/api-client";
 import { LoginCredentials, LoginResponse, RefreshTokenRequest } from "./types";
 
+type LoginMode = "new" | "legacy";
+
 export class AuthApi {
   private apiClient: ApiClient;
 
@@ -9,67 +10,90 @@ export class AuthApi {
     this.apiClient = apiClient;
   }
 
-  /**
-   * Login con POST JSON (evita el modal del navegador).
-   * El servidor setea cookie HttpOnly (zero_token).
-   */
-  async login(credentials: LoginCredentials): Promise<{ ok: boolean }> {
-    try {
-      const response = await fetch(`${this.apiClient['baseUrl']}/auth/login`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'X-Organization': this.apiClient['organization'] || 'default-org'
-        },
-        credentials: 'include', // ← Importante para cookies
-        body: JSON.stringify({
-          email: credentials.email,
-          password: credentials.password
-        })
-      });
-
-      if (!response.ok) {
-        if (response.status === 401) {
-          throw new Error('Invalid credentials');
+  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;
         }
-        throw new Error(`Login failed: ${response.status}`);
       }
+    }
 
-      const data = await response.json();
-      
-      // No guardar token en memoria, solo usar cookie
-      this.apiClient.setToken(null);
-      
-      console.log('✅ Login exitoso, cookie establecida');
-      return { ok: true };
+    // ✅ Nuevo: cookie HttpOnly, no guardes token en memoria del SDK
+    this.apiClient.setToken(null);
 
-    } catch (error) {
-      console.error('❌ SDK Login error:', error);
-      throw error;
-    }
+    return { ok: true };
   }
 
   async refreshToken(request?: RefreshTokenRequest): Promise<LoginResponse> {
-    const response = await this.apiClient.post<LoginResponse>("/auth/refresh", request);
-    if ((response as any)?.token) this.apiClient.setToken((response as any).token);
+    const response = await this.apiClient.post<LoginResponse>(
+      "/auth/refresh",
+      request
+    );
+    if ((response as any)?.token)
+      this.apiClient.setToken((response as any).token);
     return response;
   }
 
   async logout(): Promise<void> {
     try {
       await this.apiClient.post<void>("/auth/logout");
-    } catch (error) {
-      console.error("Error during logout:", error);
     } 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__;
+      }
     }
   }
 
   isAuthenticated(): boolean {
-    return this.apiClient.getToken() !== null;
+    const hasToken = this.apiClient.getToken() !== null;
+    const hasLegacy =
+      (typeof sessionStorage !== "undefined" &&
+        !!sessionStorage.getItem("legacy_token")) ||
+      (typeof window !== "undefined" && !!(window as any).__LEGACY_TOKEN__);
+
+    return hasToken || hasLegacy;
   }
 
   setToken(token: string | null): void {
     this.apiClient.setToken(token);
   }
-}
+}

package/src/types/sdk.ts

@@ -1,6 +1,5 @@
 export interface SdkConfig {
   baseUrl: string;
-  fallbackBaseUrl?: string;
   organization: string;
   token?: string | null;
   cache?: {

package/dist/core/legacy-api-client.d.ts

@@ -1,26 +0,0 @@
-export interface LegacyLoginRequest {
-    userName: string;
-    password: string;
-}
-export interface LegacyLoginResponse {
-    dataResult: {
-        token: string;
-        userType: string;
-        userId: string;
-        userName: string;
-        area: string;
-        id_Area: number;
-        id_Role: string;
-    };
-    statusResponse: {
-        code: number;
-        success: boolean;
-        message: string;
-    };
-}
-export declare class LegacyApiClient {
-    private baseUrl;
-    constructor(baseUrl: string);
-    login(userName: string, password: string): Promise<LegacyLoginResponse>;
-    logout(): void;
-}

package/dist/core/legacy-api-client.js

@@ -1,35 +0,0 @@
-export class LegacyApiClient {
-    constructor(baseUrl) {
-        this.baseUrl = baseUrl;
-    }
-    async login(userName, password) {
-        var _a, _b;
-        const url = `${this.baseUrl}/auth/login`;
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            credentials: 'include',
-            body: JSON.stringify({ userName, password }),
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({
-                statusResponse: {
-                    code: response.status,
-                    success: false,
-                    message: response.statusText
-                }
-            }));
-            throw new Error(((_a = errorData.statusResponse) === null || _a === void 0 ? void 0 : _a.message) || 'Legacy login failed');
-        }
-        const data = await response.json();
-        if ((_b = data.dataResult) === null || _b === void 0 ? void 0 : _b.token) {
-            sessionStorage.setItem('legacy_token', data.dataResult.token);
-            window.__LEGACY_TOKEN__ = data.dataResult.token;
-        }
-        return data;
-    }
-    logout() {
-        sessionStorage.removeItem('legacy_token');
-        delete window.__LEGACY_TOKEN__;
-    }
-}