@zerosls/clm-sdk 1.0.0

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

@@ -0,0 +1,52 @@
+export interface ClassificationTypeBase {
+  createdBy: string;
+  createdByName: string;
+  createdOn: string;
+  lastModBy: string;
+  lastModByName: string;
+  lastModOn: string;
+  name: string;
+  description: string | null;
+}
+
+// Entidad completa (con ID)
+export interface ClassificationType {
+  id: number;
+  name: string;
+  description: string | null;
+}
+
+// Request para crear tipo de clasificación
+export interface CreateClassificationTypeRequest extends ClassificationTypeBase {}
+
+// Request para actualizar tipo de clasificación
+export interface UpdateClassificationTypeRequest {
+  id: number;
+  name: string;
+  description: string | null;
+}
+
+// Request para eliminar tipo de clasificación
+export interface DeleteClassificationTypeRequest {
+  id: number;
+}
+
+// Respuesta del GET (lista)
+export interface ClassificationTypesResponse {
+  dataResult: ClassificationType[];
+  statusResponse: {
+    code: number;
+    success: boolean;
+    message: string;
+  };
+}
+
+// Respuesta genérica para POST/PUT/DELETE
+export interface ClassificationTypeResponse {
+  dataResult?: ClassificationType;
+  statusResponse: {
+    code: number;
+    success: boolean;
+    message: string;
+  };
+}

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

@@ -0,0 +1,75 @@
+// auth-api.ts
+import { ApiClient } from "../../../core/api-client"; 
+import { LoginCredentials, LoginResponse, RefreshTokenRequest } from "./types";
+
+export class AuthApi {
+  private apiClient: ApiClient;
+
+  constructor(apiClient: ApiClient) {
+    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');
+        }
+        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 };
+
+    } catch (error) {
+      console.error('❌ SDK Login error:', error);
+      throw error;
+    }
+  }
+
+  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);
+    return response;
+  }
+
+  async logout(): Promise<void> {
+    try {
+      await this.apiClient.post<void>("/auth/logout");
+    } catch (error) {
+      console.error("Error during logout:", error);
+    } finally {
+      this.apiClient.setToken(null);
+    }
+  }
+
+  isAuthenticated(): boolean {
+    return this.apiClient.getToken() !== null;
+  }
+
+  setToken(token: string | null): void {
+    this.apiClient.setToken(token);
+  }
+}

package/src/modules/v1/auth/types.ts

@@ -0,0 +1,20 @@
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+export interface LoginResponse {
+  token: string;
+  refreshToken?: string;
+  expiresIn: number;
+  user: {
+    id: string;
+    name: string;
+    email: string;
+    role: string;
+  };
+}
+
+export interface RefreshTokenRequest {
+  refreshToken: string;
+}

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

@@ -0,0 +1,20 @@
+import { ApiClient } from "../../../core/api-client";
+import { StatusResponse } from "./types";
+
+export class MainApi {
+  private apiClient: ApiClient;
+
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient;
+  }
+
+  /**
+   * Get api status
+   *
+   * @returns true or false
+   */
+  async status(): Promise<Boolean> {
+    const response = await this.apiClient.get<StatusResponse>("/status");
+    return response.message === "Ok" || false;
+  }
+}

package/src/modules/v1/main/types.ts

@@ -0,0 +1,3 @@
+export interface StatusResponse {
+  message: String;
+}

package/src/modules/v1/notifications/notification-api.ts

