apacuana-sdk-core 0.1.0

package/src/utils/helpers.js

@@ -0,0 +1,166 @@
+import * as pkijs from "pkijs";
+import * as asn1js from "asn1js";
+import { getCrypto } from "pkijs";
+import { STATUS_CERTIFICATE, VERIFICATION_STATUS } from "./constant";
+import { ApacuanaAPIError } from "../errors/index";
+
+const getCertificateStatus = (userData, certificateInDevice) => {
+  if (!userData) {
+    throw new Error("El parámetro userData es requerido.");
+  }
+  if (typeof certificateInDevice !== "boolean") {
+    throw new Error(
+      "El parámetro certificateInDevice es requerido y debe ser un valor booleano."
+    );
+  }
+
+  if (userData?.verificationstatus?.id !== VERIFICATION_STATUS.APPROVED)
+    return STATUS_CERTIFICATE.request;
+  if (
+    userData?.certificationId &&
+    !userData?.cangenerate &&
+    !userData?.requestscert?.pending &&
+    !certificateInDevice &&
+    userData?.certificatestatus !== STATUS_CERTIFICATE.revoque
+  )
+    return STATUS_CERTIFICATE.certificate_another_device;
+
+  if (userData?.requestscert?.pending && userData?.certificationId)
+    return STATUS_CERTIFICATE.request_revoque;
+  if (
+    !userData?.cangenerate &&
+    userData?.certificatestatus === STATUS_CERTIFICATE.revoque
+  )
+    return STATUS_CERTIFICATE.revoque;
+
+  if (!userData?.approvedUser) return STATUS_CERTIFICATE.request;
+  if (userData?.cangenerate) return STATUS_CERTIFICATE.generate;
+
+  if (userData?.certificationId) return STATUS_CERTIFICATE.current;
+
+  return STATUS_CERTIFICATE.revoque;
+};
+
+const generateKeyPair = async (
+  signAlg = "RSASSA-PKCS1-v1_5",
+  hashAlg = "SHA-256"
+) => {
+  try {
+    const crypto = getCrypto();
+    if (!crypto) {
+      throw new Error("API criptográfica no disponible a través de pkijs.");
+    }
+
+    const keyPair = await crypto.generateKey(
+      {
+        name: signAlg,
+        modulusLength: 2048,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash: { name: hashAlg },
+      },
+      true,
+      ["sign", "verify"]
+    );
+
+    return keyPair;
+  } catch (error) {
+    console.error("Error durante la generación del par de claves:", error);
+    throw new ApacuanaAPIError(
+      `Fallo en la generación del par de claves: ${error.message}`,
+      0,
+      "KEY_PAIR_GENERATION_ERROR"
+    );
+  }
+};
+
+const generateCSR = async (keyPair, userData, hashAlg = "SHA-256") => {
+  try {
+    const { publicKey, privateKey } = keyPair;
+
+    // 1. Validar los parámetros de entrada.
+    if (!keyPair || !publicKey || !privateKey) {
+      throw new Error(
+        "Par de claves no válido. Es necesario un CryptoKeyPair."
+      );
+    }
+    if (!userData || !userData.email) {
+      throw new Error(
+        "Datos de usuario incompletos. El correo electrónico es requerido."
+      );
+    }
+
+    const pkcs10 = new pkijs.CertificationRequest();
+    pkcs10.version = 0;
+
+    const subjectAttributes = [
+      {
+        type: "2.5.4.6", // OID para 'Country' (C)
+        value: new asn1js.PrintableString({ value: userData.country || "VE" }),
+      },
+      {
+        type: "2.5.4.3", // OID para 'Common Name' (CN)
+        value: new asn1js.Utf8String({ value: userData.commonName || "N/A" }),
+      },
+      {
+        type: "1.2.840.113549.1.9.1", // OID para 'E-mail' (E)
+        value: new asn1js.IA5String({ value: userData.email }),
+      },
+      // Puedes agregar más atributos aquí, como:
+      // {
+      //   type: '2.5.4.8', // OID para 'State or Province' (ST)
+      //   value: new asn1js.Utf8String({ value: userData.state || 'N/A' }),
+      // },
+      // {
+      //   type: '2.5.4.7', // OID para 'Locality' (L)
+      //   value: new asn1js.Utf8String({ value: userData.locality || 'N/A' }),
+      // },
+    ].filter((attr) => attr.value.value); // Filtra atributos sin valor.
+
+    // 3. Asignar los atributos al Subject.
+    subjectAttributes.forEach((attr) =>
+      pkcs10.subject.typesAndValues.push(new pkijs.AttributeTypeAndValue(attr))
+    );
+
+    // 4. Importar la clave pública y firmar la solicitud con la clave privada.
+    await pkcs10.subjectPublicKeyInfo.importKey(publicKey);
+    await pkcs10.sign(privateKey, hashAlg);
+
+    // 5. Codificar el CSR para el envío.
+    const csr = pkcs10.toSchema().toBER(false);
+
+    // 6. Retornar el CSR y el Subject.
+    return {
+      csr,
+      subject: pkcs10.subject,
+    };
+  } catch (error) {
+    // Manejo de errores centralizado.
+    console.error("Error durante la generación del CSR:", error);
+    throw new ApacuanaAPIError(
+      `Fallo en la generación del CSR: ${error.message}`,
+      0,
+      "CSR_GENERATION_ERROR"
+    );
+  }
+};
+
+// Función para convertir ArrayBuffer a Base64
+const arrayBufferToBase64 = (buffer) => {
+  const binary = String.fromCharCode.apply(null, new Uint8Array(buffer));
+  return window.btoa(binary);
+};
+
+export async function exportPrivateKey(key) {
+  const crypto = getCrypto();
+  const exported = await crypto.exportKey("pkcs8", key);
+  const exportablePrivateKey = new Uint8Array(exported);
+  return arrayBufferToBase64(exportablePrivateKey);
+}
+
+export const helpers = {
+  getCertificateStatus,
+  generateKeyPair,
+  generateCSR,
+  exportPrivateKey,
+  arrayBufferToBase64,
+};

