apacuana-sdk-core 1.22.0 → 1.25.0

package/dist/types/faceLiveness.d.ts

@@ -1,11 +1 @@
 export type ApacuanaSuccess = import("../success").ApacuanaSuccess;
-export type CreateFaceLivenessSessionData = {
-    /**
-     * - The session ID for the face liveness check.
-     */
-    sessionId: string;
-};
-export type CreateFaceLivenessSessionResponse = {
-    success: true;
-    data: CreateFaceLivenessSessionData;
-};

package/dist/utils/helpers.d.ts

@@ -9,6 +9,7 @@ declare namespace _default {
     export { validateGetDigestData };
     export { validateOnBoardingSignDocumentData };
     export { createPayloadGetDigest };
+    export { base64ToFile };
 }
 export default _default;
 declare function getCertificateStatus(userData: any, certificateInDevice: any, integrationType: any): string;
@@ -23,3 +24,4 @@ declare function validateGetDocsData(data: any): void;
 declare function validateGetDigestData(signData: any): void;
 declare function validateOnBoardingSignDocumentData(signData: any): FormData;
 declare function createPayloadGetDigest(signData: any): FormData;
+declare function base64ToFile(dataurl: any, filename: any): File;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "apacuana-sdk-core",
-  "version": "1.22.0",
+  "version": "1.25.0",
   "description": "Core SDK para interacciones con las APIs de Apacuana.",