@@ -0,0 +1,55 @@
+import { ApiClient } from "../../../core/api-client";
+import { buildQueryParams } from "../../../utils/http";
+import {
+  GetTasksQueryParams,
+  TasksResponse,
+  NotFoundTaskResponse,
+  StartTaskResponse,
+  RemoveTaskResponse,
+} from "./types";
+
+export class NotificationsApi {
+  private apiClient: ApiClient;
+
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient;
+  }
+
+  async getWithParams(query: GetTasksQueryParams): Promise<TasksResponse> {
+    const queryParams = buildQueryParams(query);
+    const tasks = await this.apiClient.get<TasksResponse>(
+      "/tasks" + queryParams,
+      undefined,
+      { useCache: false }
+    );
+    return tasks;
+  }
+
+  /**
+   * Inicia un proceso de notificacion especificando su Id
+   */
+  async startJob(
+    taskId: string
+  ): Promise<NotFoundTaskResponse | StartTaskResponse> {
+    const processResponse = await this.apiClient.post<
+      NotFoundTaskResponse | StartTaskResponse
+    >(`/tasks/${taskId}/process`, undefined);
+    return processResponse;
+  }
+
+  /**
+   * Elimina tareas especificando un limite y
+   * una cantidad de tiempo
+   */
+  async deletedJobsByHours(
+    limit: number,
+    hours: number,
+    status: string
+  ): Promise<RemoveTaskResponse> {
+    const processResponse = await this.apiClient.delete<RemoveTaskResponse>(
+      `/tasks?hours=${hours}&limit=${limit}&status=${status}`,
+      undefined
+    );
+    return processResponse;
+  }
+}

package/src/modules/v1/notifications/types.ts

@@ -0,0 +1,58 @@
+export interface Task {
+  id: string;
+  name: string;
+  description: string;
+  end_date: string;
+  number_period: string;
+  select_period: string;
+  actity_time: string;
+  notification_date: string;
+  userManager: string;
+  status: string;
+  created_by: string;
+  created_at: string;
+  updated_by: string;
+  updated_at: string;
+  start_date: string;
+  notification_type: string;
+  notification_type_id: string;
+  company_id: number;
+  metadata_request: {
+    id: string;
+    name: string;
+  };
+  request_id: number | null;
+}
+
+export interface TasksResponse {
+  data: Task[];
+}
+
+export interface GetTasksQueryParams {
+  status?: string;
+  notification_type?: string;
+  from_date?: string;
+  to_date?: string;
+  upcoming?: string;
+  page?: string;
+  limit?: string;
+}
+
+export interface StartTaskResponse {
+  success: boolean;
+  message: string;
+  jobId: string;
+  taskId: string;
+  taskName: string;
+  status: string;
+}
+
+export interface NotFoundTaskResponse {
+  statusCode: number;
+  error: string;
+  message: string;
+}
+
+export interface RemoveTaskResponse {
+  count: number;
+}

package/src/modules/v1/users/types.ts

@@ -0,0 +1,83 @@
+// Base User interface
+export interface User {
+    id: string;
+    email: string;
+    full_name: string;
+    role_id: number;
+    is_deleted: boolean;
+    deleted_at: string | null;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    phone: string | null;
+    area: string | null;
+    area_id: number | null;
+    organization_id: number;
+  }
+  
+  // Response when getting users with pagination
+  export interface UsersResponse {
+    data: User[];
+    meta: {
+      total: number;
+      page: number;
+      limit: number;
+      pages: number;
+    };
+  }
+  
+  // Query parameters for listing users
+  export interface UsersQuery {
+    page?: number;
+    limit?: number;
+    email?: string;
+    full_name?: string;
+    phone?: string;
+    area?: string;
+    role_id?: number;
+    area_id?: number;
+    showDeleted?: boolean;
+  }
+  
+  // Data for creating a new user
+  export interface UserCreate {
+    id?: string;
+    email: string;
+    password?: string;
+    full_name: string;
+    phone?: string;
+    area?: string;
+    area_id?: number;
+    role_id?: number;
+    organization_id?: number;
+  }
+  
+  // Data for updating a user
+  export interface UserUpdate {
+    password?: string;
+    email?: string;
+    full_name?: string;
+    phone?: string;
+    area?: string;
+    area_id?: number;
+    role_id?: number;
+  }
+  
+  // Standard API response structure
+  export interface ApiResponse<T> {
+    statusCode: number;
+    message: string;
+    data?: T;
+  }
+  
+  // Type for created user response
+  export type UserCreatedResponse = ApiResponse<User>;
+  
+  // Type for updated user response
+  export type UserUpdatedResponse = ApiResponse<User>;
+  
+  // Type for deleted user response
+  export type UserDeletedResponse = ApiResponse<undefined>;
+  
+  // Type for deactivated user response
+  export type UserDeactivatedResponse = ApiResponse<User>;

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