package/src/utils/httpClient.js

@@ -0,0 +1,187 @@
+// src/utils/httpClient.js
+import axios from "axios";
+import { ApacuanaAPIError } from "../errors/index";
+import { getConfig } from "../config/index";
+
+let axiosInstance;
+
+/**
+ * Inicializa el cliente HTTP (Axios) para todas las peticiones del SDK.
+ * @throws {Error} Si la configuración es incompleta.
+ */
+export const initHttpClient = () => {
+  const config = getConfig();
+
+  if (
+    !config.apiUrl ||
+    !config.secretKey ||
+    !config.apiKey ||
+    !config.verificationId ||
+    !config.customerId
+  ) {
+    throw new Error(
+      "HttpClient: Configuración de inicialización incompleta. Llama a apacuana.init() primero."
+    );
+  }
+
+  axiosInstance = axios.create({
+    baseURL: config.apiUrl,
+    headers: {
+      "Content-Type": "application/json",
+      "APACUANA-API-Key": config.apiKey,
+      "APACUANA-SECRET-Key": config.secretKey,
+      // La cabecera Authorization se deja vacía al inicio.
+      // Se actualizará de forma dinámica con setAuthToken().
+    },
+    timeout: 30000,
+  });
+
+  // Configura los interceptores de Axios
+  axiosInstance.interceptors.response.use(
+    (response) => {
+      // Maneja errores lógicos de la API (si el backend devuelve status 2xx con { success: false })
+      if (response.data && response.data.success === false) {
+        throw new ApacuanaAPIError(
+          response.data.message ||
+            "Error lógico en la respuesta de la API (status 2xx)",
+          response.status,
+          response.data.code || "LOGICAL_API_ERROR"
+        );
+      }
+      return response;
+    },
+    (error) => {
+      // Maneja errores HTTP (status 4xx, 5xx) o errores de red
+      // eslint-disable-next-line no-console
+      console.error(
+        "[HTTP Client] Interceptor de error de Axios:",
+        error.response || error.message
+      );
+
+      if (error.response) {
+        const { status, data } = error.response;
+        throw new ApacuanaAPIError(
+          data.message || `Error en la API: ${status}`,
+          status,
+          data.code || "API_ERROR"
+        );
+      }
+      if (error.request) {
+        // La petición fue hecha, pero no se recibió respuesta (red caída, CORS, timeout)
+        throw new ApacuanaAPIError(
+          "Error de conexión a la red, timeout o CORS.",
+          0,
+          "NETWORK_ERROR"
+        );
+      } else {
+        // Algo más ocurrió al configurar la petición
+        throw new ApacuanaAPIError(
+          `Error desconocido en la petición: ${error.message}`,
+          0,
+          "UNKNOWN_REQUEST_ERROR"
+        );
+      }
+    }
+  );
+
+  // eslint-disable-next-line no-console
+  console.log(
+    "[HTTP Client] Cliente HTTP (Axios) REAL inicializado con URL base:",
+    config.apiUrl
+  );
+};
+
+/**
+ * Establece el token de autenticación Bearer para las peticiones subsiguientes.
+ * @param {string} token - El token de sesión del usuario.
+ * @throws {Error} Si el token es inválido o el cliente no está inicializado.
+ */
+export const setAuthToken = (token) => {
+  if (!axiosInstance) {
+    throw new Error(
+      "HttpClient no inicializado. Llama a apacuana.init() primero."
+    );
+  }
+  if (!token || typeof token !== "string") {
+    throw new Error("Token de sesión inválido.");
+  }
+
+  // Actualizamos la cabecera Authorization de la instancia de Axios.
+  axiosInstance.defaults.headers.common.Authorization = `Bearer ${token}`;
+  // eslint-disable-next-line no-console
+  console.log(
+    "[HTTP Client] Cabecera Authorization actualizada con nuevo token."
+  );
+};
+
+/**
+ * Envía una petición HTTP a un endpoint de la API.
+ * Inyecta automáticamente los parámetros de inicialización en el cuerpo de la petición.
+ * @param {string} path - La ruta del endpoint de la API.
+ * @param {object} [data={}] - Los datos para enviar en la petición.
+ * @param {string} [method='POST'] - El método HTTP.
+ * @returns {Promise<object>} Los datos de la respuesta del backend.
+ * @throws {ApacuanaAPIError} Si la petición falla.
+ */
+export const httpRequest = async (path, data = {}, method = "POST") => {
+  if (!axiosInstance) {
+    throw new Error(
+      "Apacuana SDK: Cliente HTTP no inicializado. " +
+        "Llama a apacuana.init() primero."
+    );
+  }
+
+  // Creamos el cuerpo de la petición fusionando los datos de la llamada
+  // con los parámetros de inicialización.
+  const dataToSend = {
+    ...data,
+  };
+
+  // eslint-disable-next-line no-console
+  console.log(
+    `[HTTP Client] Realizando petición ${method} a: ${axiosInstance.defaults.baseURL}${path}`
+  );
+  // eslint-disable-next-line no-console
+  console.log(
+    "[HTTP Client] Headers (via Axios config):",
+    axiosInstance.defaults.headers
+  );
+  // eslint-disable-next-line no-console
+  console.log("[HTTP Client] Datos enviados:", dataToSend);
+
+  try {
+    let response;
+    switch (method.toUpperCase()) {
+      case "GET":
+        response = await axiosInstance.get(path, { params: dataToSend });
+        break;
+      case "POST":
+        response = await axiosInstance.post(path, dataToSend);
+        break;
+      case "PUT":
+        response = await axiosInstance.put(path, dataToSend);
+        break;
+      case "DELETE":
+        response = await axiosInstance.delete(path, { data: dataToSend });
+        break;
+      default:
+        throw new ApacuanaAPIError(
+          `Método HTTP no soportado: ${method}`,
+          405,
+          "UNSUPPORTED_HTTP_METHOD"
+        );
+    }
+
+    // Si la promesa se resolvió, la respuesta es exitosa.
+    // El interceptor ya manejó los errores 4xx/5xx y los errores lógicos 2xx.
+    // eslint-disable-next-line no-console
+    console.log(`[HTTP Client] Respuesta exitosa de ${path}:`, response.data);
+    return response.data;
+  } catch (error) {
+    // Si la petición falla, el interceptor ya procesó el error.
+    // Simplemente relanzamos el error para que sea capturado por la función de API.
+    // eslint-disable-next-line no-console
+    console.error(`[HTTP Client] Fallo en la petición a ${path}:`, error);
+    throw error;
+  }
+};

