apacuana-sdk-core 0.9.0 → 0.11.0

package/src/api/certs.js

@@ -1,27 +1,21 @@
+/**
+ * @typedef {import('../types/users').UserData} UserData
+ * @typedef {import('../types/certs').GenerateCertResponse} GenerateCertResponse
+ * @typedef {import('../types/certs').GetCertStatusResponse} GetCertStatusResponse
+ * @typedef {import('../types/certs').EncryptedCSRObject} EncryptedCSRObject
+ * @typedef {import('../types/certs').GetCertTypesResponse} GetCertTypesResponse
+ * @typedef {import('../types/certs').GetRequirementsResponse} GetRequirementsResponse
+ * @typedef {import('../types/certs').CertificateRequestParams} CertificateRequestParams
+ * @typedef {import('../types/certs').RequestCertificateResponse} RequestCertificateResponse
+ */
+
 import { getConfig } from "../config/index";
 import { httpRequest } from "../utils/httpClient";
 import helpers from "../utils/helpers";
 import { ApacuanaAPIError } from "../errors";
+import ApacuanaSuccess from "../success";
 import { INTEGRATION_TYPE } from "../utils/constant";
 
-/**
- * @typedef {object} GenerateCertResponse
- * @property {string} cert - El certificado generado en formato string.
- * @property {string} certifiedid - El ID del certificado generado.
- * @property {boolean} success - Indica si la operación fue exitosa.
- */
-
-/**
- * @typedef {object} GetCertStatusResponse
- * @property {string} status - El estado actual del certificado del usuario.
- * @property {boolean} success - Indica si la operación fue exitosa.
- */
-
-/**
- * @typedef {object} EncryptedCSRObject
- * @property {string} csr - The encrypted Certificate Signing Request.
- */
-
 /**
  * @param {EncryptedCSRObject} encryptedCSR
  */
@@ -41,7 +35,7 @@ const generateCertOnBoarding = async (encryptedCSR) => {
       );
     }
 
-    return { cert, certifiedid, success: true };
+    return new ApacuanaSuccess({ cert, certifiedid });
   } catch (error) {
     // The captured error is re-thrown, which will already be of type ApacuanaAPIError or a native Error.
     if (error instanceof ApacuanaAPIError) {
@@ -94,8 +88,166 @@ export const getCertStatus = (isCertificateInDevice = false) => {
     config.userData,
     isCertificateInDevice
   );
-  return {
-    status,
-    success: true,
-  };
+  return new ApacuanaSuccess({ status });
+};
+
+const getCertTypesOnBoarding = async () => {
+  try {
+    const response = await httpRequest(
+      "services/api/customer/typeusers",
+      {},
+      "GET"
+    );
+
+    return new ApacuanaSuccess(response);
+  } 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"
+  );
+};
+
+const getRequerimentsByTypeUserOnBoarding = async (type) => {
+  try {
+    const response = await httpRequest(
+      `services/api/customer/documentspref?typeuser=${type}`,
+      {},
+      "GET"
+    );
+
+    return new ApacuanaSuccess(response);
+  } 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"
+  );
+};
+
+const requestCertificateOnBoarding = async (params) => {
+  try {
+    const response = await httpRequest(
+      "services/api/customer/request-certificate",
+      params,
+      "POST"
+    );
+
+    return new ApacuanaSuccess(response);
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(`Failed to request certificate: ${error.message}`);
+  }
+};
+
+const requestCertificateOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Requesting a certificate is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+/**
+ * Requests a certificate for the user.
+ * @param {CertificateRequestParams} params - The parameters for the certificate request.
+ * @returns {Promise<RequestCertificateResponse>} Object with a confirmation message 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 params are invalid.
+ */
+export const requestCertificate = async (params) => {
+  if (
+    !params ||
+    typeof params.type !== "number" ||
+    !Array.isArray(params.documents)
+  ) {
+    throw new Error(
+      'The "params" object with a numeric "type" property and a "documents" array is required.'
+    );
+  }
+
+  const { integrationType } = getConfig();
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return requestCertificateOnBoarding(params);
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return requestCertificateOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
 };

package/src/api/faceLiveness.js

