@communecter/cocolight-api-client 1.0.30 → 1.0.32

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") {
@@ -1680,33 +1682,63 @@ export class BaseEntity {
    * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @returns {Promise<Object>} - Les données de réponse.
    */
-  async getOrganizations(data = {}, isNext = false) {
+  async getOrganizations(data = {}) {
     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 };
+    // 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 }
+    //     };
+    //   }
+  
+    //   const fetchFn = this.isMe
+    //     ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(finalData))
+    //     : () => this.endpointApi.getOrganizationsNoAdmin(finalData);
+
+    //   return fetchFn();
+    // });
+
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: 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 }
-        };
-      }
+        } 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 }
+          };
+        }
   
-      const fetchFn = this.isMe
-        ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(finalData))
-        : () => this.endpointApi.getOrganizationsNoAdmin(finalData);
+        const fetchFn = this.isMe
+          ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(finalData))
+          : () => this.endpointApi.getOrganizationsNoAdmin(finalData);
 
-      return fetchFn();
+        return fetchFn();
+      }
     });
+
+    return paginator.next();
   }
 
   /**
@@ -1716,37 +1748,70 @@ export class BaseEntity {
    * @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) {
+  async getProjects(data = {}) {
     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 finalData?.pathParams;
-        finalData.filters = {
-          "$or": {
-            [`links.contributors.${this.id}`]: { "$exists": true },
-            [`parent.${this.id}`]: { "$exists": true }
-          },
-          [`links.contributors.${this.id}`]: { "$exists": true }
-        };
-      }
+    // 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 finalData?.pathParams;
+    //     finalData.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(finalData))
+    //     : () => this.endpointApi.getProjectsNoAdmin(finalData);
+
+    //   return fetchFn();
+    // });
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: 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 finalData?.pathParams;
+          finalData.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(finalData))
-        : () => this.endpointApi.getProjectsNoAdmin(finalData);
+        const fetchFn = this.isMe
+          ? () => this.callIsMe(() => this.endpointApi.getProjectsAdmin(finalData))
+          : () => this.endpointApi.getProjectsNoAdmin(finalData);
 
-      return fetchFn();
+        return fetchFn();
+      }
     });
+
+    return paginator.next();
   }
 
   /**
@@ -1756,29 +1821,55 @@ export class BaseEntity {
    * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @returns {Promise<Object>} - Les données de réponse.
    */
-  async getPois(data = {}, isNext = false) {
+  async getPois(data = {}) {
     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 finalData?.pathParams;
-        finalData.filters = {
-          [`parent.${this.id}`]: { "$exists": true },
-        };
-      }
+    // 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 finalData?.pathParams;
+    //     finalData.filters = {
+    //       [`parent.${this.id}`]: { "$exists": true },
+    //     };
+    //   }
+  
+    //   const fetchFn = this.isMe
+    //     ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(finalData))
+    //     : () => this.endpointApi.getPoisNoAdmin(finalData);
+
+    //   return fetchFn();
+    // });
+
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: 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 finalData?.pathParams;
+          finalData.filters = {
+            [`parent.${this.id}`]: { "$exists": true },
+          };
+        }
   
-      const fetchFn = this.isMe
-        ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(finalData))
-        : () => this.endpointApi.getPoisNoAdmin(finalData);
+        const fetchFn = this.isMe
+          ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(finalData))
+          : () => this.endpointApi.getPoisNoAdmin(finalData);
 
-      return fetchFn();
+        return fetchFn();
+      }
     });
+
+    return paginator.next();
   }
 
   /**
@@ -1788,20 +1879,36 @@ export class BaseEntity {
    * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @returns {Promise<Object>} - Les données de réponse.
    */
