apacuana-sdk-core 1.0.0 → 1.2.0

package/src/utils/helpers.js

@@ -0,0 +1,370 @@
+import CryptoJS from "crypto-js";
+import { getCrypto } from "pkijs";
+import {
+  INTEGRATION_TYPE,
+  STATUS_CERTIFICATE,
+  VERIFICATION_STATUS,
+} from "./constant";
+import { ApacuanaAPIError } from "../errors/index";
+
+const KEY_HEX = "dRgUkXp2s5v8y/B?";
+
+const getCertificateStatus = (
+  userData,
+  certificateInDevice,
+  integrationType
+) => {
+  if (!userData) {
+    throw new ApacuanaAPIError(
+      "El parámetro userData es requerido.",
+      404,
+      "INVALID_USER_DATA"
+    );
+  }
+  if (typeof certificateInDevice !== "boolean") {
+    throw new ApacuanaAPIError(
+      "El parámetro certificateInDevice es requerido y debe ser un valor booleano.",
+      404,
+      "INVALID_CERTIFICATE_IN_DEVICE"
+    );
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    if (userData?.verificationstatus?.id !== VERIFICATION_STATUS.APPROVED)
+      return STATUS_CERTIFICATE.request;
+    if (
+      userData?.certifiedid &&
+      !userData?.certificatestatus?.cangenerate &&
+      !userData?.requestscert?.pending &&
+      !certificateInDevice &&
+      userData?.certificatestatus !== STATUS_CERTIFICATE.revoque
+    )
+      return STATUS_CERTIFICATE.certificate_another_device;
+    if (userData?.requestscert?.pending)
+      return STATUS_CERTIFICATE.request_revoque;
+    if (
+      !userData?.certificatestatus?.cangenerate &&
+      userData?.certificatestatus === STATUS_CERTIFICATE.revoque
+    )
+      return STATUS_CERTIFICATE.revoque;
+    if (userData?.certificatestatus?.cangenerate)
+      return STATUS_CERTIFICATE.generate;
+    if (userData?.certifiedid) return STATUS_CERTIFICATE.current;
+
+    return STATUS_CERTIFICATE.revoque;
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    throw new ApacuanaAPIError(
+      "Getting certificate status is not supported for integration type: ONPREMISE",
+      501,
+      "NOT_IMPLEMENTED"
+    );
+  }
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+// Función para convertir ArrayBuffer a Base64
+const arrayBufferToBase64 = (buffer) => {
+  const binary = String.fromCharCode.apply(null, new Uint8Array(buffer));
+  return window.btoa(binary);
+};
+
+async function exportPrivateKey(key) {
+  const crypto = getCrypto();
+  const exported = await crypto.exportKey("pkcs8", key);
+  const exportablePrivateKey = new Uint8Array(exported);
+  return arrayBufferToBase64(exportablePrivateKey);
+}
+
+const encryptedCsr = (csr, encryptKey = KEY_HEX) => {
+  const body = {
+    csr: CryptoJS.AES.encrypt(csr, encryptKey, {
+      mode: CryptoJS.mode.ECB,
+      padding: CryptoJS.pad.Pkcs7,
+    }).toString(),
+  };
+  return body;
+};
+
+const createPayloadGetDigest = (signData) => {
+  const formData = new FormData();
+
+  // Iterate over the object's own properties
+  Object.keys(signData).forEach((key) => {
+    // Conditionally handle the 'document' field
+
+    if (key === "document" && signData[key] instanceof File) {
+      // Append the file directly
+      formData.append(key, signData[key]);
+    } else if (key === "cert") {
+      formData.append("publickey", signData[key]);
+    }
+  });
+  return formData;
+};
+
+const validateOnBoardingSignerData = (signerData) => {
+  // Create a copy of the original object to avoid modifying the function parameter
+  const validatedSignerData = { ...signerData };
+
+  if (
+    !validatedSignerData.name ||
+    typeof validatedSignerData.name !== "string"
+  ) {
+    throw new ApacuanaAPIError(
+      'El campo "name" es requerido y debe ser una cadena de texto.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+
+  // Limpia 'reference' si es inválido o está vacío.
+  if (
+    !validatedSignerData.reference ||
+    typeof validatedSignerData.reference !== "string" ||
+    validatedSignerData.reference.trim() === ""
+  ) {
+    delete validatedSignerData.reference;
+  }
+
+  // Limpia 'file' si no es una instancia de File.
+  if (
+    typeof File === "undefined" ||
+    !validatedSignerData.file ||
+    !(validatedSignerData.file instanceof File)
+  ) {
+    delete validatedSignerData.file;
+  }
+
+  // Valida que solo uno de los dos campos exista después de la limpieza.
+  if (validatedSignerData.reference && validatedSignerData.file) {
+    throw new ApacuanaAPIError(
+      "No se pueden proporcionar 'reference' y 'file' simultáneamente.",
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+
+  if (!validatedSignerData.reference && !validatedSignerData.file) {
+    throw new ApacuanaAPIError(
+      "Se debe proporcionar un campo 'reference' o 'file' válido.",
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+
+  const validDocTypes = ["V", "P", "E"];
+  if (
+    !validatedSignerData.typedoc ||
+    !validDocTypes.includes(validatedSignerData.typedoc)
+  ) {
+    throw new ApacuanaAPIError(
+      'El campo "typedoc" es requerido y debe ser uno de los siguientes valores: V, P, E.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+
+  if (!validatedSignerData.doc || typeof validatedSignerData.doc !== "string") {
+    throw new ApacuanaAPIError(
+      'El campo "doc" es requerido y debe ser una cadena de texto.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+
+  if (
+    !Array.isArray(validatedSignerData.signature) ||
+    validatedSignerData.signature.length === 0
+  ) {
+    throw new ApacuanaAPIError(
+      'El campo "signature" es requerido y debe ser un array no vacío.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+
+  validatedSignerData.signature.forEach((sig, index) => {
+    if (!Number.isInteger(sig.page) || sig.page < 1) {
+      throw new ApacuanaAPIError(
+        `La página de la firma ${
+          index + 1
+        } debe ser un número entero positivo.`,
+        400,
+        "INVALID_PARAMETER_FORMAT"
+      );
+    }
+
+    if (typeof sig.x !== "number" || sig.x < 0 || sig.x > 1) {
+      throw new ApacuanaAPIError(
+        `La coordenada X de la firma ${
+          index + 1
+        } debe ser un número entre 0 y 1.`,
+        400,
+        "INVALID_PARAMETER_FORMAT"
+      );
+    }
+
+    if (typeof sig.y !== "number" || sig.y < 0 || sig.y > 1) {
+      throw new ApacuanaAPIError(
+        `La coordenada Y de la firma ${
+          index + 1
+        } debe ser un número entre 0 y 1.`,
+        400,
+        "INVALID_PARAMETER_FORMAT"
+      );
+    }
+  });
+
+  const formData = new FormData();
+  Object.keys(validatedSignerData).forEach((key) => {
+    if (key === "signature") {
+      formData.append(key, JSON.stringify(validatedSignerData[key]));
+    } else if (key === "file") {
+      formData.append("document", validatedSignerData[key]);
+    } else if (validatedSignerData[key] !== undefined) {
+      formData.append(key, validatedSignerData[key]);
+    }
+  });
+
+  return formData;
+};
+
+const validateCsr = (encryptedCSR) => {
+  if (
+    !encryptedCSR ||
+    typeof encryptedCSR !== "object" ||
+    !encryptedCSR.csr ||
+    typeof encryptedCSR.csr !== "string" ||
+    encryptedCSR.csr.trim() === ""
+  ) {
+    throw new ApacuanaAPIError(
+      'The "encryptedCSR" parameter is required and must be an object ' +
+        'with a non-empty "csr" string property.',
+      400, // Bad Request
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+};
+
+const validateGetDocsData = (data) => {
+  if (
+    !data ||
+    typeof data.page === "undefined" ||
+    typeof data.size === "undefined"
+  ) {
+    throw new ApacuanaAPIError(
+      "Los parámetros 'page' y 'size' son requeridos.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  if (
+    typeof data.status !== "undefined" &&
+    ![-1, 0, 1, 2].includes(data.status)
+  ) {
+    throw new ApacuanaAPIError(
+      "El parámetro 'status' no es válido. Los valores permitidos son: -1, 0, 1, 2.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+};
+
+const validateGetDigestData = (signData) => {
+  if (
+    !signData ||
+    !signData.cert ||
+    typeof signData.cert !== "string" ||
+    !signData.signatureId ||
+    typeof signData.signatureId !== "string"
+  ) {
+    throw new ApacuanaAPIError(
+      "Los parámetros 'cert' y 'signatureId' son requeridos y deben ser cadenas de texto.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+};
+
+const validateOnBoardingSignDocumentData = (signData) => {
+  if (!signData || typeof signData !== "object") {
+    throw new ApacuanaAPIError(
+      "Sign data is required and must be an object.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  const { signature, cert, signedDigest } = signData;
+
+  if (!signature || typeof signature !== "object" || !signature.id) {
+    throw new ApacuanaAPIError(
+      "Signature object with an 'id' property is required.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  if (!Array.isArray(signature.positions)) {
+    throw new ApacuanaAPIError(
+      "Signature 'positions' must be an array.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  if (!cert || typeof cert !== "string") {
+    throw new ApacuanaAPIError(
+      "Certificate 'cert' is required and must be a string.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  if (!signedDigest || typeof signedDigest !== "string") {
+    throw new ApacuanaAPIError(
+      "Signed digest 'signedDigest' is required and must be a string.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  const formData = new FormData();
+  formData.append(
+    "positions",
+    JSON.stringify(
+      signature.positions.map((p) => ({
+        x: p.x,
+        y: p.y,
+        page: p.page,
+        status: 1,
+      }))
+    )
+  );
+  formData.append("publickey", cert);
+  formData.append("signeddigest", signedDigest);
+  if (signData.document && signData.document instanceof File) {
+    formData.append("document", signData.document);
+  }
+
+  return formData;
+};
+
+export default {
+  getCertificateStatus,
+  exportPrivateKey,
+  arrayBufferToBase64,
+  encryptedCsr,
+  validateOnBoardingSignerData,
+  validateCsr,
+  validateGetDocsData,
+  validateGetDigestData,
+  validateOnBoardingSignDocumentData,
+  createPayloadGetDigest,
+};

package/src/utils/httpClient.js

@@ -0,0 +1,179 @@
+// 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
+  ) {
+    throw new Error(
+      "HttpClient: Configuración de inicialización incompleta. Llama a apacuana.init() primero."
+    );
+  }
+
+  axiosInstance = axios.create({
+    baseURL: config.apiUrl,
+    headers: {
+      "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) {
+        const errorMessage =
+          response.data?.msg ||
+          response.data?.message ||
+          "Error lógico desconocido desde la API.";
+        throw new ApacuanaAPIError(
+          errorMessage,
+          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;
+        const errorMessage =
+          data?.msg || data?.message || "Error desconocido desde la API.";
+        throw new ApacuanaAPIError(
+          errorMessage,
+          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"
+        );
+      }
+    }
+  );
+};
+
+/**
+ * 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
+};
+
+/**
+ * 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."
+    );
+  }
+
+  let dataToSend;
+  const requestConfig = {};
+
+  if (typeof FormData !== "undefined" && data instanceof FormData) {
+    dataToSend = data;
+  } else {
+    const hasFile = Object.values(data).some(
+      (value) => typeof File !== "undefined" && value instanceof File
+    );
+    if (hasFile) {
+      const formData = new FormData();
+      Object.keys(data).forEach((key) => {
+        formData.append(key, data[key]);
+      });
+      dataToSend = formData;
+    } else {
+      dataToSend = { ...data };
+    }
+  }
+
+  try {
+    let response;
+    switch (method.toUpperCase()) {
+      case "GET":
+        response = await axiosInstance.get(path, { params: dataToSend });
+        break;
+      case "POST":
+        response = await axiosInstance.post(path, dataToSend, requestConfig);
+        break;
+      case "PUT":
+        response = await axiosInstance.put(path, dataToSend, requestConfig);
+        break;
+      case "DELETE":
+        response = await axiosInstance.delete(path, {
+          data: dataToSend,
+          ...requestConfig,
+        });
+        break;
+      default:
+        throw new ApacuanaAPIError(
+          `Método HTTP no soportado: ${method}`,
+          405,
+          "UNSUPPORTED_HTTP_METHOD"
+        );
+    }
+
+    return response.data;
+  } catch (error) {
+    console.error(`[HTTP Client] Fallo en la petición a ${path}:`, error);
+    throw error;
+  }
+};