apacuana-sdk-core 0.1.0 → 0.3.0

package/src/utils/helpers.js

@@ -1,9 +1,10 @@
-import * as pkijs from "pkijs";
-import * as asn1js from "asn1js";
+import CryptoJS from "crypto-js";
 import { getCrypto } from "pkijs";
 import { STATUS_CERTIFICATE, VERIFICATION_STATUS } from "./constant";
 import { ApacuanaAPIError } from "../errors/index";
 
+const KEY_HEX = "dRgUkXp2s5v8y/B?";
+
 const getCertificateStatus = (userData, certificateInDevice) => {
   if (!userData) {
     throw new Error("El parámetro userData es requerido.");
@@ -41,126 +42,183 @@ const getCertificateStatus = (userData, certificateInDevice) => {
   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.");
-    }
+// Función para convertir ArrayBuffer a Base64
+const arrayBufferToBase64 = (buffer) => {
+  const binary = String.fromCharCode.apply(null, new Uint8Array(buffer));
+  return window.btoa(binary);
+};
 
-    const keyPair = await crypto.generateKey(
-      {
-        name: signAlg,
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: { name: hashAlg },
-      },
-      true,
-      ["sign", "verify"]
+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 validateOnBoardingSignerData = (signerData) => {
+  if (!signerData.name || typeof signerData.name !== "string") {
+    throw new ApacuanaAPIError(
+      'El campo "name" es requerido y debe ser una cadena de texto.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
     );
+  }
 
-    return keyPair;
-  } catch (error) {
-    console.error("Error durante la generación del par de claves:", error);
+  if (!signerData.reference || typeof signerData.reference !== "string") {
     throw new ApacuanaAPIError(
-      `Fallo en la generación del par de claves: ${error.message}`,
-      0,
-      "KEY_PAIR_GENERATION_ERROR"
+      'El campo "reference" es requerido y debe ser una cadena de texto.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
+
+  const validDocTypes = ["V", "P", "E"];
+  if (!signerData.typedoc || !validDocTypes.includes(signerData.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 (!signerData.doc || typeof signerData.doc !== "string") {
+    throw new ApacuanaAPIError(
+      'El campo "doc" es requerido y debe ser una cadena de texto.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
     );
   }
-};
 
-const generateCSR = async (keyPair, userData, hashAlg = "SHA-256") => {
-  try {
-    const { publicKey, privateKey } = keyPair;
+  if (
+    !Array.isArray(signerData.signature) ||
+    signerData.signature.length === 0
+  ) {
+    throw new ApacuanaAPIError(
+      'El campo "signature" es requerido y debe ser un array no vacío.',
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
 
-    // 1. Validar los parámetros de entrada.
-    if (!keyPair || !publicKey || !privateKey) {
-      throw new Error(
-        "Par de claves no válido. Es necesario un CryptoKeyPair."
+  signerData.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 (!userData || !userData.email) {
-      throw new Error(
-        "Datos de usuario incompletos. El correo electrónico es requerido."
+
+    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"
       );
     }
 
-    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))
+    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 validateCsr = (csr) => {
+  const base64Regex = /^[A-Za-z0-9+/=]+$/;
+
+  if (!csr) {
+    throw new ApacuanaAPIError(
+      "La solicitud de firma de certificado (CSR) es requerida.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  if (typeof csr !== "string" || csr.trim() === "") {
+    throw new ApacuanaAPIError(
+      "El CSR debe ser una cadena de texto válida y no puede estar vacía.",
+      400,
+      "INVALID_PARAMETER_FORMAT"
     );
+  }
 
-    // 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);
+  if (!base64Regex.test(csr)) {
     throw new ApacuanaAPIError(
-      `Fallo en la generación del CSR: ${error.message}`,
-      0,
-      "CSR_GENERATION_ERROR"
+      "El CSR debe estar codificado en formato base64 válido.",
+      400,
+      "INVALID_PARAMETER_FORMAT"
     );
   }
 };
 
-// Función para convertir ArrayBuffer a Base64
-const arrayBufferToBase64 = (buffer) => {
-  const binary = String.fromCharCode.apply(null, new Uint8Array(buffer));
-  return window.btoa(binary);
+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"
+    );
+  }
 };
 
-export async function exportPrivateKey(key) {
-  const crypto = getCrypto();
-  const exported = await crypto.exportKey("pkcs8", key);
-  const exportablePrivateKey = new Uint8Array(exported);
-  return arrayBufferToBase64(exportablePrivateKey);
-}
+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"
+    );
+  }
+};
 
-export const helpers = {
+export default {
   getCertificateStatus,
-  generateKeyPair,
-  generateCSR,
   exportPrivateKey,
   arrayBufferToBase64,
+  encryptedCsr,
+  validateOnBoardingSignerData,
+  validateCsr,
+  validateGetDocsData,
+  validateGetDigestData,
 };

package/tests/api/certs.test.js

@@ -1,6 +1,112 @@
-// tests/api/certs.test.js
-describe('Certificates API', () => {
-  test('placeholder test', () => {
-    expect(true).toBe(true);
+import { getConfig } from "../../src/config/index";
+import { httpRequest } from "../../src/utils/httpClient";
+import helpers from "../../src/utils/helpers";
+import { ApacuanaAPIError } from "../../src/errors";
+import { generateCert, getCertStatus } from "../../src/api/certs";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
+
+jest.mock("../../src/config/index");
+jest.mock("../../src/utils/httpClient");
+jest.mock("../../src/utils/helpers");
+
+describe("Certificate API - certs.js", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
   });
-});
+
+  describe("generateCert", () => {
+    it("should generate a certificate for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      helpers.encryptedCsr.mockReturnValue("encrypted-csr");
+      httpRequest.mockResolvedValue({ cert: "new-cert", success: true });
+
+      const result = await generateCert("some-csr");
+
+      expect(helpers.validateCsr).toHaveBeenCalledWith("some-csr");
+      expect(helpers.encryptedCsr).toHaveBeenCalledWith("some-csr");
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/register/certificate",
+        "encrypted-csr",
+        "POST"
+      );
+      expect(result).toEqual({ cert: "new-cert", success: true });
+    });
+
+    it("should throw an error if API response does not contain a certificate", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      helpers.encryptedCsr.mockReturnValue("encrypted-csr");
+      httpRequest.mockResolvedValue({ success: false });
+
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        new ApacuanaAPIError(
+          "The API response does not contain the certificate.",
+          undefined,
+          "INVALID_API_RESPONSE"
+        )
+      );
+    });
+
+    it("should throw an error for ONPREMISE", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Certificate generation is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error if integration type is not supported", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        "Unsupported integration type: INVALID_TYPE"
+      );
+    });
+
+    it("should re-throw ApacuanaAPIError if httpRequest fails", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const apiError = new ApacuanaAPIError("API Error", 500, "API_ERROR");
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(generateCert("some-csr")).rejects.toThrow(apiError);
+    });
+
+    it("should throw a generic error if something else fails", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const genericError = new Error("Something failed");
+      httpRequest.mockRejectedValue(genericError);
+
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        "Certificate generation failed: Something failed"
+      );
+    });
+  });
+
+  describe("getCertStatus", () => {
+    it("should return the certificate status from helpers", () => {
+      const mockUserData = { certStatus: "VALID" };
+      getConfig.mockReturnValue({ userData: mockUserData });
+      helpers.getCertificateStatus.mockReturnValue("VALID");
+
+      const result = getCertStatus(true);
+
+      expect(helpers.getCertificateStatus).toHaveBeenCalledWith(
+        mockUserData,
+        true
+      );
+      expect(result).toEqual({ status: "VALID", success: true });
+    });
+  });
+});

