apacuana-sdk-core 1.0.0 → 1.1.0

package/package.json

@@ -1,15 +1,57 @@
 {
   "name": "apacuana-sdk-core",
-  "version": "1.0.0",
-  "description": "",
+  "version": "1.1.0",
+  "description": "Core SDK para interacciones con las APIs de Apacuana.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "clean": "rimraf dist",
+    "clean-modules": "rimraf node_modules",
+    "test": "jest",
+    "lint": "eslint src/",
+    "build": "npm run clean && tsc && rollup -c",
+    "prepublishOnly": "npm run validate",
+    "validate": "npm run lint && npm test && npm run build"
+  },
   "keywords": [
-    "sdk-apacuana"
+    "apacuana",
+    "sdk",
+    "core",
+    "certificados",
+    "firma"
   ],
-  "license": "MIT",
-  "author": "apacuana",
-  "type": "commonjs",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "author": "Gega",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.24.5",
+    "@babel/plugin-transform-class-properties": "^7.24.1",
+    "@babel/plugin-transform-private-methods": "^7.24.1",
+    "@babel/plugin-transform-private-property-in-object": "^7.24.1",
+    "@babel/preset-env": "^7.24.5",
+    "@babel/preset-flow": "^7.24.1",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "babel-jest": "^29.7.0",
+    "eslint": "^8.57.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.29.1",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.7",
+    "rollup": "^4.17.2",
+    "typescript": "^5.9.2"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "asn1js": "^3.0.6",
+    "axios": "^1.11.0",
+    "crypto-js": "^4.2.0",
+    "pkijs": "^3.2.5"
   }
 }

package/rollup.config.js

@@ -0,0 +1,32 @@
+import babel from '@rollup/plugin-babel';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json'; // Add this import
+
+export default {
+  input: 'src/index.js',
+  output: [
+    {
+      file: 'dist/index.js',
+      format: 'cjs',
+      sourcemap: true,
+    },
+    {
+      file: 'dist/index.mjs',
+      format: 'es',
+      sourcemap: true,
+    },
+  ],
+  plugins: [
+    json(), // Add this plugin before nodeResolve
+    nodeResolve({
+      preferBuiltins: false,
+    }),
+    commonjs(),
+    babel({
+      babelHelpers: 'bundled',
+      exclude: 'node_modules/**',
+    }),
+  ],
+  external: ['axios'], // Mark only axios as external
+};

package/src/api/certs.js

@@ -0,0 +1,256 @@
+/**
+ * @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, PARSE_STATUS } from "../utils/constant";
+
+/**
+ * @param {EncryptedCSRObject} encryptedCSR
+ */
+const generateCertOnBoarding = async (encryptedCSR) => {
+  try {
+    const response = await httpRequest(
+      "services/api/register/certificate",
+      encryptedCSR,
+      "POST"
+    );
+    const { cert, certifiedid } = response;
+    if (!cert || !certifiedid) {
+      throw new ApacuanaAPIError(
+        "The API response does not contain the certificate.",
+        response.status,
+        "INVALID_API_RESPONSE"
+      );
+    }
+
+    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) {
+      throw error;
+    }
+    throw new Error(`Certificate generation failed: ${error.message}`);
+  }
+};
+
+const generateCertOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Certificate generation is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+/**
+ * Generates a digital certificate.
+ * @param {EncryptedCSRObject} encryptedCSR - Certificate Signing Request (CSR) object.
+ * @returns {Promise<GenerateCertResponse>} Object with the generated certificate and a success indicator.
+ * @throws {ApacuanaAPIError} If the CSR is invalid, if the API response does not contain the certificate, or if the integration type is not supported.
+ * @throws {Error} If certificate generation fails for another reason.
+ */
+export const generateCert = async (encryptedCSR) => {
+  const { integrationType } = getConfig();
+  helpers.validateCsr(encryptedCSR);
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return generateCertOnBoarding(encryptedCSR);
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return generateCertOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+/**
+ * Gets the user's certificate status.
+ * @param {boolean} [isCertificateInDevice=false] - Indicates if the certificate is already on the device.
+ * @returns {GetCertStatusResponse} Object with the certificate status and a success indicator.
+ */
+export const getCertStatus = (isCertificateInDevice = false) => {
+  const config = getConfig();
+  const status = helpers.getCertificateStatus(
+    config.userData,
+    isCertificateInDevice,
+    config.integrationType
+  );
+  const parseStatus = PARSE_STATUS[status];
+
+  return new ApacuanaSuccess({ status: parseStatus });
+};
+
+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,146 @@
+/**
+ * @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";
+
+/**
+ * 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 () => {
+  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 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

@@ -0,0 +1,109 @@
+import { httpRequest } from "../utils/httpClient";
+import { getConfig } from "../config";
+import { INTEGRATION_TYPE } from "../utils/constant";
+import { ApacuanaAPIError } from "../errors";
+import ApacuanaSuccess from "../success";
+
+/** @typedef {import("../types/revocations").RequestRevocationResponse} RequestRevocationResponse */
+/** @typedef {import("../types/revocations").GetRevocationReasonsResponse} GetRevocationReasonsResponse */
+
+const requestRevocationOnBoarding = async (params) => {
+  try {
+    const response = await httpRequest(
+      "services/api/onboardingclient/requestcert",
+      { reason: params.reasonCode },
+      "POST"
+    );
+    return new ApacuanaSuccess(response);
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(`Failed to request revocation: ${error.message}`);
+  }
+};
+
+const requestRevocationOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "Requesting revocation is not supported for integration type: ONPREMISE",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+/**
+ * Solicita la revocación de un certificado.
+ * @param {object} params - Parámetros para la solicitud.
+ * @param {number} params.reasonCode - El código de la razón de la revocación.
+ * @returns {Promise<RequestRevocationResponse>} Una promesa que resuelve con la confirmación de la solicitud.
+ * @throws {Error} Si los parámetros son inválidos.
+ */
+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) {
+    return requestRevocationOnPremise(params);
+  }
+  throw new ApacuanaAPIError(
+    `Unsupported integration type: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+const getRevocationReasonsOnBoarding = async () => {
+  try {
+    const response = await httpRequest(
+      "config/api/revocation/reasonsonboarding",
+      {},
+      "GET"
+    );
+    if (!response || !response.records) {
+      throw new ApacuanaAPIError("Failed to fetch revocation reasons.");
+    }
+    return new ApacuanaSuccess({ reasons: response.records });
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    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"
+  );
+};
+
+/**
+ * Obtiene la lista de razones de revocación de certificados.
+ * @returns {Promise<GetRevocationReasonsResponse>} Una promesa que resuelve con la lista de razones de revocación.
+ * @throws {ApacuanaAPIError} Si la llamada a la API falla o el tipo de integración no es soportado.
+ */
+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"
+  );
+};