@zerosls/clm-sdk 1.0.0

package/src/core/api-client.ts

@@ -0,0 +1,272 @@
+import { SdkConfig, SdkEventType, SdkEvents } from "../types/sdk";
+import { PaginatedResponse, RequestOptions } from "../types/common";
+import { EventEmitter } from "./event-emitter";
+import { ApiError } from "./api-error";
+import { Cache } from "../utils/cache";
+import {
+  buildUrl,
+  buildHeaders,
+  generateCacheKey,
+  parseResponse,
+} from "../utils/http";
+
+export class ApiClient {
+  private baseUrl: string;
+  private organization: string;
+  private token: string | null = null;
+  private eventEmitter: EventEmitter;
+  private cache: Cache;
+  private debug: boolean;
+  private cacheEnabled: boolean;
+
+  constructor(config: SdkConfig, eventEmitter: EventEmitter) {
+    this.baseUrl = config.baseUrl;
+    this.organization = config.organization;
+    this.token = config.token || null;
+    this.eventEmitter = eventEmitter;
+    this.cacheEnabled = config.cache?.enabled !== false;
+    this.cache = new Cache(config.cache?.ttl);
+    this.debug = config.debug || false;
+  }
+
+  // Métodos para gestión del token
+  public setToken(token: string | null): void {
+    this.token = token;
+    this.eventEmitter.emit("tokenChanged", token);
+  }
+
+  public getToken(): string | null {
+    return this.token;
+  }
+
+  public setOrganization(organization: string): void {
+    this.organization = organization;
+  }
+
+  // Método GET
+  public async get<T>(
+    endpoint: string,
+    params?: Record<string, any>,
+    options?: RequestOptions
+  ): Promise<T> {
+    return this.request<T>("GET", endpoint, undefined, params, options);
+  }
+
+  // Método POST
+  public async post<T>(
+    endpoint: string,
+    data?: any,
+    options?: RequestOptions
+  ): Promise<T> {
+    return this.request<T>("POST", endpoint, data, undefined, options);
+  }
+
+  // Método PATCH
+  public async patch<T>(
+    endpoint: string,
+    data?: any,
+    options?: RequestOptions
+  ): Promise<T> {
+    const result = await this.request<T>(
+      "PATCH",
+      endpoint,
+      data,
+      undefined,
+      options
+    );
+    this.invalidateCache(endpoint);
+    return result;
+  }
+
+  // Método PUT
+  public async put<T>(
+    endpoint: string,
+    data?: any,
+    options?: RequestOptions
+  ): Promise<T> {
+    const result = await this.request<T>(
+      "PUT",
+      endpoint,
+      data,
+      undefined,
+      options
+    );
+    this.invalidateCache(endpoint);
+    return result;
+  }
+
+  // ✅ Método DELETE - CORREGIDO
+  public async delete<T>(
+    endpoint: string,
+    data?: any,  // ✅ Cambiar params por data para enviarlo en el body
+    options?: RequestOptions
+  ): Promise<T> {
+    console.log("🗑️ DELETE request:", { endpoint, data });
+    
+    const result = await this.request<T>(
+      "DELETE",
+      endpoint,
+      data,        // ✅ Enviar como body (data)
+      undefined,   // ✅ params es undefined
+      options
+    );
+    
+    this.invalidateCache(endpoint);
+    console.log("✅ DELETE response:", result);
+    return result;
+  }
+
+  /**
+   * Invalida la caché relacionada con un endpoint específico
+   */
+  private invalidateCache(endpoint: string): void {
+    if (this.cacheEnabled) {
+      const basePath = endpoint.split("/").slice(0, 2).join("/");
+      this.cache.clearByPrefix(`GET:${this.baseUrl}${basePath}`);
+
+      if (this.debug) {
+        console.log(`[SDK-Cache] Invalidated cache for: ${basePath}`);
+      }
+    }
+  }
+
+  // Método central para todas las peticiones HTTP
+  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);
+
+    // =====================================================
+    // 1. Construir headers base
+    // =====================================================
+    const base: HeadersInit = buildHeaders(this.token, {
+      "X-Organization": this.organization,
+      ...(options.headers || {}),
+    });
+
+    const headers = new Headers(base);
+
+    if (!this.token) {
+      headers.delete("Authorization");
+    }
+
+    // =====================================================
+    // 2. Si el endpoint es /legacy/** → agregar Bearer legacy
+    // =====================================================
+    if (endpoint.startsWith("/legacy/")) {
+      const legacyToken =
+        (window as any).__LEGACY_TOKEN__ ||
+        sessionStorage.getItem("legacy_token") ||
+        null;
+
+      if (legacyToken) {
+        headers.set("Authorization", `Bearer ${legacyToken}`);
+      }
+    }
+
+    // =====================================================
+    // 3. Cache
+    // =====================================================
+    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 {
+      // =====================================================
+      // 4. Preparar options de fetch
+      // =====================================================
+      const fetchOptions: RequestInit = {
+        method,
+        headers,
+        credentials: "include",
+      };
+
+      // ✅ CRÍTICO: Agregar body para POST, PUT, PATCH y DELETE
+      if (data && method !== "GET") {
+        fetchOptions.body = JSON.stringify(data);
+        console.log(`📤 ${method} Body:`, data);
+      }
+
+      // =====================================================
+      // 5. Hacer la llamada real
+      // =====================================================
+      console.log(`🌐 ${method} ${url}`, fetchOptions);
+      const response = await fetch(url, fetchOptions);
+
+      // Manejo de errores HTTP
+      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;
+      }
+
+      // Parsear respuesta exitosa
+      const responseData = await parseResponse<T>(response);
+
+      // Guardar en caché si aplica
+      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,
+      });
+    }
+  }
+}

