apacuana-sdk-core 0.1.0 → 0.2.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,166 @@ 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);
+};
+
+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 keyPair = await crypto.generateKey(
-      {
-        name: signAlg,
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: { name: hashAlg },
-      },
-      true,
-      ["sign", "verify"]
+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 generateCSR = async (keyPair, userData, hashAlg = "SHA-256") => {
-  try {
-    const { publicKey, privateKey } = keyPair;
+  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"
+    );
+  }
 
-    // 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 (!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"
+    );
+  }
+
+  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"
+    );
+  }
+
+  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"
     );
+  }
 
-    // 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 (typeof csr !== "string" || csr.trim() === "") {
     throw new ApacuanaAPIError(
-      `Fallo en la generación del CSR: ${error.message}`,
-      0,
-      "CSR_GENERATION_ERROR"
+      "El CSR debe ser una cadena de texto válida y no puede estar vacía.",
+      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);
+  if (!base64Regex.test(csr)) {
+    throw new ApacuanaAPIError(
+      "El CSR debe estar codificado en formato base64 válido.",
+      400,
+      "INVALID_PARAMETER_FORMAT"
+    );
+  }
 };
 
-export async function exportPrivateKey(key) {
-  const crypto = getCrypto();
-  const exported = await crypto.exportKey("pkcs8", key);
-  const exportablePrivateKey = new Uint8Array(exported);
-  return arrayBufferToBase64(exportablePrivateKey);
-}
+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 const helpers = {
+export default {
   getCertificateStatus,
-  generateKeyPair,
-  generateCSR,
   exportPrivateKey,
   arrayBufferToBase64,
+  encryptedCsr,
+  validateOnBoardingSignerData,
+  validateCsr,
+  validateGetDocsData,
 };

package/tests/api/certs.test.js

@@ -1,6 +1,128 @@
-// tests/api/certs.test.js
-describe('Certificates API', () => {
-  test('placeholder test', () => {
-    expect(true).toBe(true);
+import { generateCert, getCertStatus } from "../../src/api/certs";
+import { getConfig } from "../../src/config";
+import { httpRequest } from "../../src/utils/httpClient";
+import { ApacuanaAPIError } from "../../src/errors";
+import {
+  INTEGRATION_TYPE,
+  STATUS_CERTIFICATE,
+} from "../../src/utils/constant";
+
+jest.mock("../../src/utils/httpClient");
+jest.mock("../../src/config");
+
+describe("API de Certificados - certs.js", () => {
+  const validBase64Csr = "dGVzdA=="; // "test" in base64
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("generateCert", () => {
+    it("debería generar un certificado con éxito para ONBOARDING", async () => {
+      const mockResponse = { cert: "new-cert", success: true };
+      httpRequest.mockResolvedValue(mockResponse);
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+
+      const result = await generateCert(validBase64Csr);
+
+      expect(result).toEqual(mockResponse);
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/register/certificate",
+        expect.any(Object),
+        "POST"
+      );
+    });
+
+    it("debería lanzar un error si el CSR no se proporciona", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      await expect(generateCert()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "La solicitud de firma de certificado (CSR) es requerida.",
+          400,
+          "CSR_REQUIRED"
+        )
+      );
+    });
+
+    it("debería lanzar un error si el CSR no es un string", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      await expect(generateCert(12345)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El CSR debe ser una cadena de texto válida y no puede estar vacía.",
+          400,
+          "INVALID_CSR_FORMAT"
+        )
+      );
+    });
+
+    it("debería lanzar un error si el CSR no está en formato Base64", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      await expect(generateCert("csr-invalido")).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El CSR debe estar codificado en formato base64 válido.",
+          400,
+          "INVALID_CSR_ENCODING"
+        )
+      );
+    });
+
+    it("debería manejar la lógica para ONPREMISE", async () => {
+      getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONPREMISE });
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+      await generateCert(validBase64Csr);
+      expect(consoleSpy).toHaveBeenCalledWith("-> Lógica para On-premise");
+      consoleSpy.mockRestore();
+    });
+
+    it("debería lanzar un error para tipos de integración no soportados", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED_TYPE" });
+      await expect(generateCert(validBase64Csr)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Tipo de integración no soportado: UNSUPPORTED_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("debería lanzar un ApacuanaAPIError si la respuesta de la API no contiene el certificado", async () => {
+      httpRequest.mockResolvedValue({ success: true }); // No 'cert' property
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+
+      await expect(generateCert(validBase64Csr)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "La respuesta de la API no contiene el certificado.",
+          undefined,
+          "INVALID_API_RESPONSE"
+        )
+      );
+    });
+  });
+
+  describe("getCertStatus", () => {
+    it("debería devolver el estado del certificado correctamente", () => {
+      const mockUserData = {
+        cert: "some-cert-data",
+        verificationstatus: { id: 1 }, // VERIFICATION_STATUS.APPROVED
+        certificationId: "some-cert-id",
+        approvedUser: true,
+      };
+      getConfig.mockReturnValue({ userData: mockUserData });
+      const result = getCertStatus(true);
+      expect(result).toEqual({
+        status: STATUS_CERTIFICATE.current,
+        success: true,
+      });
+    });
   });
 });