package/tests/api/certs.test.js

@@ -0,0 +1,6 @@
+// tests/api/certs.test.js
+describe('Certificates API', () => {
+  test('placeholder test', () => {
+    expect(true).toBe(true);
+  });
+});

package/tests/api/revocations.test.js

@@ -0,0 +1,6 @@
+// tests/api/revocations.test.js
+describe('Revocations API', () => {
+  test('placeholder test', () => {
+    expect(true).toBe(true);
+  });
+});

package/tests/api/signatures.test.js

@@ -0,0 +1,6 @@
+// tests/api/signatures.test.js
+describe('Signatures API', () => {
+  test('placeholder test', () => {
+    expect(true).toBe(true);
+  });
+});

package/tests/api/users.test.js

@@ -0,0 +1,115 @@
+// tests/api/users.test.js
+import { httpRequest } from "../../src/utils/httpClient.js";
+import { getConfig } from "../../src/config/index.js";
+import { ApacuanaAPIError } from "../../src/errors/index.js";
+import getCustomer from "../../src/api/users.js";
+
+// Mockear las dependencias:
+jest.mock("../../src/utils/httpClient.js", () => ({
+  httpRequest: jest.fn(),
+}));
+
+jest.mock("../../src/config/index.js", () => ({
+  getConfig: jest.fn(),
+}));
+
+describe("getCustomer", () => {
+  const mockConfig = {
+    verificationId: "mock-verify-id",
+    customerId: "mock-customer-id",
+  };
+
+  beforeEach(() => {
+    httpRequest.mockClear();
+    getConfig.mockClear();
+    getConfig.mockReturnValue(mockConfig);
+    jest.spyOn(console, "log").mockImplementation(() => {});
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    console.log.mockRestore();
+    console.error.mockRestore();
+  });
+
+  test("debe llamar a httpRequest con los parámetros de la configuración y devolver un objeto con token y userData", async () => {
+    const mockResponse = {
+      success: true,
+      sessionid: "mock-session-id-12345",
+      entry: {
+        userId: "mock-user",
+        name: "John Doe",
+        email: "john@example.com",
+      },
+    };
+    httpRequest.mockResolvedValueOnce(mockResponse);
+
+    const result = await getCustomer();
+
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+    expect(httpRequest).toHaveBeenCalledWith(
+      "services/api/register/init",
+      {
+        verificationid: mockConfig.verificationId,
+        customerid: mockConfig.customerId,
+      },
+      "POST"
+    );
+
+    expect(result).toEqual({
+      token: "mock-session-id-12345",
+      userData: {
+        userId: "mock-user",
+        name: "John Doe",
+        email: "john@example.com",
+      },
+    });
+  });
+
+  test("debe lanzar un error si la configuración está incompleta", async () => {
+    getConfig.mockReturnValue({
+      verificationId: "mock-verify-id",
+      customerId: null,
+    });
+
+    await expect(getCustomer()).rejects.toThrow(
+      "El 'body' con 'userId' es un parámetro requerido para getCustomer."
+    );
+    expect(httpRequest).not.toHaveBeenCalled();
+  });
+
+  test("debe lanzar un ApacuanaAPIError si el backend no devuelve sessionid o entry", async () => {
+    httpRequest.mockResolvedValueOnce({
+      success: true,
+      message: "Error en el backend, no se pudo generar el token.",
+      entry: { userId: "mock-user" },
+    });
+
+    await expect(getCustomer()).rejects.toThrow(
+      "La respuesta de la API no contiene el usuario."
+    );
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+  });
+
+  test("debe relanzar el ApacuanaAPIError si la petición falla en el httpClient", async () => {
+    const apiError = new ApacuanaAPIError(
+      "Error de autenticación",
+      401,
+      "AUTH_ERROR"
+    );
+    httpRequest.mockRejectedValueOnce(apiError);
+
+    await expect(getCustomer()).rejects.toThrow(apiError);
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+  });
+
+  test("debe lanzar un ApacuanaAPIError si ocurre un error inesperado", async () => {
+    const genericError = new Error("Error de red o desconocido");
+    httpRequest.mockRejectedValueOnce(genericError);
+
+    await expect(getCustomer()).rejects.toThrow(
+      "Fallo inesperado al obtener el token: Error de red o desconocido"
+    );
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/index.test.js

@@ -0,0 +1,122 @@
+// tests/index.test.js
+import apacuana from "../src/index.js";
+import { setConfig, getConfig } from "../src/config/index.js";
+import { initHttpClient } from "../src/utils/httpClient.js";
+import getCustomer from "../src/api/users.js";
+
+// Mockear todas las dependencias del index.js
+jest.mock("../src/config/index.js", () => ({
+  setConfig: jest.fn(),
+  getConfig: jest.fn(),
+}));
+jest.mock("../src/utils/httpClient.js", () => ({
+  initHttpClient: jest.fn(),
+  setAuthToken: jest.fn(), // Agregar el mock de setAuthToken
+}));
+jest.mock("../src/api/users.js", () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+describe("Apacuana SDK Initialization (init)", () => {
+  const mockConfig = {
+    apiUrl: "http://test-api.com",
+    secretKey: "mock-secret",
+    apiKey: "mock-api-key",
+    verificationId: "mock-verify-id",
+    customerId: "mock-customer-id",
+  };
+
+  beforeEach(() => {
+    // Limpiar todos los mocks antes de cada prueba.
+    jest.clearAllMocks();
+
+    // Configurar el mock de getConfig para devolver una configuración válida por defecto.
+    getConfig.mockReturnValue(mockConfig);
+
+    // Mockear la respuesta exitosa de getCustomer para la mayoría de las pruebas.
+    getCustomer.mockResolvedValue({
+      token: "mock-session-token",
+      userData: { id: "mock-user-id" }
+    });
+
+    // Opcional: Mockear console.log para no ensuciar la consola durante las pruebas.
+    jest.spyOn(console, "log").mockImplementation(() => {});
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restaurar los mocks de console después de cada prueba.
+    console.log.mockRestore();
+    console.error.mockRestore();
+  });
+
+  test("debe llamar a setConfig, initHttpClient y getCustomer en orden y devolver true al finalizar", async () => {
+    const result = await apacuana.init(mockConfig);
+
+    // 1. Verificar que setConfig fue llamado con los parámetros correctos.
+    expect(setConfig).toHaveBeenCalledWith(mockConfig);
+
+    // 2. Verificar que initHttpClient fue llamado sin argumentos.
+    expect(initHttpClient).toHaveBeenCalled();
+
+    // 3. Verificar que getCustomer fue llamado.
+    expect(getCustomer).toHaveBeenCalledWith();
+
+    // 4. Verificar que se retorna true al finalizar la inicialización.
+    expect(result).toBe(true);
+
+    // 5. Verificar que las funciones se llamaron el número correcto de veces.
+    expect(setConfig).toHaveBeenCalledTimes(2); // Una vez inicial, una vez para guardar token
+    expect(initHttpClient).toHaveBeenCalledTimes(1);
+    expect(getCustomer).toHaveBeenCalledTimes(1);
+  });
+
+  test("debe lanzar un error si la configuración inicial está incompleta", async () => {
+    // Sobrescribir el mock de setConfig para que lance un error.
+    setConfig.mockImplementationOnce(() => {
+      throw new Error("Apacuana SDK: La configuración inicial debe incluir...");
+    });
+
+    // Verificar que el método init lanza el error esperado.
+    await expect(apacuana.init({})).rejects.toThrow(
+      "Apacuana SDK: La configuración inicial debe incluir..."
+    );
+
+    // Verificar que initHttpClient y getCustomer no fueron llamados.
+    expect(initHttpClient).not.toHaveBeenCalled();
+    expect(getCustomer).not.toHaveBeenCalled();
+  });
+
+  test("debe lanzar un error si getCustomer falla", async () => {
+    // Configurar el mock de getCustomer para que rechace la promesa.
+    getCustomer.mockRejectedValueOnce(
+      new Error("Error del servidor al obtener token")
+    );
+
+    // Verificar que el método init propaga el error de getCustomer.
+    await expect(apacuana.init(mockConfig)).rejects.toThrow(
+      "Error del servidor al obtener token"
+    );
+
+    // Verificar que setConfig e initHttpClient sí fueron llamados, pero getCustomer falló.
+    expect(setConfig).toHaveBeenCalledWith(mockConfig);
+    expect(initHttpClient).toHaveBeenCalled();
+  });
+
+  test("debe llamar a getConfig y setConfig para guardar el token", async () => {
+    const result = await apacuana.init(mockConfig);
+
+    // La primera llamada a setConfig se hace con la configuración inicial.
+    // La segunda llamada se hace para guardar el token y userData.
+    expect(setConfig).toHaveBeenCalledTimes(2);
+    expect(setConfig).toHaveBeenLastCalledWith({
+      ...mockConfig,
+      token: "mock-session-token",
+      userData: { id: "mock-user-id" }
+    });
+
+    // Verificar que el token es devuelto.
+    expect(result).toBe(true);
+  });
+});