@zerosls/clm-sdk 1.0.0

package/src/utils/http.ts

@@ -0,0 +1,77 @@
+// import { RequestOptions } from "../types/common";
+
+// Construye URL con parámetros query
+export function buildUrl(
+  baseUrl: string,
+  endpoint: string,
+  params?: Record<string, any>
+): string {
+  const url = new URL(`${baseUrl}${endpoint}`);
+
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+  }
+
+  return url.toString();
+}
+
+// Construye cabeceras HTTP
+export function buildHeaders(
+  token?: string | null,
+  customHeaders?: Record<string, string>
+): Headers {
+  const headers = new Headers({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    ...customHeaders,
+  });
+
+  if (token && !headers.get("Authorization")) {
+    headers.append("Authorization", `Bearer ${token}`);
+  }
+
+  return headers;
+}
+
+// Genera una clave de caché única para cada petición
+export function generateCacheKey(
+  method: string,
+  url: string,
+  data?: any
+): string {
+  const dataString = data ? JSON.stringify(data) : "";
+  return `${method}:${url}:${dataString}`;
+}
+
+// Parse respuesta JSON con manejo de errores
+export async function parseResponse<T>(response: Response): Promise<T> {
+  const responseText = await response.text();
+  try {
+    // Si no hay contenido, devolver objeto vacío
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    // Intentar parsear como JSON
+    const data = JSON.parse(responseText);
+    return data as T;
+  } catch (error) {
+    return responseText as T;
+  }
+}
+
+export function buildQueryParams(params: object | null): string {
+  if (!params) return "";
+  const queryParams = Object.entries(params)
+    .filter((line) => Boolean(line[1]))
+    .map(
+      ([key, value]) =>
+        `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+    );
+  if (queryParams.length === 0) return "";
+  return "?" + queryParams.join("&");
+}

package/tests/integration/legacy/auth-areas.test.ts

@@ -0,0 +1,115 @@
+// tests/integration/auth-areas.test.ts
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA, AREAS_TEST_DATA } from '../../utils/test-utils';
+
+describe('Integración Auth + Areas', () => {
+  let sdk: ClmSdk;
+  
+  beforeEach(() => {
+    sdk = new ClmSdk({
+      baseUrl: 'http://216.250.117.119/ZeroServicesQA/api/v1',
+      organization: 'default-org'
+    });
+  });
+  
+  it('debe autenticar y luego obtener áreas', async () => {
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/catalog/areas',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AREAS_TEST_DATA.areasList
+        }
+      }
+    ]);
+    
+    const token = await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    expect(token).toBe(AUTH_TEST_DATA.loginToken);
+    
+    const areasResponse = await sdk.areas.getAreas();
+    
+    expect(areasResponse.dataResult).toBeDefined();
+    expect(areasResponse.statusResponse.success).toBe(true);
+  });
+  
+  it('debe realizar el flujo CRUD completo', async () => {
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/catalog/areas',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AREAS_TEST_DATA.areasList
+        }
+      },
+      {
+        url: '/catalog/areas',
+        method: 'POST',
+        response: {
+          status: 200,
+          data: AREAS_TEST_DATA.createAreaResponse
+        }
+      },
+      {
+        url: '/catalog/areas',
+        method: 'PATCH',
+        response: {
+          status: 200,
+          data: AREAS_TEST_DATA.updateAreaResponse
+        }
+      },
+      {
+        url: '/catalog/areas',
+        method: 'DELETE',
+        response: {
+          status: 200,
+          data: AREAS_TEST_DATA.deleteAreaResponse
+        }
+      }
+    ]);
+    
+    // 1. Login
+    await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    // 2. Listar áreas
+    const areas = await sdk.areas.getAreas();
+    expect(areas.dataResult.length).toBeGreaterThan(0);
+    
+    // 3. Crear área
+    const created = await sdk.areas.createArea(AREAS_TEST_DATA.newAreaRequest);
+    expect(created.statusResponse.success).toBe(true);
+    
+    // 4. Actualizar área
+    const updated = await sdk.areas.updateArea(AREAS_TEST_DATA.updateAreaRequest);
+    expect(updated.statusResponse.success).toBe(true);
+    
+    // 5. Eliminar área
+    const deleted = await sdk.areas.deleteArea({ id: 26 });
+    expect(deleted.statusResponse.success).toBe(true);
+  });
+});

package/tests/integration/legacy/auth-classification-types.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA, CLASSIFICATION_TYPES_TEST_DATA } from '../../utils/test-utils';
+
+describe('Integración Auth + ClassificationTypes', () => {
+  let sdk: ClmSdk;
+  
+  beforeEach(() => {
+    sdk = new ClmSdk({
+      baseUrl: 'http://216.250.117.119/ZeroServicesQA/api/v1',
+      organization: 'default-org'
+    });
+  });
+  
+  it('debe realizar el flujo CRUD completo', async () => {
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/catalog/clasificationtype',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: CLASSIFICATION_TYPES_TEST_DATA.classificationTypesList
+        }
+      },
+      {
+        url: '/catalog/clasificationtype',
+        method: 'POST',
+        response: {
+          status: 200,
+          data: CLASSIFICATION_TYPES_TEST_DATA.createClassificationTypeResponse
+        }
+      },
+      {
+        url: '/catalog/clasificationtype',
+        method: 'PUT',
+        response: {
+          status: 200,
+          data: CLASSIFICATION_TYPES_TEST_DATA.updateClassificationTypeResponse
+        }
+      },
+      {
+        url: '/catalog/clasificationtype',
+        method: 'DELETE',
+        response: {
+          status: 200,
+          data: CLASSIFICATION_TYPES_TEST_DATA.deleteClassificationTypeResponse
+        }
+      }
+    ]);
+    
+    await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    const list = await sdk.classificationTypes.getClassificationTypes();
+    expect(list.dataResult.length).toBeGreaterThan(0);
+    
+    const created = await sdk.classificationTypes.createClassificationType(
+      CLASSIFICATION_TYPES_TEST_DATA.newClassificationTypeRequest
+    );
+    expect(created.statusResponse.success).toBe(true);
+    
+    const updated = await sdk.classificationTypes.updateClassificationType(
+      CLASSIFICATION_TYPES_TEST_DATA.updateClassificationTypeRequest
+    );
+    expect(updated.statusResponse.success).toBe(true);
+    
+    const deleted = await sdk.classificationTypes.deleteClassificationType({ id: 20 });
+    expect(deleted.statusResponse.success).toBe(true);
+  });
+});

package/tests/integration/v1/auth-logs.test.ts

@@ -0,0 +1,145 @@
+// tests/integration/v1/auth-logs.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA, LOGS_TEST_DATA } from '../../utils/test-utils';
+
+describe('Integración Auth + Logs', () => {
+  let sdk: ClmSdk;
+  
+  beforeEach(() => {
+    sdk = new ClmSdk({
+      baseUrl: 'https://dev-api.zeroclm.io',
+      organization: 'default-org'
+    });
+  });
+  
+  it('debe autenticar y luego obtener logs', async () => {
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/logs',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: LOGS_TEST_DATA.logsList
+        }
+      }
+    ]);
+    
+    const token = await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    expect(token).toBe(AUTH_TEST_DATA.loginToken);
+    expect(sdk.auth.isAuthenticated()).toBe(true);
+    
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+    const loginHeaders = (global.fetch as any).mock.calls[0][1].headers;
+    expect(loginHeaders.get('Authorization')).toMatch(/^Basic /);
+    
+    const logsResponse = await sdk.logs.findLogs({});
+    
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+    const logsHeaders = (global.fetch as any).mock.calls[1][1].headers;
+    expect(logsHeaders.get('Authorization')).toBe(`Bearer ${token}`);
+    
+    expect(logsResponse).toEqual(LOGS_TEST_DATA.logsList);
+    expect(logsResponse.results.length).toBe(2);
+  });
+  
+  it('debe manejar el flujo completo con parámetros de consulta', async () => {
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/logs',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: LOGS_TEST_DATA.logsFiltered
+        }
+      }
+    ]);
+    
+    await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    const logsResponse = await sdk.logs.findLogs({
+      level: 'info',
+      page: 1,
+      limit: 1
+    });
+    
+    const calledUrl = (global.fetch as any).mock.calls[1][0];
+    expect(calledUrl).toContain('level=info');
+    expect(calledUrl).toContain('page=1');
+    expect(calledUrl).toContain('limit=1');
+    
+    expect(logsResponse.results[0].level).toBe('info');
+    expect(logsResponse.pagination.limit).toBe(1);
+  });
+  
+  it('debe mantener la sesión después de autenticar', async () => {
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/logs',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: LOGS_TEST_DATA.logsList
+        }
+      }
+    ]);
+    
+    await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    await sdk.logs.findLogs({});
+    
+    vi.resetAllMocks();
+    setupFetchMock([
+      {
+        url: '/logs',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: LOGS_TEST_DATA.logsList
+        }
+      }
+    ]);
+    
+    await sdk.logs.findLogs({ page: 2 });
+    
+    const headers = (global.fetch as any).mock.calls[0][1].headers;
+    expect(headers.get('Authorization')).toBe(`Bearer ${AUTH_TEST_DATA.loginToken}`);
+    
+    const calledUrl = (global.fetch as any).mock.calls[0][0];
+    expect(calledUrl).toContain('page=2');
+  });
+});

package/tests/integration/v1/auth-users.test.ts

@@ -0,0 +1,189 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA, USERS_TEST_DATA } from '../../utils/test-utils';
+
+describe('Integración Auth + Users', () => {
+  let sdk: ClmSdk;
+  
+  beforeEach(() => {
+    // Inicializar SDK sin token (lo obtendremos al hacer login)
+    sdk = new ClmSdk({
+      baseUrl: 'https://dev-api.zeroclm.io',
+      organization: 'default-org'
+    });
+  });
+  
+  it('debe autenticar y luego obtener usuarios', async () => {
+    // 1. Configurar mock para login
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      // 2. Configurar mock para obtener usuarios (se usará después del login)
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: USERS_TEST_DATA.usersList
+        }
+      }
+    ]);
+    
+    // 3. Hacer login primero
+    const token = await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    // Verificar que el login funcionó
+    expect(token).toBe(AUTH_TEST_DATA.loginToken);
+    expect(sdk.auth.isAuthenticated()).toBe(true);
+    
+    // Verificar que se hizo la petición de login con Basic Auth
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+    const loginHeaders = (global.fetch as any).mock.calls[0][1].headers;
+    expect(loginHeaders.get('Authorization')).toMatch(/^Basic /);
+    
+    // 4. Ahora obtener usuarios (con el token ya establecido)
+    const usersResponse = await sdk.users.getAll();
+    
+    // Verificar que se hizo la petición de usuarios con el token Bearer
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+    const usersHeaders = (global.fetch as any).mock.calls[1][1].headers;
+    expect(usersHeaders.get('Authorization')).toBe(`Bearer ${token}`);
+    
+    // Verificar la respuesta de usuarios
+    expect(usersResponse).toEqual(USERS_TEST_DATA.usersList);
+    expect(usersResponse.data.length).toBe(1);
+  });
+  
+  it('debe manejar el flujo completo con parámetros de consulta', async () => {
+    // Configurar mocks para ambas peticiones
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: {
+            data: [
+              {
+                id: 'filtered-user-id',
+                email: 'ivan@zeroclm.com',
+                full_name: 'Iván Test',
+                role_id: 1,
+                is_deleted: false,
+                deleted_at: null,
+                is_active: true,
+                created_at: '2025-05-01T13:48:57.411Z',
+                updated_at: '2025-05-01T13:48:57.411Z',
+                phone: null,
+                area: null,
+                area_id: null,
+                organization_id: 1
+              }
+            ],
+            meta: {
+              total: 1,
+              page: 1,
+              limit: 10,
+              pages: 1
+            }
+          }
+        }
+      }
+    ]);
+    
+    // 1. Hacer login
+    await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Passsssss8080'
+    });
+    
+    // 2. Obtener usuarios con filtros
+    const usersResponse = await sdk.users.getAll({
+      email: 'ivan@zeroclm.com',
+      page: 1,
+      limit: 10
+    });
+    
+    // Verificar que la URL contiene los parámetros de consulta
+    const calledUrl = (global.fetch as any).mock.calls[1][0];
+    expect(calledUrl).toContain('email=ivan%40zeroclm.com');
+    expect(calledUrl).toContain('page=1');
+    expect(calledUrl).toContain('limit=10');
+    
+    // Verificar la respuesta filtrada
+    expect(usersResponse.data[0].email).toBe('ivan@zeroclm.com');
+    expect(usersResponse.meta.limit).toBe(10);
+  });
+  
+  it('debe mantener la sesión después de autenticar', async () => {
+    // Configurar mocks
+    setupFetchMock([
+      {
+        url: '/auth/login',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: AUTH_TEST_DATA.loginToken
+        }
+      },
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: USERS_TEST_DATA.usersList
+        }
+      }
+    ]);
+    
+    // 1. Hacer login
+    await sdk.auth.login({
+      email: 'ivan@zeroclm.com',
+      password: 'Pass#Dev2024'
+    });
+    
+    // 2. Hacer varias peticiones sin volver a autenticar
+    await sdk.users.getAll();
+    
+    // Resetear el mock para la siguiente petición
+    vi.resetAllMocks();
+    setupFetchMock([
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: USERS_TEST_DATA.usersList
+        }
+      }
+    ]);
+    
+    // 3. Hacer otra petición para verificar que el token sigue siendo válido
+    await sdk.users.getAll({ page: 2 });
+    
+    // Verificar que el token se mantiene en las peticiones
+    const headers = (global.fetch as any).mock.calls[0][1].headers;
+    expect(headers.get('Authorization')).toBe(`Bearer ${AUTH_TEST_DATA.loginToken}`);
+    
+    // La URL debería contener el nuevo parámetro de página
+    const calledUrl = (global.fetch as any).mock.calls[0][0];
+    expect(calledUrl).toContain('page=2');
+  });
+});