package/tests/api/signatures.test.js

@@ -1,6 +1,209 @@
-// 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 } 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(),
+}));
+
+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 call addSignerOnPremise for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+      const signerData = { name: "John Doe" };
+
+      const result = await addSigner(signerData);
+
+      expect(result).toEqual({
+        signerId: "on-premise-signer-id",
+        status: "added",
+      });
+    });
+
+    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(
+          "Tipo de integración no soportado: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("should throw an error if signerData is invalid", async () => {
+      await expect(addSigner(null)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Los datos del firmante (signerData) son requeridos y deben ser un objeto no vacío.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+  });
+
+  /*
+  describe("signDocument", () => {
+    const onBoardingData = {
+      documentData: { id: "doc1" },
+      signatureData: { id: "sig1" },
+    };
+    const onPremiseData = {
+      signature: { id: "sig1", positions: [] },
+      cert: "my-cert",
+      privateKey: "my-key",
+    };
+
+    it("should call signDocumentOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
+      const mockResponse = {
+        success: true,
+        id: "signed-doc-id",
+        message: "Firmado",
+      };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await signDocument(onBoardingData);
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "/docs/sign",
+        onBoardingData,
+        "POST"
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it("should throw TypeError for ONPREMISE integration due to implementation issue", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+      httpRequest
+        .mockResolvedValueOnce({ data: { digest: "test-digest" } })
+        .mockResolvedValueOnce({ data: "signed-response" });
+      helpers.signDigest.mockResolvedValue("signed-digest");
+
+      await expect(signDocument(onPremiseData)).rejects.toThrow(
+        "Fallo en la firma del documento (on-premise): Cannot read properties of undefined (reading 'map')"
+      );
+    });
+
+    it("should throw an error if data is invalid", async () => {
+      await expect(signDocument({})).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El parámetro 'data' es requerido y debe ser un objeto no vacío.",
+          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 due to implementation issue", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+        customerId: "test-customer",
+      });
+      httpRequest.mockResolvedValue({ docs: [] });
+
+      await expect(getDocs(paginationData)).rejects.toThrow(
+        "La obtención de documentos no está soportada para el tipo de integración: ONBOARDING"
+      );
+    });
+
+    it("should throw an error if page or size are missing", async () => {
+      const validationError = new ApacuanaAPIError(
+        "Los parámetros 'page' y 'size' son requeridos.",
+        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(
+        "El parámetro 'status' no es válido.",
+        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", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      await expect(getDocs(paginationData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El 'customerId' no está configurado. Por favor, configure el 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",

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;
-};