apacuana-sdk-core 1.0.0 → 1.2.0

package/src/api/signatures.js

@@ -0,0 +1,445 @@
+// src/api/signatures.js
+import { getConfig } from "../config/index";
+import { httpRequest } from "../utils/httpClient";
+import { ApacuanaAPIError } from "../errors";
+import ApacuanaSuccess from "../success";
+import helpers from "../utils/helpers";
+import { INTEGRATION_TYPE } from "../utils/constant";
+
+/** @typedef {import("../types/signatures").Signer} Signer */
+/** @typedef {import("../types/signatures").SignerData} SignerData */
+/** @typedef {import("../types/signatures").AddSignerResponse} AddSignerResponse */
+/** @typedef {import("../types/signatures").GetDigestData} GetDigestData */
+/** @typedef {import("../types/signatures").GetDigestResponse} GetDigestResponse */
+/** @typedef {import("../types/signatures").GetDocsParams} GetDocsParams */
+/** @typedef {import("../types/signatures").GetDocsResponse} GetDocsResponse */
+/** @typedef {import("../types/signatures").SignDocumentData} SignDocumentData */
+/** @typedef {import("../types/signatures").SignaturePosition} SignaturePosition */
+/** @typedef {import("../types/signatures").OnboardingSignerData} OnboardingSignerData */
+
+// =================================================================
+// Internal Functions
+// =================================================================
+
+const signDocumentOnBoarding = async (signData) => {
+  const payload = helpers.validateOnBoardingSignDocumentData(signData);
+
+  const { signature } = signData;
+  try {
+    const response = await httpRequest(
+      `services/api/documents/sign/${signature.id}`,
+      payload,
+      "PUT"
+    );
+    return new ApacuanaSuccess(response);
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to sign document: ${error.message || "Unknown error"}`
+    );
+  }
+};
+
+const signDocumentOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Document signing is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const getDigestToSignOnBoarding = async (signData) => {
+  try {
+    const formData = helpers.createPayloadGetDigest(signData);
+    const response = await httpRequest(
+      `services/api/documents/getdigest/${signData.signatureId}`,
+      formData,
+      "POST"
+    );
+    const digest = response.data?.digest || response.digest;
+    if (!digest) {
+      throw new ApacuanaAPIError(
+        "Signature generation failed: digest not found in the response.",
+        500,
+        "API_RESPONSE_ERROR"
+      );
+    }
+
+    return new ApacuanaSuccess({ digest });
+  } catch (error) {
+    if (error.name === "ApacuanaAPIError") {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to sign document (on-boarding): ${error.message}`
+    );
+  }
+};
+
+const getDigestToSignOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Digest retrieval is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const addSignerOnBoarding = async (signerData) => {
+  const payload = helpers.validateOnBoardingSignerData(signerData);
+  try {
+    await httpRequest("services/api/documents/signingsdk", payload, "POST");
+    return new ApacuanaSuccess({
+      signer: signerData.typedoc + signerData.doc,
+    });
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(`Failed to add signer in On-Boarding: ${error.message}`);
+  }
+};
+
+const addSignerOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Adding signers is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const getDocsOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Document retrieval is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const getDocsOnBoarding = async (data) => {
+  const { customerId } = getConfig();
+  if (!customerId) {
+    throw new ApacuanaAPIError(
+      "'customerId' is not configured. Please configure the SDK.",
+      400,
+      "CONFIGURATION_ERROR"
+    );
+  }
+
+  try {
+    const params = new URLSearchParams({
+      page: data.page,
+      customerid: customerId,
+      size: data.size,
+    });
+
+    if (typeof data.status !== "undefined") {
+      params.append("status", data.status);
+    }
+
+    const apiUrl = `services/api/documents/listcustomer?${params.toString()}`;
+    const response = await httpRequest(apiUrl, {}, "GET");
+    return new ApacuanaSuccess({
+      totalRecords: response.numofrecords,
+      records: response.records,
+    });
+  } catch (error) {
+    if (error.name === "ApacuanaAPIError") {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Failed to get document list (on-boarding): ${error.message}`
+    );
+  }
+};
+
+const uploadSignatureVariantOnBoarding = async ({ file }) => {
+  try {
+    const response = await httpRequest(
+      "services/api/customer/signaturephoto",
+      { file },
+      "POST"
+    );
+    return new ApacuanaSuccess(response);
+  } 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 new ApacuanaSuccess(response);
+  } 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 new ApacuanaSuccess(response);
+  } 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
+// =================================================================
+
+/**
+ * Firma un documento PDF con un certificado digital.
+ * NOTA: Esta función no está implementada actualmente para ningún tipo de integración.
+ * @param {SignDocumentData} signData - Datos necesarios para la firma.
+ * @returns {Promise<object>}
+ * @throws {ApacuanaAPIError} Arroja un error 'NOT_IMPLEMENTED' para cualquier tipo de integración.
+ */
+export const signDocument = async (signData) => {
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return signDocumentOnBoarding(signData);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return signDocumentOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+/**
+ * Obtiene el digest de un documento para ser firmado.
+ * @param {GetDigestData} signData - Datos requeridos para obtener el digest.
+ * @returns {Promise<GetDigestResponse>} Una promesa que resuelve a un objeto con el digest del documento.
+ * @throws {ApacuanaAPIError} Si los datos de entrada son inválidos, la llamada a la API falla, o el tipo de integración no es soportado.
+ */
+export const getDigest = async (signData) => {
+  helpers.validateGetDigestData(signData);
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getDigestToSignOnBoarding(signData);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getDigestToSignOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Document retrieval is not supported for an unknown integration type: ${integrationType}`,
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+/**
+ * Añade un firmante a un documento.
+ * @param {SignerData} signerData - Los datos del firmante que se va a añadir.
+ * @returns {Promise<AddSignerResponse>} Una promesa que resuelve a un objeto con el resultado de la operación.
+ * @throws {ApacuanaAPIError} Si los datos del firmante son inválidos, la llamada a la API falla, o el tipo de integración no es soportado.
+ */
+export const addSigner = async (signerData) => {
+  if (
+    !signerData ||
+    typeof signerData !== "object" ||
+    Object.keys(signerData).length === 0
+  ) {
+    throw new ApacuanaAPIError(
+      "Signer data (signerData) is required and must be a non-empty object.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return addSignerOnBoarding(signerData);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return addSignerOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+/**
+ * Obtiene una lista de documentos basada en los filtros especificados.
+ * @param {GetDocsParams} data - Objeto con parámetros de paginación y filtros.
+ * @returns {Promise<GetDocsResponse>} Una promesa que resuelve a un objeto con la lista de documentos.
+ * @throws {ApacuanaAPIError} Si los parámetros de paginación son inválidos, 'customerId' no está configurado, la llamada a la API falla, o el tipo de integración no es soportado.
+ */
+export const getDocs = async (data) => {
+  helpers.validateGetDocsData(data);
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getDocsOnBoarding(data);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getDocsOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Document retrieval is not supported for an unknown integration type: ${integrationType}`,
+    501,
+    "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/api/users.js

@@ -0,0 +1,127 @@
+import { httpRequest } from "../utils/httpClient";
+import { ApacuanaAPIError } from "../errors/index";
+import { getConfig } from "../config/index";
+import ApacuanaSuccess from "../success";
+
+/**
+ * @typedef {object} GetCustomerData
+ * @property {string} token - El token de sesión del usuario.
+ * @property {object} userData - Los datos del usuario obtenidos.
+ */
+
+/**
+ * @typedef {object} GetCustomerResponse
+ * @property {true} success - Indica que la operación fue exitosa.
+ * @property {GetCustomerData} data - El payload de la respuesta.
+ */
+
+/**
+ * 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<GetCustomerResponse>} Una promesa que resuelve a un objeto con la respuesta exitosa.
+ * @throws {Error} Si los parámetros de entrada son inválidos.
+ * @throws {ApacuanaAPIError} Si ocurre un error en la API de Apacuana.
+ */
+export const getCustomer = async () => {
+  const { verificationId, customerId } = getConfig();
+
+  if (!verificationId || !customerId) {
+    throw new ApacuanaAPIError(
+      "Both 'verificationId' and 'customerId' must be configured.",
+      400,
+      "CONFIGURATION_ERROR"
+    );
+  }
+
+  const body = {
+    verificationid: verificationId,
+    customerid: customerId,
+  };
+
+  try {
+    const response = await httpRequest(
+      "services/api/register/init",
+      body,
+      "POST"
+    );
+
+    if (!response.sessionid || !response.entry) {
+      throw new ApacuanaAPIError(
+        "The API response does not contain the user.",
+        200,
+        "INVALID_API_RESPONSE"
+      );
+    }
+
+    return new ApacuanaSuccess({
+      token: response.sessionid,
+      userData: response.entry,
+    });
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Unexpected failure getting token: ${error.message || "Unknown error"}`
+    );
+  }
+};
+
+/**
+ * @typedef {object} CreateUserPayload
+ * @property {string} usr - Correo electrónico del usuario.
+ * @property {string} pwd - Contraseña del usuario.
+ * @property {string} kinddoc - Tipo de documento de identidad (ej. 'V', 'P', 'E').
+ * @property {string} doc - Número de documento de identidad.
+ */
+
+/**
+ * @typedef {object} CreateUserResponse
+ * @property {string} message - Mensaje de confirmación de la creación del usuario.
+ */
+
+/**
+ * Crea un nuevo usuario en la plataforma de Apacuana.
+ * @param {CreateUserPayload} userData - Objeto con los datos del usuario a crear.
+ * @returns {Promise<ApacuanaSuccess>} Una promesa que resuelve a un objeto con la respuesta exitosa.
+ * @throws {ApacuanaAPIError} Si los datos de entrada son inválidos o si ocurre un error en la API.
+ */
+
+export const createApacuanaUser = async (userData) => {
+  try {
+    const formData = new FormData();
+    Object.keys(userData).forEach((key) => {
+      const value = userData[key];
+      const isRNFile =
+        value &&
+        typeof value === "object" &&
+        value.uri &&
+        value.name &&
+        value.type;
+      if (value instanceof File || isRNFile) {
+        formData.append(key, value);
+      } else if (value !== null && value !== undefined) {
+        formData.append(key, String(value));
+      }
+    });
+
+    const response = await httpRequest(
+      "services/api/register/initial",
+      formData,
+      "POST"
+    );
+
+    return new ApacuanaSuccess({
+      ...response,
+    });
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Unexpected failure creating user: ${error.message || "Unknown error"}`
+    );
+  }
+};

package/src/config/index.js

@@ -0,0 +1,57 @@
+// src/config/index.js
+import { INTEGRATION_TYPE } from "../utils/constant";
+
+/**
+ * @typedef {object} SDKConfig
+ * @property {string} apiUrl
+ * @property {string} secretKey
+ * @property {string} apiKey
+ * @property {string} verificationId
+ * @property {string} customerId
+ * @property {string} integrationType
+ * @property {object} [userData]
+ * @property {string} [token]
+ */
+
+const defaultConfig = {
+  apiUrl: "",
+  secretKey: "",
+  apiKey: "",
+  verificationId: "",
+  customerId: "",
+  integrationType: "",
+  userData: undefined,
+  token: undefined,
+};
+
+/** @type {SDKConfig} */
+let config = { ...defaultConfig };
+
+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
+};
+
+export const getConfig = () => ({ ...config });
+
+export const close = () => {
+  config = { ...defaultConfig };
+};

package/src/errors/index.js

@@ -0,0 +1,21 @@
+// 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;
+    this.success = false; // Añadir el atributo success con valor false
+
+    // Mantener el stack trace correcto
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ApacuanaAPIError);
+    }
+  }
+}
+
+export default ApacuanaAPIError;