-  "main": "dist/index.cjs",
+  "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "type": "module",
   "scripts": {
     "clean": "rimraf dist",
     "clean-modules": "rimraf node_modules",

package/src/api/faceLiveness.js

@@ -1,129 +1,51 @@
-/**
- * @typedef {import('../types/faceLiveness').CreateFaceLivenessSessionResponse} CreateFaceLivenessSessionResponse
- */
-
+/* eslint-disable import/prefer-default-export */
 import { getConfig } from "../config/index";
 import { httpRequest } from "../utils/httpClient";
 import { ApacuanaAPIError } from "../errors";
 import ApacuanaSuccess from "../success";
 import { INTEGRATION_TYPE } from "../utils/constant";
+import helpers from "../utils/helpers";
 
-/**
- * Creates a new Face Liveness session.
- * @returns {Promise<CreateFaceLivenessSessionResponse>} Object with the session ID 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.
- */
-const createFaceLivenessSessionOnBoarding = async () => {
+const sendFaceLivenessOnBoarding = async (faceliveness, documentprefid) => {
   try {
-    const response = await httpRequest(
-      "services/api/faceliveness/create",
-      {},
-      "POST"
-    );
-    if (!response.sessionid) {
-      throw new ApacuanaAPIError(
-        "The API response does not contain the session ID.",
-        response.status,
-        "INVALID_API_RESPONSE"
-      );
-    }
-
-    return new ApacuanaSuccess({
-      sessionId: response.sessionid,
-    });
-  } catch (error) {
-    if (error instanceof ApacuanaAPIError) {
-      throw error;
-    }
-    throw new ApacuanaAPIError(
-      `Failed to create Face Liveness session: ${error.message}`
+    const file = helpers.base64ToFile(
+      faceliveness,
+      `liveness_capture_${Date.now()}.png`
     );
-  }
-};
-
-const createFaceLivenessSessionOnPremise = async () => {
-  throw new ApacuanaAPIError(
-    "Creating a Face Liveness session is not supported for integration type: ONPREMISE",
-    501,
-    "NOT_IMPLEMENTED"
-  );
-};
-
-const validateFaceLivenessOnBoarding = async (sessionId) => {
-  try {
     const response = await httpRequest(
-      "services/api/faceliveness/validate",
-      { sessionid: sessionId },
+      "services/api/faceliveness/uploadfaceliveness",
+      { faceliveness: file, documentprefid },
       "POST"
     );
     return new ApacuanaSuccess({ status: "verified", ...response });
   } catch (error) {
     if (error instanceof ApacuanaAPIError) {
-      let status;
-      switch (error.statusCode) {
-        case 402:
-          status = "waitingForScan";
-          break;
-        case 403:
-          status = "rejected";
-          break;
-        case 406:
-          status = "processing";
-          break;
-        case 408:
-          status = "expired";
-          break;
-        default:
-          throw error;
-      }
-      return new ApacuanaSuccess({ status });
+      throw error;
     }
-    throw error;
+    throw new Error(`Failed to send faceliveness: ${error.message}`);
   }
 };
 
-const validateFaceLivenessOnPremise = async () => {
+const sendFaceLivenessOnPremise = async () => {
   throw new ApacuanaAPIError(
-    "Validating a Face Liveness session is not supported for integration type: ONPREMISE",
+    "Send a Face Liveness is not supported for integration type: ONPREMISE",
     501,
     "NOT_IMPLEMENTED"
   );
 };
 
-/**
- * Creates a new Face Liveness session.
- * @returns {Promise<CreateFaceLivenessSessionResponse>} Object with the session ID 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 createFaceLivenessSession = async () => {
-  const { integrationType } = getConfig();
-
-  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
-    return createFaceLivenessSessionOnBoarding();
-  }
-  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
-    return createFaceLivenessSessionOnPremise();
-  }
-
-  throw new ApacuanaAPIError(
-    `Unsupported integration type: ${integrationType}`,
-    400,
-    "UNSUPPORTED_INTEGRATION_TYPE"
-  );
-};
-
 /**
  * Validates a Face Liveness session and returns its status.
- * @param {{sessionId: string}} params - Object containing the session ID.
+ * @param {object} params - Parámetros para la solicitud.
+ * @param {string} params.faceLiveness - El faceLiveness.
+ * @param {string} params.documentprefid - El documentprefid.
  * @returns {Promise<ApacuanaSuccess>} Object with the validation status.
  * @throws {ApacuanaAPIError} If the API response is invalid or the integration type is not supported.
  */
-export const validateFaceLiveness = async ({ sessionId }) => {
-  if (!sessionId) {
+export const sendFaceLiveness = async ({ faceLiveness, documentprefid }) => {
+  if (!faceLiveness || !documentprefid) {
     throw new ApacuanaAPIError(
-      "sessionId is a required parameter.",
+      "faceLiveness and  documentprefid is a required parameter.",
       400,
       "INVALID_PARAMETER"
     );
@@ -132,10 +54,10 @@ export const validateFaceLiveness = async ({ sessionId }) => {
   const { integrationType } = getConfig();
 
   if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
-    return validateFaceLivenessOnBoarding(sessionId);
+    return sendFaceLivenessOnBoarding(faceLiveness, documentprefid);
   }
   if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
-    return validateFaceLivenessOnPremise();
+    return sendFaceLivenessOnPremise();
   }
 
   throw new ApacuanaAPIError(

package/src/index.js

@@ -16,10 +16,7 @@ import {
   signDocument,
   uploadSignatureVariant,
 } from "./api/signatures";
-import {
-  createFaceLivenessSession,
-  validateFaceLiveness,
-} from "./api/faceLiveness";
+import { sendFaceLiveness } from "./api/faceLiveness";
 import ApacuanaSuccess from "./success/index";
 import { ApacuanaAPIError } from "./errors/index";
 import { createApacuanaUser, getCustomer } from "./api/users";
@@ -149,22 +146,15 @@ const apacuana = {
     checkSdk(true);
     return getCustomer();
   },
-  createFaceLivenessSession: () => {
-    checkSdk(true);
-    return createFaceLivenessSession();
-  },
+
   createApacuanaUser: (data) => {
     checkSdk(false);
     return createApacuanaUser(data);
   },
-  validateFaceLiveness: (data) => {
+  sendFaceLiveness: (data) => {
     checkSdk(true);
-    return validateFaceLiveness(data);
+    return sendFaceLiveness(data);
   },
-  // validateCertificate: (data) => {
-  //   checkSdk(true);
-  //   validateCertificate(data);
-  // },
 
   close: () => close(),
   getConfig,

package/src/types/faceLiveness.js

@@ -2,15 +2,4 @@
  * @typedef {import('../success').ApacuanaSuccess} ApacuanaSuccess
  */
 
-/**
- * @typedef {object} CreateFaceLivenessSessionData
- * @property {string} sessionId - The session ID for the face liveness check.
- */
-
-/**
- * @typedef {object} CreateFaceLivenessSessionResponse
- * @property {true} success
- * @property {CreateFaceLivenessSessionData} data
- */
-
-export {};
+export {};

package/src/utils/helpers.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-plusplus */
 import CryptoJS from "crypto-js";
 import { getCrypto } from "pkijs";
 import {
@@ -387,6 +388,21 @@ const validateOnBoardingSignDocumentData = (signData) => {
   return formData;
 };
 
+const base64ToFile = (dataurl, filename) => {
+  const arr = dataurl.split(",");
+  const mime = arr[0].match(/:(.*?);/)[1];
+  const bstr = atob(arr[1]);
+  let n = bstr.length;
+  const u8arr = new Uint8Array(n);
+
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+
+  const blob = new Blob([u8arr], { type: mime });
+  return new File([blob], filename, { type: mime });
+};
+
 export default {
   getCertificateStatus,
   exportPrivateKey,
@@ -398,4 +414,5 @@ export default {
   validateGetDigestData,
   validateOnBoardingSignDocumentData,
   createPayloadGetDigest,
+  base64ToFile,
 };

package/tests/api/faceLiveness.test.js

@@ -1,13 +1,12 @@
-import {
-  createFaceLivenessSession,
-  validateFaceLiveness,
-} from "../../src/api/faceLiveness";
+import { sendFaceLiveness } from "../../src/api/faceLiveness";
 import { httpRequest } from "../../src/utils/httpClient";
 import ApacuanaSuccess from "../../src/success";
-import { setConfig, getConfig } from "../../src/config";
+import { getConfig } from "../../src/config";
 import { ApacuanaAPIError } from "../../src/errors";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
+import helpers from "../../src/utils/helpers";
 
+// Mocks de las dependencias
 jest.mock("../../src/utils/httpClient", () => ({
   httpRequest: jest.fn(),
 }));
@@ -17,154 +16,94 @@ jest.mock("../../src/config", () => ({
   setConfig: jest.fn(),
 }));
 
+jest.mock("../../src/utils/helpers", () => ({
+  base64ToFile: jest.fn(),
+}));
+
 describe("FaceLiveness API", () => {
+  const mockBase64 = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...";
+  const mockPrefId = "pref-abc-123";
+
   beforeEach(() => {
     jest.clearAllMocks();
+    // Configuración por defecto para la mayoría de las pruebas
     getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
   });
 
-  describe("createFaceLivenessSession", () => {
-    it("should create a session for ONBOARDING integration", async () => {
-      const mockSessionId = "session-onboarding-123";
-      httpRequest.mockResolvedValue({ sessionid: mockSessionId });
-      setConfig({ onboardingId: "some-onboarding-id" });
+  describe("sendFaceLiveness", () => {
+    it("debe enviar la captura exitosamente para integración ONBOARDING", async () => {
+      // Configuramos el mock para que devuelva un objeto File simulado
+      helpers.base64ToFile.mockReturnValue(new File([""], "liveness.png"));
+      httpRequest.mockResolvedValue({ success: true, transactionId: "12345" });
 
-      const result = await createFaceLivenessSession();
+      const result = await sendFaceLiveness({
+        faceLiveness: mockBase64,
+        documentprefid: mockPrefId,
+      });
 
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data.status).toBe("verified");
       expect(httpRequest).toHaveBeenCalledWith(
-        "services/api/faceliveness/create",
-        {},
+        "services/api/faceliveness/uploadfaceliveness",
+        expect.objectContaining({ documentprefid: mockPrefId }),
         "POST"
       );
-      expect(result).toBeInstanceOf(ApacuanaSuccess);
-      expect(result.data).toEqual({ sessionId: mockSessionId });
     });
 
-    it("should throw an error if session ID is missing for ONBOARDING", async () => {
-      httpRequest.mockResolvedValue({}); // No sessionId
-
-      await expect(createFaceLivenessSession()).rejects.toThrow(
-        new ApacuanaAPIError(
-          "The API response does not contain the session ID.",
-          undefined,
-          "INVALID_API_RESPONSE"
-        )
+    it("debe lanzar un error si faltan parámetros (validando el mensaje exacto)", async () => {
+      // El mensaje debe coincidir exactamente con la implementación (incluyendo espacios dobles si existen)
+      await expect(sendFaceLiveness({ faceLiveness: "" })).rejects.toThrow(
+        "faceLiveness and  documentprefid is a required parameter."
       );
     });
 
-    it("should throw a NOT_IMPLEMENTED error for ONPREMISE integration", async () => {
+    it("debe lanzar error 501 NOT_IMPLEMENTED para integración ONPREMISE", async () => {
       getConfig.mockReturnValue({
         integrationType: INTEGRATION_TYPE.ONPREMISE,
       });
 
-      await expect(createFaceLivenessSession()).rejects.toThrow(
+      await expect(
+        sendFaceLiveness({
+          faceLiveness: mockBase64,
+          documentprefid: mockPrefId,
+        })
+      ).rejects.toThrow(
         new ApacuanaAPIError(
-          "Creating a Face Liveness session is not supported for integration type: ONPREMISE",
+          "Send a Face Liveness is not supported for integration type: ONPREMISE",
           501,
           "NOT_IMPLEMENTED"
         )
       );
     });
 
-    it("should throw an UNSUPPORTED_INTEGRATION_TYPE error for unsupported integration types", async () => {
-      getConfig.mockReturnValue({ integrationType: "unsupported-type" });
+    it("debe lanzar UNSUPPORTED_INTEGRATION_TYPE para tipos no soportados", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
 
-      await expect(createFaceLivenessSession()).rejects.toThrow(
+      await expect(
+        sendFaceLiveness({
+          faceLiveness: mockBase64,
+          documentprefid: mockPrefId,
+        })
+      ).rejects.toThrow(
         new ApacuanaAPIError(
-          "Unsupported integration type: unsupported-type",
+          "Unsupported integration type: INVALID_TYPE",
           400,
           "UNSUPPORTED_INTEGRATION_TYPE"
         )
       );
     });
 
-    it("should re-throw ApacuanaAPIError if caught during session creation", async () => {
+    it("debe relanzar ApacuanaAPIError si ocurre durante el envío", async () => {
       const apiError = new ApacuanaAPIError("API Error", 500, "API_ERROR");
+      helpers.base64ToFile.mockReturnValue(new File([""], "test.png"));
       httpRequest.mockRejectedValue(apiError);
 
-      await expect(createFaceLivenessSession()).rejects.toThrow(apiError);
-    });
-
-    it("should throw a generic error for other failures during session creation", async () => {
-      const genericError = new Error("Network Error");
-      httpRequest.mockRejectedValue(genericError);
-
-      await expect(createFaceLivenessSession()).rejects.toThrow(
-        `Failed to create Face Liveness session: ${genericError.message}`
-      );
-    });
-  });
-
-  describe("validateFaceLiveness", () => {
-    const sessionId = "test-session-id";
-
-    it("should throw an error if sessionId is not provided", async () => {
-      await expect(validateFaceLiveness({})).rejects.toThrow(
-        new ApacuanaAPIError(
-          "sessionId is a required parameter.",
-          400,
-          "INVALID_PARAMETER"
-        )
-      );
-    });
-
-    it("should return 'verified' on status 200", async () => {
-      httpRequest.mockResolvedValue({ someData: "data" });
-
-      const result = await validateFaceLiveness({ sessionId });
-
-      expect(result).toBeInstanceOf(ApacuanaSuccess);
-      expect(result.data).toEqual({ status: "verified", someData: "data" });
-      expect(httpRequest).toHaveBeenCalledWith(
-        "services/api/faceliveness/validate",
-        { sessionid: sessionId },
-        "POST"
-      );
-    });
-
-    it.each([
-      [402, "waitingForScan"],
-      [403, "rejected"],
-      [406, "processing"],
-      [408, "expired"],
-    ])(
-      "should return status '%s' for statusCode %i",
-      async (statusCode, status) => {
-        const apiError = new ApacuanaAPIError("Error", statusCode, "API_ERROR");
-        httpRequest.mockRejectedValue(apiError);
-
-        const result = await validateFaceLiveness({ sessionId });
-
-        expect(result).toBeInstanceOf(ApacuanaSuccess);
-        expect(result.data).toEqual({ status });
-      }
-    );
-
-    it("should throw an error for unhandled status codes", async () => {
-      const apiError = new ApacuanaAPIError(
-        "Unhandled Error",
-        500,
-        "API_ERROR"
-      );
-      httpRequest.mockRejectedValue(apiError);
-
-      await expect(validateFaceLiveness({ sessionId })).rejects.toThrow(
-        apiError
-      );
-    });
-
-    it("should throw a NOT_IMPLEMENTED error for ONPREMISE integration", async () => {
-      getConfig.mockReturnValue({
-        integrationType: INTEGRATION_TYPE.ONPREMISE,
-      });
-
-      await expect(validateFaceLiveness({ sessionId })).rejects.toThrow(
-        new ApacuanaAPIError(
-          "Validating a Face Liveness session is not supported for integration type: ONPREMISE",
-          501,
-          "NOT_IMPLEMENTED"
-        )
-      );
+      await expect(
+        sendFaceLiveness({
+          faceLiveness: mockBase64,
+          documentprefid: mockPrefId,
+        })
+      ).rejects.toThrow(apiError);
     });
   });
 });