@communecter/cocolight-api-client 1.0.20 → 1.0.21

package/src/mixin/EntityMixin.js

@@ -1,428 +0,0 @@
-import { ApiError, ApiResponseError } from "../error.js";
-
-// EntityMixin.js
-export const EntityMixin = {
-  /**
-     * Récupère le profil complet de l'organisation.
-     *
-     * @returns {Promise<Object>} Le profil complet.
-     */
-  async get() {
-    return this.apiClient.safeCall(async () => {
-      const data = await this.getPublicProfile();
-      this._setData(data);
-      return 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
-   * @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 = {}) {
-    data.idEntity = this.id;
-    data.typeEntity = this.getEntityType();
-    return this.callIsConnected(() => this.endpointApi.updateSettings(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.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 updateDescription(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockDescription(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
-     */
-  async updateInfo(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockInfo(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
-   */
-  async updateSocial(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockSocial(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
-   */
-  async updateLocality(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockLocality(data));
-  },
-    
-  /**
-   * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
-   * Constant : UPDATE_BLOCK_SLUG
-   */
-  async updateSlug({ slug }) {
-    try {
-      await this.endpointApi.check({ type: this.getEntityType(), id: this.id, slug });
-    } catch (error) {
-      if(error instanceof ApiResponseError) {
-        throw new ApiResponseError("Erreur lors de la vérification du slug.", error.status, error.data);
-      }
-      throw error;
-    }
-    return this.callIsConnected(() => this.endpointApi.updateBlockSlug({ typeElement: this.getEntityType(), id: this.id, slug }));
-  },
-    
-  /**
-   * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
-   * Constant : PROFIL_IMAGE
-   */
-  async updateImageProfil({ profil_avatar: image  }) {
-    image = await this._validateImage(image);
-    const data = { pathParams: { folder: this.getEntityType(), ownerId: this.id },  profil_avatar: image };
-    return this.callIsConnected(() => this.endpointApi.profilImage(data));
-  },
-
-  /**
-   * Crée une instance d'organisation et récupère son profil si nécessaire.
-   *
-   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
-   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
-   */
-  async organization(organizationData = {}) {
-    if(!this.isMe){
-      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une organisation.");
-    }
-    return this.entity("organizations", organizationData);
-  },
-
-  /**
-   * Crée une instance de projet et récupère son profil si nécessaire.
-   *
-   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
-   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
-   * @throws {Error} Si une erreur se produit lors de la création du projet.
-   */
-  async project(projectData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un projet.");
-    }
-    return this.entity("projects", projectData);
-  },
-
-  /**
-   * Crée une instance de POI et la récupère si nécessaire.
-   * 
-   * @param {Object} poiData - Les données nécessaires pour initialiser le POI.
-   * @returns {Promise<Poi>} Une promesse qui résout l'objet POI créé.
-   * @throws {Error} Si une erreur se produit lors de la création du POI.
-   */
-  async poi(poiData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un POI.");
-    }
-    return this.entity("poi", poiData);
-  },
-
-  /**
-   * Crée une instance d'événement et la récupère si nécessaire.
-   * 
-   * @param {Object} eventData - Les données nécessaires pour initialiser l'événement.
-   * @returns {Promise<Event>} Une promesse qui résout l'objet Événement créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'événement.
-   */
-  async event(eventData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un événement.");
-    }
-    return this.entity("events", eventData);
-  },
-
-  /**
-   * Crée une instance de badge et la récupère si nécessaire.
-   * 
-   * @param {Object} badgeData - Les données nécessaires pour initialiser le badge.
-   * @returns {Promise<Badge>} Une promesse qui résout l'objet Badge créé.
-   * @throws {Error} Si une erreur se produit lors de la création du badge.
-   */
-  async badge(badgeData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté pour créer un badge.");
-    }
-    return this.entity("badges", badgeData);
-  },
-
-  /**
-   * Crée une instance de news et la récupère si nécessaire.
-   * 
-   * @param {Object} newsData - Les données nécessaires pour initialiser la news.
-   * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
-   * @throws {Error} Si une erreur se produit lors de la création de la news.
-   */
-  async news(newsData = {}) {
-    if(!this.isConnected){
-      throw new ApiError("Vous devez être connecté.");
-    }
-    return this.entity("news", newsData);
-  },
-
-  /**
-   * Récupérer les organisations d'une entitée : la liste des organisations dont l'entité est membre ou admin valide.
-   * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN
-   * @param {Object} data - Les données à envoyer.
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async getOrganizations(data = {}) {
-
-    if(this.isMe){
-      data.pathParams = { type: this.getEntityType(), id: this.id };
-      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
-      // data.filters = {
-      //   [`links.members.${this.id}`]: { "$exists": true },
-      //   [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
-      //   [`links.members.${this.id}.isInviting`]: { "$exists": false }
-      // };
-    } else {
-      delete data?.pathParams;
-      data.filters = {
-        [`links.members.${this.id}`]: { "$exists": true },
-        [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
-        [`links.members.${this.id}.isInviting`]: { "$exists": false }
-      };
-    }
-  
-    const fetchFn = this.isMe
-      ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(data))
-      : () => this.endpointApi.getOrganizationsNoAdmin(data);
-  
-    const arrayObjetOrganizations = await fetchFn();
-  
-    if (!Array.isArray(arrayObjetOrganizations.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des organisations.", 500, arrayObjetOrganizations.results);
-    }
-  
-    // nettoyage du count
-    delete arrayObjetOrganizations?.count?.spam;
-  
-    // calcul du total
-    const totalCount = Object.values(arrayObjetOrganizations.count || {}).reduce((acc, val) => acc + val, 0);
-    arrayObjetOrganizations.count.total = totalCount;
-  
-    const rawOrganizationsList = arrayObjetOrganizations.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
-  
-    return {
-      count: arrayObjetOrganizations.count,
-      results: rawOrganizationsList
-    };
-  },
-
-  /**
-     * Récupérer les projets d'une entitée : liste des projets de l'entité ou elle est "parent" ou "contributeur".
-     * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
-     * @param {Object} data - Les données à envoyer.
-     * @returns {Promise<Object>} - Les données de réponse.
-     */
-  async getProjects(data = {}) {
-
-    if(this.isMe){
-      data.pathParams = { type: this.getEntityType(), id: this.id };
-      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
-      // data.filters = {
-      //   "$or": {
-      //     [`links.contributors.${this.id}`]: { "$exists": true },
-      //     [`parent.${this.id}`]: { "$exists": true }
-      //   },
-      //   [`links.contributors.${this.id}`]: { "$exists": true }
-      // };
-    } else {
-      delete data?.pathParams;
-      data.filters = {
-        "$or": {
-          [`links.contributors.${this.id}`]: { "$exists": true },
-          [`parent.${this.id}`]: { "$exists": true }
-        },
-        [`links.contributors.${this.id}`]: { "$exists": true }
-      };
-    }
-    
-    const fetchFn = this.isMe
-      ? () => this.callIsMe(() => this.endpointApi.getProjectsAdmin(data))
-      : () => this.endpointApi.getProjectsNoAdmin(data);
-    
-    
-    const arrayObjetProjects = await fetchFn();
-    
-    if (!Array.isArray(arrayObjetProjects.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des projets.", 500, arrayObjetProjects.results);
-    }
-  
-    const rawProjectsList = arrayObjetProjects.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
-    
-    return {
-      count: arrayObjetProjects?.count?.projects ?? 0,
-      results: rawProjectsList
-    };
-  },
-
-  /**
-   * Récupérer les POIs d'une entité : liste des POIs de l'entité ou elle est "parent".
-   * Constant : GET_POIS_NO_ADMIN / GET_POIS_ADMIN
-   * @param {Object} data - Les données à envoyer.
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async getPois(data = {}) {
-
-    if(this.isMe){
-      data.pathParams = { type: this.getEntityType(), id: this.id };
-      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
-      // data.filters = {
-      //   [`parent.${this.id}`]: { "$exists": true },
-      // };
-    } else {
-      delete data?.pathParams;
-      data.filters = {
-        [`parent.${this.id}`]: { "$exists": true },
-      };
-    }
-  
-    const fetchFn = this.isMe
-      ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(data))
-      : () => this.endpointApi.getPoisNoAdmin(data);
-  
-    const arrayObjetPois = await fetchFn();
-    if (!Array.isArray(arrayObjetPois.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des POIs.", 500, arrayObjetPois.results);
-    }
-
-    // lier les entités au objets
-    const rawPoisList = arrayObjetPois.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
-
-    return {
-      count: arrayObjetPois.count?.poi ?? 0,
-      results: rawPoisList
-    };
-  },
-
-  /**
-   * Récupérer les abonnés d'une entité
-   * Constant : GET_SUBSCRIBERS
-   * @param {Object} data - Les données à envoyer.
-   * @returns {Promise<Object>} - Les données de réponse.
-   */
-  async getSubscribers(data = {}) {
-    delete data?.pathParams;
-
-    data.filters =  {
-      [`links.follows.${this.id}`]: { "$exists": true },
-      [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
-      [`links.follows.${this.id}.isInviting`]: { "$exists": false }
-    };
-  
-    const arrayObjetSubscribers = await  this.endpointApi.getSubscribers(data);
-    if (!Array.isArray(arrayObjetSubscribers.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des abonnés.", 500, arrayObjetSubscribers.results);
-    }
-
-    // lier les entités au objets
-    const rawSubscribersList = arrayObjetSubscribers.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
-
-    return {
-      count: arrayObjetSubscribers.count,
-      results: rawSubscribersList
-    };
-  },
-
-  /**
-   * Liste des badges créés par l'entité
-   * Constant : GET_BADGES
-   * @param {Object} data - Les données à envoyer.
-   * @returns {Promise<Object>} - Les données de réponse. 
-   */
-  async getBadgesIssuer(data = {}) {
-    delete data?.pathParams;
-  
-    data.filters = data.filters || {};
-    data.filters["$or"] = {};
-    data.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
-
-    const arrayObjetBadges = await this.endpointApi.getBadges(data);
-    if (!Array.isArray(arrayObjetBadges.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des badges.", 500, arrayObjetBadges.results);
-    }
-
-    // lier les entités au objets
-    const rawBadgesList = arrayObjetBadges.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
-
-    return {
-      count: arrayObjetBadges.count?.badges ?? 0,
-      results: rawBadgesList
-    };
-  },
-
-  /**
-   * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
-   * Constant : GET_NEWS
-   * @param {Object} data - Les données à envoyer.
-   * @param {number} data.dateLimit - Limite de date timestamp ou 0 (default: 0)
-   * @param {object} data.search - data.search
-   * @param {string} data.search.name - Nom ou terme recherché (default: "")
-   * @param {number} data.indexStep - Nombre de résultats par page (default: 12)
-   * @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 getNews(data = {}) {
-    data.pathParams = { type: this.getEntityType(), id: this.id };
-    const arrayObjetNews =  await this.endpointApi.getNews(data);
-    if(!Array.isArray(arrayObjetNews)){
-      throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
-    }
-
-    const rawNewsList = arrayObjetNews.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
-
-    return this._createFilteredProxy(rawNewsList);
-  }
-
-
-};
-  

package/src/mixin/MutualEntityMixin.js

@@ -1,269 +0,0 @@
-import { ApiResponseError } from "../error.js";
-
-// MutualEntityMixin.js
-export const MutualEntityMixin = {
-  /**
-     * 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.endpointApi.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.endpointApi.getElementsAbout({ pathParams: { id: this.id, type: this.getEntityType() } });
-  },
-
-  /**
- * Récupère la classe d'entité et ses dépendances à partir du type d'entité.
- * 
- * @param {string} entityType - Le type d'entité.
- * @return {{ entityClass: Function, deps: Object } | null}
- */
-  _getEntityMeta(entityType) {
-    const selfClass = this.constructor;
-    const selfTag = this.__entityTag;
-  
-    const commonDeps = {
-      EndpointApi: this.deps.EndpointApi,
-      User: selfTag === "User" ? selfClass : this.deps.User,
-      Organization: selfTag === "Organization" ? selfClass : this.deps.Organization,
-      Project: selfTag === "Project" ? selfClass : this.deps.Project,
-      Event: selfTag === "Event" ? selfClass : this.deps.Event,
-      Poi: selfTag === "Poi" ? selfClass : this.deps.Poi,
-      Badge: selfTag === "Badge" ? selfClass : this.deps.Badge,
-      News: selfTag === "News" ? selfClass : this.deps.News
-    };
-  
-    const map = {
-      citoyens:     { entityClass: commonDeps.User,         deps: commonDeps },
-      organizations:{ entityClass: commonDeps.Organization, deps: commonDeps },
-      projects:      { entityClass: commonDeps.Project,      deps: commonDeps },
-      events:       { entityClass: commonDeps.Event,        deps: { ...commonDeps, Badge: undefined } },
-      poi:          { entityClass: commonDeps.Poi,          deps: { ...commonDeps, Badge: undefined, News: undefined } },
-      news:         { entityClass: commonDeps.News,         deps: { ...commonDeps } },
-      badges:       { entityClass: commonDeps.Badge,        deps: { 
-        EndpointApi: commonDeps.EndpointApi, 
-        User: commonDeps.User, 
-        Organization: commonDeps.Organization, 
-        Project: commonDeps.Project 
-      } }
-    };
-  
-    return map[entityType] || null;
-  },
-
-  /**
- * Lier des données d'entité à une instance d'entité.
- * 
- * @param {string} entityType - Le type d'entité (ex : "citoyens", "organisations", "projets").
- * @param {Object} entityData - Les données de l'entité à lier.
- * @return {Object} L'entité liée.
- */
-  linkEntity(entityType, entityData) {
-    const meta = this._getEntityMeta(entityType);
-    if (!meta) return entityData;
-    return meta.entityClass.fromServerData(entityData, this, meta.deps);
-  },
-
-  /**
- * Récupère et lie une entité à partir de son ID.
- * 
- * @param {string} entityType - Le type d'entité.
- * @param {string} entityId - L'identifiant de l'entité.
- * @param {Object} [options] - Options supplémentaires :
- * @param {boolean} [options.skipGet] - Si true, ne pas appeler `get()` sur l'entité.
- * @return {Promise<Object|null>} L'entité liée ou null.
- */
-  async linkEntityById(entityType, entityId, options = {}) {
-    const meta = this._getEntityMeta(entityType);
-    if (!meta) return null;
-    const entity = new meta.entityClass(this, { id: entityId }, meta.deps);
-    if(options?.skipGet) return entity;
-    await entity.get();
-    return entity;
-  },
-
-
-  /**
-   * Lie des entités présentes dans `this.serverData` à partir de leurs IDs,
-   * en les filtrant dynamiquement et en optionnellement les transformant.
-   *
-   * @param {string} entityType - Le type d'entité (ex : "badges", "citoyens", etc.).
-   * @param {Object} filters - Clés/valeurs de filtres dynamiques. Les valeurs peuvent être :
-   *   - un littéral (comparaison stricte ou intelligente selon le type),
-   *   - une chaîne (utilise `includes` insensible à la casse),
-   *   - une RegExp (appliquée si la valeur est une chaîne),
-   *   - une fonction `(value) => boolean`.
-   * @param {Object} [options] - Options supplémentaires :
-   * @param {string} [options.key] - Le champ de `this.serverData` à utiliser (par défaut = entityType).
-   * @param {Function} [options.mapFn] - Fonction de transformation `(entity) => any` appliquée au résultat.
-   *
-   * @return {Promise<Array<Object>>} Liste des entités liées, filtrées et éventuellement transformées.
-   *
-   * @example
-   * // Tous les badges avec `name` contenant "codev"
-   * const badges = await this.linkEntitiesFromServerData("badges", { name: "codev" });
-   *
-   * @example
-   * // Badges non expirés et visibles
-   * const badges = await this.linkEntitiesFromServerData("badges", {
-   *   expiredOn: false,
-   *   show: "true"
-   * });
-   *
-   * @example
-   * // Badges émis après 2023
-   * const badges = await this.linkEntitiesFromServerData("badges", {
-   *   issuedOn: (v) => new Date(v) >= new Date("2023-01-01")
-   * });
-   *
-   * @example
-   * // Extraire uniquement les noms des badges
-   * const namesOnly = await this.linkEntitiesFromServerData("badges", {}, {
-   *   mapFn: (badge) => badge.meta.name
-   * });
-   */
-  async linkEntitiesFromServerData(entityType, filters = {}, options = {}) {
-    const key = options.key || entityType;
-    const mapFn = typeof options.mapFn === "function" ? options.mapFn : null;
-
-    const isTruthy = (v) => v === true || v === "true";
-    const isFalsy = (v) => v === false || v === "false";
-
-    const data = this.serverData?.[key];
-    const result = [];
-
-    if (data && typeof data === "object" && Object.keys(data).length > 0) {
-      for (const id of Object.keys(data)) {
-        const meta = data[id];
-
-        const matches = Object.entries(filters).every(([key, expected]) => {
-          const actual = meta[key];
-
-          if (typeof expected === "function") {
-            try {
-              return expected(actual);
-            } catch (err) {
-              console.warn(`Erreur dans le filtre personnalisé pour ${key}`, err);
-              return false;
-            }
-          }
-
-          if (expected instanceof RegExp) {
-            return typeof actual === "string" && expected.test(actual);
-          }
-
-          if (typeof expected === "string" && typeof actual === "string") {
-            return actual.toLowerCase().includes(expected.toLowerCase());
-          }
-
-          if (isTruthy(expected)) return isTruthy(actual);
-          if (isFalsy(expected)) return isFalsy(actual);
-
-          if (
-            typeof actual === "string" &&
-            typeof expected === "string" &&
-            !isNaN(Date.parse(actual)) &&
-            !isNaN(Date.parse(expected))
-          ) {
-            return new Date(actual).getTime() === new Date(expected).getTime();
-          }
-
-          return actual === expected;
-        });
-
-        if (!matches) continue;
-
-        try {
-          const entity = await this.linkEntityById(entityType, id);
-          if (entity) {
-            entity.meta = meta;
-            result.push(mapFn ? mapFn(entity) : entity);
-          }
-        } catch (error) {
-          this._logger?.error?.(`Erreur lors de la récupération de l'entité ${entityType} (${id}) :`, error);
-        }
-      }
-    }
-    return result;
-  },
-
-
-  entityInstanceData(entityType, entityData) {
-    const meta = this._getEntityMeta(entityType);
-    const selfKey = this.__entityTag; // ex: "User", "Organization", etc.
-    const selfClass = this.constructor;
-
-    // pour citoyens la signature est différentes
-    return new meta.entityClass(this, entityData, {
-      [selfKey]: selfClass,
-      ...meta.deps
-    });
-  },
-
-  /**
-   * Crée une instance d'entité, et déclenche get() si certaines propriétés sont présentes.
-   * TODO : pas finis
-   * @param {string} entityType
-   * @param {Object} entityData
-   * @return {Promise<Object>}
-   */
-  async entity(entityType, entityData = {}) {
-    try {
-      const entity = this.entityInstanceData(entityType, entityData);
-
-      const fetchKeysByEntity = {
-        citoyens: ["id", "slug"],
-        organisations: ["id", "slug"],
-        projets: ["id", "slug"],
-        events: ["id", "slug"],
-        poi: ["id", "slug"],
-        news: ["id"],
-        badges: ["id"],
-      };
-
-      const fetchKeys = fetchKeysByEntity[entityType];
-
-      if (fetchKeys && this._hasAtLeastOne(entityData, fetchKeys)) {
-        await entity.get();
-      }
-
-      return entity;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.${entityType}] Erreur lors de la création d'une instance ${entityType} :`, error.message);
-      throw error;
-    }
-  }
-  
-};