apacuana-sdk-core 0.9.0 → 0.10.0

package/package.json

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

package/src/api/certs.js

@@ -99,3 +99,130 @@ export const getCertStatus = (isCertificateInDevice = false) => {
     success: true,
   };
 };
+
+/**
+ * @typedef {object} CertType
+ * @property {string} id - The ID of the certificate type.
+ * @property {string} name - The name of the certificate type.
+ */
+
+/**
+ * @typedef {object} GetCertTypesResponse
+ * @property {Array<CertType>} types - A list of available certificate types.
+ * @property {boolean} success - Indicates if the operation was successful.
+ */
+
+const getCertTypesOnBoarding = async () => {
+  try {
+    const response = await httpRequest(
+      "services/api/customer/typeusers",
+      {},
+      "GET"
+    );
+
+    return { ...response, success: true };
+  } 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"
+  );
+};
+
+/**
+ * @typedef {object} Requirement
+ * @property {string} id - The ID of the requirement.
+ * @property {string} description - The description of the requirement.
+ */
+
+/**
+ * @typedef {object} GetRequirementsResponse
+ * @property {Array<Requirement>} requirements - A list of requirements for the user type.
+ * @property {boolean} success - Indicates if the operation was successful.
+ */
+
+const getRequerimentsByTypeUserOnBoarding = async (type) => {
+  try {
+    const response = await httpRequest(
+      `services/api/customer/documentspref?typeuser=${type}`,
+      {},
+      "GET"
+    );
+
+    return { ...response, success: true };
+  } 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"
+  );
+};

package/src/index.js

@@ -2,7 +2,12 @@ import { setConfig, getConfig, close } from "./config/index";
 import { initHttpClient, setAuthToken } from "./utils/httpClient";
 import getCustomer from "./api/users";
 import { requestRevocation, getRevocationReasons } from "./api/revocations";
-import { generateCert, getCertStatus } from "./api/certs";
+import {
+  generateCert,
+  getCertStatus,
+  getCertTypes,
+  getRequerimentsByTypeUser,
+} from "./api/certs";
 import {
   addSigner,
   deleteSignatureVariant,
@@ -61,6 +66,8 @@ const apacuana = {
   uploadSignatureVariant,
   getSignatureVariant,
   deleteSignatureVariant,
+  getCertTypes,
+  getRequerimentsByTypeUser,
 };
 
 export default apacuana;

package/tests/api/certs.test.js

@@ -2,7 +2,12 @@ import { getConfig } from "../../src/config/index";
 import { httpRequest } from "../../src/utils/httpClient";
 import helpers from "../../src/utils/helpers";
 import { ApacuanaAPIError } from "../../src/errors";
-import { generateCert, getCertStatus } from "../../src/api/certs";
+import {
+  generateCert,
+  getCertStatus,
+  getCertTypes,
+  getRequerimentsByTypeUser,
+} from "../../src/api/certs";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
 
 jest.mock("../../src/config/index");
@@ -91,4 +96,111 @@ describe("Certificate API - certs.js", () => {
       expect(result).toEqual({ status: "VALID", success: true });
     });
   });
+
+  describe("getCertTypes", () => {
+    it("should call getCertTypesOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockApiResponse = { types: [{ id: "1", name: "Type 1" }] };
+      httpRequest.mockResolvedValue(mockApiResponse);
+
+      const result = await getCertTypes();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/typeusers",
+        {},
+        "GET"
+      );
+      expect(result).toEqual({ types: mockApiResponse.types, success: true });
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getCertTypes()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting certificate types is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for an unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+
+      await expect(getCertTypes()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: INVALID_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("getRequerimentsByTypeUser", () => {
+    it("should call getRequerimentsByTypeUserOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockApiResponse = {
+        requirements: [{ id: "1", description: "Requirement 1" }],
+      };
+      httpRequest.mockResolvedValue(mockApiResponse);
+
+      const result = await getRequerimentsByTypeUser({ type: 1 });
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/documentspref?typeuser=1",
+        {},
+        "GET"
+      );
+      expect(result).toEqual({
+        requirements: mockApiResponse.requirements,
+        success: true,
+      });
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getRequerimentsByTypeUser({ type: 1 })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting requirements by user type is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for an unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+
+      await expect(getRequerimentsByTypeUser({ type: 1 })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: INVALID_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("should throw an error if params are invalid", async () => {
+      await expect(getRequerimentsByTypeUser()).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+      await expect(getRequerimentsByTypeUser({})).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+      await expect(getRequerimentsByTypeUser({ type: "1" })).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+    });
+  });
 });