apacuana-sdk-core 0.1.0

package/jest.config.cjs

@@ -0,0 +1,7 @@
+// jest.config.js
+module.exports = {
+  testEnvironment: "node", // Para tests de backend, si tu SDK es universal
+  collectCoverage: true,
+  coverageDirectory: "coverage",
+  // Puedes añadir más configuraciones de cobertura si lo deseas
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "apacuana-sdk-core",
+  "version": "0.1.0",
+  "description": "Core SDK para interacciones con las APIs de Apacuana.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "type": "module",
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint src/",
+    "build": "rollup -c",
+    "prepublishOnly": "npm test && npm run build",
+    "validate": "npm run lint && npm test && npm run build"
+  },
+  "keywords": [
+    "apacuana",
+    "sdk",
+    "core",
+    "certificados",
+    "firma"
+  ],
+  "author": "Gega",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.24.7",
+    "@babel/preset-env": "^7.24.7",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "eslint": "^8.57.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.29.1",
+    "jest": "^29.7.0",
+    "rollup": "^4.18.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "asn1js": "^3.0.6",
+    "axios": "^1.11.0",
+    "crypto-js": "^4.2.0",
+    "pkijs": "^3.2.5"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,32 @@
+import babel from '@rollup/plugin-babel';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json'; // Add this import
+
+export default {
+  input: 'src/index.js',
+  output: [
+    {
+      file: 'dist/index.js',
+      format: 'cjs',
+      sourcemap: true,
+    },
+    {
+      file: 'dist/index.mjs',
+      format: 'es',
+      sourcemap: true,
+    },
+  ],
+  plugins: [
+    json(), // Add this plugin before nodeResolve
+    nodeResolve({
+      preferBuiltins: false,
+    }),
+    commonjs(),
+    babel({
+      babelHelpers: 'bundled',
+      exclude: 'node_modules/**',
+    }),
+  ],
+  external: ['axios'], // Mark axios as external to prevent bundling issues
+};

package/src/api/certs.js

@@ -0,0 +1,70 @@
+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 { httpRequest } from "../utils/httpClient";
+
+const generateCertOnBoarding = async () => {
+  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 response = await httpRequest(
+      "services/api/register/certificate",
+      body,
+      "POST"
+    );
+
+    const { cert } = response;
+    if (!cert) {
+      throw new ApacuanaAPIError(
+        "La respuesta de la API no contiene el certificado.",
+        response.status,
+        "INVALID_API_RESPONSE"
+      );
+    }
+
+    const exportedPrivateKey = await helpers.exportPrivateKey(
+      keyPair.privateKey
+    );
+
+    return { cert, privateKey: exportedPrivateKey };
+  } catch (error) {
+    // Se lanza el error capturado, que ya será de tipo ApacuanaAPIError o un Error nativo.
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(`Fallo en la generación del certificado: ${error.message}`);
+  }
+};
+
+export const generateCert = async () => {
+  const { integrationType } = getConfig();
+
+  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);
+  }
+};
+
+export const getCertStatus = () => {
+  const config = getConfig();
+  const status = helpers.getCertificateStatus(config.userData, false);
+  return {
+    status,
+  };
+};

package/src/api/revocations.js

