@communecter/cocolight-api-client 1.0.0

package/src/ApiClient.js

@@ -0,0 +1,1083 @@
+import { EventEmitter } from "events";
+
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import axios from "axios";
+import axiosRetry from "axios-retry";
+import EJSON from "ejson";
+import pino from "pino";
+
+import MongoID from "./EJSONType.js";
+import endpointsJson from "./endpoints.module.js";
+import { ApiClientError, CircuitBreakerError } from "./error.js";
+
+EJSON.addType("oid", value => {
+  return new MongoID.ObjectID(value);
+});
+
+export default class ApiClient extends EventEmitter {
+  /**
+   * @param {Object} options
+   * @param {string}  options.baseURL
+   * @param {string}  [options.accessToken]
+   * @param {string}  [options.refreshToken]
+   * @param {string}  [options.refreshUrl=/api/cocolight/refreshtoken]
+   * @param {Array}   [options.endpoints=endpointsJson.endpoints]
+   * @param {number}  [options.timeout=30000]
+   * @param {boolean} [options.debug=false]
+   * @param {number}  [options.maxRetries=0]  - Nombre de tentatives auto (axios-retry)
+   * @param {number}  [options.circuitBreakerThreshold=5] - Nb d'erreurs avant de bloquer
+   * @param {number}  [options.circuitBreakerResetTime=60000] - Ms avant de reset le breaker
+   * @param {boolean} [options.fromJSONValue=true] - Si true, les données sont transformées en EJSON
+   */
+  constructor({
+    baseURL,
+    accessToken,
+    refreshToken,
+    refreshUrl = "/api/cocolight/refreshtoken",
+    endpoints = endpointsJson.endpoints,
+    timeout = 30000,
+    debug = false,
+    maxRetries = 0,
+    circuitBreakerThreshold = 5,
+    circuitBreakerResetTime = 60000,
+    fromJSONValue = true
+  } = {}) {
+    super(); // EventEmitter
+
+    if (!baseURL) {
+      throw new ApiClientError("Le paramètre \"baseURL\" est obligatoire.", 500);
+    }
+
+    this._baseURL = baseURL;
+    this._refreshToken = refreshToken;
+    this._refreshUrl = refreshUrl;
+    this._endpoints = endpoints;
+    this._debug = debug;
+    let _userId = null;
+
+    // Active la transformation des données en EJSON globalement
+    this._fromJSONValue = fromJSONValue;
+
+    Object.defineProperty(this, "userId", {
+      get: () => _userId,
+      set: () => {
+        throw new Error("Modification directe de userId non autorisée.");
+      },
+      enumerable: true
+    });
+
+    this._setUserId = (id) => {
+      _userId = id;
+      this._logger.debug(`[ApiClient] userId set: ${id}`);
+    };
+
+    // AJV
+    this._ajv = new Ajv({ strict: false, useDefaults: true });
+    addFormats(this._ajv);
+
+    // Pino logger
+    // (Ici en mode pretty-print sur la console, tu peux configurer comme tu veux)
+    this._logger = pino({
+      transport: {
+        target: "pino-pretty",
+        options: { colorize: true }
+      },
+      level: debug ? "debug" : "info"
+    });
+
+    // Création instance Axios
+    this._client = axios.create({
+      baseURL,
+      timeout
+    });
+
+    // axios-retry : pour retenter en cas de soucis réseau ou code 5xx
+    if (maxRetries > 0) {
+      axiosRetry(this._client, {
+        retries: maxRetries,
+        retryDelay: axiosRetry.exponentialDelay,
+        retryCondition: (error) => {
+          // Retry sur erreurs 5xx ou erreurs réseau
+          return axiosRetry.isNetworkError(error) || axiosRetry.isRetryableError(error);
+        }
+      });
+      this._logger.info(`[ApiClient] Retry activé : ${maxRetries} max`);
+    }
+
+    // Circuit breaker (simplifié)
+    this._breakerThreshold = circuitBreakerThreshold;
+    this._breakerResetTime = circuitBreakerResetTime;
+    this._breakerErrorCount = 0;
+    this._breakerOpen = false;
+    this._lastBreakerOpenTime = null;
+
+    // Applique un token initial
+    if (accessToken) {
+      this.setToken(accessToken);
+    }
+
+    // Intercepteur 401 -> refresh
+    this._client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response && error.response.status === 401) {
+          if (this._refreshToken) {
+            try {
+              const refreshed = await this._refreshAccessToken();
+              if (refreshed) {
+                return this._client.request(error.config);
+              }
+            } catch (err) {
+              throw new ApiClientError(err.message, 401, err);
+            }
+          }
+        }
+        throw error;
+      }
+    );
+  }
+
+  /**
+   * Sets the access token for the API client and updates the authorization header.
+   *
+   * @param {string} token - The access token to be set.
+   */
+  setToken(token) {
+    this._accessToken = token;
+    this._client.defaults.headers.common["Authorization"] = "Bearer " + token;
+    this._logger.debug(`[ApiClient] setToken: ${token}`);
+  }
+
+  /**
+   * Retrieves the current access token.
+   *
+   * @returns {string} The access token.
+   */
+  getToken() {
+    return this._accessToken;
+  }
+
+  /**
+   * Sets the refresh token for the API client.
+   *
+   * @param {string} rt - The refresh token to be set.
+   */
+  setRefreshToken(rt) {
+    this._refreshToken = rt;
+    this._logger.debug(`[ApiClient] setRefreshToken: ${rt}`);
+  }
+
+  /**
+   * Retrieves the current refresh token.
+   *
+   * @returns {string} The refresh token.
+   */
+  getRefreshToken() {
+    return this._refreshToken;
+  }
+
+  /**
+   * Méthode simplifiée de refresh (en JSON). 
+   * Emet un event refreshSuccess si ça marche
+   */
+  async _refreshAccessToken() {
+    if (!this._refreshToken) return false;
+    try {
+      const response = await this._client.post(
+        this._refreshUrl,
+        { refreshToken: this._refreshToken },
+        { headers: { "Content-Type": "application/json" } }
+      );
+      if (response.data && response.data.accessToken) {
+        this.setToken(response.data.accessToken);
+        if (response.data.refreshToken) {
+          this.setRefreshToken(response.data.refreshToken);
+        }
+        this.emit("refreshSuccess", response.data);
+        return true;
+      }
+      return false;
+    } catch (err) {
+      this._logger.error(`[ApiClient] Refresh Error : ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * checkCircuitBreaker : vérifie si on peut appeler l'API ou non
+   * si le breaker est \"open\", on regarde si on peut \"reset\" 
+   */
+  _checkCircuitBreaker() {
+    if (!this._breakerOpen) return true;
+    const now = Date.now();
+    if (now - this._lastBreakerOpenTime > this._breakerResetTime) {
+      // On reset
+      this._breakerOpen = false;
+      this._breakerErrorCount = 0;
+      this._logger.warn("[ApiClient] Circuit breaker réinitialisé");
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * updateCircuitBreaker : incremente le compteur d'erreurs 
+   * si on dépasse le threshold, on \"open\" le breaker.
+   */
+  _updateCircuitBreakerError() {
+    this._breakerErrorCount += 1;
+    this._logger.warn(`[ApiClient] Erreur #${this._breakerErrorCount} sur ${this._breakerThreshold}`);
+    if (this._breakerErrorCount >= this._breakerThreshold) {
+      this._breakerOpen = true;
+      this._lastBreakerOpenTime = Date.now();
+      this._logger.error("[ApiClient] Circuit breaker ACTIVÉ - L'API est considérée indisponible");
+    }
+  }
+
+  /**
+   * resetCircuitBreaker : en cas de succès on reset le compteur
+   */
+  _resetCircuitBreakerSuccess() {
+    this._breakerErrorCount = 0;
+    if (this._breakerOpen) {
+      this._breakerOpen = false;
+      this._logger.warn("[ApiClient] Circuit breaker refermé suite à un succès");
+    }
+  }
+
+  static stripNullsInPlace(obj) {
+    // Si l'objet semble être un "fichier uploadé", c'est-à-dire qu'il possède une propriété "value" qui est un stream, on le laisse intact.
+    if (obj && typeof obj === "object" && obj.value && typeof obj.value.pipe === "function") {
+      return obj;
+    }
+    
+    if (Array.isArray(obj)) {
+      for (let i = obj.length - 1; i >= 0; i--) {
+        if (obj[i] === null || obj[i] === undefined) {
+          obj.splice(i, 1);
+        } else if (typeof obj[i] === "object") {
+          ApiClient.stripNullsInPlace(obj[i]);
+        }
+      }
+    } else if (obj && typeof obj === "object") {
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          if (obj[key] === null || obj[key] === undefined) {
+            delete obj[key];
+          } else if (typeof obj[key] === "object") {
+            ApiClient.stripNullsInPlace(obj[key]);
+          }
+        }
+      }
+    }
+    return obj;
+  }
+  
+  _resolveSpecialValuesInPlace(obj) {
+    // Si l'objet ressemble à un fichier uploadé (détecte la présence d'un stream dans la propriété value), ne rien modifier.
+    if (obj && typeof obj === "object" && obj.value && typeof obj.value.pipe === "function") {
+      return obj;
+    }
+  
+    const aliasMap = {
+      userId: () => this.userId,
+      accessToken: () => this._accessToken,
+      refreshToken: () => this._refreshToken,
+      baseURL: () => this._baseURL,
+      // vous pouvez ajouter d'autres alias ici
+    };
+  
+    if (typeof obj === "string" && obj.startsWith("@")) {
+      const varName = obj.slice(1);
+      return typeof aliasMap[varName] === "function" ? aliasMap[varName]() : obj;
+    } else if (Array.isArray(obj)) {
+      for (let i = 0; i < obj.length; i++) {
+        obj[i] = this._resolveSpecialValuesInPlace(obj[i]);
+      }
+    } else if (obj && typeof obj === "object") {
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          obj[key] = this._resolveSpecialValuesInPlace(obj[key]);
+        }
+      }
+    }
+    return obj;
+  }
+  
+
+  /**
+   * Calls an API endpoint with the specified parameters.
+   *
+   * @param {string} constant - The constant representing the endpoint to call.
+   * @param {Object} [data={}] - The data to send with the request.
+   * @param {boolean|function} [transformResponseData=true] - Whether to transform the response data or a function to transform it.
+   * @param {boolean} [validateResponseSchema=true] - Whether to validate the response schema.
+   * @returns {Promise<Object>} The response from the API.
+   * @throws {CircuitBreakerError} If the circuit breaker is activated.
+   * @throws {ApiClientError} If the endpoint is not found, token is required but not provided, or validation fails.
+   */
+  async callEndpoint(constant, data = {}, transformResponseData = true, validateResponseSchema = true) {
+    if (!this._checkCircuitBreaker()) {
+      throw new CircuitBreakerError("Le circuit breaker est activé, impossible d'appeler l'API");
+    }
+  
+    const endpoint = this._endpoints.find((ep) => ep.constant === constant);
+    if (!endpoint) {
+      throw new ApiClientError(`Endpoint introuvable : ${constant}`, 404);
+    }
+  
+    const {
+      path,
+      method,
+      contentType,
+      auth,
+      pathParams: pathSchema,
+      request: requestSchema,
+      responses
+    } = endpoint;
+  
+    const lowerMethod = (method || "GET").toLowerCase();
+    const realContentType = contentType || "application/json";
+    const headers = { "Content-Type": realContentType };
+  
+    // Auth headers
+    if (this._accessToken) {
+      if (auth === "bearer") {
+        headers["Authorization"] = `Bearer ${this._accessToken}`;
+      } else if (!auth || auth === "none") {
+        if (!headers["Authorization"]) {
+          headers["Authorization"] = `Bearer ${this._accessToken}`;
+        }
+      }
+    } else if (auth === "bearer") {
+      throw new ApiClientError(`Token requis pour l'endpoint sécurisé : ${constant}`, 401);
+    }
+  
+    // === 1. PathParams ===
+    let resolvedPath = path;
+    if (pathSchema) {
+      const pathParams = data.pathParams || {};
+      const validatePathParams = this._ajv.compile(pathSchema);
+      const valid = validatePathParams(pathParams);
+  
+      if (!valid) {
+        this.emit("validationError", { stage: "pathParams", errors: validatePathParams.errors });
+        throw new ApiClientError("Path parameter validation failed.", 400, validatePathParams.errors);
+      }
+  
+      const resolvedParams = this._resolveSpecialValuesInPlace(pathParams);
+  
+      resolvedPath = resolvedPath.replace(/\{(\w+)\}/g, (_, key) => {
+        const val = resolvedParams[key];
+        if (val !== undefined) return encodeURIComponent(val);
+        throw new ApiClientError(`Path param manquant ou non résolu : {${key}}`, 400);
+      });
+    }
+  
+    // === 2. Validation données (request schema) ===
+    if (requestSchema) {
+      const dataForValidation = { ...data };
+      delete dataForValidation.pathParams;
+      const cleanedData = ApiClient.stripNullsInPlace(dataForValidation);
+
+      const validateRequest = this._ajv.compile(requestSchema);
+      const valid = validateRequest(cleanedData);
+      if (!valid) {
+        this.emit("validationError", { stage: "request", errors: validateRequest.errors });
+        throw new ApiClientError("Request validation failed.", 400, validateRequest.errors);
+      }
+
+      data = this._resolveSpecialValuesInPlace(cleanedData);
+    }
+  
+    // === 3. Payload ===
+    let payload;
+    if (realContentType === "application/json" || realContentType === "multipart/form-data") {
+      payload = data;
+    } else if (realContentType === "application/x-www-form-urlencoded") {
+      payload = ApiClient.toURLSearchParams(data);
+    }
+  
+    this._logger.debug(`[ApiClient] callEndpoint: ${constant} -> ${resolvedPath}, method=${lowerMethod}`);
+
+    try {
+      const response = await this._client.request({
+        url: resolvedPath,
+        method: lowerMethod,
+        headers,
+        [lowerMethod === "get" ? "params" : "data"]: payload
+      });
+  
+      if (validateResponseSchema) {
+        const status = response.status.toString();
+        const schema = responses?.[status];
+        if (schema) {
+          const validateResponse = this._ajv.compile(schema);
+          const valid = validateResponse(response.data);
+          if (!valid) {
+            this.emit("validationError", { stage: "response", errors: validateResponse.errors });
+            throw new ApiClientError("Response validation failed.", status, validateResponse.errors);
+          }
+        }
+      }
+  
+      this._resetCircuitBreakerSuccess();
+  
+      if (typeof transformResponseData === "function") {
+        response.data = transformResponseData(response.data);
+      } else if (transformResponseData === true) {
+        response.data = this._transformData(response.data);
+      }
+  
+      // postActions éventuelles
+      if (Array.isArray(endpoint.postActions)) {
+        endpoint.postActions.forEach(action => {
+          const value = action.path ? this._getValueByPath(response.data, action.path) : null;
+      
+          switch (action.type) {
+          case "setToken":
+            this.setToken(value);
+            break;
+      
+          case "setRefreshToken":
+            this.setRefreshToken(value);
+            break;
+      
+          case "setUserId":
+            this._setUserId(value);
+            break;
+            
+          case "resetSession":
+            this.resetSession();
+            break;
+      
+          case "emitEvent":
+            if (action.event) {
+              this.emit(action.event, value);
+              this._logger.debug(`[ApiClient] Event émis : ${action.event}`, value);
+            }
+            break;
+      
+          case "callMethod":
+            if (typeof this[action.method] === "function") {
+              this[action.method]();
+              this._logger.debug(`[ApiClient] Méthode appelée : ${action.method}`);
+            } else {
+              this._logger.warn(`[ApiClient] Méthode inconnue : ${action.method}`);
+            }
+            break;
+      
+          default:
+            this._logger.warn(`[ApiClient] Action inconnue : ${action.type}`);
+          }
+        });
+      }
+      
+  
+      return response;
+    } catch (error) {
+      this._updateCircuitBreakerError();
+      throw error;
+    }
+  }
+  
+  /**
+ * Réinitialise complètement la session de l'utilisateur :
+ * - Token d'accès
+ * - Token de rafraîchissement
+ * - userId
+ * - En-têtes Axios
+ */
+  resetSession() {
+    this.setToken(null);
+    this.setRefreshToken(null);
+    this._setUserId(null);
+
+    // Suppression des en-têtes
+    delete this._client.defaults.headers.common["Authorization"];
+
+    this._logger.info("[ApiClient] Session utilisateur réinitialisée.");
+    this.emit("sessionReset");
+  }
+
+  /**
+   * Retrieves the value from an object based on a dot-separated path.
+   *
+   * @param {Object} obj - The object from which to retrieve the value.
+   * @param {string} path - The dot-separated path string indicating the value to retrieve.
+   * @returns {*} - The value found at the specified path, or undefined if the path is invalid.
+   */
+  _getValueByPath(obj, path) {
+    if (!path) return undefined;
+    const keys = path.split(".");
+    return keys.reduce((acc, key) => acc && acc[key], obj);
+  }
+  
+  // Conversions
+
+  /**
+   * Converts an object to URL search parameters.
+   *
+   * @param {Object} obj - The object to be converted to URL search parameters.
+   * @param {Object} [options={}] - Optional settings for the conversion.
+   * @returns {URLSearchParams} The URL search parameters generated from the object.
+   */
+  static toURLSearchParams(obj, options = {}) {
+    return this._buildParams(obj, new URLSearchParams(), options);
+  }
+
+  /**
+   * Builds parameters for an API request from a given object.
+   *
+   * @param {Object} obj - The object to be converted into parameters.
+   * @param {FormData|URLSearchParams} paramsInstance - The instance to which the parameters will be appended.
+   * @param {Object} [options={}] - Optional settings.
+   * @param {boolean} [options.dots=false] - Whether to use dots in the parameter keys.
+   * @param {boolean} [options.indexes=false] - Whether to include array indexes in the parameter keys.
+   * @param {boolean} [options.metaTokens=true] - Whether to include meta tokens in the parameter keys.
+   * @throws {TypeError} If the provided obj is not an object or is null.
+   * @returns {FormData|URLSearchParams} The instance with the appended parameters.
+   */
+  static _buildParams(obj, paramsInstance, options = {}) {
+    if (typeof obj !== "object" || obj === null) {
+      throw new TypeError("La donnée doit être un objet non nul.");
+    }
+
+    const { dots = false, indexes = false, metaTokens = true } = options;
+    const stack = [];
+
+    function isVisitable(thing) {
+      return Object.prototype.toString.call(thing) === "[object Object]" || Array.isArray(thing);
+    }
+
+    function removeBrackets(key) {
+      return key.endsWith("[]") ? key.slice(0, -2) : key;
+    }
+
+    function renderKey(path, key, useDots = false) {
+      if (!path) return key;
+      return path.concat(key).map((token, i) => {
+        token = removeBrackets(token);
+        return !useDots && i ? `[${token}]` : token;
+      }).join(useDots ? "." : "");
+    }
+
+    function convertValue(value) {
+      if (value === null || value === undefined) return "";
+      if (value instanceof Date) return value.toISOString();
+      if (
+        value instanceof Blob ||
+        value instanceof File ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value)
+      ) {
+        return value;
+      }
+      return value;
+    }
+
+    function defaultVisitor(value, key, path) {
+      if (value && typeof value === "object") {
+        if (key.endsWith("{}")) {
+          key = metaTokens ? key : key.slice(0, -2);
+          paramsInstance.append(renderKey(path, key, dots), JSON.stringify(value));
+          return false;
+        }
+
+        if ((Array.isArray(value) && !value.some(isVisitable)) || key.endsWith("[]")) {
+          key = removeBrackets(key);
+          value.forEach((el, index) => {
+            if (el !== undefined && el !== null) {
+              // const fieldKey = indexes ? renderKey([key], index, dots) : `${key}[]`;
+              const fieldKey = indexes
+                ? renderKey(path.concat(key), index, dots)
+                : `${renderKey(path, key, dots)}[]`;
+              paramsInstance.append(fieldKey, convertValue(el));
+            }
+          });
+          return false;
+        }
+      }
+
+      if (isVisitable(value)) return true;
+      paramsInstance.append(renderKey(path, key, dots), convertValue(value));
+      return false;
+    }
+
+    function build(value, path = []) {
+      if (value === undefined || value === null || stack.includes(value)) return;
+      stack.push(value);
+
+      Object.entries(value).forEach(([k, el]) => {
+        if (el !== undefined && defaultVisitor(el, k.trim(), path)) {
+          build(el, path.concat(removeBrackets(k)));
+        }
+      });
+
+      stack.pop();
+    }
+
+    build(obj);
+    return paramsInstance;
+  }
+
+
+  /**
+     * Transforms the given data based on its structure.
+     * 
+     * This method normalizes various structures of data into a consistent format.
+     * It handles different types of data including objects, arrays, and specific
+     * nested structures like `resultGoods`, `resultErrors`, `results`, `news`, 
+     * `notif`, `citoyens`, `organizations`, `cities`, `newComment`, `map`, and `object`.
+     * 
+     * @param {Object|Array} data - The data to be transformed.
+     * @returns {Object|Array} - The transformed data.
+     * 
+     * @private
+     */
+  _transformData(data) {
+    if (data && typeof data === "object") {
+      if (data.resultGoods?.msg) {
+        data = this._normalizeJsonData({ msg: data.resultGoods.msg, ...data });
+      } else if (data.resultErrors?.msg) {
+        data = this._normalizeJsonData({ msg: data.resultErrors.msg, ...data });
+      } else if (data.results && typeof data.results === "object" && !Array.isArray(data.results)) {
+        data.results = Object.keys(data.results).map((key) => {
+          return this._normalizeJsonData({ id: key, ...data.results[key] });
+        });
+      } else if (Array.isArray(data.results)) {
+        data.results = data.results.map((item) => this._normalizeJsonData(item));
+      } else if (data.news && Array.isArray(data.news) && data.news.length === 0) {
+        data = data.news;
+      } else if (data.news && typeof data.news === "object" && !Array.isArray(data.news)) {
+        data = Object.keys(data.news).map((key) => {
+          return this._normalizeJsonData({ id: key, ...data.news[key] });
+        });
+      } else if (data.notif && typeof data.notif === "object" && !Array.isArray(data.notif)) {
+        data.notif = Object.keys(data.notif).map((key) => {
+          return this._normalizeJsonData({ id: key, ...data.notif[key] });
+        });
+      } else if (
+        data.citoyens && typeof data.citoyens === "object" && !Array.isArray(data.citoyens) &&
+          data.organizations && typeof data.organizations === "object" && !Array.isArray(data.organizations)
+      ) {
+        data = [
+          ...Object.keys(data.citoyens).map(key => this._normalizeJsonData({ id: key, ...data.citoyens[key] })),
+          ...Object.keys(data.organizations).map(key => this._normalizeJsonData({ id: key, ...data.organizations[key] }))
+        ];
+      } else if (
+        data.citoyens && typeof data.citoyens === "object" && !Array.isArray(data.citoyens)
+      ) {
+        data = Object.keys(data.citoyens).map(key => this._normalizeJsonData({ id: key, ...data.citoyens[key] }));
+      } else if (data.cities && typeof data.cities === "object" && !Array.isArray(data.cities)) {
+        data = Object.keys(data.cities).map(key => this._normalizeJsonData({ id: key, ...data.cities[key] }));
+      } else if (data.cities && Array.isArray(data.cities) && data.cities.length === 0) {
+        data = data.cities;
+      } else if (data.newComment && typeof data.newComment === "object") {
+        data.newComment = this._normalizeJsonData({ ...data.newComment });
+      } else if (Array.isArray(data)) {
+        data = data.map((item) => this._normalizeJsonData(item));
+      } else if (data.map && typeof data.map === "object") {
+        data.map = this._normalizeJsonData(data.map);
+      } else if (data.object && typeof data.object === "object") {
+        data.object = this._normalizeJsonData(data.object);
+      } else if (typeof data === "object" && Object.keys(data).length > 0) {
+        // Vérifie si toutes les clés sont des IDs mongo
+        const allMongoIds = Object.keys(data).every((key) => /^[0-9a-fA-F]{24}$/.test(key));
+        if (allMongoIds) {
+          data = Object.keys(data).map((key) => ({
+            id: key,
+            ...this._normalizeJsonData(data[key])
+          }));
+        } else {
+          data = this._normalizeJsonData(data);
+        }
+      }
+    }
+    return data;
+  }
+  
+
+  /**
+     * Normalizes JSON data by transforming specific fields and ensuring URLs are complete.
+     *
+     * @param {Object} item - The JSON object to be normalized.
+     * @returns {Object} - The normalized JSON object.
+     *
+     * The function performs the following transformations:
+     * - Normalizes the ID field if it matches a specific pattern.
+     * - Converts date fields from seconds to milliseconds.
+     * - Ensures URLs in specific fields are complete.
+     * - Filters and normalizes nested objects and arrays.
+     * - Removes the `timeAgo` field if it exists.
+     * - Converts the object to EJSON format if necessary.
+     */
+  _normalizeJsonData(item) {
+    if (!item || typeof item !== "object") {
+      return item;
+    }
+  
+    // Application des normalisations récursives
+    item = this._normalizeRecursively(item);
+
+    // item = this._normalizeIdRecursively(item);
+    // item = this._normalizeDatesRecursively(item);
+    // item = this._normalizeImagesRecursively(item);
+
+    // if(item?.preferences){
+    //   item.preferences = this._normalizeBooleansRecursively(item.preferences);
+    // }
+
+    if (item?.mediaImg?.images && Array.isArray(item.mediaImg.images) && item.mediaImg.images.length > 0) {
+      item.mediaImg.countImages = item.mediaImg.images.length;
+    }
+  
+    if (item?.mediaFile?.files && Array.isArray(item.mediaFile.files) && item.mediaFile.files.length > 0) {
+      item.mediaFile.countFiles = item.mediaFile.files.length;
+    }
+
+    if (
+      item?.src?.changes &&
+        typeof item.src.changes === "object" &&
+        Object.keys(item.src.changes).length > 0
+    ) {
+      Object.keys(item.src.changes).forEach((key) => {
+        if (item.src.changes[key]) {
+          item.src.changes[key] = this._ensureFullURL(item.src.changes[key]);
+        }
+      });
+    }
+  
+    if (item?.openingHours && Array.isArray(item.openingHours) && item.openingHours.length > 0) {
+      item.openingHours = item.openingHours.filter(
+        (day) => day.dayOfWeek && day.hours && day.hours[0] && day.hours[0].opens
+      );
+    }
+  
+    if (item.replies && typeof item.replies === "object" && Object.keys(item.replies).length > 0) {
+      item.replies = Object.keys(item.replies).map((key) => {
+        return this._normalizeJsonData({ id: key, ...item.replies[key] });
+      });
+    }
+  
+    if (
+      item?.author &&
+      typeof item.author === "object" &&
+      Object.keys(item.author).length > 0
+    ) {
+      // Si author contient déjà une propriété attendue (ici "profilThumbImageUrl"),
+      // on considère qu'il est déjà aplatit.
+      if (!("profilThumbImageUrl" in item.author)) {
+        // Sinon, on considère que author est un mapping et on prend le premier sous-objet.
+        const firstKey = Object.keys(item.author)[0];
+        // On remplace author par le contenu du sous-objet
+        item.author = { ...item.author[firstKey] };
+      }
+    }
+  
+    // Supprime timeAgo
+    if (item?.timeAgo) {
+      delete item.timeAgo;
+    }
+  
+    // Convertit en EJSON si besoin
+    return this._fromJSONValue ? EJSON.fromJSONValue(item) : item;
+  }
+  
+
+  /**
+     * Ensures that the given image path is a full URL. If the image path is already a full URL
+     * (i.e., it starts with "http://" or "https://"), it is returned as is. Otherwise, the image path
+     * is concatenated with the base URL of the ApiClient instance.
+     *
+     * @param {string} imagePath - The image path to ensure as a full URL.
+     * @returns {string} - The full URL of the image path.
+     */
+  _ensureFullURL(imagePath) {
+    if (!imagePath) return imagePath;
+    imagePath = imagePath.trim();
+    if (!imagePath || /^https?:\/\//i.test(imagePath)) {
+      return imagePath;
+    }
+  
+    let separator = "/";
+    if (this._baseURL.endsWith("/") && imagePath.startsWith("/")) {
+      separator = "";
+    } else if (!this._baseURL.endsWith("/") && !imagePath.startsWith("/")) {
+      separator = "/";
+    } else {
+      separator = "";
+    }
+  
+    return `${this._baseURL}${separator}${imagePath}`;
+  }
+
+  /**
+ * Parcourt récursivement un objet pour normaliser les champs de date.
+ * Pour chaque clé présente dans dateFields, si la valeur est un nombre ou un objet
+ * contenant une propriété sec (nombre), la transforme en { $date: valeurEnMs }.
+ *
+ * @param {Object} obj - L’objet à normaliser.
+ * @returns {Object} L’objet normalisé.
+ */
+  _normalizeDatesRecursively(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+
+    // Si c'est un tableau, on traite chaque élément récursivement.
+    if (Array.isArray(obj)) {
+      return obj.map(item => this._normalizeDatesRecursively(item));
+    }
+
+    Object.keys(obj).forEach((key) => {
+      if (this._dateFields.includes(key)) {
+        if (obj[key] && typeof obj[key] === "object" && obj[key].sec && typeof obj[key].sec === "number") {
+          obj[key] = { $date: obj[key].sec * 1000 };
+        } else if (typeof obj[key] === "number") {
+          obj[key] = { $date: obj[key] * 1000 };
+        }
+      }
+      if (obj[key] && typeof obj[key] === "object") {
+        this._normalizeDatesRecursively(obj[key]);
+      }
+    });
+    return obj;
+  }
+
+  /**
+ * Parcourt récursivement un objet pour normaliser les chemins d'images.
+ * Pour chaque propriété correspondant à un champ d'image (dans imageFields),
+ * vérifie et convertit le chemin en URL complète à l’aide de _ensureFullURL.
+ * Les cas particuliers (comme mediaImg.images ou mediaFile.files) sont également gérés.
+ *
+ * @param {Object} obj - L’objet à normaliser.
+ * @returns {Object} L’objet normalisé.
+ */
+  _normalizeImagesRecursively(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+
+    // Si c'est un tableau, on traite chaque élément récursivement.
+    if (Array.isArray(obj)) {
+      return obj.map(item => this._normalizeImagesRecursively(item));
+    }
+
+    Object.keys(obj).forEach((key) => {
+      if (this._imageFields.includes(key) && typeof obj[key] === "string" && obj[key].trim() !== "") {
+        obj[key] = this._ensureFullURL(obj[key]);
+      }
+
+      // Cas particulier pour content.image
+      if (key === "content" && obj[key]?.image) {
+        obj[key].image = this._ensureFullURL(obj[key].image);
+      }
+
+      if (obj[key] && typeof obj[key] === "object") {
+        this._normalizeImagesRecursively(obj[key]);
+      }
+    });
+    return obj;
+  }
+
+  /**
+ * Parcourt récursivement un objet ou un tableau pour normaliser les identifiants (ID).
+ * Si un objet possède une propriété "_id" ou "id" contenant un sous-objet "$id" valide,
+ * l'ID est normalisé et la propriété _id est convertie au format EJSON attendu.
+ *
+ * @param {Object|Array} obj - L'objet ou le tableau à normaliser.
+ * @returns {Object|Array} L'objet ou le tableau normalisé.
+ */
+  _normalizeIdRecursively(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+
+    // Si c'est un tableau, on traite chaque élément récursivement.
+    if (Array.isArray(obj)) {
+      return obj.map(item => this._normalizeIdRecursively(item));
+    }
+
+    // Vérifier et normaliser l'ID dans l'objet
+    if (obj._id && obj._id.$id && /^[0-9a-fA-F]{24}$/.test(obj._id.$id)) {
+      obj.id = obj._id.$id;
+      obj._id = { $type: "oid", $value: obj._id.$id };
+    }
+    if (obj.id && obj.id.$id && /^[0-9a-fA-F]{24}$/.test(obj.id.$id)) {
+      obj._id = { $type: "oid", $value: obj.id.$id };
+      obj.id = obj.id.$id;
+    }
+
+    // Appel récursif pour chaque propriété de l'objet
+    Object.keys(obj).forEach(key => {
+      if (obj[key] && typeof obj[key] === "object") {
+        obj[key] = this._normalizeIdRecursively(obj[key]);
+      }
+    });
+
+    return obj;
+  }
+
+  /**
+ * Normalise récursivement les valeurs booléennes.
+ * Si une valeur est une chaîne "true" ou "false", elle est convertie en booléen.
+ *
+ * @param {any} data - L'objet, le tableau ou la valeur à normaliser.
+ * @returns {any} La donnée normalisée.
+ */
+  _normalizeBooleansRecursively(data) {
+    if (typeof data === "string") {
+      if (data === "true") return true;
+      if (data === "false") return false;
+      return data;
+    }
+    if (Array.isArray(data)) {
+      return data.map(item => this._normalizeBooleansRecursively(item));
+    }
+    if (data !== null && typeof data === "object") {
+      Object.keys(data).forEach(key => {
+        data[key] = this._normalizeBooleansRecursively(data[key]);
+      });
+    }
+    return data;
+  }
+
+  /**
+ * Transforme une chaîne "true" ou "false" en booléen.
+ *
+ * @param {string} str - La chaîne à normaliser.
+ * @returns {boolean|string} La valeur booléenne ou la chaîne originale.
+ */
+  _normalizeString(str) {
+    if (str === "true") return true;
+    if (str === "false") return false;
+    return str;
+  }
+
+  /**
+ * Normalise les identifiants dans un objet.
+ * Si l'objet possède une propriété "_id" ou "id" contenant un sous-objet "$id" valide,
+ * il met à jour l'objet en assignant la valeur de l'ID et en formattant _id en EJSON.
+ *
+ * @param {Object} obj - L'objet à normaliser.
+ * @returns {Object} L'objet avec l'ID normalisé.
+ */
+  _normalizeId(obj) {
+    if (obj._id && obj._id.$id && /^[0-9a-fA-F]{24}$/.test(obj._id.$id)) {
+      obj.id = obj._id.$id;
+      obj._id = { $type: "oid", $value: obj._id.$id };
+    }
+    if (obj.id && obj.id.$id && /^[0-9a-fA-F]{24}$/.test(obj.id.$id)) {
+      obj._id = { $type: "oid", $value: obj.id.$id };
+      obj.id = obj.id.$id;
+    }
+    return obj;
+  }
+
+  /**
+ * Normalise une valeur de date.
+ * Si la valeur est un objet contenant "sec" (nombre) ou un nombre,
+ * elle est convertie en { $date: valeurEnMs }.
+ *
+ * @param {any} value - La valeur à normaliser.
+ * @returns {any} La valeur normalisée.
+ */
+  _normalizeDate(value) {
+    if (value && typeof value === "object" && typeof value.sec === "number") {
+      return { $date: value.sec * 1000 };
+    } else if (typeof value === "number") {
+      return { $date: value * 1000 };
+    }
+    return value;
+  }
+
+  /**
+ * Normalise une URL d'image.
+ * Si la valeur est une chaîne non vide, retourne l'URL complète via _ensureFullURL.
+ *
+ * @param {any} value - La valeur à normaliser.
+ * @returns {any} La valeur normalisée.
+ */
+  _normalizeImage(value) {
+    if (typeof value === "string" && value.trim() !== "") {
+      return this._ensureFullURL(value);
+    }
+    return value;
+  }
+
+  /**
+ * Liste des champs d'image à normaliser.
+ */
+  _imageFields = [
+    "profilImageUrl",
+    "profilThumbImageUrl",
+    "profilMediumImageUrl",
+    "profilMarkerImageUrl",
+    "profilBannerUrl",
+    "profilRealBannerUrl",
+    "imagePath",
+    "imageThumbPath",
+    "docPath"
+  ];
+
+  /**
+ * Liste des champs de date à normaliser.
+ */
+  _dateFields = ["modified", "created", "updated", "birthDate", "lastLoginDate", "startDate", "endDate", "date"];
+
+  /**
+ * Normalise récursivement un objet, un tableau ou une valeur simple.
+ * Cette fonction réalise en une seule passe les opérations suivantes :
+ * - Conversion des chaînes "true"/"false" en booléens.
+ * - Normalisation des dates (pour les champs spécifiés).
+ * - Normalisation des images (pour les champs spécifiés).
+ * - Transformation récursive des objets et tableaux.
+ * - Normalisation des identifiants.
+ *
+ * @param {any} data - La donnée à normaliser.
+ * @returns {any} La donnée normalisée.
+ */
+  _normalizeRecursively(data) {
+  // Cas de base pour les chaînes
+    if (typeof data === "string") {
+      return this._normalizeString(data);
+    }
+
+    // Traitement des tableaux
+    if (Array.isArray(data)) {
+      return data.map(item => this._normalizeRecursively(item));
+    }
+
+    // Traitement des objets non nuls
+    if (data !== null && typeof data === "object") {
+    // On crée une copie de l'objet pour éviter les effets de bord.
+      const normalizedData = {};
+
+      Object.keys(data).forEach(key => {
+      // Appliquer récursivement la normalisation sur la valeur.
+        let value = this._normalizeRecursively(data[key]);
+
+        // Si la clé correspond à un champ de date, on applique la normalisation de date.
+        if (this._dateFields.includes(key)) {
+          value = this._normalizeDate(value);
+        }
+
+        // Si la clé correspond à un champ d'image, on applique la normalisation d'image.
+        if (this._imageFields.includes(key)) {
+          value = this._normalizeImage(value);
+        }
+
+        // Cas particulier : si la clé est "content" et qu'elle possède une propriété "image".
+        if (key === "content" && value && typeof value === "object" && value.image) {
+          value.image = this._normalizeImage(value.image);
+        }
+
+        normalizedData[key] = value;
+      });
+
+      // Normalisation des identifiants après traitement de l'objet.
+      return this._normalizeId(normalizedData);
+    }
+
+    // Pour les autres types (nombres, booléens déjà, etc.), on renvoie la donnée inchangée.
+    return data;
+  }
+
+
+}