apacuana-sdk-core 0.2.0 → 0.4.0

package/dist/utils/constant.d.ts

@@ -0,0 +1,18 @@
+export namespace STATUS_CERTIFICATE {
+    let request: string;
+    let generate: string;
+    let current: string;
+    let revoque: string;
+    let expire: string;
+    let request_revoque: string;
+    let certificate_another_device: string;
+    let sign_pending: string;
+}
+export namespace VERIFICATION_STATUS {
+    let IN_REGISTER: number;
+    let APPROVED: number;
+}
+export namespace INTEGRATION_TYPE {
+    let ONBOARDING: string;
+    let ONPREMISE: string;
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,21 @@
+declare namespace _default {
+    export { getCertificateStatus };
+    export { exportPrivateKey };
+    export { arrayBufferToBase64 };
+    export { encryptedCsr };
+    export { validateOnBoardingSignerData };
+    export { validateCsr };
+    export { validateGetDocsData };
+    export { validateGetDigestData };
+}
+export default _default;
+declare function getCertificateStatus(userData: any, certificateInDevice: any): string;
+declare function exportPrivateKey(key: any): Promise<string>;
+declare function arrayBufferToBase64(buffer: any): string;
+declare function encryptedCsr(csr: any, encryptKey?: string): {
+    csr: any;
+};
+declare function validateOnBoardingSignerData(signerData: any): void;
+declare function validateCsr(csr: any): void;
+declare function validateGetDocsData(data: any): void;
+declare function validateGetDigestData(signData: any): void;

package/dist/utils/httpClient.d.ts

@@ -0,0 +1,3 @@
+export function initHttpClient(): void;
+export function setAuthToken(token: string): void;
+export function httpRequest(path: string, data?: object, method?: string): Promise<object>;

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "apacuana-sdk-core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Core SDK para interacciones con las APIs de Apacuana.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
+    "clean": "rimraf dist",
+    "clean-modules": "rimraf node_modules",
     "test": "jest",
     "lint": "eslint src/",
-    "build": "rollup -c",
-    "prepublishOnly": "npm test && npm run build",
+    "build": "npm run clean && tsc && rollup -c",
+    "prepublishOnly": "npm run validate",
     "validate": "npm run lint && npm test && npm run build"
   },
   "keywords": [
@@ -33,7 +36,9 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
-    "rollup": "^4.18.0"
+    "rollup": "^4.18.0",
+    "rimraf": "^5.0.7",
+    "typescript": "^5.4.5"
   },
   "engines": {
     "node": ">=14.0.0"

package/src/api/certs.js

@@ -16,7 +16,7 @@ const generateCertOnBoarding = async (csr = undefined) => {
     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"
       );
@@ -24,14 +24,29 @@ const generateCertOnBoarding = async (csr = undefined) => {
 
     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}`);
   }
 };
 
+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] - 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);
@@ -39,21 +54,21 @@ export const generateCert = async (csr = undefined) => {
     return generateCertOnBoarding(csr);
   }
   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 Promise.resolve(); // Retornar una promesa resuelta para consistencia
+    return generateCertOnPremise();
   }
 
-  // Lanzar un error si el tipo de integración no es soportado
   throw new ApacuanaAPIError(
-    `Tipo de integración no soportado: ${integrationType}`,
+    `Unsupported integration type: ${integrationType}`,
     400,
     "UNSUPPORTED_INTEGRATION_TYPE"
   );
 };
 
+/**
+ * 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(

package/src/api/revocations.js

@@ -1,6 +1,5 @@
-// src/api/revocations.js
-import { httpRequest } from '../utils/httpClient';
-import { ApacuanaAPIError } from '../errors/index';
+import { httpRequest } from "../utils/httpClient";
+import { ApacuanaAPIError } from "../errors/index";
 
 /**
  * Simula la solicitud de revocación de un certificado.
@@ -8,31 +7,31 @@ import { ApacuanaAPIError } from '../errors/index';
  * @returns {Promise<object>} Objeto con el estado de la solicitud de revocación.
  */
 const requestRevocation = async (reasonCode) => {
-  console.log('-> Función \'requestRevocation\' ejecutada.');
-  console.log('Parámetros recibidos para solicitud de revocación:', {
+  console.log("-> Función 'requestRevocation' ejecutada.");
+  console.log("Parámetros recibidos para solicitud de revocación:", {
     reasonCode,
   });
 
   if (!reasonCode) {
     throw new Error(
-      'ID de certificado y motivo son requeridos para requestRevocation.',
+      "ID de certificado y motivo son requeridos para requestRevocation."
     );
   }
 
   try {
     const response = await httpRequest(
-      'users/api/customers/requestcert',
+      "users/api/customers/requestcert",
       { reason: reasonCode },
-      'POST',
+      "POST"
     );
-    console.log('Respuesta del servidor', response);
+    console.log("Respuesta del servidor", response);
     if (!response.success) {
       throw new ApacuanaAPIError(
-        response.message || 'Error desconocido al solicitar revocación.',
+        response.message || "Error desconocido al solicitar revocación."
       );
     }
     return {
-      revocationStatus: response.status || 'pending',
+      revocationStatus: response.status || "pending",
       requestId: response.id,
     };
   } catch (error) {

package/src/api/signatures.js

@@ -5,124 +5,113 @@ import { ApacuanaAPIError } from "../errors";
 import helpers from "../utils/helpers";
 import { INTEGRATION_TYPE } from "../utils/constant";
 
-/*
-const signDocumentOnBoarding = async (documentData, signatureData) => {
-  try {
-    const response = await httpRequest(
-      "/docs/sign",
-      { documentData, signatureData },
-      "POST"
-    );
-    if (!response.success) {
-      throw new ApacuanaAPIError(
-        response.message || "Error desconocido al firmar documento."
-      );
-    }
-    return { signedDocId: response.id, status: response.message };
-  } catch (error) {
-    if (error.name === "ApacuanaAPIError") {
-      throw error;
-    }
-    throw new ApacuanaAPIError(
-      `Fallo en la firma del documento (on-boarding): ${error.message}`
-    );
+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"
+  );
+};
+
+/**
+ * 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 () => {
+  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 signDocumentOnPremise = async (signature, cert, privateKey) => {
-  helpers.validateSignOnPremiseData({ signature, cert, privateKey });
+const getDigestToSignOnBoarding = async (signData) => {
   try {
-    const digestBody = {
-      publickey: cert,
-    };
-
-    const digestResponse = await httpRequest(
-      `services/api/documents/getdigest/${signature.id}`,
-      digestBody,
+    const response = await httpRequest(
+      `services/api/documents/getdigest/${signData.signatureId}`,
+      {
+        publickey: signData.cert,
+      },
       "POST"
     );
-
-    const digest = digestResponse.data?.digest || digestResponse.digest;
+    const digest = response.data?.digest || response.digest;
     if (!digest) {
       throw new ApacuanaAPIError(
-        "La generación de firma ha fallado: no se pudo obtener el digest del documento."
+        "Signature generation failed: digest not found in the response.",
+        500,
+        "API_RESPONSE_ERROR"
       );
     }
 
-    const signedDigest = await helpers.signDigest(digest, privateKey);
-
-    const signBody = {
-      positions: JSON.stringify(
-        signature.positions.map((p) => ({
-          x: p.x,
-          y: p.y,
-          page: p.page,
-          status: 1,
-        }))
-      ),
-      publickey: cert,
-      signeddigest: signedDigest,
-    };
-
-    const signResponse = await httpRequest(
-      `services/api/documents/sign/${signature.id}`,
-      signBody,
-      "PUT"
-    );
-
-    return signResponse;
+    return { digest, success: true };
   } catch (error) {
     if (error.name === "ApacuanaAPIError") {
       throw error;
     }
     throw new ApacuanaAPIError(
-      `Fallo en la firma del documento (on-premise): ${error.message}`
+      `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"
+  );
+};
 
 /**
- * Firma un documento PDF con un certificado digital.
- * @param {object} data - Datos para la firma. Para 'on-boarding', debe contener {documentData, signatureData}. Para 'on-premise', debe contener {signature, cert, privateKey}.
- * @returns {Promise<object>} Objeto con el resultado de la firma.
+ * 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 signDocument = async (signData) => {
-  if (
-    !signData ||
-    typeof signData !== "object" ||
-    Object.keys(signData).length === 0
-  ) {
-    throw new ApacuanaAPIError(
-      "El parámetro 'data' es requerido y debe ser un objeto no vacío.",
-      400,
-      "INVALID_PARAMETER"
-    );
-  }
+export const getDigest = async (signData) => {
+  helpers.validateGetDigestData(signData);
 
   const { integrationType } = getConfig();
 
   if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
-    return signDocumentOnBoarding(signData);
+    return getDigestToSignOnBoarding(signData);
   }
 
   if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
-    return signDocumentOnPremise(signData);
+    return getDigestToSignOnPremise();
   }
 
   throw new ApacuanaAPIError(
-    `Tipo de integración no soportado: ${integrationType}`,
-    400,
-    "UNSUPPORTED_INTEGRATION_TYPE"
+    `Document retrieval is not supported for an unknown integration type: ${integrationType}`,
+    501,
+    "NOT_IMPLEMENTED"
   );
 };
-*/
 
 const addSignerOnBoarding = async (signerData) => {
   helpers.validateOnBoardingSignerData(signerData);
   try {
-    // La lógica actual de httpRequest se mueve aquí
+    // Current httpRequest logic is moved here
     await httpRequest("services/api/documents/signing", signerData, "POST");
     return { signer: signerData.typedoc + signerData.doc, success: true };
   } catch (error) {
@@ -130,18 +119,24 @@ const addSignerOnBoarding = async (signerData) => {
       throw error;
     }
     throw new Error(
-      `Fallo al agregar firmante en On-Boarding: ${error.message}`
+      `Failed to add signer in On-Boarding: ${error.message}`
     );
   }
 };
 