-  async getSubscribers(data = {}, isNext = false) {
+  async getSubscribers(data = {}) {
     data.searchType = this._getDefaultFromEndpoint("GET_SUBSCRIBERS", "searchType");
     // data.searchBy = "ALL";
-    return this._paginateWith(data, isNext, async (finalData) => {
-      delete finalData?.pathParams;
+    // return this._paginateWith(data, isNext, async (finalData) => {
+    //   delete finalData?.pathParams;
+
+    //   finalData.filters =  {
+    //     [`links.follows.${this.id}`]: { "$exists": true },
+    //     [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
+    //     [`links.follows.${this.id}.isInviting`]: { "$exists": false }
+    //   };
+
+    //   return this.endpointApi.getSubscribers(finalData);
+    // });
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: async (finalData) => {
+        delete finalData?.pathParams;
 
-      finalData.filters =  {
-        [`links.follows.${this.id}`]: { "$exists": true },
-        [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
-        [`links.follows.${this.id}.isInviting`]: { "$exists": false }
-      };
+        finalData.filters =  {
+          [`links.follows.${this.id}`]: { "$exists": true },
+          [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
+          [`links.follows.${this.id}.isInviting`]: { "$exists": false }
+        };
 
-      return this.endpointApi.getSubscribers(finalData);
+        return this.endpointApi.getSubscribers(finalData);
+      }
     });
+
+    return paginator.next();
   }
 
   /**
@@ -1811,18 +1918,32 @@ export class BaseEntity {
    * @param {boolean} isNext - Indique si c'est une recherche suivante (pagination).
    * @returns {Promise<Object>} - Les données de réponse. 
    */
-  async getBadgesIssuer(data = {}, isNext = false) {
+  async getBadgesIssuer(data = {}) {
     data.searchType = this._getDefaultFromEndpoint("GET_BADGES", "searchType");
     // data.searchBy = "ALL";
-    return this._paginateWith(data, isNext, async (finalData) => {
-      delete finalData?.pathParams;
+    // return this._paginateWith(data, isNext, async (finalData) => {
+    //   delete finalData?.pathParams;
+  
+    //   finalData.filters = finalData.filters || {};
+    //   finalData.filters["$or"] = {};
+    //   finalData.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
+
+    //   return this.endpointApi.getBadges(finalData);
+    // });
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: async (finalData) => {
+        delete finalData?.pathParams;
   
-      finalData.filters = finalData.filters || {};
-      finalData.filters["$or"] = {};
-      finalData.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
+        finalData.filters = finalData.filters || {};
+        finalData.filters["$or"] = {};
+        finalData.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
 
-      return this.endpointApi.getBadges(finalData);
+        return this.endpointApi.getBadges(finalData);
+      }
     });
+
+    return paginator.next();
   }
 
   /**
@@ -2197,109 +2318,109 @@ export class BaseEntity {
    * @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 };
-    }
+  // 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;
+  //   const cursor = this._paginationCursor;
 
-    if (isNext) {
-      this._paginationHistory.push({ ...cursor });
+  //   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;
-      }
+  //     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 };
-    }
+  //     this._paginationCursor = { ...cursor };
+  //   }
 
-    data = { ...this._paginationCursor };
+  //   data = { ...this._paginationCursor };
 
-    if (!isNext && (!data?.searchType || !Array.isArray(data.searchType) || data.searchType.length === 0)) {
-      throw new ApiError("searchType non défini");
-    }
+  //   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);
-    }
+  //   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);
+  //   this._paginationCount += result.results.length;
+  //   this._paginationPageSizes.push(result.results.length);
 
-    if (isNext) {
-      this._paginationPageIndex++;
-    }
+  //   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);
-    }
+  //   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);
-      };
-    }
+  //   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;
-  }
+  //   return response;
+  // }
 
 
   /**
    * Réinitialise l'état de pagination.
    */
-  resetPagination() {
-    this._paginationCursor = undefined;
-    this._paginationCount = 0;
-    this._paginationPageIndex = 0;
-    this._paginationHistory = [];
-    this._paginationPageSizes = [];
-  }
+  // resetPagination() {
+  //   this._paginationCursor = undefined;
+  //   this._paginationCount = 0;
+  //   this._paginationPageIndex = 0;
+  //   this._paginationHistory = [];
+  //   this._paginationPageSizes = [];
+  // }
 
 
   /**
@@ -2323,23 +2444,167 @@ export class BaseEntity {
    * @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()
-      };
+  // 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];
-      }
+  //     if (finalData.sourceKey?.length) {
+  //       finalData.sourceKey = [...finalData.sourceKey, this.serverData.slug];
+  //     } else {
+  //       finalData.sourceKey = [this.serverData.slug];
+  //     }
 
-      return this.endpointApi.globalAutocompleteCostum(finalData);
+  //     return this.endpointApi.globalAutocompleteCostum(finalData);
+  //   });
+  // }
+
+  /**
+   * Recherche liée à l'entité, version stateless.
+   *
+   * @param {Object} data - Données initiales de recherche.
+   * @returns {Object} - Un paginateur avec .next(), .prev(), etc.
+   */
+  async searchCostum(data = {}) {
+
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: this._withCostumContext((finalData) => this.endpointApi.globalAutocompleteCostum(finalData)),
     });
+
+    return paginator.next();
+  }
+
+  /**
+   * Coeur de pagination stateless et réutilisable, sans logique métier.
+   *
+   * @param {Object} config
+   * @param {Object} config.initialData - Paramètres de départ
+   * @param {Function} config.finalizer - Fonction async qui retourne { results, count }
+   *
+   * @returns {Object} paginator avec .next() et .prev()
+   */
+  _createPaginatorEngine({ initialData, finalizer }) {
+    const Entity = this;
+
+    const state = {
+      cursor: undefined,
+      count: 0,
+      index: 0,
+      history: [],
+      sizes: []
+    };
+
+    const hasStep = (d) => d?.indexStep && d.indexStep > 0;
+
+    async function getPage(isNext = false) {
+      let data = { ...initialData };
+
+      if (!state.cursor || (!isNext && state.history.length === 0)) {
+        state.count = 0;
+        state.index = 0;
+        state.history = [];
+        state.sizes = [];
+
+        data.countType = data.searchType;
+
+        if (!data?.searchBy && hasStep(data)) {
+          data.ranges = Entity._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;
+        }
+
+        state.cursor = { ...data };
+      }
+
+      const cursor = state.cursor;
+
+      if (isNext) {
+        state.history.push({ ...cursor });
+
+        if (!cursor.searchBy && hasStep(cursor)) {
+          cursor.ranges = Entity._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;
+        }
+
+        state.cursor = { ...cursor };
+      }
+
+      data = { ...state.cursor };
+
+      if (!isNext && (!data?.searchType || !Array.isArray(data.searchType) || data.searchType.length === 0)) {
+        throw new Error("searchType non défini");
+      }
+
+      const result = await finalizer(data);
+      if (!Array.isArray(result.results)) {
+        throw new Error("Les résultats doivent être un tableau");
+      }
+
+      state.count += result.results.length;
+      state.sizes.push(result.results.length);
+      if (isNext) state.index++;
+
+      const count = Entity._normalizeCount(result.count);
+      const rawList = Entity._linkEntities(result.results);
+
+      const hasNext = hasStep(data) && state.count < count.total;
+      const hasPrev = state.history.length > 0;
+
+      return {
+        count,
+        results: rawList,
+        pageIndex: state.index,
+        pageNumber: state.index + 1,
+        hasNext,
+        hasPrev,
+        next: hasNext ? () => getPage(true) : undefined,
+        prev: hasPrev
+          ? async () => {
+            const previous = state.history.pop();
+            const lastPageSize = state.sizes.pop() ?? 0;
+            state.count -= lastPageSize;
+            state.index = Math.max(0, state.index - 1);
+            state.cursor = { ...previous };
+            return getPage(false);
+          }
+          : undefined
+      };
+    }
+
+    return {
+      next: () => getPage(false)
+    };
+  }
+
+  /**
+ * Injection de contexte Communecter dans une requête finalizer.
+ *
+ * @param {Function} baseFinalizer - fonction async(data) => { results, count }
+ * @returns {Function} fonction enrichie
+ */
+  _withCostumContext(baseFinalizer) {
+    return async (data) => {
+      const finalData = {
+        ...data,
+        costumSlug: this.serverData.slug,
+        contextId: this.serverData.id,
+        contextType: this.getEntityType(),
+        sourceKey: [...(data.sourceKey || []), this.serverData.slug]
+      };
+      return baseFinalizer(finalData);
+    };
   }