sysone-api-mapper 1.0.137 → 1.0.138

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sysone-api-mapper",
-  "version": "1.0.137",
+  "version": "1.0.138",
   "description": "Paquete mapper para portal de productores",
   "main": "src/index.js",
   "scripts": {

package/src/mapper/Mapper.js

@@ -1,108 +1,43 @@
 import axiosInstance from "../../axiosInstance";
 import { methods, tenantsConfig } from "./endpointsConfig";
-import {
-	SecurityManager,
-} from "@sysone/components";
-
-const getApiMapperConfig = () => {
-	// 1. Intentar desde variables de entorno compiladas (Webpack DefinePlugin)
-	if (process.env.API_MAPPER) {
-		try {
-			// Si es un string, parsearlo
-			const parsed = typeof process.env.API_MAPPER === 'string'
-				? JSON.parse(process.env.API_MAPPER)
-				: process.env.API_MAPPER;
-
-			if (parsed && Object.keys(parsed).length > 0) {
-				console.log("✅ Usando API_MAPPER de process.env", parsed);
-				return parsed;
-			}
-		} catch (error) {
-			console.error("❌ Error parseando API_MAPPER de process.env:", error);
-		}
-	}
 
-	// 2. Intentar desde variable global inyectada
-	if (window.__API_MAPPER__ && Object.keys(window.__API_MAPPER__).length > 0) {
-		console.log("✅ Usando API_MAPPER de window");
-		return window.__API_MAPPER__;
-	}
 
-	console.error("❌ No se pudo cargar API_MAPPER desde ninguna fuente");
-	return null;
-};
+let apiConfig = null;
 
-const getSalesAgent = () => {
-	return SecurityManager.getExtra("salesAgent") || null;
-};
+export const configureApiMapper = (config) => {
+	if (!config?.baseURL) {
+		throw new Error("apiMapper requires baseURL");
+	}
 
-const getSalesChannel = () => {
-	return SecurityManager.getExtra("salesAgent") || null;
-	// si "sales-channel" no tiene su propio campo en extras, usa el mismo que agent
+	apiConfig = {
+		baseURL: config.baseURL,
+		headers: config.headers || {},
+	};
 };
 
-const getDynamicHeaders = (tenant) => {
-	if (tenant === "cnp") {
-		// Intenta obtener el X-Agent de localStorage (inyectado desde el front)
-		const xAgent = SecurityManager.getExtra("intermediaryCode") ||
-			configs.cnp.headers["X-Agent"];
-
-		const salesCode = getSalesAgent();
-		const salesChannel = getSalesChannel();
-
-		return {
-			"X-Agent": xAgent,
-			"X-Sales-Channel": salesChannel || xAgent,
-			"X-Sales-Agent": salesCode || xAgent
-		};
+const getConfig = () => {
+	if (!apiConfig) {
+		throw new Error(
+			"apiMapper not configured. Call configureApiMapper() first."
+		);
 	}
-	return {};
+	return apiConfig;
 };
 
-const API_MAPPER = getApiMapperConfig();
-
-if (!API_MAPPER) {
-	console.error("⚠️ API_MAPPER no está configurado");
-}
-
-const configs = {
-	default: {
-		baseURL: API_MAPPER?.default?.baseURL || '',
-		headers: {
-			["X-Tenant"]: API_MAPPER?.default?.headers?.["X-Tenant"] || '',
-			["X-User"]: API_MAPPER?.default?.headers?.["X-User"] || '',
-			["X-Api-Key"]: API_MAPPER?.default?.headers?.["X-Api-Key"] || '',
-			["X-Origin"]: "sysone-api-mapper"
-		},
-	},
-	cnp: {
-		baseURL: API_MAPPER?.cnp?.baseURL || '',
-		headers: {
-			["X-Channel"]: API_MAPPER?.cnp?.headers?.["X-Channel"] || '',
-			["X-Agent"]: API_MAPPER?.cnp?.headers?.["X-Agent"] || '',
-			["X-Client"]: API_MAPPER?.cnp?.headers?.["X-Client"] || '',
-			["Ocp-Apim-Subscription-Key"]: API_MAPPER?.cnp?.headers?.["Ocp-Apim-Subscription-Key"] || '',
-			["X-Origin"]: "sysone-api-mapper",
-			["X-Sales-Agent"]: API_MAPPER?.cnp?.headers?.["X-Agent"] || '',
-			["X-Sales-Channel"]: API_MAPPER?.cnp?.headers?.["X-Agent"] || '',
-		},
-	},
+/**
+ * Normaliza tenant (ej: "cnp/foo" → "cnp")
+ */
+const normalizeTenant = (tenant) => {
+	if (!tenant || typeof tenant !== "string") return tenant;
+	return tenant.split("/")[0];
 };
 
 const getUrl = (serviceUrl, routeParams) => {
 	if (!routeParams || routeParams.length === 0) return serviceUrl;
-	return serviceUrl.replace(/{(\d+)}/g, function (match, routeParamNumber) {
-		return routeParams[routeParamNumber]
-			? routeParams[routeParamNumber]
-			: match;
-	});
-};
-
-const normalizeTenant = (tenant) => {
-	if (!tenant || typeof tenant !== "string") return tenant;
 
-	// Toma solo lo que está antes del primer "/"
-	return tenant.split("/")[0];
+	return serviceUrl.replace(/{(\d+)}/g, (match, index) =>
+		routeParams[index] !== undefined ? routeParams[index] : match
+	);
 };
 
 
@@ -113,110 +48,94 @@ export const apiMapper = async (
 	params = null,
 	additionalHeaders = {}
 ) => {
-	try {
-		const configData = tenantsConfig[endpointCode];
-		const normalizedTenant = normalizeTenant(tenant);
-		if (!configData)
-			throw new Error(`Endpoint no configurado: ${endpointCode}`);
+	/* -------- Endpoint config -------- */
 
-		const endpointData = configData[normalizedTenant] ?? configData.default;
+	const configData = tenantsConfig[endpointCode];
+	if (!configData) {
+		throw new Error(`Endpoint no configurado: ${endpointCode}`);
+	}
 
-		if (endpointData === null) {
-			console.warn(`⚠️ No hay configuración para el endpoint ${endpointCode} y tenant ${tenant}, y no existe configuración por defecto.`);
-			throw new Error(`No hay configuración para el endpoint ${endpointCode} y tenant ${tenant}`);
-		}
+	const normalizedTenant = normalizeTenant(tenant);
 
-		let config;
+	const endpointData =
+		configData[normalizedTenant] ?? configData.default;
 
-		if (!configs) {
-			throw new Error("No se pudo cargar la configuración del API Mapper");
-		}
+	if (!endpointData) {
+		throw new Error(
+			`No hay configuración para endpoint ${endpointCode} y tenant ${normalizedTenant}`
+		);
+	}
+
+	/* -------- Axios config -------- */
 
-		const dynamicHeaders = getDynamicHeaders(normalizedTenant);
+	const { baseURL, headers } = getConfig();
 
-		if (normalizedTenant === "cnp") {
-			config = {
-				...configs.cnp,
+	const axiosConfig = {
+		baseURL,
+		headers: {
+			...headers,
+			...additionalHeaders,
+		},
+		validateStatus: (s) => s < 500,
+	};
+
+	const url = getUrl(endpointData.url, routeParams);
+
+	/* -------- Request -------- */
+
+	switch (endpointData.method) {
+		case methods.GET: {
+			const {
+				mappedParams,
+				responseType,
+				headers: requestHeaders,
+				...otherOptions
+			} = endpointData.requestMapper(params);
+
+			const response = await axiosInstance.get(url, {
+				...axiosConfig,
+				params: mappedParams,
+				responseType,
 				headers: {
-					...configs.cnp.headers,
-					...dynamicHeaders,
-					...additionalHeaders,
-				}
-			};
-		} else {
-			config = {
-				...configs.default,
+					...axiosConfig.headers,
+					...requestHeaders,
+				},
+				...otherOptions,
+			});
+
+			return endpointData.responseMapper(response);
+		}
+
+		case methods.POST: {
+			const { mappedPostParams, mappedBody, headers: requestHeaders } =
+				endpointData.requestMapper(params);
+
+			const response = await axiosInstance.post(url, mappedBody, {
+				...axiosConfig,
+				params: mappedPostParams,
 				headers: {
-					...configs.default.headers,
-					["X-Tenant"]: normalizedTenant,
-					["X-User"]: normalizedTenant,
-					...additionalHeaders
+					...axiosConfig.headers,
+					...requestHeaders,
 				},
-			};
+			});
+
+			return endpointData.responseMapper(response.data);
+		}
+
+		case methods.PUT: {
+			const response = await axiosInstance.put(url, params, axiosConfig);
+			return endpointData.responseMapper(response.data);
 		}
 
-		config = {
-			...config,
-			validateStatus: (status) => status < 500,
-		};
-
-		const urlWithParams = getUrl(endpointData.url, routeParams);
-		const fullUrl = `${config.baseURL}${urlWithParams}`.replace(/([^:]\/)\/+/g, "$1");
-
-		let response;
-		let request;
-
-		switch (endpointData.method) {
-			case methods.GET:
-				request = endpointData.requestMapper(params);
-				const { mappedParams, responseType, headers: requestHeaders, ...otherOptions } = request;
-
-				response = await axiosInstance.get(fullUrl, {
-					...config,
-					params: mappedParams,
-					responseType: responseType,
-					headers: {
-						...config.headers,
-						...requestHeaders
-					},
-					validateStatus: config.validateStatus,
-					...otherOptions
-				});
-				return endpointData.responseMapper(response);
-
-			case methods.POST:
-				request = endpointData.requestMapper(params);
-				const { mappedPostParams, mappedBody } = request;
-				response = await axiosInstance.post(fullUrl, mappedBody, {
-					params: mappedPostParams,
-					headers: config.headers,
-					validateStatus: config.validateStatus,
-				});
-				return endpointData.responseMapper(response.data);
-
-			case methods.PUT:
-				response = await axiosInstance.put(fullUrl, params, {
-					headers: config.headers,
-					validateStatus: config.validateStatus,
-				});
-				return endpointData.responseMapper(response.data);
-
-			case methods.DELETE:
-				response = await axiosInstance.delete(fullUrl, {
-					data: params,
-					headers: config.headers,
-					validateStatus: config.validateStatus,
-				});
-				return endpointData.responseMapper(response.data);
-
-			default:
-				response = null;
-				throw new Error(
-					"Request error: Method not allowed. Only use GET, POST, PUT, DELETE"
-				);
+		case methods.DELETE: {
+			const response = await axiosInstance.delete(url, {
+				...axiosConfig,
+				data: params,
+			});
+			return endpointData.responseMapper(response.data);
 		}
-	} catch (e) {
-		console.error("❌ Error en apiMapper:", e);
-		throw e;
+
+		default:
+			throw new Error("HTTP method not supported");
 	}
 };