package/src/core/api-error.ts

@@ -0,0 +1,54 @@
+import { ErrorType } from '../types/sdk';
+
+export class ApiError extends Error {
+  public readonly isApiError = true;
+  public readonly statusCode: number;
+  public readonly type: ErrorType;
+  public readonly details?: any;
+
+  constructor(message: string, statusCode: number, details?: any) {
+    super(message);
+    this.name = 'ApiError';
+    this.statusCode = statusCode;
+    this.details = details;
+    this.type = this.determineErrorType(statusCode);
+    
+    // Para que instanceof funcione correctamente con clases extendidas
+    Object.setPrototypeOf(this, ApiError.prototype);
+  }
+
+  // Determina el tipo de error según el código HTTP
+  private determineErrorType(statusCode: number): ErrorType {
+    if (statusCode === 401) return ErrorType.AUTHENTICATION;
+    if (statusCode === 403) return ErrorType.AUTHORIZATION;
+    if (statusCode === 404) return ErrorType.NOT_FOUND;
+    if (statusCode >= 400 && statusCode < 500) return ErrorType.VALIDATION;
+    if (statusCode >= 500) return ErrorType.SERVER;
+    return ErrorType.UNKNOWN;
+  }
+
+  // Propiedades útiles para verificación de tipo de error
+  get isNetworkError(): boolean {
+    return this.type === ErrorType.NETWORK;
+  }
+
+  get isAuthenticationError(): boolean {
+    return this.type === ErrorType.AUTHENTICATION;
+  }
+
+  get isAuthorizationError(): boolean {
+    return this.type === ErrorType.AUTHORIZATION;
+  }
+
+  get isNotFoundError(): boolean {
+    return this.type === ErrorType.NOT_FOUND;
+  }
+
+  get isValidationError(): boolean {
+    return this.type === ErrorType.VALIDATION;
+  }
+
+  get isServerError(): boolean {
+    return this.type === ErrorType.SERVER;
+  }
+}

package/src/core/event-emitter.ts

