apacuana-sdk-core 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apacuana-sdk-core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Core SDK para interacciones con las APIs de Apacuana.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/api/certs.js

@@ -1,70 +1,82 @@
-import CryptoJS from "crypto-js";
-import { getConfig } from "../config";
-import { INTEGRATION_TYPE } from "../utils/constant";
-import { helpers } from "../utils/helpers";
-import { ApacuanaAPIError } from "../errors/index";
+import { getConfig } from "../config/index";
 import { httpRequest } from "../utils/httpClient";
+import helpers from "../utils/helpers";
+import { ApacuanaAPIError } from "../errors";
+import { INTEGRATION_TYPE } from "../utils/constant";
 
-const generateCertOnBoarding = async () => {
+const generateCertOnBoarding = async (csr = undefined) => {
   try {
-    const config = getConfig();
-    const { userData } = config;
-    const keyPair = await helpers.generateKeyPair();
-    const { csrBase64 } = await helpers.generateCSR(keyPair, userData);
-
-    const body = {
-      csr: CryptoJS.AES.encrypt(csrBase64, config.secretKey, {
-        mode: CryptoJS.mode.ECB,
-        padding: CryptoJS.pad.Pkcs7,
-      }).toString(),
-    };
+    const encryptedCSR = helpers.encryptedCsr(csr);
 
     const response = await httpRequest(
       "services/api/register/certificate",
-      body,
+      encryptedCSR,
       "POST"
     );
-
     const { cert } = response;
     if (!cert) {
       throw new ApacuanaAPIError(
-        "La respuesta de la API no contiene el certificado.",
+        "The API response does not contain the certificate.",
         response.status,
         "INVALID_API_RESPONSE"
       );
     }
 
-    const exportedPrivateKey = await helpers.exportPrivateKey(
-      keyPair.privateKey
-    );
-
-    return { cert, privateKey: exportedPrivateKey };
+    return { cert, success: true };
   } catch (error) {
-    // Se lanza el error capturado, que ya será de tipo ApacuanaAPIError o un Error nativo.
+    // The captured error is re-thrown, which will already be of type ApacuanaAPIError or a native Error.
     if (error instanceof ApacuanaAPIError) {
       throw error;
     }
-    throw new Error(`Fallo en la generación del certificado: ${error.message}`);
+    throw new Error(`Certificate generation failed: ${error.message}`);
   }
 };
 
-export const generateCert = async () => {
-  const { integrationType } = getConfig();
+const generateCertOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Certificate generation is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
 
+/**
+ * Generates a digital certificate.
+ * @param {string} [csr] - Optional Certificate Signing Request (CSR).
+ * @returns {Promise<{cert: string, success: boolean}>} Object with the generated certificate and a success indicator.
+ * @throws {ApacuanaAPIError} If the CSR is invalid, if the API response does not contain the certificate, or if the integration type is not supported.
+ * @throws {Error} If certificate generation fails for another reason.
+ */
+export const generateCert = async (csr = undefined) => {
+  const { integrationType } = getConfig();
+  helpers.validateCsr(csr);
   if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
-    await generateCertOnBoarding();
-  } else if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
-    // eslint-disable-next-line no-console
-    console.log("-> Lógica para On-premise");
-    // Aquí iría la llamada a httpRequest para el endpoint de on-premise
-    // return httpRequest('/certs/generate-onpremise', data);
+    return generateCertOnBoarding(csr);
   }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return generateCertOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
 };
 
