apacuana-sdk-core 0.8.0 → 0.10.0

package/package.json

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

package/src/api/certs.js

@@ -99,3 +99,130 @@ export const getCertStatus = (isCertificateInDevice = false) => {
     success: true,
   };
 };
+
+/**
+ * @typedef {object} CertType
+ * @property {string} id - The ID of the certificate type.
+ * @property {string} name - The name of the certificate type.
+ */
+
+/**
+ * @typedef {object} GetCertTypesResponse
+ * @property {Array<CertType>} types - A list of available certificate types.
+ * @property {boolean} success - Indicates if the operation was successful.
+ */
+
+const getCertTypesOnBoarding = async () => {
+  try {
+    const response = await httpRequest(
+      "services/api/customer/typeusers",
+      {},
+      "GET"
+    );
+
+    return { ...response, success: true };
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(`Failed to get certificate types: ${error.message}`);
+  }
+};
+
+const getCertTypesOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Getting certificate types is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+/**
+ * Gets the available certificate types.
+ * @returns {Promise<GetCertTypesResponse>} Object with the list of certificate types and a success indicator.
+ * @throws {ApacuanaAPIError} If the API response is invalid or the integration type is not supported.
+ * @throws {Error} If the request fails for another reason.
+ */
+export const getCertTypes = async () => {
+  const { integrationType } = getConfig();
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getCertTypesOnBoarding();
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getCertTypesOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+/**
+ * @typedef {object} Requirement
+ * @property {string} id - The ID of the requirement.
+ * @property {string} description - The description of the requirement.
+ */
+
+/**
+ * @typedef {object} GetRequirementsResponse
+ * @property {Array<Requirement>} requirements - A list of requirements for the user type.
+ * @property {boolean} success - Indicates if the operation was successful.
+ */
+
+const getRequerimentsByTypeUserOnBoarding = async (type) => {
+  try {
+    const response = await httpRequest(
+      `services/api/customer/documentspref?typeuser=${type}`,
+      {},
+      "GET"
+    );
+
+    return { ...response, success: true };
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(`Failed to get requirements: ${error.message}`);
+  }
+};
+
+const getRequerimentsByTypeUserOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Getting requirements by user type is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+/**
+ * Gets the requirements for a given user type.
+ * @param {object} params - The parameters.
+ * @param {number} params.type - The user type to get requirements for.
+ * @returns {Promise<GetRequirementsResponse>} Object with the list of requirements and a success indicator.
+ * @throws {ApacuanaAPIError} If the API response is invalid or the integration type is not supported.
+ * @throws {Error} If the request fails for another reason or the type is invalid.
+ */
+export const getRequerimentsByTypeUser = async (params) => {
+  if (!params || typeof params.type !== "number") {
+    throw new Error(
+      'The "params" object with a numeric "type" property is required.'
+    );
+  }
+  const { type } = params;
+
+  const { integrationType } = getConfig();
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getRequerimentsByTypeUserOnBoarding(type);
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getRequerimentsByTypeUserOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};

package/src/api/revocations.js

@@ -1,5 +1,7 @@
 import { httpRequest } from "../utils/httpClient";
 import { ApacuanaAPIError } from "../errors/index";
+import { getConfig } from "../config";
+import { INTEGRATION_TYPE } from "../utils/constant";
 
 /**
  * @typedef {object} RequestRevocationResponse
@@ -60,11 +62,21 @@ export const requestRevocation = async (reasonCode) => {
  * @throws {ApacuanaAPIError} If fetching the reasons fails.
  */
 export const getRevocationReasons = async () => {
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    throw new ApacuanaAPIError(
+      `Get revocation reasons is not supported for integration type: ${integrationType}`,
+      501,
+      "NOT_IMPLEMENTED"
+    );
+  }
+
   try {
     const response = await httpRequest(
+      "GET",
       "config/api/revocation/reasonsonboarding",
-      {},
-      "GET"
+      {}
     );
 
     if (!response.records) {

package/src/api/signatures.js

@@ -218,6 +218,85 @@ const getDocsOnBoarding = async (data) => {
   }
 };
 
+const uploadSignatureVariantOnBoarding = async ({ file }) => {
+  try {
+    const response = await httpRequest(
+      "services/api/customer/signaturephoto",
+      { file },
+      "POST"
+    );
+    return { ...response, success: true };
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to upload signature variant: ${error.message || "Unknown error"}`
+    );
+  }
+};
+
+const uploadSignatureVariantOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Uploading signature variants is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const getSignatureVariantOnBoarding = async () => {
+  const { customerId } = getConfig();
+  try {
+    const response = await httpRequest(
+      `services/api/customer/getsignaturephotosdk/${customerId}`,
+      {},
+      "GET"
+    );
+    return { ...response, success: true };
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to get signature variant: ${error.message || "Unknown error"}`
+    );
+  }
+};
+
+const getSignatureVariantOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Getting signature variants is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const deleteSignatureVariantOnBoarding = async () => {
+  try {
+    const response = await httpRequest(
+      "services/api/customer/cleansignaturephoto",
+      {},
+      "DELETE"
+    );
+    return { ...response, success: true };
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to delete signature variant: ${error.message || "Unknown error"}`
+    );
+  }
+};
+
+const deleteSignatureVariantOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Deleting signature variants is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
 // =================================================================
 // Exported Functions
 // =================================================================
@@ -358,3 +437,98 @@ export const getDocs = async (data) => {
     "NOT_IMPLEMENTED"
   );
 };
+
+/**
+ * Sube una variante de firma para un firmante.
+ * @param {object} data - Datos para la subida.
+ * @param {File} data.file - El archivo de la variante de firma (debe ser PNG).
+ * @returns {Promise<object>} Una promesa que resuelve a un objeto con el resultado de la operación.
+ * @throws {ApacuanaAPIError} Si los datos son inválidos o la llamada a la API falla.
+ */
+export const uploadSignatureVariant = async (data) => {
+  if (!data || !data.file) {
+    throw new ApacuanaAPIError(
+      "El parámetro 'file' es requerido.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  if (typeof File === "undefined" || !(data.file instanceof File)) {
+    throw new ApacuanaAPIError(
+      "El parámetro 'file' debe ser una instancia de 'File'.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  if (data.file.type !== "image/png") {
+    throw new ApacuanaAPIError(
+      "El archivo debe ser de tipo PNG (image/png).",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return uploadSignatureVariantOnBoarding(data);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return uploadSignatureVariantOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+/**
+ * Obtiene la variante de firma del firmante.
+ * @returns {Promise<object>} Una promesa que resuelve a un objeto con los datos de la variante de firma.
+ * @throws {ApacuanaAPIError} Si la llamada a la API falla o el tipo de integración no es soportado.
+ */
+export const getSignatureVariant = async () => {
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getSignatureVariantOnBoarding();
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getSignatureVariantOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+/**
+ * Elimina la variante de firma del firmante.
+ * @returns {Promise<object>} Una promesa que resuelve a un objeto con el resultado de la operación.
+ * @throws {ApacuanaAPIError} Si la llamada a la API falla o el tipo de integración no es soportado.
+ */
+export const deleteSignatureVariant = async () => {
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return deleteSignatureVariantOnBoarding();
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return deleteSignatureVariantOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};

package/src/index.js

@@ -2,8 +2,21 @@ import { setConfig, getConfig, close } from "./config/index";
 import { initHttpClient, setAuthToken } from "./utils/httpClient";
 import getCustomer from "./api/users";
 import { requestRevocation, getRevocationReasons } from "./api/revocations";
-import { generateCert, getCertStatus } from "./api/certs";
-import { addSigner, getDigest, getDocs, signDocument } from "./api/signatures";
+import {
+  generateCert,
+  getCertStatus,
+  getCertTypes,
+  getRequerimentsByTypeUser,
+} from "./api/certs";
+import {
+  addSigner,
+  deleteSignatureVariant,
+  getDigest,
+  getDocs,
+  getSignatureVariant,
+  signDocument,
+  uploadSignatureVariant,
+} from "./api/signatures";
 
 const apacuana = {
   /**
@@ -50,6 +63,11 @@ const apacuana = {
   signDocument,
   getDigest,
   getRevocationReasons,
+  uploadSignatureVariant,
+  getSignatureVariant,
+  deleteSignatureVariant,
+  getCertTypes,
+  getRequerimentsByTypeUser,
 };
 
 export default apacuana;

package/src/utils/httpClient.js

@@ -27,7 +27,6 @@ export const initHttpClient = () => {
   axiosInstance = axios.create({
     baseURL: config.apiUrl,
     headers: {
-      "Content-Type": "application/json",
       "APACUANA-API-Key": config.apiKey,
       "APACUANA-SECRET-Key": config.secretKey,
       // La cabecera Authorization se deja vacía al inicio.
@@ -41,9 +40,12 @@ export const initHttpClient = () => {
     (response) => {
       // Maneja errores lógicos de la API (si el backend devuelve status 2xx con { success: false })
       if (response.data && response.data.success === false) {
+        const errorMessage =
+          response.data?.msg ||
+          response.data?.message ||
+          "Error lógico desconocido desde la API.";
         throw new ApacuanaAPIError(
-          response.data.message ||
-            "Error lógico en la respuesta de la API (status 2xx)",
+          errorMessage,
           response.status,
           response.data.code || "LOGICAL_API_ERROR"
         );
@@ -60,10 +62,12 @@ export const initHttpClient = () => {
 
       if (error.response) {
         const { status, data } = error.response;
+        const errorMessage =
+          data?.msg || data?.message || "Error desconocido desde la API.";
         throw new ApacuanaAPIError(
-          data.message || `Error en la API: ${status}`,
+          errorMessage,
           status,
-          data.code || "API_ERROR"
+          data?.code || "API_ERROR"
         );
       }
       if (error.request) {
@@ -122,12 +126,21 @@ export const httpRequest = async (path, data = {}, method = "POST") => {
     );
   }
 
-  // Creamos el cuerpo de la petición fusionando los datos de la llamada
-  // con los parámetros de inicialización.
-  const dataToSend = {
-    ...data,
-  };
+  let dataToSend;
+  const requestConfig = {};
 
+  const hasFile = Object.values(data).some(
+    (value) => typeof File !== "undefined" && value instanceof File
+  );
+  if (hasFile) {
+    const formData = new FormData();
+    Object.keys(data).forEach((key) => {
+      formData.append(key, data[key]);
+    });
+    dataToSend = formData;
+  } else {
+    dataToSend = { ...data };
+  }
   try {
     let response;
     switch (method.toUpperCase()) {
@@ -135,13 +148,16 @@ export const httpRequest = async (path, data = {}, method = "POST") => {
         response = await axiosInstance.get(path, { params: dataToSend });
         break;
       case "POST":
-        response = await axiosInstance.post(path, dataToSend);
+        response = await axiosInstance.post(path, dataToSend, requestConfig);
         break;
       case "PUT":
-        response = await axiosInstance.put(path, dataToSend);
+        response = await axiosInstance.put(path, dataToSend, requestConfig);
         break;
       case "DELETE":
-        response = await axiosInstance.delete(path, { data: dataToSend });
+        response = await axiosInstance.delete(path, {
+          data: dataToSend,
+          ...requestConfig,
+        });
         break;
       default:
         throw new ApacuanaAPIError(
@@ -151,14 +167,8 @@ export const httpRequest = async (path, data = {}, method = "POST") => {
         );
     }
 
-    // Si la promesa se resolvió, la respuesta es exitosa.
-    // El interceptor ya manejó los errores 4xx/5xx y los errores lógicos 2xx.
-    // eslint-disable-next-line no-console
     return response.data;
   } catch (error) {
-    // Si la petición falla, el interceptor ya procesó el error.
-    // Simplemente relanzamos el error para que sea capturado por la función de API.
-    // eslint-disable-next-line no-console
     console.error(`[HTTP Client] Fallo en la petición a ${path}:`, error);
     throw error;
   }

package/tests/api/certs.test.js

@@ -2,7 +2,12 @@ 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 {
+  generateCert,
+  getCertStatus,
+  getCertTypes,
+  getRequerimentsByTypeUser,
+} from "../../src/api/certs";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
 
 jest.mock("../../src/config/index");
@@ -91,4 +96,111 @@ describe("Certificate API - certs.js", () => {
       expect(result).toEqual({ status: "VALID", success: true });
     });
   });
+
+  describe("getCertTypes", () => {
+    it("should call getCertTypesOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockApiResponse = { types: [{ id: "1", name: "Type 1" }] };
+      httpRequest.mockResolvedValue(mockApiResponse);
+
+      const result = await getCertTypes();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/typeusers",
+        {},
+        "GET"
+      );
+      expect(result).toEqual({ types: mockApiResponse.types, success: true });
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getCertTypes()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting certificate types is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for an unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+
+      await expect(getCertTypes()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: INVALID_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("getRequerimentsByTypeUser", () => {
+    it("should call getRequerimentsByTypeUserOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockApiResponse = {
+        requirements: [{ id: "1", description: "Requirement 1" }],
+      };
+      httpRequest.mockResolvedValue(mockApiResponse);
+
+      const result = await getRequerimentsByTypeUser({ type: 1 });
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/documentspref?typeuser=1",
+        {},
+        "GET"
+      );
+      expect(result).toEqual({
+        requirements: mockApiResponse.requirements,
+        success: true,
+      });
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getRequerimentsByTypeUser({ type: 1 })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting requirements by user type is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for an unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+
+      await expect(getRequerimentsByTypeUser({ type: 1 })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: INVALID_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("should throw an error if params are invalid", async () => {
+      await expect(getRequerimentsByTypeUser()).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+      await expect(getRequerimentsByTypeUser({})).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+      await expect(getRequerimentsByTypeUser({ type: "1" })).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+    });
+  });
 });