apacuana-sdk-core 0.8.0 → 0.9.0

package/package.json

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

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

@@ -3,7 +3,15 @@ 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 {
+  addSigner,
+  deleteSignatureVariant,
+  getDigest,
+  getDocs,
+  getSignatureVariant,
+  signDocument,
+  uploadSignatureVariant,
+} from "./api/signatures";
 
 const apacuana = {
   /**
@@ -50,6 +58,9 @@ const apacuana = {
   signDocument,
   getDigest,
   getRevocationReasons,
+  uploadSignatureVariant,
+  getSignatureVariant,
+  deleteSignatureVariant,
 };
 
 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/revocations.test.js

@@ -1,6 +1,119 @@
-// tests/api/revocations.test.js
-describe('Revocations API', () => {
-  test('placeholder test', () => {
-    expect(true).toBe(true);
+import { httpRequest } from "../../src/utils/httpClient";
+import { ApacuanaAPIError } from "../../src/errors";
+import {
+  requestRevocation,
+  getRevocationReasons,
+} from "../../src/api/revocations";
+import { getConfig } from "../../src/config";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
+
+jest.mock("../../src/utils/httpClient");
+jest.mock("../../src/config");
+
+describe("Revocations API", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
   });
-});
+
+  describe("requestRevocation", () => {
+    it("should throw an error if reasonCode is not provided", async () => {
+      await expect(requestRevocation(null)).rejects.toThrow(
+        "Código de motivo es requerido para requestRevocation."
+      );
+    });
+
+    it("should make a POST request to the correct endpoint with the reasonCode", async () => {
+      const reasonCode = "COMPROMISED";
+      const mockResponse = { success: true, message: "Revocation requested" };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await requestRevocation(reasonCode);
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/onboardingclient/requestcert",
+        { reason: reasonCode },
+        "POST"
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it("should throw a generic error if the httpRequest fails", async () => {
+      const reasonCode = "COMPROMISED";
+      const apiError = new Error("Network error");
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(requestRevocation(reasonCode)).rejects.toThrow(
+        `Fallo en la solicitud de revocación: ${apiError.message}`
+      );
+    });
+  });
+
+  describe("getRevocationReasons", () => {
+    it("should make a GET request and return the reasons for ONBOARDING", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockReasons = [
+        { code: "0", description: "Unspecified" },
+        { code: "1", description: "Key Compromise" },
+      ];
+      httpRequest.mockResolvedValue({ records: mockReasons });
+
+      const result = await getRevocationReasons();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "GET",
+        "config/api/revocation/reasonsonboarding",
+        {}
+      );
+      expect(result).toEqual(mockReasons);
+    });
+
+    it("should throw an error if the API response does not contain 'records'", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      httpRequest.mockResolvedValue({ data: [] }); // Respuesta inválida
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        new ApacuanaAPIError("Failed to fetch revocation reasons.")
+      );
+    });
+
+    it("should re-throw ApacuanaAPIError if caught", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const apiError = new ApacuanaAPIError("API is down", 500);
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(getRevocationReasons()).rejects.toThrow(apiError);
+    });
+
+    it("should throw a generic error for other types of errors", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const genericError = new Error("Something went wrong");
+      httpRequest.mockRejectedValue(genericError);
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        "Failed to get revocation reasons. Please try again later."
+      );
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Get revocation reasons is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+  });
+});