@@ -0,0 +1,43 @@
+// src/api/revocations.js
+import { httpRequest } from '../utils/httpClient';
+import { ApacuanaAPIError } from '../errors/index';
+
+/**
+ * Simula la solicitud de revocación de un certificado.
+ * @param {string} reasonCode - Código o descripción del motivo de la revocación.
+ * @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:', {
+    reasonCode,
+  });
+
+  if (!reasonCode) {
+    throw new Error(
+      'ID de certificado y motivo son requeridos para requestRevocation.',
+    );
+  }
+
+  try {
+    const response = await httpRequest(
+      'users/api/customers/requestcert',
+      { reason: reasonCode },
+      'POST',
+    );
+    console.log('Respuesta del servidor', response);
+    if (!response.success) {
+      throw new ApacuanaAPIError(
+        response.message || 'Error desconocido al solicitar revocación.',
+      );
+    }
+    return {
+      revocationStatus: response.status || 'pending',
+      requestId: response.id,
+    };
+  } catch (error) {
+    throw new Error(`Fallo en la solicitud de revocación: ${error.message}`);
+  }
+};
+
+export default requestRevocation;

package/src/api/signatures.js

@@ -0,0 +1,77 @@
+// src/api/signatures.js
+import { httpRequest } from '../utils/httpClient';
+import { ApacuanaAPIError } from '../errors/index';
+
+/**
+ * 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.
+ */
+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.',
+    );
+  }
+
+  try {
+    const response = await httpRequest(
+      '/docs/sign',
+      { documentData, signatureData },
+      'POST',
+    );
+    console.log(
+      'Respuesta del servidor simulada para firmar documento:',
+      response,
+    );
+    if (!response.success) {
+      throw new ApacuanaAPIError(
+        response.message || 'Error desconocido al firmar documento.',
+      );
+    }
+    return { signedDocId: response.id, status: response.message };
+  } catch (error) {
+    throw new Error(`Fallo en la firma del documento: ${error.message}`);
+  }
+};
+
+/**
+ * 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.
+ */
+export const addSigner = async (signerData) => {
+  console.log("-> Función 'addSigner' ejecutada.");
+  console.log('Parámetros recibidos para agregar firmante:', signerData);
+
+  if (!signerData || typeof signerData !== 'object') {
+    throw new Error('Datos de firmante son requeridos para addSigner.');
+  }
+
+  try {
+    const response = await httpRequest(
+      '/docs/signers',
+      signerData,
+      'POST',
+    );
+    console.log(
+      'Respuesta del servidor simulada para agregar firmante:',
+      response,
+    );
+    if (!response.success) {
+      throw new ApacuanaAPIError(
+        response.message || 'Error desconocido al agregar firmante.',
+      );
+    }
+    return { signerId: response.id, status: response.message };
+  } catch (error) {
+    throw new Error(`Fallo al agregar firmante: ${error.message}`);
+  }
+};

package/src/api/users.js

@@ -0,0 +1,74 @@
+import { httpRequest } from "../utils/httpClient";
+import { ApacuanaAPIError } from "../errors/index";
+import { getConfig } from "../config/index";
+
+/**
+ * Obtiene el token de un usuario a través de una petición POST.
+ * 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.
+ * @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();
+  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
+      "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.",
+        200,
+        "INVALID_API_RESPONSE"
+      );
+    }
+
+    return {
+      token: response.sessionid,
+      userData: response.entry,
+    }; // 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"
+      }`
+    );
+  }
+};
+
+export default getCustomer;

package/src/auth/index.js

@@ -0,0 +1,24 @@
+// 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;
+};

package/src/config/index.js

@@ -0,0 +1,41 @@
+// src/config/index.js
+import { INTEGRATION_TYPE } from '../utils/constant';
+
+let config = {
+  apiUrl: "",
+  secretKey: "",
+  apiKey: "",
+  verificationId: "",
+  customerId: "",
+  integrationType: "",
+  userData: undefined,
+  token: undefined,
+};
+
+export const setConfig = (newConfig) => {
+  const { apiUrl, secretKey, apiKey, verificationId, integrationType } = newConfig;
+
+  if (!apiUrl || !secretKey || !apiKey || !verificationId || !integrationType) {
+    throw new Error(
+      "Apacuana SDK: La configuración inicial debe incluir apiUrl, " +
+        "secretKey, apiKey, verificationId e integrationType."
+    );
+  }
+
+  // Nueva validación para el valor de integrationType
+  if (!Object.values(INTEGRATION_TYPE).includes(integrationType)) {
+    throw new Error(
+      `Apacuana SDK: El valor de integrationType ('${integrationType}') no es válido. ` +
+      `Valores permitidos: ${Object.values(INTEGRATION_TYPE).join(', ')}`
+    );
+  }
+
+  config = { ...config, ...newConfig };
+  // eslint-disable-next-line no-console
+  console.log("[Config] SDK Configuración actualizada (desde config):", {
+    ...config,
+    secretKey: "********",
+  });
+};
+
+export const getConfig = () => ({ ...config });

package/src/errors/index.js

@@ -0,0 +1,20 @@
+// src/errors/index.js
+
+/**
+ * Clase de error personalizada para errores de la API de Apacuana.
+ */
+export class ApacuanaAPIError extends Error {
+  constructor(message, statusCode = 500, errorCode = null) {
+    super(message);
+    this.name = "ApacuanaAPIError";
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+
+    // Mantener el stack trace correcto
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ApacuanaAPIError);
+    }
+  }
+}
+
+export default ApacuanaAPIError;

