@communecter/cocolight-api-client 1.0.6 → 1.0.8

package/dist/cocolight-api-client.mjs.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.6",
+    "version": "1.0.8",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",
@@ -17,6 +17,7 @@
     "scripts": {
         "test": "node --experimental-vm-modules ./node_modules/.bin/jest --config jest.config.js",
         "exemple": "node exemple/exemple.js",
+        "exemple-api": "node exemple/exemple-api.js",
         "lint": "eslint ./src ./exemple ./scripts --ext .js",
         "lint:fix": "eslint ./src ./scripts --ext .js --fix",
         "build:browser": "webpack --config webpack.config.standalone.js",
@@ -28,7 +29,10 @@
         "generate:module:publish": "node ./scripts/transform-json-module.publish.js",
         "generate:doc": "node ./scripts/generate-doc.js",
         "generate:test": "node ./scripts/generate-tests.js",
-        "generate:testdata": "node ./scripts/generate-test-data.js"
+        "generate:testdata": "node ./scripts/generate-test-data.js",
+        "generate:reponses": "node ./scripts/generate-constant-response-200.js",
+        "generate:methodeapi": "node ./scripts/generate-methode-api.js",
+        "generate:ajv-standalone": "node ./scripts/generate-validate-function-ajv.js"
     },
     "keywords": [
         "communecter",
@@ -46,25 +50,28 @@
         "README.md"
     ],
     "peerDependencies": {
+        "@segment/ajv-human-errors": "^2.15.0",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "axios": "^1.4.0",
         "axios-retry": "^4.5.0",
         "ejson": "^2.2.3",
         "events": "^3.3.0",
+        "jwt-decode": "^4.0.0",
         "pino": "^9.6.0",
         "pino-pretty": "^13.0.0",
-        "jwt-decode": "^4.0.0"
+        "file-type": "^20.4.1"
     },
     "devDependencies": {
         "@babel/core": "^7.26.10",
         "@babel/preset-env": "^7.26.9",
         "@eslint/js": "^9.23.0",
+        "@segment/ajv-human-errors": "^2.15.0",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "axios": "^1.4.0",
         "axios-retry": "^4.5.0",
-        "jwt-decode": "^4.0.0",
+        "file-type": "^20.4.1",
         "babel-jest": "^29.7.0",
         "babel-loader": "^10.0.0",
         "ejson": "^2.2.3",
@@ -73,6 +80,7 @@
         "events": "^3.3.0",
         "globals": "^16.0.0",
         "jest": "^29.7.0",
+        "jwt-decode": "^4.0.0",
         "nodemon": "^3.1.9",
         "pino": "^9.6.0",
         "pino-pretty": "^13.0.0",

package/src/Api.js

@@ -0,0 +1,157 @@
+// Api.js
+import { Organization } from "./api/Organization.js";
+import { Project } from "./api/Project.js";
+import { User } from "./api/User.js";
+import { UserApi } from "./api/UserApi.js";
+import { ApiAuthenticationError, ApiClientError } from "./error.js";
+
+export default class Api {
+  /**
+   * Authentifie l'utilisateur et retourne une instance d'Api.
+   *
+   * @param {string} email - L'adresse email.
+   * @param {string} password - Le mot de passe.
+   * @param {Object} options - Options pour l'ApiClient (baseURL, debug, etc.)
+   * @returns {Promise<Api>}
+   */
+  static async userLogin(email, password, options) {
+    const userApi = Api.userApi(options);
+    return await Api.userApiLogin(userApi, email, password);
+  }
+
+  /**
+   * Creates an instance of the UserApi class with the provided options.
+   *
+   * @param {Object} options - Configuration options for initializing the UserApi instance.
+   * @returns {UserApi} An instance of the UserApi class.
+   * @throws {Error} Throws an error if the UserApi instance cannot be created.
+   */
+  static userApi(options) {
+    try {
+      const userApi = new UserApi(options);
+      return userApi;
+    } catch (error) {
+      console.error("[Api.userApi] Erreur lors de la création d'un objet utilisateur :", error.message);
+      throw error;
+    }
+  }
+  
+  /**
+     * Logs in a user using the provided userApi instance, email, and password.
+     *
+     * @param {Object} userApi - The API instance used for user authentication.
+     * @param {string} email - The email address of the user.
+     * @param {string} password - The password of the user.
+     * @returns {Promise<Api>} A promise that resolves to an instance of the Api class
+     *                         initialized with the logged-in user and the API client.
+     * @throws {ApiAuthenticationError} If the login fails due to authentication issues.
+     * @throws {Error} If an unexpected error occurs during the login process.
+     */
+  static async userApiLogin(userApi, email, password) {
+    try {
+      const loggedUser = await userApi.login(email, password);
+      return new Api(loggedUser, userApi.client);
+    } catch (error) {
+      if(error instanceof ApiClientError) {
+        if(error?.details?.error) {
+          throw new ApiAuthenticationError(error.details.error, error.status, error.details);
+        }
+      }
+      throw error;
+    }
+  }
+    
+  /**
+   * Construit une instance d'Api.
+   *
+   * @param {User|null} loggedUser - L'utilisateur connecté ou null.
+   * @param {ApiClient} client - L'instance d'ApiClient.
+   */
+  constructor(loggedUser, client) {
+    this._loggedUser = loggedUser;
+    this._client = client;
+  }
+
+  /**
+   * Retourne l'utilisateur connecté.
+   *
+   * @returns {User} L'utilisateur connecté.
+   */
+  me() {
+    if (!this._loggedUser) {
+      throw new ApiAuthenticationError("Accès refusé : utilisateur non authentifié.");
+    }
+    return this._loggedUser;
+  }
+
+  /**
+   * Crée une instance User pour un utilisateur donné (autre que le connecté).
+   *
+   * @param {Object} userData - Les données de l'utilisateur public.
+   * @returns {User}
+   */
+  user(userData) {
+    try {
+      return new User(this._client, userData);
+    } catch (error) {
+      console.error("[Api.user] Erreur lors de la création d'un objet utilisateur public :", error.message);
+      throw error;
+    }
+  }
+
+
+  /**
+   * Creates an Organization object and optionally retrieves its profile.
+   *
+   * @param {Object} organizationData - The data required to initialize the Organization object.
+   * @param {Object} [options={ getProfile: true }] - Additional options for the organization creation.
+   * @param {boolean} [options.getProfile=true] - Whether to fetch the organization's profile after creation.
+   * @returns {Promise<Organization>} A promise that resolves to the created Organization object.
+   * @throws {Error} Throws an error if the organization creation or profile retrieval fails.
+   */
+  async organization(organizationData, options = { getProfile: true }) {
+    try {
+      const oraganization = new Organization(this._client, organizationData);
+      if (options.getProfile) {
+        await oraganization.getProfil();
+      }
+      return oraganization;
+    } catch (error) {
+      console.error("[Api.organization] Erreur lors de la création d'un objet organisation :", error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Creates a new Project instance and optionally retrieves its profile.
+   *
+   * @param {Object} projectData - The data used to initialize the Project instance.
+   * @param {Object} [options={ getProfile: true }] - Additional options for project creation.
+   * @param {boolean} [options.getProfile=true] - Whether to retrieve the project's profile after creation.
+   * @returns {Promise<Project>} A promise that resolves to the created Project instance.
+   * @throws {Error} If an error occurs during project creation or profile retrieval.
+   */
+  async project(projectData, options = { getProfile: true }) {
+    try {
+      const project = new Project(this._client, projectData);
+      if (options.getProfile) {
+        await project.getProfil();
+      }
+      return project;
+    } catch (error) {
+      console.error("[Api.project] Erreur lors de la création d'un objet projet :", error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Retourne l'instance d'ApiClient.
+   *
+   * @returns {ApiClient}
+   */
+
+  get client() {
+    return this._client;
+  }
+
+}

package/src/ApiClient.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
 
+import { AggregateAjvError } from "@segment/ajv-human-errors";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import axios from "axios";
@@ -10,7 +11,7 @@ import pino from "pino";
 
 import MongoID from "./EJSONType.js";
 import endpointsJson from "./endpoints.module.js";
-import { ApiClientError, CircuitBreakerError } from "./error.js";
+import { ApiClientError, ApiResponseError, ApiValidationError, CircuitBreakerError } from "./error.js";
 
 EJSON.addType("oid", value => {
   return new MongoID.ObjectID(value);
@@ -74,7 +75,7 @@ export default class ApiClient extends EventEmitter {
     };
 
     // AJV
-    this._ajv = new Ajv({ strict: false, useDefaults: true });
+    this._ajv = new Ajv({ strict: false, useDefaults: true, allErrors: true, verbose: true });
     addFormats(this._ajv);
 
     // Pino logger
@@ -190,6 +191,16 @@ export default class ApiClient extends EventEmitter {
     return this._refreshToken;
   }
 
+  /**
+   * Indique si le client est connecté.
+   * On considère que le client est connecté si un token d'accès (_accessToken) est défini.
+   *
+   * @returns {boolean} True si connecté, false sinon.
+   */
+  get isConnected() {
+    return !!this._accessToken;
+  }
+
   /**
  * Extrait l'identifiant depuis un JWT.
  *
@@ -202,10 +213,10 @@ export default class ApiClient extends EventEmitter {
       // Décodage du token grâce à jwt-decode
       const payload = jwtDecode(token);
       // L'identifiant peut être dans "id" ou "userId"
-      this._logger.log("[ApiClient] Payload décodé :", payload);
+      this._logger.debug("[ApiClient] Payload décodé :", payload);
       return payload.id || payload.userId || null;
     } catch (err) {
-      this._logger.error("[ApiClient] Erreur lors du décodage du token :", err.message);
+      this._logger.error("[ApiClient] Erreur lors du décodage du token :", err);
       return null;
     }
   }
@@ -232,6 +243,8 @@ export default class ApiClient extends EventEmitter {
       }
       return false;
     } catch (err) {
+      // Si on a une erreur, on reset la session
+      this.resetSession();
       this._logger.error(`[ApiClient] Refresh Error : ${err.message}`);
       return false;
     }
@@ -458,6 +471,23 @@ export default class ApiClient extends EventEmitter {
     return obj;
   }
   
+  /**
+   * Safely calls an asynchronous function and handles any errors that occur.
+   * Logs the error message using the instance's logger before re-throwing the error.
+   *
+   * @param {Function} fn - The asynchronous function to be called.
+   * @param {...any} args - The arguments to pass to the function.
+   * @returns {Promise<any>} The result of the asynchronous function.
+   * @throws {Error} Re-throws any error that occurs during the function execution.
+   */
+  async safeCall(fn, ...args) {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      this._logger.error(`[ApiClient.safeCall] Erreur: ${error.message}`);
+      throw error;
+    }
+  }
 
   /**
    * Calls an API endpoint with the specified parameters.
@@ -523,8 +553,9 @@ export default class ApiClient extends EventEmitter {
       const valid = validatePathParams(pathParams);
   
       if (!valid) {
+        const errorMessages = this._ajvErrorHuman(validatePathParams.errors);
         this.emit("validationError", { stage: "pathParams", errors: validatePathParams.errors });
-        throw new ApiClientError("Path parameter validation failed.", 400, validatePathParams.errors);
+        throw new ApiValidationError("Path parameter validation failed.", 400, errorMessages, validatePathParams.errors);
       }
   
       resolvedParams = this._resolveSpecialValuesInPlace(pathParams);
@@ -551,8 +582,9 @@ export default class ApiClient extends EventEmitter {
       const validateRequest = this._ajv.compile(schemaToCompile);
       const valid = validateRequest(cleanedData);
       if (!valid) {
+        const errorMessages = this._ajvErrorHuman(validateRequest.errors);
         this.emit("validationError", { stage: "request", errors: validateRequest.errors });
-        throw new ApiClientError("Request validation failed.", 400, validateRequest.errors);
+        throw new ApiValidationError("Request validation failed.", 400, errorMessages, validateRequest.errors);
       }
 
       data = this._resolveSpecialValuesInPlace(cleanedData, resolvedParams);
@@ -583,8 +615,9 @@ export default class ApiClient extends EventEmitter {
           const validateResponse = this._ajv.compile(schema);
           const valid = validateResponse(response.data);
           if (!valid) {
+            const errorMessages = this._ajvErrorHuman(validateResponse.errors);
             this.emit("validationError", { stage: "response", errors: validateResponse.errors });
-            throw new ApiClientError("Response validation failed.", status, validateResponse.errors);
+            throw new ApiValidationError("Response validation failed.", status, errorMessages, validateResponse.errors);
           }
         }
       }
@@ -645,10 +678,74 @@ export default class ApiClient extends EventEmitter {
       return response;
     } catch (error) {
       this._updateCircuitBreakerError();
-      throw error;
+      this._logger.error(`[ApiClient] Erreur lors de l'appel de ${constant}: ${error.message}`);
+      throw new ApiClientError(
+        `Erreur lors de l'appel de l'API : ${error.message}`,
+        error.response ? error.response.status : 500,
+        error.response ? error.response.data : null
+      );
     }
   }
   
+  /**
+   * Converts AJV (Another JSON Schema Validator) errors into human-readable messages.
+   *
+   * @param {Array} errors - An array of AJV validation error objects.
+   * @returns {Array<string>} An array of human-readable error messages extracted from the AJV errors.
+   */
+  _ajvErrorHuman(errors){
+    const errorsMessages = new AggregateAjvError(errors);
+    const messages = errorsMessages.errors.map(({ message }) => message);
+    return messages;
+  }
+
+  /**
+   * Checks the API response for errors and throws an `ApiResponseError` if any are found.
+   *
+   * This method examines the `response.data` object to determine if it contains
+   * error information. It handles both standard and nested error cases:
+   * 
+   * - Standard case: If `data.result` is a boolean and is `false`, an error is thrown.
+   * - Nested case: If `data.resultErrors` exists and contains a `result` property
+   *   that is a boolean and is `false`, an error is thrown.
+   *
+   * If no errors are found, the original `response` is returned.
+   *
+   * @param {Object} response - The API response object to check.
+   * @param {Object} response.data - The data payload of the response.
+   * @param {number} response.status - The HTTP status code of the response.
+   * @throws {ApiResponseError} If an error is detected in the response data.
+   * @returns {Object} The original `response` object if no errors are found.
+   */
+  checkAndThrowApiResponseError(response) {
+    const data = response.data;
+    if (!data || typeof data !== "object") {
+      return response;
+    }
+  
+    // Cas standard : vérifie si data.result vaut false
+    if (typeof data.result === "boolean" && data.result === false) {
+      throw new ApiResponseError(
+        data.msg || "Erreur inconnue",
+        response.status,
+        data
+      );
+    }
+  
+    // Cas imbriqué : vérifie si data.resultErrors existe et contient une erreur
+    if (data.resultErrors && typeof data.resultErrors === "object") {
+      if (typeof data.resultErrors.result === "boolean" && data.resultErrors.result === false) {
+        throw new ApiResponseError(
+          data.resultErrors.msg || "Erreur inconnue",
+          response.status,
+          data
+        );
+      }
+    }
+  
+    return response;
+  }
+    
   /**
  * Réinitialise complètement la session de l'utilisateur :
  * - Token d'accès

package/src/api/EntityMixin.js

@@ -0,0 +1,249 @@
+import { ApiResponseError } from "../error.js";
+
+// EntityMixin.js
+export const EntityMixin = {
+  /**
+     * Résout l'identifiant de l'entité si seul le slug est fourni.
+     * @param {string} type - Le type d'entité (ex : "citoyens", "organizations", "projects").
+     * @returns {Promise<string>} L'identifiant résolu.
+     */
+  async resolveId(type) {
+    if (!this.id && this.slug) {
+      try {
+        const data = await this._getElementsKey({
+          pathParams:{
+            slug: this.slug
+          }
+        });
+        if(data?.contextId && data?.contextType === type) {
+          this._id(data.contextId);
+        } else {
+          throw new ApiResponseError(`Le slug ${this.slug} ne correspond pas à un ${type}`, 200, data);
+        }
+      } catch (error) {
+        if(error instanceof ApiResponseError) {
+          if(error?.responseData?.contextType !== type) {
+            throw error;
+          } else {
+            throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${this.slug}`, error.status, error.responseData);
+          }
+        } else {
+          throw error;
+        }
+      }
+    }
+    return this.id;
+  },
+  
+  /**
+     * Récupère le profil public de l'entité.
+     * @returns {Promise<Object>} Les données du profil public.
+     */
+  async getPublicProfile() {
+    await this.resolveId(this.getEntityType());
+    return this._getElementsAbout({ pathParams: { id: this.id, type: this.getEntityType() } });
+  },
+
+  /**
+   * Obtenir les éléments liés : Récupère les informations détaillées d'un élément et de ses éléments liés.
+   * Constant : GET_ELEMENTS_ABOUT
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.tpl - Template utilisé (ex: ficheInfoElement) (default: "ficheInfoElement")
+   * @param {Object} data.pathParams - Les paramètres de chemin.
+   * @param {string} data.pathParams.type - Type d'entité (default: "citoyens")
+   * @param {string} data.pathParams.id - ID de l'utilisateur ou de l'entité
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _getElementsAbout(data = {}) {
+    return this.call("GET_ELEMENTS_ABOUT", data);
+  },
+
+  /**
+   * Récuperer l'id et la collection d'un element en fonction du slug : Récuperer l'id et la collection d'un element en fonction du slug
+   * Constant : GET_ELEMENTS_KEY
+   * @param {Object} data.pathParams - Les paramètres de chemin.
+   * @param {string} data.pathParams.slug - Slug de l'élément à récupérer
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _getElementsKey(data = {}) {
+    return this.call("GET_ELEMENTS_KEY", data);
+  },
+
+  /**
+   * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
+   * Constant : PROFIL_IMAGE
+   * @param {Object} data - Les données à envoyer.
+   * @param {undefined} data.profil_avatar - Fichier image de profil au format binaire
+   * @param {Object} data.pathParams - Les paramètres de chemin.
+   * @param {string} data.pathParams.folder - Type d'entité (default: "citoyens")
+   * @param {string} data.pathParams.ownerId - ID de l'utilisateur ou de l'entité
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _profilImage(data = {}) {
+    return this.callIsConnected("PROFIL_IMAGE", data);
+  },
+
+  /**
+   * Mettre à jour les paramètres d'un élément : Mise à jour des paramètres spécifiques d'un élément.
+   * Constant : UPDATE_SETTINGS
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.type - data.type
+   * @param {undefined} data.value - data.value
+   * @param {string} data.typeEntity - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+   * @param {string} data.idEntity - Id de l'élément
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _updateSettings(data = {}) {
+    return this.callIsConnected("UPDATE_SETTINGS", data);
+  },
+
+  /**
+   * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
+   * Constant : UPDATE_BLOCK_DESCRIPTION
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.block - Nom du bloc à mettre à jour (doit être 'descriptions') (default: "descriptions")
+   * @param {string} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+   * @param {string} data.id - ID de l'élément concerné
+   * @param {string | null} data.scope - Périmètre de mise à jour (default: "")
+   * @param {string} data.descMentions - Mentions dans la description (default: "")
+   * @param {string} data.shortDescription - Courte description
+   * @param {string} data.description - Description complète
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _updateBlockDescription(data = {}) {
+    return this.callIsConnected("UPDATE_BLOCK_DESCRIPTION", data);
+  },
+  
+  /**
+     * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
+     * Constant : UPDATE_BLOCK_INFO
+     * @param {Object} data - Les données à envoyer.
+     * @param {string} data.block - Nom du bloc à mettre à jour (doit être 'info') (default: "info")
+     * @param {string} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+     * @param {string} data.id - ID de l'élément concerné
+     * @param {string} data.scope - Périmètre de mise à jour (default: "")
+     * @returns {Promise<Object>} - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
+     */
+  async _updateBlockInfo(data = {}) {
+    return this.callIsConnected("UPDATE_BLOCK_INFO", data);
+  },
+  
+  /**
+     * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
+     * Constant : UPDATE_BLOCK_SOCIAL
+     * @param {Object} data - Les données à envoyer.
+     * @param {string} data.block - Nom du bloc à mettre à jour (doit être 'network') (default: "network")
+     * @param {string} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+     * @param {string} data.id - ID de l'élément concerné
+     * @param {string} data.scope - Périmètre de mise à jour (default: "")
+     * @param {string} data.gitlab - Compte Gitlab
+     * @param {string} data.github - Compte Github
+     * @param {string} data.twitter - Compte Twitter
+     * @param {string} data.facebook - Compte Facebook
+     * @param {string} data.instagram - Compte Instagram
+     * @param {string} data.diaspora - Compte Diaspora
+     * @param {string} data.mastodon - Compte Mastodon
+     * @param {string} data.telegram - Compte Telegram
+     * @param {string} data.signal - Compte Signal
+     * @returns {Promise<Object>} - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
+     */
+  async _updateBlockSocial(data = {}) {
+    return this.callIsConnected("UPDATE_BLOCK_SOCIAL", data);
+  },
+  
+  /**
+     * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
+     * Constant : UPDATE_BLOCK_LOCALITY
+     * @param {Object} data - Les données à envoyer.
+     * @param {string} data.block - Nom du bloc à mettre à jour (doit être 'localities') (default: "localities")
+     * @param {string} data.typeElement - Type d'élément (default: "citoyens")
+     * @param {string} data.id - ID de l'élément concerné
+     * @param {string} data.scope - Périmètre de mise à jour (default: "")
+     * @param {object} data.geo - Coordonnées géographiques
+     * @param {string} data.geo.@type - data.geo.@type
+     * @param {string | number} data.geo.latitude - data.geo.latitude
+     * @param {string | number} data.geo.longitude - data.geo.longitude
+     * @param {object} data.geoPosition - Position géographique GeoJSON
+     * @param {string} data.geoPosition.type - Type GeoJSON (doit être 'Point')
+     * @param {Array<number>} data.geoPosition.coordinates - Tableau contenant [longitude, latitude]
+     * @param {boolean} data.geoPosition.float - Indicateur pour forcer la conversion en float côté serveur (default: true)
+     * @param {object} data.address - data.address
+     * @param {string} data.address.@type - data.address.@type
+     * @param {string} data.address.addressCountry - data.address.addressCountry
+     * @param {string} data.address.codeInsee - data.address.codeInsee
+     * @param {string} data.address.addressLocality - data.address.addressLocality
+     * @param {string} data.address.localityId - data.address.localityId
+     * @param {string} data.address.level1 - data.address.level1
+     * @param {string} data.address.level1Name - data.address.level1Name
+     * @param {string} data.address.level3 - ID du département. Peut être vide pour les pays étrangers.
+     * @param {string} data.address.level3Name - Nom du département. Peut être vide pour les pays étrangers.
+     * @param {string} data.address.level4 - ID de la commune. Peut être vide pour les pays étrangers.
+     * @param {string} data.address.level4Name - Nom de la commune. Peut être vide pour les pays étrangers.
+     * @param {string} data.address.postalCode - data.address.postalCode
+     * @param {string} data.address.streetAddress - data.address.streetAddress
+     * @returns {Promise<Object>} - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
+     */
+  async _updateBlockLocality(data = {}) {
+    return this.callIsConnected("UPDATE_BLOCK_LOCALITY", data);
+  },
+  
+  /**
+     * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
+     * Constant : UPDATE_BLOCK_SLUG
+     * @param {Object} data - Les données à envoyer.
+     * @param {string} data.block - Nom du bloc à mettre à jour (doit être 'info') (default: "info")
+     * @param {string} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+     * @param {string} data.id - ID de l'élément concerné
+     * @param {string} data.scope - data.scope (default: "")
+     * @param {string} data.slug - Slug simplifié pour URL
+     * @returns {Promise<Object>} - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
+     */
+  async _updateBlockSlug(data = {}) {
+    return this.callIsConnected("UPDATE_BLOCK_SLUG", data);
+  },
+  
+  /**
+     * Vérifier l'état d'une URL : Vérifie si une URL (slug) est valide ou disponible.
+     * Constant : CHECK
+     * @param {Object} data - Les données à envoyer.
+     * @param {string} data.block - Nom du bloc (default: "info")
+     * @param {string} data.id - ID de l'élément
+     * @param {string} data.type - Type d'élément (default: "citoyens")
+     * @param {string} data.slug - Slug à vérifier
+     * @returns {Promise<Object>} - Les données de réponse.
+     * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+     * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+     * @throws {Error} - En cas d'erreur inattendue.
+     */
+  async _check(data = {}) {
+    return this.callIsConnected("CHECK", data);
+  }
+  
+
+};
+