@communecter/cocolight-api-client 1.0.31 → 1.0.33

package/src/api/BaseEntity.js

@@ -266,6 +266,109 @@ export class BaseEntity {
    */
   transforms = {};
 
+  /**
+   * ───────────────────────────────
+   * JSON
+   * ───────────────────────────────
+   */
+
+  /**
+   * Convertit l'instance en JSON pour l'envoi au serveur.
+   * 
+   * @returns {Object} Représentation JSON de l'instance.
+   */
+  toJSON() {
+    const parentMeta = {};
+    if (this.parent?.id) parentMeta.id = this.parent.id;
+    if (typeof this.parent?.getEntityType === "function") parentMeta.type = this.parent.getEntityType();
+    if (this.parent?.__entityTag) parentMeta.__entityTag = this.parent.__entityTag;
+
+    return {
+      __entityTag: this.__entityTag,
+      _serverData: this._serialize(this._serverData),
+      parent: Object.keys(parentMeta).length > 0 ? parentMeta : null
+    };
+  }
+
+  _serialize(obj, seen = new WeakSet()) {
+    if (obj === null || typeof obj !== "object") return obj;
+
+    // Évite les boucles circulaires
+    if (seen.has(obj)) return null;
+    seen.add(obj);
+
+    // Si c'est une Date (normale ou Proxy)
+    if (obj instanceof Date || Object.prototype.toString.call(obj) === "[object Date]") {
+      return obj.toISOString();
+    }
+
+    // Si c'est un Proxy réactif de ton système maison
+    if (obj.__isReactive && typeof obj.__raw === "object") {
+      return this._serialize(obj.__raw, seen);
+    }
+
+    // Tableaux
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this._serialize(item, seen));
+    }
+
+    // Objets simples
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      const value = obj[key];
+
+      // Ignore les fonctions, symboles, ou undefined
+      if (typeof value === "function" || typeof value === "symbol" || typeof value === "undefined") {
+        continue;
+      }
+
+      try {
+        result[key] = this._serialize(value, seen);
+      // eslint-disable-next-line no-unused-vars
+      } catch (e) {
+        result[key] = null;
+      }
+    }
+
+    return result;
+  }
+
+  static _revive(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+
+    // Détecter et restaurer les ISO string en Date
+    if (typeof obj === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/.test(obj)) {
+      return new Date(obj);
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this._revive(item));
+    }
+
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      result[key] = this._revive(obj[key]);
+    }
+
+    return result;
+  }
+
+  /**
+   * Crée une instance d'entité à partir de données JSON.
+   * 
+   * @param {Object} json - Données JSON à utiliser.
+   * @param {Object} parent - Instance parente.
+   * @param {Object} deps - Dépendances injectées.
+   * @returns {object} Nouvelle instance d'entité.
+   */
+  static fromJSON(json, parent, deps) {
+
+    const { _serverData } = json;
+
+    const instance = this.fromServerData(this._revive(_serverData), parent, deps);
+
+    return instance;
+  }
 
   /**
    * ───────────────────────────────
@@ -1682,33 +1785,39 @@ 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 };
+
+    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();
   }
 
   /**
@@ -1718,37 +1827,43 @@ 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 }
-        };
-      }
+
+    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();
   }
 
   /**
@@ -1758,29 +1873,35 @@ 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 },
-        };
-      }
+
+    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();
   }
 
   /**
@@ -1790,20 +1911,26 @@ 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;
 
-      finalData.filters =  {
-        [`links.follows.${this.id}`]: { "$exists": true },
-        [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
-        [`links.follows.${this.id}.isInviting`]: { "$exists": false }
-      };
+    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 }
+        };
 
-      return this.endpointApi.getSubscribers(finalData);
+        return this.endpointApi.getSubscribers(finalData);
+      }
     });
+
+    return paginator.next();
   }
 
   /**
@@ -1813,18 +1940,24 @@ 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;
+
+    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();
   }
 
   /**
@@ -2187,161 +2320,163 @@ export class BaseEntity {
 
     return count;
   }
-  
+
   /**
-   * Méthode générique de pagination contextuelle avec support next / prev.
+   * Récupère une valeur par défaut depuis un endpoint donné.
    *
-   * @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
+   * @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
    */
-  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");
+  _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;
+  }
 
-    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;
-      }
+  /**
+   * 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 = {}) {
 
-      this._paginationCursor = { ...data };
-    }
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: this._withCostumContext((finalData) => this.endpointApi.globalAutocompleteCostum(finalData)),
+    });
 
-    const cursor = this._paginationCursor;
+    return paginator.next();
+  }
 
-    if (isNext) {
-      this._paginationHistory.push({ ...cursor });
+  /**
+   * 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;
 
-      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;
-      }
+    const state = {
+      cursor: undefined,
+      count: 0,
+      index: 0,
+      history: [],
+      sizes: []
+    };
 
-      this._paginationCursor = { ...cursor };
-    }
+    const hasStep = (d) => d?.indexStep && d.indexStep > 0;
 
-    data = { ...this._paginationCursor };
+    async function getPage(isNext = false) {
+      let data = { ...initialData };
 
-    if (!isNext && (!data?.searchType || !Array.isArray(data.searchType) || data.searchType.length === 0)) {
-      throw new ApiError("searchType non défini");
-    }
+      if (!state.cursor || (!isNext && state.history.length === 0)) {
+        state.count = 0;
+        state.index = 0;
+        state.history = [];
+        state.sizes = [];
 
-    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);
-    }
+        data.countType = data.searchType;
 
-    this._paginationCount += result.results.length;
-    this._paginationPageSizes.push(result.results.length);
+        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;
+        }
 
-    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
-    };
+        state.cursor = { ...data };
+      }
 
-    if (hasNext) {
-      response.next = async () => this._paginateWith({}, true, finalizer);
-    }
+      const cursor = state.cursor;
 
-    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 (isNext) {
+        state.history.push({ ...cursor });
 
-    return response;
-  }
+        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 };
+      }
 
-  /**
-   * Réinitialise l'état de pagination.
-   */
-  resetPagination() {
-    this._paginationCursor = undefined;
-    this._paginationCount = 0;
-    this._paginationPageIndex = 0;
-    this._paginationHistory = [];
-    this._paginationPageSizes = [];
-  }
+      data = { ...state.cursor };
 
+      if (!isNext && (!data?.searchType || !Array.isArray(data.searchType) || data.searchType.length === 0)) {
+        throw new Error("searchType non défini");
+      }
 
-  /**
-   * 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;
+      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)
+    };
   }
 
   /**
-   * 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,
+ * 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()
+        contextType: this.getEntityType(),
+        sourceKey: [...(data.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 baseFinalizer(finalData);
+    };
   }