package/src/index.js

@@ -0,0 +1,67 @@
+// 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";
+
+const apacuana = {
+  /**
+   * Inicializa el Apacuana SDK con la configuración necesaria y obtiene
+   * los detalles del usuario.
+   * @param {object} config - Objeto de configuración.
+   * @param {string} config.apiUrl - La URL base de la API de Apacuana.
+   * @param {string} config.secretKey - La clave secreta para la autenticación.
+   * @param {string} config.apiKey - La clave de API para la autenticación.
+   * @param {string} config.verificationId - El ID de verificación del usuario.
+   * @param {string} config.customerId - El ID del cliente.
+   * @param {string} config.integrationType - El tipo de integración ('onpremise' o 'onboarding').
+   * @returns {Promise<object>} retorna los detalles del usuario si la inicialización es exitosa.
+   */
+  init: async (config) => {
+    // eslint-disable-next-line no-console
+    console.log(
+      "-> apacuana-sdk: Iniciando configuración y validando usuario..."
+    );
+
+    try {
+      // 1. Guardar la configuración inicial
+      setConfig(config);
+
+      // 2. Inicializar el cliente HTTP con la configuración guardada
+      initHttpClient();
+
+      // 3. Opcional: Validar que la configuración se guardó correctamente
+      const currentConfig = getConfig();
+      if (!currentConfig.customerId) {
+        throw new Error(
+          "Apacuana SDK: La configuración de CustomerId no se ha guardado" +
+            " correctamente."
+        );
+      }
+
+      // 4. Obtener los detalles del usuario como parte de la inicialización
+      const { token, userData } = await getCustomer();
+
+      // Opcional: Guardar los detalles del usuario en la configuración
+      // para acceso futuro si fuera necesario
+      setConfig({ ...currentConfig, token, userData });
+      setAuthToken(token);
+      // eslint-disable-next-line no-console
+      console.log(
+        "-> apacuana-sdk: Inicialización completa. Usuario validado:",
+        token
+      );
+      return true;
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error("Error durante la inicialización del SDK:", error);
+      throw error;
+    }
+  },
+  getConfig,
+  requestRevocation,
+  getCertStatus,
+};
+
+export default apacuana;

package/src/utils/constant.js

@@ -0,0 +1,20 @@
+export const STATUS_CERTIFICATE = {
+  request: "SOLICITUD",
+  generate: "GENERAR",
+  current: "VIGENTE",
+  revoque: "REVOCADO",
+  expire: "EXPIRADO",
+  request_revoque: "SOLICITUD_DE_REVOCACION",
+  certificate_another_device: "CERTIFICADO_EN_OTRO_DISPOSITIVO",
+  sign_pending: "PENDIENTE_POR_FIRMAR",
+};
+
+export const VERIFICATION_STATUS = {
+  IN_REGISTER: 0,
+  APPROVED: 1,
+};
+
+export const INTEGRATION_TYPE = {
+  ONBOARDING: 'onboarding',
+  ONPREMISE: 'onpremise',
+};