@@ -0,0 +1,148 @@
+import { ApiClient } from '../../../core/api-client';
+import { ApiError } from '../../../core/api-error';
+import { RequestOptions } from '../../../types/common';
+import { 
+  User, 
+  UsersResponse, 
+  UsersQuery, 
+  UserCreate, 
+  UserUpdate, 
+  UserCreatedResponse, 
+  UserUpdatedResponse, 
+  UserDeletedResponse,
+  UserDeactivatedResponse
+} from './types';
+
+export class UsersApi {
+  private apiClient: ApiClient;
+  private readonly CACHE_PREFIX = 'GET:/users';
+  
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient;
+  }
+  
+  /**
+   * Get all users with optional filters and pagination
+   * 
+   * @param query - Query parameters for filtering and pagination
+   * @param options - Request options
+   * @returns Paginated list of users
+   */
+  async getAll(query?: UsersQuery, options?: RequestOptions): Promise<UsersResponse> {
+    const allUsers = this.apiClient.get<UsersResponse>('/users', query, options);
+    console.log(allUsers);
+    return allUsers;
+  }
+  
+  /**
+   * Get a specific user by ID
+   * 
+   * @param id - User ID (UUID)
+   * @param showDeleted - Whether to include deleted users
+   * @param options - Request options
+   * @returns User data
+   */
+  async getById(id: string, showDeleted: boolean = false, options?: RequestOptions): Promise<User> {
+    return this.apiClient.get<User>(
+      `/users/${id}`, 
+      { showDeleted },
+      options
+    );
+  }
+  
+  /**
+   * Create a new user
+   * 
+   * @param userData - User data for creation
+   * @param options - Request options
+   * @returns Created user response
+   */
+  async create(userData: UserCreate, options?: RequestOptions): Promise<UserCreatedResponse> {
+    return this.apiClient.post<UserCreatedResponse>('/users', userData, options);
+  }
+  
+  /**
+   * Update an existing user
+   * 
+   * @param id - User ID (UUID)
+   * @param userData - Data to update
+   * @param options - Request options
+   * @returns Updated user response
+   */
+  async update(id: string, userData: UserUpdate, options?: RequestOptions): Promise<UserUpdatedResponse> {
+    return this.apiClient.patch<UserUpdatedResponse>(`/users/${id}`, userData, options);
+  }
+  
+  /**
+   * Permanently delete a user
+   * 
+   * @param id - User ID (UUID)
+   * @param options - Request options
+   * @returns Delete confirmation response
+   */
+  async delete(id: string, options?: RequestOptions): Promise<UserDeletedResponse> {
+    return this.apiClient.delete<UserDeletedResponse>(`/users/${id}`, undefined, options);
+  }
+  
+  /**
+   * Deactivate a user (soft delete)
+   * 
+   * @param id - User ID (UUID)
+   * @param options - Request options
+   * @returns Deactivated user response
+   */
+  async deactivate(id: string, options?: RequestOptions): Promise<UserDeactivatedResponse> {
+    return this.apiClient.patch<UserDeactivatedResponse>(
+      `/users/${id}/desactivate`, 
+      undefined, 
+      options
+    );
+  }
+  
+  /**
+   * Search users by email or name
+   * Helper method that uses getAll with specific filters
+   * 
+   * @param searchTerm - Term to search for in email or name
+   * @param options - Request options
+   * @returns Matching users
+   */
+  async search(searchTerm: string, options?: RequestOptions): Promise<UsersResponse> {
+    // Determine if searchTerm looks like an email
+    const isEmail = searchTerm.includes('@');
+    
+    const query: UsersQuery = isEmail 
+      ? { email: searchTerm } 
+      : { full_name: searchTerm };
+    
+    return this.getAll(query, options);
+  }
+  
+  /**
+   * Get users by role ID
+   * Helper method that uses getAll with role filter
+   * 
+   * @param roleId - Role ID to filter by
+   * @param options - Request options
+   * @returns Users with the specified role
+   */
+  async getByRole(roleId: number, options?: RequestOptions): Promise<UsersResponse> {
+    return this.getAll({ role_id: roleId }, options);
+  }
+  
+  /**
+   * Clear cache for users
+   * Private method used internally after modifications
+   */
+  private clearCache(): void {
+    try {
+      // @ts-ignore - This works because the SDK has a cache.clearByPrefix method
+      if (this.apiClient['cache'] && typeof this.apiClient['cache'].clearByPrefix === 'function') {
+        // @ts-ignore
+        this.apiClient['cache'].clearByPrefix(this.CACHE_PREFIX);
+      }
+    } catch (error) {
+      console.error('Error clearing cache:', error);
+    }
+  }
+}