-export const getCertStatus = () => {
+/**
+ * Gets the user's certificate status.
+ * @param {boolean} [isCertificateInDevice=false] - Indicates if the certificate is already on the device.
+ * @returns {{status: string, success: boolean}} Object with the certificate status and a success indicator.
+ */
+export const getCertStatus = (isCertificateInDevice = false) => {
   const config = getConfig();
-  const status = helpers.getCertificateStatus(config.userData, false);
+  const status = helpers.getCertificateStatus(
+    config.userData,
+    isCertificateInDevice
+  );
   return {
     status,
+    success: true,
   };
 };

package/src/api/signatures.js

@@ -1,77 +1,241 @@
 // src/api/signatures.js
-import { httpRequest } from '../utils/httpClient';
-import { ApacuanaAPIError } from '../errors/index';
+import { getConfig } from "../config/index";
+import { httpRequest } from "../utils/httpClient";
+import { ApacuanaAPIError } from "../errors";
+import helpers from "../utils/helpers";
+import { INTEGRATION_TYPE } from "../utils/constant";
+
+const signDocumentOnBoarding = async () => {
+  throw new ApacuanaAPIError(
+    "Document signing is not supported for integration type: ONBOARDING",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const signDocumentOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Document signing is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
 
 /**
- * Simula la firma de un documento.
- * @param {object} documentData - Datos del documento a firmar.
- * @param {object} signatureData - Datos de la firma.
- * @returns {Promise<object>} Objeto con el resultado de la firma.
+ * Signs a PDF document with a digital certificate.
+ * @param {object} data - Data for the signature. For 'on-boarding', it must contain {documentData, signatureData}. For 'on-premise', it must contain {signature, cert, privateKey}.
+ * @returns {Promise<{digest: string}>} Object with the document's digest.
+ * @throws {ApacuanaAPIError} If the integration type is not supported or the function is not implemented for the integration type.
  */
-export const signDocument = async (documentData, signatureData) => {
-  console.log("-> Función 'signDocument' ejecutada.");
-  console.log('Parámetros recibidos para firmar documento:', {
-    documentData,
-    signatureData,
-  });
-
-  if (!documentData || !signatureData) {
-    throw new Error(
-      'Datos de documento y firma son requeridos para signDocument.',
-    );
+export const signDocument = async () => {
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return signDocumentOnBoarding();
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return signDocumentOnPremise();
   }
 
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+const getDigestToSignOnBoarding = async (signData) => {
   try {
     const response = await httpRequest(
-      '/docs/sign',
-      { documentData, signatureData },
-      'POST',
+      `services/api/documents/getdigest/${signData.signatureId}`,
+      {
+        publickey: signData.cert,
+      },
+      "POST"
     );
-    console.log(
-      'Respuesta del servidor simulada para firmar documento:',
-      response,
-    );
-    if (!response.success) {
+    const digest = response.data?.digest || response.digest;
+    if (!digest) {
       throw new ApacuanaAPIError(
-        response.message || 'Error desconocido al firmar documento.',
+        "Signature generation failed: digest not found in the response.",
+        500,
+        "API_RESPONSE_ERROR"
       );
     }
-    return { signedDocId: response.id, status: response.message };
+
+    return { digest, success: true };
   } catch (error) {
-    throw new Error(`Fallo en la firma del documento: ${error.message}`);
+    if (error.name === "ApacuanaAPIError") {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to sign document (on-boarding): ${error.message}`
+    );
   }
 };
 
+const getDigestToSignOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Digest retrieval is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
 /**
- * Simula la adición de un firmante a un documento.
- * @param {object} signerData - Datos del firmante a agregar.
- * @returns {Promise<object>} Objeto con el resultado de agregar el firmante.
+ * Gets the digest of a document to be signed.
+ * @param {object} signData - Data for the signature. Must contain { cert, signatureId }.
+ * @returns {Promise<{digest: string, success: boolean}>} Object with the document's digest.
+ * @throws {ApacuanaAPIError} If the input data is invalid, if the API call fails, or if the integration type is not supported.
  */
-export const addSigner = async (signerData) => {
-  console.log("-> Función 'addSigner' ejecutada.");
-  console.log('Parámetros recibidos para agregar firmante:', signerData);
+export const getDigest = async (signData) => {
+  helpers.validateGetDigestData(signData);
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getDigestToSignOnBoarding(signData);
+  }
 
-  if (!signerData || typeof signerData !== 'object') {
-    throw new Error('Datos de firmante son requeridos para addSigner.');
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getDigestToSignOnPremise();
   }
 
+  throw new ApacuanaAPIError(
+    `Document retrieval is not supported for an unknown integration type: ${integrationType}`,
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const addSignerOnBoarding = async (signerData) => {
+  helpers.validateOnBoardingSignerData(signerData);
   try {
-    const response = await httpRequest(
-      '/docs/signers',
-      signerData,
-      'POST',
+    // Current httpRequest logic is moved here
+    await httpRequest("services/api/documents/signing", signerData, "POST");
+    return { signer: signerData.typedoc + signerData.doc, success: true };
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to add signer in On-Boarding: ${error.message}`
+    );
+  }
+};
+
+const addSignerOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Adding signers is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+/**
+ * Adds a signer to a document, handling different integration types.
+ * @param {object} signerData - Data of the signer to be added.
+ * @returns {Promise<{signer: string, success: boolean}>} Object with the result of adding the signer.
+ * @throws {ApacuanaAPIError} If the signer data is invalid, if the API call fails, or if the integration type is not supported.
+ */
+export const addSigner = async (signerData) => {
+  if (
+    !signerData ||
+    typeof signerData !== "object" ||
+    Object.keys(signerData).length === 0
+  ) {
+    throw new ApacuanaAPIError(
+      "Signer data (signerData) is required and must be a non-empty object.",
+      400,
+      "INVALID_PARAMETER"
     );
-    console.log(
-      'Respuesta del servidor simulada para agregar firmante:',
-      response,
+  }
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return addSignerOnBoarding(signerData);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return addSignerOnPremise(signerData);
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+const getDocsOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Document retrieval is not supported for integration type: ONBOARDING",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const getDocsOnBoarding = async (data) => {
+  const { customerId } = getConfig();
+  if (!customerId) {
+    throw new ApacuanaAPIError(
+      "'customerId' is not configured. Please configure the SDK.",
+      400,
+      "CONFIGURATION_ERROR"
     );
-    if (!response.success) {
-      throw new ApacuanaAPIError(
-        response.message || 'Error desconocido al agregar firmante.',
-      );
+  }
+
+  try {
+    const params = new URLSearchParams({
+      page: data.page,
+      customerid: customerId,
+      size: data.size,
+    });
+
+    if (typeof data.status !== "undefined") {
+      params.append("status", data.status);
     }
-    return { signerId: response.id, status: response.message };
+
+    const apiUrl = `services/api/documents/listcustomer?${params.toString()}`;
+    const response = await httpRequest(apiUrl, {}, "GET");
+    return {
+      totalRecords: response.numofrecords,
+      records: response.records,
+      success: true,
+    };
   } catch (error) {
-    throw new Error(`Fallo al agregar firmante: ${error.message}`);
+    if (error.name === "ApacuanaAPIError") {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to get document list (on-premise): ${error.message}`
+    );
+  }
+};
+
+/**
+ * Gets a list of documents.
+ * @param {object} data - Object with pagination parameters. Must contain {page, size}.
+ * @returns {Promise<{totalRecords: number, records:any[], success: boolean}>} Object with the list of documents.
+ * @throws {ApacuanaAPIError} If pagination parameters are invalid, if 'customerId' is not configured, if the API call fails, or if the integration type is not supported.
+ */
+export const getDocs = async (data) => {
+  helpers.validateGetDocsData(data);
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getDocsOnBoarding(data);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getDocsOnPremise();
   }
+
+  throw new ApacuanaAPIError(
+    `Document retrieval is not supported for an unknown integration type: ${integrationType}`,
+    501,
+    "NOT_IMPLEMENTED"
+  );
 };

package/src/api/users.js

@@ -7,46 +7,36 @@ import { getConfig } from "../config/index";
  * Este método es útil para endpoints que requieren datos en el cuerpo de la petición
  * para buscar un usuario, como un ID de sesión o un token de acceso.
  *
- * @returns {Promise<object>} Objeto con los detalles del usuario.
+ * @returns {Promise<{token: string, userData: object, success: boolean}>} Objeto con el token de sesión, los datos del usuario y un indicador de éxito.
  * @throws {Error} Si los parámetros de entrada son inválidos.
  * @throws {ApacuanaAPIError} Si ocurre un error en la API de Apacuana.
  */
 const getCustomer = async () => {
   const { verificationId, customerId } = getConfig();
+
+  if (!verificationId || !customerId) {
+    throw new ApacuanaAPIError(
+      "Both 'verificationId' and 'customerId' must be configured.",
+      400,
+      "CONFIGURATION_ERROR"
+    );
+  }
+
   const body = {
     verificationid: verificationId,
     customerid: customerId,
   };
-  // eslint-disable-next-line no-console
-  console.log("-> Función 'getCustomer' ejecutada.");
-  // eslint-disable-next-line no-console
-  console.log("Parámetros recibidos para buscar usuario:", body);
-
-  // 1. Validación de Parámetros de Entrada (Lado del SDK)
-  if (!body || !body.verificationid || !body.customerid) {
-    throw new Error(
-      "El 'body' con 'userId' es un parámetro requerido para getCustomer."
-    );
-  }
 
   try {
-    // 2. Realizar la Llamada al Backend a través del HttpClient
-    // Usamos POST ya que la búsqueda podría requerir datos sensibles o complejos en el cuerpo.
     const response = await httpRequest(
-      "services/api/register/init", // Endpoint de ejemplo
-      body, // Los datos a enviar en el cuerpo de la petición
+      "services/api/register/init",
+      body,
       "POST"
     );
 
-    // 3. Procesar la Respuesta del Backend
-    // Asumiendo que la respuesta exitosa del backend incluye un objeto 'user'
-    // eslint-disable-next-line no-console
-    console.log("Respuesta del servidor para el token:", response);
-
     if (!response.sessionid || !response.entry) {
-      // Si el backend no devuelve el objeto 'user' esperado
       throw new ApacuanaAPIError(
-        "La respuesta de la API no contiene el usuario.",
+        "The API response does not contain the user.",
         200,
         "INVALID_API_RESPONSE"
       );
@@ -55,17 +45,15 @@ const getCustomer = async () => {
     return {
       token: response.sessionid,
       userData: response.entry,
-    }; // Retorna el objeto de usuario directamente
+      success: true,
+    };
   } catch (error) {
-    // 4. Manejo de Errores
-    // eslint-disable-next-line no-console
-    console.error("Error en getCustomer:", error);
     if (error instanceof ApacuanaAPIError) {
       throw error;
     }
     throw new ApacuanaAPIError(
-      `Fallo inesperado al obtener el token: ${
-        error.message || "Error desconocido"
+      `Unexpected failure getting token: ${
+        error.message || "Unknown error"
       }`
     );
   }

package/src/errors/index.js

@@ -9,6 +9,7 @@ export class ApacuanaAPIError extends Error {
     this.name = "ApacuanaAPIError";
     this.statusCode = statusCode;
     this.errorCode = errorCode;
+    this.success = false; // Añadir el atributo success con valor false
 
     // Mantener el stack trace correcto
     if (Error.captureStackTrace) {

package/src/index.js

@@ -1,9 +1,9 @@
-// src/index.js
 import { setConfig, getConfig } from "./config/index";
 import { initHttpClient, setAuthToken } from "./utils/httpClient";
 import getCustomer from "./api/users";
 import requestRevocation from "./api/revocations";
 import { getCertStatus } from "./api/certs";
+import { addSigner, getDocs } from "./api/signatures";
 
 const apacuana = {
   /**
@@ -62,6 +62,9 @@ const apacuana = {
   getConfig,
   requestRevocation,
   getCertStatus,
+  getCustomer,
+  addSigner,
+  getDocs,
 };
 
 export default apacuana;