@communecter/cocolight-api-client 1.0.29 → 1.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.29",
+    "version": "1.0.31",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",

package/src/Api.js

@@ -163,7 +163,7 @@ export default class Api {
    */
   async project(projectData) {
     try {
-      const project = new Project(this._client, projectData, { EndpointApi, User, Event, Poi, Badge, News });
+      const project = new Project(this._client, projectData, { EndpointApi, User, Organization, Event, Poi, Badge, News });
       if (!projectData.id && !projectData.slug) {
         throw new Error("Vous devez fournir un id ou un slug pour créer une instance Project.");
       }

package/src/api/Badge.js

@@ -4,6 +4,8 @@ import BaseEntity from "./BaseEntity.js";
 export class Badge extends BaseEntity {
   static entityType = "badges";
 
+  static entityTag = "Badge";
+
   static SCHEMA_CONSTANTS = [
     "ADD_BADGES",
   ];

package/src/api/BaseEntity.js

@@ -34,6 +34,8 @@ export class BaseEntity {
   /** @type {boolean} Indique si le draft est synchronisé avec le serveur */
   _syncReactiveDraft = false;
 
+  static entityTag = "BaseEntity";
+
   /**
    * Constructeur de l'entité.
    * @param {Object} parent - L'ApiClient ou une entité parente.
@@ -54,7 +56,7 @@ export class BaseEntity {
    * @throws {ApiError} Si les dépendances ou parent sont invalides.
    */
   constructor(parent, data = {}, deps = {}, config = {}) {
-    this.__entityTag = config.entityTag || this.getEntityTag(this.constructor.name)  || "BaseEntity";
+    this.__entityTag = config.entityTag || this.getEntityTag(this.constructor.entityTag) || "BaseEntity";
     this.deps = deps;
 
     if (this.getEntityTag(parent?.__entityTag) === "ApiClient") {
@@ -1002,7 +1004,14 @@ export class BaseEntity {
    * @private
    */
   _linkEntities(results) {
-    return results.map(d => this._linkEntity?.(d.collection, d) ?? d);
+    return results.flatMap(d => {
+      if (!d?.collection) {
+        this.apiClient._logger?.warn?.(`Objet ignoré car sans 'collection' : ${d?.id}`);
+        return []; // exclu de la liste
+      }
+
+      return [this._linkEntity?.(d.collection, d) ?? d];
+    });
   }
 
   /**
@@ -1670,193 +1679,152 @@ export class BaseEntity {
    * 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.
+   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @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 arrayObjet = await fetchFn();
-  
-    if (!Array.isArray(arrayObjet.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des organisations.", 500, arrayObjet.results);
-    }
-  
-    // nettoyage du count
-    delete arrayObjet?.count?.spam;
-  
-    // calcul du total
-    const totalCount = Object.values(arrayObjet.count || {}).reduce((acc, val) => acc + val, 0);
-    arrayObjet.count.total = totalCount;
-  
-    const rawList = this._linkEntities(arrayObjet.results);
+  async getOrganizations(data = {}, isNext = false) {
+    data.searchType = this._getDefaultFromEndpoint("GET_ORGANIZATIONS_NO_ADMIN", "searchType");
+    // data.searchBy = "ALL";
+    return this._paginateWith(data, isNext, async (finalData) => {
+      if(this.isMe){
+        finalData.pathParams = { type: this.getEntityType(), id: this.id };
+        // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
+        // finalData.filters = {
+        //   [`links.members.${this.id}`]: { "$exists": true },
+        //   [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
+        //   [`links.members.${this.id}.isInviting`]: { "$exists": false }
+        // };
+      } else {
+        delete finalData?.pathParams;
+        finalData.filters = {
+          [`links.members.${this.id}`]: { "$exists": true },
+          [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
+          [`links.members.${this.id}.isInviting`]: { "$exists": false }
+        };
+      }
   
-    return {
-      count: arrayObjet.count,
-      results: rawList
-    };
+      const fetchFn = this.isMe
+        ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(finalData))
+        : () => this.endpointApi.getOrganizationsNoAdmin(finalData);
+
+      return fetchFn();
+    });
   }
 
   /**
-     * 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 = {
+   * 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.
+   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
+   * @returns {Promise<Object>} - Les données de réponse.
+   */
+  async getProjects(data = {}, isNext = false) {
+    data.searchType = this._getDefaultFromEndpoint("GET_PROJECTS_ADMIN", "searchType");
+    // data.searchBy = "ALL";
+    return this._paginateWith(data, isNext, async (finalData) => {
+      if(this.isMe){
+        finalData.pathParams = { type: this.getEntityType(), id: this.id };
+      // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
+      // finalData.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 arrayObjet = await fetchFn();
+      } else {
+        delete finalData?.pathParams;
+        finalData.filters = {
+          "$or": {
+            [`links.contributors.${this.id}`]: { "$exists": true },
+            [`parent.${this.id}`]: { "$exists": true }
+          },
+          [`links.contributors.${this.id}`]: { "$exists": true }
+        };
+      }
     
-    if (!Array.isArray(arrayObjet.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des projets.", 500, arrayObjet.results);
-    }
+      const fetchFn = this.isMe
+        ? () => this.callIsMe(() => this.endpointApi.getProjectsAdmin(finalData))
+        : () => this.endpointApi.getProjectsNoAdmin(finalData);
 
-    const rawList = this._linkEntities(arrayObjet.results);
-    
-    return {
-      count: arrayObjet?.count?.projects ?? 0,
-      results: rawList
-    };
+      return fetchFn();
+    });
   }
 
   /**
    * 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.
+   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @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 = {
+  async getPois(data = {}, isNext = false) {
+    data.searchType = this._getDefaultFromEndpoint("GET_POIS_ADMIN", "searchType");
+    // data.searchBy = "ALL";
+    return this._paginateWith(data, isNext, async (finalData) => {
+      if(this.isMe){
+        finalData.pathParams = { type: this.getEntityType(), id: this.id };
+      // NOTE : dans le schema je crois que si pas de finalData.filters alors le default ce fait avec finalData.pathParams
+      // finalData.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);
+      } else {
+        delete finalData?.pathParams;
+        finalData.filters = {
+          [`parent.${this.id}`]: { "$exists": true },
+        };
+      }
   
-    const arrayObjet = await fetchFn();
-    if (!Array.isArray(arrayObjet.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des POIs.", 500, arrayObjet.results);
-    }
+      const fetchFn = this.isMe
+        ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(finalData))
+        : () => this.endpointApi.getPoisNoAdmin(finalData);
 
-    // lier les entités au objets
-    const rawList = this._linkEntities(arrayObjet.results);
-
-    return {
-      count: arrayObjet.count?.poi ?? 0,
-      results: rawList
-    };
+      return fetchFn();
+    });
   }
 
   /**
    * Récupérer les abonnés d'une entité
    * Constant : GET_SUBSCRIBERS
    * @param {Object} data - Les données à envoyer.
+   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @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 arrayObjet = await  this.endpointApi.getSubscribers(data);
-    if (!Array.isArray(arrayObjet.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des abonnés.", 500, arrayObjet.results);
-    }
+  async getSubscribers(data = {}, isNext = false) {
+    data.searchType = this._getDefaultFromEndpoint("GET_SUBSCRIBERS", "searchType");
+    // data.searchBy = "ALL";
+    return this._paginateWith(data, isNext, async (finalData) => {
+      delete finalData?.pathParams;
 
-    // lier les entités au objets
-    const rawList = this._linkEntities(arrayObjet.results);
+      finalData.filters =  {
+        [`links.follows.${this.id}`]: { "$exists": true },
+        [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
+        [`links.follows.${this.id}.isInviting`]: { "$exists": false }
+      };
 
-    return {
-      count: arrayObjet.count,
-      results: rawList
-    };
+      return this.endpointApi.getSubscribers(finalData);
+    });
   }
 
   /**
    * Liste des badges créés par l'entité
    * Constant : GET_BADGES
    * @param {Object} data - Les données à envoyer.
+   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @returns {Promise<Object>} - Les données de réponse. 
    */
-  async getBadgesIssuer(data = {}) {
-    delete data?.pathParams;
+  async getBadgesIssuer(data = {}, isNext = false) {
+    data.searchType = this._getDefaultFromEndpoint("GET_BADGES", "searchType");
+    // data.searchBy = "ALL";
+    return this._paginateWith(data, isNext, async (finalData) => {
+      delete finalData?.pathParams;
   
-    data.filters = data.filters || {};
-    data.filters["$or"] = {};
-    data.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
-
-    const arrayObjet = await this.endpointApi.getBadges(data);
-    if (!Array.isArray(arrayObjet.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des badges.", 500, arrayObjet.results);
-    }
+      finalData.filters = finalData.filters || {};
+      finalData.filters["$or"] = {};
+      finalData.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
 
-    // lier les entités au objets
-    const rawList = this._linkEntities(arrayObjet.results);
-
-    return {
-      count: arrayObjet.count?.badges ?? 0,
-      results: rawList
-    };
+      return this.endpointApi.getBadges(finalData);
+    });
   }
 
   /**
@@ -2164,6 +2132,217 @@ export class BaseEntity {
     return this._isLinked("follows");
   }
 
+  /**
+   * Récupère le JSON personnalisé de l'entité
+   * 
+   * @returns {Promise<Object>} - Le JSON personnalisé de l'entité.
+   * @throws {ApiError} - Si le slug de l'entité n'est pas défini.
+   */
+  async getCostumJson() {
+    if (!this.serverData.slug) {
+      throw new ApiError("slug de l'entité non défini");
+    }
+    const data = {
+      pathParams: {
+        slug: this.serverData.slug
+      }
+    };
+    return this.endpointApi.getCostumJson(data);
+  }
+
+  /**
+   * Génère des plages d'index pour la pagination.
+   * 
+   * @param {Array<string>} searchType - Types de recherche.
+   * @param {number} indexStep - Pas d'index.
+   * @param {Object} previousRanges - Plages précédentes.
+   * @returns {Object} - Plages d'index générées.
+   * @private
+   */
+  _generateRanges(searchType, indexStep, previousRanges = {}) {
+    const ranges = {};
+    for (const type of searchType) {
+      const previous = previousRanges[type] || { indexMax: 0 };
+      ranges[type] = {
+        indexMin: previous.indexMax || 0,
+        indexMax: previous.indexMax + indexStep
+      };
+    }
+    return ranges;
+  }
+
+  /**
+   * Normalise le compte des résultats.
+   * 
+   * @param {Object} count - Compte des résultats.
+   * @returns {Object} - Compte normalisé.
+   * @private
+   */
+  _normalizeCount(count = {}) {
+    // suppression des indésirables
+    delete count.spam;
+
+    // calcul du total (somme des valeurs numériques)
+    count.total = Object.values(count).reduce((acc, val) => acc + (typeof val === "number" ? val : 0), 0);
+
+    return count;
+  }
+  
+  /**
+   * Méthode générique de pagination contextuelle avec support next / prev.
+   *
+   * @param {Object} data - Données d'entrée
+   * @param {boolean} isNext - true si appel de page suivante
+   * @param {Function} finalizer - fonction qui transforme et envoie les données (exécute la requête)
+   * @returns {Promise<Object>} { count, results, next, prev }
+   * @throws {ApiError} - Si le slug ou l'id de l'entité n'est pas défini.
+   * @throws {ApiResponseError} - Si les résultats ne sont pas un tableau.
+   * @private
+   */
+  async _paginateWith(data = {}, isNext = false, finalizer) {
+    if (!this.serverData.slug) throw new ApiError("slug de l'entité non défini");
+    if (!this.serverData.id) throw new ApiError("id de l'entité non défini");
+
+    const hasStep = (d) => d?.indexStep && d.indexStep > 0;
+
+    if (!this._paginationCursor || (!isNext && this._paginationHistory.length === 0)) {
+      this._paginationCount = 0;
+      this._paginationPageIndex = 0;
+      this._paginationHistory = [];
+      this._paginationPageSizes = [];
+      data.countType = data.searchType;
+
+      if (!data?.searchBy && hasStep(data)) {
+        data.ranges = this._generateRanges(data.searchType, data.indexStep);
+        data.indexMin = data.indexMin ?? 0;
+        data.indexMax = data.indexMax ?? data.indexStep;
+      } else if (data?.searchBy === "ALL" && hasStep(data)) {
+        data.indexMin = data.indexMin ?? 0;
+        data.indexMax = data.indexMax ?? data.indexStep;
+      }
+
+      this._paginationCursor = { ...data };
+    }
+
+    const cursor = this._paginationCursor;
+
+    if (isNext) {
+      this._paginationHistory.push({ ...cursor });
+
+      if (!cursor.searchBy && hasStep(cursor)) {
+        cursor.ranges = this._generateRanges(cursor.searchType, cursor.indexStep, cursor.ranges);
+        cursor.indexMin = cursor.indexMax ?? 0;
+        cursor.indexMax = (cursor.indexMax ?? 0) + cursor.indexStep;
+      } else if (cursor.searchBy === "ALL" && hasStep(cursor)) {
+        cursor.indexMin = cursor.indexMax ?? 0;
+        cursor.indexMax = (cursor.indexMax ?? 0) + cursor.indexStep;
+      }
+
+      this._paginationCursor = { ...cursor };
+    }
+
+    data = { ...this._paginationCursor };
+
+    if (!isNext && (!data?.searchType || !Array.isArray(data.searchType) || data.searchType.length === 0)) {
+      throw new ApiError("searchType non défini");
+    }
+
+    const result = await finalizer(data);
+    if (!Array.isArray(result.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des résultats", 500, result.results);
+    }
+
+    this._paginationCount += result.results.length;
+    this._paginationPageSizes.push(result.results.length);
+
+    if (isNext) {
+      this._paginationPageIndex++;
+    }
+  
+    const count = this._normalizeCount(result.count);
+    const rawList = this._linkEntities(result.results);
+    const hasNext = hasStep(data) && this._paginationCount < count.total;
+    const hasPrev = this._paginationHistory?.length > 0;
+
+    const response = {
+      count,
+      results: rawList,
+      pageIndex: this._paginationPageIndex,
+      pageNumber: this._paginationPageIndex + 1,
+      hasNext,
+      hasPrev
+    };
+
+    if (hasNext) {
+      response.next = async () => this._paginateWith({}, true, finalizer);
+    }
+
+    if (this._paginationHistory?.length > 0) {
+      response.prev = async () => {
+        const previous = this._paginationHistory.pop();
+        const lastPageSize = this._paginationPageSizes.pop() ?? 0;
+        this._paginationCount -= lastPageSize;
+        this._paginationPageIndex = Math.max(0, this._paginationPageIndex - 1);
+        this._paginationCursor = { ...previous };
+        return this._paginateWith({}, false, finalizer);
+      };
+    }
+
+    return response;
+  }
+
+
+  /**
+   * Réinitialise l'état de pagination.
+   */
+  resetPagination() {
+    this._paginationCursor = undefined;
+    this._paginationCount = 0;
+    this._paginationPageIndex = 0;
+    this._paginationHistory = [];
+    this._paginationPageSizes = [];
+  }
+
+
+  /**
+   * Récupère une valeur par défaut depuis un endpoint donné.
+   *
+   * @param {string} constant - Le nom unique de l’endpoint (ex: "GET_ORGANIZATIONS_NO_ADMIN")
+   * @param {string} path - Le chemin vers la propriété (ex: "searchType")
+   * @returns {*} La valeur par défaut, ou undefined si non trouvée
+   */
+  _getDefaultFromEndpoint(constant, path) {
+    const endpoint = this.apiClient._endpoints.find((ep) => ep.constant === constant);
+    if (!endpoint?.request?.properties?.[path]) return undefined;
+    return endpoint.request.properties[path].default;
+  }
+
+  /**
+   * recherche lié à l'entité.
+   *
+   * @param {Object} data - Les données de recherche.
+   * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
+   * @returns {Promise<Object>} - Résultat de la recherche.
+   * @throws {ApiError} - Si le slug ou l'id de entité n'est pas défini.
+   */
+  async searchCostum(data = {}, isNext = false) {
+    return this._paginateWith(data, isNext, async (finalData) => {
+      finalData = {
+        ...finalData,
+        costumSlug: this.serverData.slug,
+        contextId: this.serverData.id,
+        contextType: this.getEntityType()
+      };
+
+      if (finalData.sourceKey?.length) {
+        finalData.sourceKey = [...finalData.sourceKey, this.serverData.slug];
+      } else {
+        finalData.sourceKey = [this.serverData.slug];
+      }
+
+      return this.endpointApi.globalAutocompleteCostum(finalData);
+    });
+  }
 
 
 }

package/src/api/EndpointApi.js

@@ -1363,6 +1363,21 @@ class EndpointApi {
     return this.call("GET_COSTUM_JSON", data);
   }
     
+  /**
+   * Recherche globale lier à un costum : Effectue une recherche globale lier à un costum
+   * Constant : GLOBAL_AUTOCOMPLETE_COSTUM
+   * @param {import("./EndpointApi.types").GlobalAutocompleteCostumData} data - Données envoyées à l'API
+   * @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 globalAutocompleteCostum(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("GLOBAL_AUTOCOMPLETE_COSTUM", data);
+  }
+    
 }
 
 export default EndpointApi;