-const addSignerOnPremise = async () =>
-  Promise.resolve({ signerId: "on-premise-signer-id", status: "added" });
+const addSignerOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Adding signers is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
 
 /**
- * Agrega un firmante a un documento, manejando diferentes tipos de integración.
- * @param {object} signerData - Datos del firmante a agregar.
- * @returns {Promise<object>} Objeto con el resultado de agregar el firmante.
+ * 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 (
@@ -150,7 +145,7 @@ export const addSigner = async (signerData) => {
     Object.keys(signerData).length === 0
   ) {
     throw new ApacuanaAPIError(
-      "Los datos del firmante (signerData) son requeridos y deben ser un objeto no vacío.",
+      "Signer data (signerData) is required and must be a non-empty object.",
       400,
       "INVALID_PARAMETER"
     );
@@ -167,7 +162,7 @@ export const addSigner = async (signerData) => {
   }
 
   throw new ApacuanaAPIError(
-    `Tipo de integración no soportado: ${integrationType}`,
+    `Unsupported integration type: ${integrationType}`,
     400,
     "UNSUPPORTED_INTEGRATION_TYPE"
   );
@@ -175,7 +170,7 @@ export const addSigner = async (signerData) => {
 
 const getDocsOnPremise = async () => {
   throw new ApacuanaAPIError(
-    "La obtención de documentos no está soportada para el tipo de integración: ONBOARDING",
+    "Document retrieval is not supported for integration type: ONBOARDING",
     501,
     "NOT_IMPLEMENTED"
   );
@@ -185,31 +180,45 @@ const getDocsOnBoarding = async (data) => {
   const { customerId } = getConfig();
   if (!customerId) {
     throw new ApacuanaAPIError(
-      "El 'customerId' no está configurado. Por favor, configure el SDK.",
+      "'customerId' is not configured. Please configure the SDK.",
       400,
       "CONFIGURATION_ERROR"
     );
   }
 
   try {
-    const apiUrl = `services/api/documents/listcustomer?page=${data.page}&customerid=${customerId}&size=${data.size}&status=${data.status}`;
+    const params = new URLSearchParams({
+      page: data.page,
+      customerid: customerId,
+      size: data.size,
+    });
+
+    if (typeof data.status !== "undefined") {
+      params.append("status", data.status);
+    }
 
+    const apiUrl = `services/api/documents/listcustomer?${params.toString()}`;
     const response = await httpRequest(apiUrl, {}, "GET");
-    return response;
+    return {
+      totalRecords: response.numofrecords,
+      records: response.records,
+      success: true,
+    };
   } catch (error) {
     if (error.name === "ApacuanaAPIError") {
       throw error;
     }
     throw new ApacuanaAPIError(
-      `Fallo al obtener la lista de documentos (on-premise): ${error.message}`
+      `Failed to get document list (on-premise): ${error.message}`
     );
   }
 };
 
 /**
- * Obtiene una lista de documentos.
- * @param {object} data - Objeto con los parámetros de paginación. Debe contener {page, size}.
- * @returns {Promise<object>} Objeto con la lista de documentos.
+ * 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);
@@ -225,7 +234,7 @@ export const getDocs = async (data) => {
   }
 
   throw new ApacuanaAPIError(
-    `La obtención de documentos no está soportada para un tipo de integración desconocido: ${integrationType}`,
+    `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"
       );
@@ -56,17 +46,14 @@ const getCustomer = async () => {
       token: response.sessionid,
       userData: response.entry,
       success: true,
-    }; // Retorna el objeto de usuario directamente
+    };
   } 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/index.js

@@ -2,7 +2,7 @@ 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 { generateCert, getCertStatus } from "./api/certs";
 import { addSigner, getDocs } from "./api/signatures";
 
 const apacuana = {
@@ -65,6 +65,7 @@ const apacuana = {
   getCustomer,
   addSigner,
   getDocs,
+  generateCert,
 };
 
 export default apacuana;

package/src/utils/helpers.js

@@ -196,6 +196,22 @@ const validateGetDocsData = (data) => {
   }
 };
 
+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 default {
   getCertificateStatus,
   exportPrivateKey,
@@ -204,4 +220,5 @@ export default {
   validateOnBoardingSignerData,
   validateCsr,
   validateGetDocsData,
+  validateGetDigestData,
 };