package/src/types/common.ts

@@ -0,0 +1,22 @@
+export interface PaginatedResponse<T> {
+    results: T[];
+    pagination: {
+      page: number;
+      limit: number;
+      totalPages: number;
+      totalItems: number;
+    };
+  }
+  
+  // Opciones para peticiones HTTP
+  export interface RequestOptions {
+    useCache?: boolean;
+    cacheTime?: number;
+    headers?: Record<string, string>;
+  }
+  
+  // Parámetros de paginación
+  export interface PaginationParams {
+    page?: number;
+    limit?: number;
+  }

package/src/types/sdk.ts

@@ -0,0 +1,38 @@
+export interface SdkConfig {
+  baseUrl: string;
+  organization: string;
+  token?: string | null;
+  cache?: {
+    enabled?: boolean;
+    ttl?: number;
+  };
+  debug?: boolean;
+}
+
+// Tipos de eventos que puede emitir el SDK
+export type SdkEventType =
+  | "tokenChanged"
+  | "beforeRequest"
+  | "afterRequest"
+  | "requestError"
+  | "authError";
+
+// Información de evento por tipo
+export interface SdkEvents {
+  tokenChanged: string | null;
+  beforeRequest: { url: string; method: string; data?: any };
+  afterRequest: { url: string; method: string; response: any };
+  requestError: { url: string; method: string; error: any };
+  authError: { statusCode: number; message: string };
+}
+
+// Tipos de errores HTTP
+export enum ErrorType {
+  NETWORK = "NETWORK",
+  AUTHENTICATION = "AUTHENTICATION",
+  AUTHORIZATION = "AUTHORIZATION",
+  NOT_FOUND = "NOT_FOUND",
+  VALIDATION = "VALIDATION",
+  SERVER = "SERVER",
+  UNKNOWN = "UNKNOWN",
+}

package/src/utils/cache.ts

@@ -0,0 +1,58 @@
+interface CacheItem<T> {
+    data: T;
+    timestamp: number;
+    expiry: number;
+  }
+  
+  export class Cache {
+    private store: Map<string, CacheItem<any>> = new Map();
+    private defaultTtl: number;
+  
+    constructor(defaultTtl: number = 60000) { // 1 minuto por defecto
+      this.defaultTtl = defaultTtl;
+    }
+  
+    // Guardar dato en caché
+    set<T>(key: string, data: T, ttl?: number): void {
+      const expiry = ttl || this.defaultTtl;
+      this.store.set(key, {
+        data,
+        timestamp: Date.now(),
+        expiry
+      });
+    }
+  
+    // Obtener dato desde caché
+    get<T>(key: string): T | null {
+      const item = this.store.get(key);
+      
+      // Si no existe o está expirado, devolver null
+      if (!item || Date.now() > item.timestamp + item.expiry) {
+        if (item) {
+          this.store.delete(key); // Limpiar item expirado
+        }
+        return null;
+      }
+      
+      return item.data as T;
+    }
+  
+    // Eliminar dato específico
+    delete(key: string): void {
+      this.store.delete(key);
+    }
+  
+    // Limpiar caché por prefijo
+    clearByPrefix(prefix: string): void {
+      for (const key of this.store.keys()) {
+        if (key.startsWith(prefix)) {
+          this.store.delete(key);
+        }
+      }
+    }
+  
+    // Limpiar toda la caché
+    clear(): void {
+      this.store.clear();
+    }
+  }