@@ -0,0 +1,137 @@
+/**
+ * @typedef {import('../types/faceLiveness').CreateFaceLivenessSessionResponse} CreateFaceLivenessSessionResponse
+ */
+
+import { getConfig } from "../config/index";
+import { httpRequest } from "../utils/httpClient";
+import { ApacuanaAPIError } from "../errors";
+import ApacuanaSuccess from "../success";
+import { INTEGRATION_TYPE } from "../utils/constant";
+
+const createFaceLivenessSessionOnBoarding = async () => {
+  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 Error(`Failed to create Face Liveness session: ${error.message}`);
+  }
+};
+
+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 },
+      "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;
+  }
+};
+
+const validateFaceLivenessOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Validating a Face Liveness session 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.
+ * @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) {
+    throw new ApacuanaAPIError(
+      "sessionId is a required parameter.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return validateFaceLivenessOnBoarding(sessionId);
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return validateFaceLivenessOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};

package/src/api/revocations.js

@@ -1,95 +1,94 @@
 import { httpRequest } from "../utils/httpClient";
-import { ApacuanaAPIError } from "../errors/index";
 import { getConfig } from "../config";
 import { INTEGRATION_TYPE } from "../utils/constant";
+import { ApacuanaAPIError } from "../errors";
+import ApacuanaSuccess from "../success";
 
-/**
- * @typedef {object} RequestRevocationResponse
- * @property {string} revocationStatus - El estado de la solicitud de revocación (e.g., "pending").
- * @property {string|number} requestId - El ID de la solicitud de revocación.
- */
-
-/**
- * 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<RequestRevocationResponse>} Objeto con el estado de la solicitud de revocación.
- */
-/**
- * @typedef {object} RevocationResponse
- * @property {boolean} success - Indicates if the revocation request was successful.
- * @property {string} [message] - A message providing details about the outcome.
- */
-
-/**
- * @typedef {object} RevocationReason
- * @property {string} code - The code for the revocation reason.
- * @property {string} description - The description of the revocation reason.
- */
-
-/**
- * @typedef {object} RevocationReasonsResponse
- * @property {boolean} success - Indicates if the request was successful.
- * @property {RevocationReason[]} reasons - A list of revocation reasons.
- */
-
-/**
- * Requests the revocation of a certificate.
- * @param {number} reasonCode - Código o descripción del motivo de la revocación.
- * @returns {Promise<RevocationResponse>} An object indicating the success of the request.
- * @throws {ApacuanaAPIError} If the revocation request fails.
- */
-export const requestRevocation = async (reasonCode) => {
-  if (!reasonCode) {
-    throw new Error("Código de motivo es requerido para requestRevocation.");
-  }
-
+const requestRevocationOnBoarding = async (params) => {
   try {
     const response = await httpRequest(
-      "services/api/onboardingclient/requestcert",
-      { reason: reasonCode },
+      "services/api/certificate/revocation",
+      params,
       "POST"
     );
-
-    return response;
+    return new ApacuanaSuccess(response);
   } catch (error) {
-    throw new Error(`Fallo en la solicitud de revocación: ${error.message}`);
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(`Failed to request revocation: ${error.message}`);
   }
 };
 
-/**
- * Retrieves the available reasons for certificate revocation.
- * @returns {Promise<RevocationReasonsResponse>} An object containing the list of revocation reasons.
- * @throws {ApacuanaAPIError} If fetching the reasons fails.
- */
-export const getRevocationReasons = async () => {
+const requestRevocationOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Requesting revocation is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+export const requestRevocation = async (params) => {
+  if (!params || typeof params.reasonCode !== "number") {
+    throw new Error(
+      'The "params" object with a numeric "reasonCode" property is required.'
+    );
+  }
+
   const { integrationType } = getConfig();
 
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return requestRevocationOnBoarding(params);
+  }
   if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
-    throw new ApacuanaAPIError(
-      `Get revocation reasons is not supported for integration type: ${integrationType}`,
-      501,
-      "NOT_IMPLEMENTED"
-    );
+    return requestRevocationOnPremise(params);
   }
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
 
+const getRevocationReasonsOnBoarding = async () => {
   try {
     const response = await httpRequest(
-      "GET",
-      "config/api/revocation/reasonsonboarding",
-      {}
+      "services/api/certificate/revocation-reasons",
+      {},
+      "GET"
     );
-
-    if (!response.records) {
+    if (!response || !response.records) {
       throw new ApacuanaAPIError("Failed to fetch revocation reasons.");
     }
-
-    return response.records;
+    return new ApacuanaSuccess(response.records);
   } catch (error) {
     if (error instanceof ApacuanaAPIError) {
       throw error;
     }
-    throw new Error(
-      "Failed to get revocation reasons. Please try again later."
-    );
+    throw new Error(`Failed to get revocation reasons: ${error.message}`);
+  }
+};
+
+const getRevocationReasonsOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Getting revocation reasons is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+export const getRevocationReasons = async () => {
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getRevocationReasonsOnBoarding();
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getRevocationReasonsOnPremise();
   }
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
 };