package/tests/api/signatures.test.js

@@ -1,6 +1,154 @@
-// tests/api/signatures.test.js
-describe('Signatures API', () => {
-  test('placeholder test', () => {
-    expect(true).toBe(true);
+import { getConfig } from "../../src/config";
+import { httpRequest } from "../../src/utils/httpClient";
+import { ApacuanaAPIError } from "../../src/errors";
+import { addSigner, getDocs, getDigest, signDocument } from "../../src/api/signatures";
+import helpers from "../../src/utils/helpers";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
+
+jest.mock("../../src/config");
+jest.mock("../../src/utils/httpClient");
+jest.mock("../../src/utils/helpers", () => ({
+  validateOnBoardingSignerData: jest.fn(),
+  validateSignOnBoardingData: jest.fn(),
+  validateSignOnPremiseData: jest.fn(),
+  signDigest: jest.fn(),
+  validateGetDocsData: jest.fn(),
+  validateGetDigestData: jest.fn(),
+}));
+
+describe("API - Signatures", () => {
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("addSigner", () => {
+    it("should call addSignerOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
+      const signerData = { typedoc: "V", doc: "12345678" };
+      httpRequest.mockResolvedValue({ success: true });
+
+      await addSigner(signerData);
+
+      expect(helpers.validateOnBoardingSignerData).toHaveBeenCalledWith(
+        signerData
+      );
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/documents/signing",
+        signerData,
+        "POST"
+      );
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+      const signerData = { name: "John Doe" };
+
+      await expect(addSigner(signerData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Adding signers is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      const signerData = { name: "test" };
+      await expect(addSigner(signerData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("should throw an error if signerData is invalid", async () => {
+      await expect(addSigner(null)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Signer data (signerData) is required and must be a non-empty object.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+  });
+
+  describe("getDocs", () => {
+    const paginationData = { page: 1, size: 10 };
+
+    it("should call httpRequest with correct URL when status is provided", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+        customerId: "test-customer",
+      });
+      const dataWithStatus = { ...paginationData, status: 1 };
+      httpRequest.mockResolvedValue({ docs: [] });
+
+      await getDocs(dataWithStatus);
+
+      expect(helpers.validateGetDocsData).toHaveBeenCalledWith(dataWithStatus);
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/documents/listcustomer?page=1&customerid=test-customer&size=10&status=1",
+        {},
+        "GET"
+      );
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+        customerId: "test-customer",
+      });
+      httpRequest.mockResolvedValue({ docs: [] });
+
+      await expect(getDocs(paginationData)).rejects.toThrow(
+        "Document retrieval is not supported for integration type: ONBOARDING"
+      );
+    });
+
+    it("should throw an error if page or size are missing", async () => {
+      const validationError = new ApacuanaAPIError(
+        "Parameters 'page' and 'size' are required.",
+        400,
+        "INVALID_PARAMETER"
+      );
+      helpers.validateGetDocsData.mockImplementation(() => {
+        throw validationError;
+      });
+
+      await expect(getDocs({})).rejects.toThrow(validationError);
+    });
+
+    it("should throw an error if status is invalid", async () => {
+      const validationError = new ApacuanaAPIError(
+        "Parameter 'status' is not valid.",
+        400,
+        "INVALID_PARAMETER"
+      );
+      helpers.validateGetDocsData.mockImplementationOnce(() => {
+        throw validationError;
+      });
+
+      await expect(getDocs({ ...paginationData, status: 99 })).rejects.toThrow(
+        validationError
+      );
+    });
+
+    it("should throw an error for non-on-premise integrations when customerId is missing", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      await expect(getDocs(paginationData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "'customerId' is not configured. Please configure the SDK.",
+          400,
+          "CONFIGURATION_ERROR"
+        )
+      );
+    });
   });
 });

package/tests/api/users.test.js

@@ -57,6 +57,7 @@ describe("getCustomer", () => {
     );
 
     expect(result).toEqual({
+      success: true,
       token: "mock-session-id-12345",
       userData: {
         userId: "mock-user",
@@ -66,34 +67,34 @@ describe("getCustomer", () => {
     });
   });
 
-  test("debe lanzar un error si la configuración está incompleta", async () => {
+  test("should throw an error if configuration is incomplete", 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."
+      "Both 'verificationId' and 'customerId' must be configured."
     );
     expect(httpRequest).not.toHaveBeenCalled();
   });
 
-  test("debe lanzar un ApacuanaAPIError si el backend no devuelve sessionid o entry", async () => {
+  test("should throw ApacuanaAPIError if backend does not return sessionid or entry", async () => {
     httpRequest.mockResolvedValueOnce({
       success: true,
-      message: "Error en el backend, no se pudo generar el token.",
+      message: "Backend error, token could not be generated.",
       entry: { userId: "mock-user" },
     });
 
     await expect(getCustomer()).rejects.toThrow(
-      "La respuesta de la API no contiene el usuario."
+      "The API response does not contain the user."
     );
     expect(httpRequest).toHaveBeenCalledTimes(1);
   });
 
-  test("debe relanzar el ApacuanaAPIError si la petición falla en el httpClient", async () => {
+  test("should rethrow ApacuanaAPIError if httpClient request fails", async () => {
     const apiError = new ApacuanaAPIError(
-      "Error de autenticación",
+      "Authentication error",
       401,
       "AUTH_ERROR"
     );
@@ -103,12 +104,12 @@ describe("getCustomer", () => {
     expect(httpRequest).toHaveBeenCalledTimes(1);
   });
 
-  test("debe lanzar un ApacuanaAPIError si ocurre un error inesperado", async () => {
-    const genericError = new Error("Error de red o desconocido");
+  test("should throw ApacuanaAPIError on unexpected error", async () => {
+    const genericError = new Error("Network or unknown error");
     httpRequest.mockRejectedValueOnce(genericError);
 
     await expect(getCustomer()).rejects.toThrow(
-      "Fallo inesperado al obtener el token: Error de red o desconocido"
+      "Unexpected failure getting token: Network or unknown error"
     );
     expect(httpRequest).toHaveBeenCalledTimes(1);
   });

package/src/auth/index.js

@@ -1,24 +0,0 @@
-// src/auth/index.js
-// Si httpClient construye los headers directamente de la config,
-// este módulo se vuelve menos crítico o puede desaparecer por ahora.
-// Lo dejaremos por si hay lógica de auth más compleja después.
-import { getConfig } from '../config/index';
-
-export const getAuthHeaders = () => {
-  const { secretKey, apiKey } = getConfig();
-  if (!secretKey || !apiKey) {
-    throw new Error('Apacuana SDK: secretKey o apiKey no configuradas.');
-  }
-  return {
-    'X-Api-Key': apiKey,
-    Authorization: `Bearer ${secretKey}`,
-  };
-};
-
-export const getVerificationId = () => {
-  const { verificationId } = getConfig();
-  if (!verificationId) {
-    throw new Error('Apacuana SDK: verificationId no configurado.');
-  }
-  return verificationId;
-};