@@ -0,0 +1,43 @@
+import { SdkEventType, SdkEvents } from '../types/sdk';
+
+type Listener<T> = (data: T) => void;
+
+interface Subscription {
+  unsubscribe: () => void;
+}
+
+export class EventEmitter {
+  private listeners: Map<string, Array<Listener<any>>> = new Map();
+
+  // Suscribirse a un evento
+  public on<K extends SdkEventType>(event: K, listener: Listener<SdkEvents[K]>): Subscription {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+
+    const eventListeners = this.listeners.get(event)!;
+    eventListeners.push(listener);
+
+    // Devolver objeto para cancelar suscripción
+    return {
+      unsubscribe: () => {
+        const index = eventListeners.indexOf(listener);
+        if (index !== -1) {
+          eventListeners.splice(index, 1);
+        }
+      }
+    };
+  }
+
+  // Emitir un evento con datos
+  public emit<K extends SdkEventType>(event: K, data: SdkEvents[K]): void {
+    if (!this.listeners.has(event)) {
+      return;
+    }
+
+    const eventListeners = this.listeners.get(event)!;
+    for (const listener of eventListeners) {
+      listener(data);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,89 @@
+import { SdkConfig } from "./types/sdk";
+import { mergeWithDefaultConfig } from "./config/config";
+import { ApiClient } from "./core/api-client";
+import { EventEmitter } from "./core/event-emitter";
+import { Cache } from "./utils/cache";
+import { SdkEventType } from "./types/sdk";
+
+// v1
+import { AuthApi } from "./modules/v1/auth/auth-api";
+import { UsersApi } from "./modules/v1/users/users-api";
+import { MainApi } from "./modules/v1/main/main-api";
+import { NotificationsApi } from "./modules/v1/notifications/notification-api";
+//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";
+
+/**
+ * Main SDK for consuming CLM API
+ */
+export class ClmSdk {
+  private apiClient: ApiClient;
+  private eventEmitter: EventEmitter;
+  private cacheInstance: Cache;
+
+  // Public modules v1
+  public auth: AuthApi;
+  public users: UsersApi;
+  public main: MainApi;
+  public notifications: NotificationsApi;
+  //public logs: LogsApi;
+
+  // Public modules legacy
+  public areas: AreasApi;
+  public classificationTypes: ClassificationTypesApi;
+
+  constructor(config: Partial<SdkConfig>) {
+    this.eventEmitter = new EventEmitter();
+
+    // Apply default configuration
+    const fullConfig = mergeWithDefaultConfig(config);
+
+    // Initialize core utilities
+    this.cacheInstance = new Cache(fullConfig.cache?.ttl);
+    this.apiClient = new ApiClient(fullConfig, this.eventEmitter);
+
+    // Initialize modules v1
+    this.auth = new AuthApi(this.apiClient);
+    this.users = new UsersApi(this.apiClient);
+    this.main = new MainApi(this.apiClient);
+    this.notifications = new NotificationsApi(this.apiClient);
+    //this.logs = new LogsApi(this.apiClient);
+
+    // Initialize legacy modules
+    this.areas = new AreasApi(this.apiClient);
+    this.classificationTypes = new ClassificationTypesApi(this.apiClient);
+  }
+
+  /**
+   * Access to events system
+   */
+  public on(
+    event: SdkEventType,
+    listener: any
+  ): ReturnType<typeof this.eventEmitter.on> {
+    return this.eventEmitter.on(event, listener);
+  }
+
+  /**
+   * Access to cache functions
+   */
+  public cache = {
+    clear: () => this.cacheInstance.clear(),
+    clearByPrefix: (prefix: string) => this.cacheInstance.clearByPrefix(prefix),
+  };
+}
+ 
+export * from "./types/common";
+export * from "./types/sdk";
+
+// Export v1 types
+export * from "./modules/v1/auth/types";
+export * from "./modules/v1/users/types";
+export * from "./modules/v1/notifications/types";
+//export * from "./modules/v1/logs/types";
+// Export legacy types
+export * from "./modules/legacy/areas/types";
+export * from "./modules/legacy/classificationtypes/types";

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

@@ -0,0 +1,73 @@
+import { ApiClient } from "../../../core/api-client";
+import {
+  CreateAreaRequest,
+  UpdateAreaRequest,
+  DeleteAreaRequest,
+  AreaResponse,
+  AreasResponse
+} from "./types";
+
+export class AreasApi {
+  private apiClient: ApiClient;
+  private readonly basePath = "/legacy/catalog/areas"; //Siempre debe empezar con /legacy/ por que lo usa en el Gateway del API para que todas las request de API LEGACY y API V1 salgan de http://localhost:3001 URL del API que fusiona el API LEGACY y el API V1 y que el puerto lo toma por defecto del manifest
+
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient;
+  }
+
+  /**
+   * GET - Obtener todas las áreas
+   */
+  async getAreas(): Promise<AreasResponse> {
+    return await this.apiClient.get<AreasResponse>(
+      this.basePath,
+      undefined,
+      { useCache: false }
+    );
+  }
+
+  /**
+   * POST - Crear una nueva área
+   */
+  async createArea(data: CreateAreaRequest): Promise<AreaResponse> {
+    return await this.apiClient.post<AreaResponse>(
+      this.basePath,
+      data
+    );
+  }
+  
+  /**
+   * PATCH - Actualizar datos de un área existente
+   */
+  async updateArea(data: UpdateAreaRequest): Promise<AreaResponse> {
+    return await this.apiClient.patch<AreaResponse>(
+      this.basePath,
+      data
+    );
+  }
+
+  /**
+   * DELETE - Eliminar un área existente
+   */
+  async deleteArea(data: DeleteAreaRequest): Promise<AreaResponse> {
+    return await this.apiClient.delete<AreaResponse>(
+      this.basePath,
+      data
+    );
+  }
+
+  /**
+   * Helper: Generar datos de auditoría actuales
+   */
+  generateAuditData(userId: string, userName: string) {
+    const now = new Date().toISOString();
+    return {
+      createdBy: userId,
+      createdByName: userName,
+      createdOn: now,
+      lastModBy: userId,
+      lastModByName: userName,
+      lastModOn: now
+    };
+  }
+}

package/src/modules/legacy/areas/types.ts

@@ -0,0 +1,49 @@
+// Entidad base con metadatos de auditoría
+export interface AreaBase {
+  createdBy: string;
+  createdByName: string;
+  createdOn: string; // ISO DateTime
+  lastModBy: string;
+  lastModByName: string;
+  lastModOn: string; // ISO DateTime
+  name: string;
+  description: string;
+}
+
+// Entidad completa (con ID)
+export interface Area extends AreaBase {
+  id: number;
+}
+
+// Request para crear área
+export interface CreateAreaRequest extends AreaBase {}
+
+// Request para actualizar área
+export interface UpdateAreaRequest extends AreaBase {
+  id: number;
+}
+
+// Request para eliminar área
+export interface DeleteAreaRequest {
+  id: number;
+}
+
+// Respuesta del GET (lista de áreas)
+export interface AreasResponse {
+  dataResult: Area[];
+  statusResponse: {
+    code: number;
+    success: boolean;
+    message: string;
+  };
+}
+
+// Respuesta genérica para POST/PUT/DELETE
+export interface AreaResponse {
+  dataResult?: Area;
+  statusResponse: {
+    code: number;
+    success: boolean;
+    message: string;
+  };
+}

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

@@ -0,0 +1,80 @@
+import { ApiClient } from "../../../core/api-client";
+import {
+  CreateClassificationTypeRequest,
+  UpdateClassificationTypeRequest,
+  DeleteClassificationTypeRequest,
+  ClassificationTypeResponse,
+  ClassificationTypesResponse
+} from "./types";
+
+export class ClassificationTypesApi {
+  private apiClient: ApiClient;
+  private readonly basePath = "/legacy/catalog/clasificationtype";
+
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient;
+  }
+
+  /**
+   * GET - Obtener todos los tipos de clasificación
+   */
+  async getClassificationTypes(): Promise<ClassificationTypesResponse> {
+    return await this.apiClient.get<ClassificationTypesResponse>(
+      this.basePath,
+      undefined,
+      { useCache: false }
+    );
+  }
+
+  /**
+   * POST - Crear un nuevo tipo de clasificación
+   */
+  async createClassificationType(
+    data: CreateClassificationTypeRequest
+  ): Promise<ClassificationTypeResponse> {
+    const response = await this.apiClient.post<ClassificationTypeResponse>(
+      `${this.basePath}/create`,
+      data
+    );
+    return response;
+  }
+
+  /**
+   * PUT - Actualizar un tipo de clasificación existente
+   */
+  async updateClassificationType(
+    data: UpdateClassificationTypeRequest
+  ): Promise<ClassificationTypeResponse> {
+    return await this.apiClient.put<ClassificationTypeResponse>(
+      `${this.basePath}/update`,  // Puede necesitar /update
+      data
+    );
+  }
+
+  /**
+   * DELETE - Eliminar un tipo de clasificación
+   */
+  async deleteClassificationType(
+    data: DeleteClassificationTypeRequest
+  ): Promise<ClassificationTypeResponse> {
+    return await this.apiClient.delete<ClassificationTypeResponse>(
+      `${this.basePath}/delete`,
+      data
+    );
+  }
+
+  /**
+   * Helper: Generar datos de auditoría actuales
+   */
+  generateAuditData(userId: string, userName: string) {
+    const now = new Date().toISOString();
+    return {
+      createdBy: userId,
+      createdByName: userName,
+      createdOn: now,
+      lastModBy: userId,
+      lastModByName: userName,
+      lastModOn: now
+    };
+  }
+}