apacuana-sdk-core 1.26.9 → 1.26.11

package/package.json

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

package/src/api/users.js

@@ -89,6 +89,46 @@ export const getCustomer = async () => {
  * @throws {ApacuanaAPIError} Si los datos de entrada son inválidos o si ocurre un error en la API.
  */
 
+/**
+ * Busca clientes en el flujo de onboarding por correo y/o cédula.
+ * @param {object} params
+ * @param {string} [params.email] - Correo electrónico a buscar.
+ * @param {string} [params.doc] - Número de cédula a buscar.
+ * @returns {Promise<ApacuanaSuccess>} Resuelve con `{ customer }`, el registro del cliente encontrado.
+ * @throws {ApacuanaAPIError} Si la búsqueda es inválida o la API falla.
+ */
+export const searchCustomer = async ({ email, doc } = {}) => {
+  if (!email && !doc) {
+    throw new ApacuanaAPIError(
+      "At least one of 'email' or 'doc' is required.",
+      400,
+      "INVALID_SEARCH_QUERY"
+    );
+  }
+
+  const params = {};
+  if (email) params.email = email;
+  if (doc) params.doc = doc;
+
+  try {
+    const response = await httpRequest(
+      "services/api/onboardingclient/searchcustomers",
+      params,
+      "GET",
+      { skipAuth: true }
+    );
+
+    return new ApacuanaSuccess({ customer: response.entry ?? null });
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Unexpected failure searching customer: ${error.message || "Unknown error"}`
+    );
+  }
+};
+
 export const createApacuanaUser = async (userData) => {
   try {
     const formData = new FormData();

package/src/index.js

@@ -23,7 +23,7 @@ import {
 import { sendFaceLiveness } from "./api/faceLiveness";
 import ApacuanaSuccess from "./success/index";
 import { ApacuanaAPIError } from "./errors/index";
-import { createApacuanaUser, getCustomer } from "./api/users";
+import { createApacuanaUser, getCustomer, searchCustomer } from "./api/users";
 
 /**
  * Valida si el SDK está inicializado y si se dispone de un customerId.
@@ -159,6 +159,11 @@ const apacuana = {
     return getCustomer();
   },
 
+  searchCustomer: (data) => {
+    checkSdk(false);
+    return searchCustomer(data);
+  },
+
   createApacuanaUser: (data) => {
     checkSdk(false);
     return createApacuanaUser(data);

package/tests/api/users.test.js

@@ -3,7 +3,7 @@ import { httpRequest } from "../../src/utils/httpClient.js";
 import { getConfig } from "../../src/config/index.js";
 import { ApacuanaAPIError } from "../../src/errors/index.js";
 import ApacuanaSuccess from "../../src/success/index.js";
-import { getCustomer } from "../../src/api/users.js";
+import { getCustomer, searchCustomer } from "../../src/api/users.js";
 
 // Mockear las dependencias:
 jest.mock("../../src/utils/httpClient.js", () => ({
@@ -115,3 +115,84 @@ describe("getCustomer", () => {
     expect(httpRequest).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("searchCustomer", () => {
+  beforeEach(() => {
+    httpRequest.mockClear();
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    console.error.mockRestore();
+  });
+
+  test("should GET with email param and return the unwrapped customer entry", async () => {
+    httpRequest.mockResolvedValueOnce({ entry: { id: "abc", usr: "a@b.com" } });
+
+    const result = await searchCustomer({ email: "a@b.com" });
+
+    expect(httpRequest).toHaveBeenCalledWith(
+      "services/api/onboardingclient/searchcustomers",
+      { email: "a@b.com" },
+      "GET",
+      { skipAuth: true }
+    );
+    expect(result).toBeInstanceOf(ApacuanaSuccess);
+    expect(result.data).toEqual({ customer: { id: "abc", usr: "a@b.com" } });
+  });
+
+  test("should call with skipAuth: true so a Bearer token is not sent", async () => {
+    httpRequest.mockResolvedValueOnce({ entry: null });
+
+    await searchCustomer({ email: "a@b.com" });
+
+    // Public lookup — must not carry a Bearer token from the active session,
+    // otherwise the backend scopes the search to that session's customer
+    // and 404s for any other user.
+    const [, , , options] = httpRequest.mock.calls[0];
+    expect(options).toEqual({ skipAuth: true });
+  });
+
+  test("should send both email and doc when provided", async () => {
+    httpRequest.mockResolvedValueOnce({ entry: {} });
+
+    await searchCustomer({ email: "a@b.com", doc: "28152139" });
+
+    expect(httpRequest).toHaveBeenCalledWith(
+      "services/api/onboardingclient/searchcustomers",
+      { email: "a@b.com", doc: "28152139" },
+      "GET",
+      { skipAuth: true }
+    );
+  });
+
+  test("should return null customer when entry is absent", async () => {
+    httpRequest.mockResolvedValueOnce({});
+
+    const result = await searchCustomer({ doc: "28152139" });
+
+    expect(result.data).toEqual({ customer: null });
+  });
+
+  test("should throw without calling the API when no email or doc is given", async () => {
+    await expect(searchCustomer({})).rejects.toThrow(
+      "At least one of 'email' or 'doc' is required."
+    );
+    expect(httpRequest).not.toHaveBeenCalled();
+  });
+
+  test("should rethrow ApacuanaAPIError from the API", async () => {
+    const apiError = new ApacuanaAPIError("Bad request", 400, "API_ERROR");
+    httpRequest.mockRejectedValueOnce(apiError);
+
+    await expect(searchCustomer({ doc: "1" })).rejects.toThrow(apiError);
+  });
+
+  test("should wrap unexpected errors", async () => {
+    httpRequest.mockRejectedValueOnce(new Error("boom"));
+
+    await expect(searchCustomer({ doc: "1" })).rejects.toThrow(
+      "Unexpected failure searching customer: boom"
+    );
+  });
+});

package/tests/integration/searchCustomer.test.js

@@ -0,0 +1,75 @@
+/**
+ * Integration test for searchCustomer
+ *
+ * Requires environment variables (copy .env.example to .env and fill in):
+ *   APACUANA_API_URL=https://api.dev.apacuana.3dlinkweb.com
+ *   APACUANA_SECRET_KEY=your-secret-key
+ *   APACUANA_API_KEY=your-api-key
+ *   APACUANA_VERIFICATION_ID=your-verification-id
+ *   APACUANA_SEARCH_EMAIL=samuel_dear@hotmail.com   (or APACUANA_SEARCH_DOC)
+ *
+ * Run with: NODE_ENV=test npm test -- --testPathPatterns="integration/searchCustomer.test.js"
+ */
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+const envPath = resolve(process.cwd(), ".env");
+
+try {
+	const envContent = readFileSync(envPath, "utf-8");
+	envContent.split("\n").forEach(line => {
+		const [key, ...valueParts] = line.split("=");
+		if (key && key.trim() && !key.startsWith("#")) {
+			process.env[key.trim()] = valueParts.join("=").replace(/"/g, "").trim();
+		}
+	});
+} catch (err) {
+	// .env file not found, continue without it
+}
+
+import apacuana from "../../src/index.js";
+
+const requiredEnvVars = [
+	"APACUANA_API_URL",
+	"APACUANA_SECRET_KEY",
+	"APACUANA_API_KEY",
+	"APACUANA_VERIFICATION_ID",
+];
+
+const missingVars = requiredEnvVars.filter(v => !process.env[v]);
+if (missingVars.length > 0) {
+	test.skip("searchCustomer integration", () => {});
+	throw new Error(
+		`\n⚠️  Missing environment variables: ${missingVars.join(", ")}\n` +
+			"Create a .env file based on .env.example.\n"
+	);
+}
+
+describe("searchCustomer - Integration", () => {
+	beforeAll(async () => {
+		await apacuana.init({
+			apiUrl: process.env.APACUANA_API_URL,
+			secretKey: process.env.APACUANA_SECRET_KEY,
+			apiKey: process.env.APACUANA_API_KEY,
+			verificationId: process.env.APACUANA_VERIFICATION_ID,
+			integrationType: process.env.APACUANA_INTEGRATION_TYPE || "ONBOARDING",
+		});
+	});
+
+	afterAll(() => {
+		apacuana.close();
+	});
+
+	test("should search a customer by email or doc and return a result object", async () => {
+		const query = process.env.APACUANA_SEARCH_DOC
+			? { doc: process.env.APACUANA_SEARCH_DOC || "28152139" }
+			: { email: process.env.APACUANA_SEARCH_EMAIL || "samuel_dear@hotmail.com" };
+
+		const result = await apacuana.searchCustomer(query);
+
+		expect(result).toBeDefined();
+		expect(result.success).toBe(true);
+		// customer is the unwrapped entry, or null when there is no match
+		expect(result.data).toHaveProperty("customer");
+	});
+});