@communecter/cocolight-api-client 1.0.103 → 1.0.105

package/package.json

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

package/src/api/BaseEntity.ts

@@ -548,7 +548,7 @@ export class BaseEntity<TServerData = any> {
    */
   protected _setData(newData: TServerData, { forceInitialDraftReset = false }: { forceInitialDraftReset?: boolean } = {}): void {
     if (this.userContext && this.userContext !== (this as object)) {
-      this.apiClient._logger?.info?.(`[${this.__entityTag}] Mise à jour liée à userContext : ${this.userContext.id}`);
+      this.apiClient._logger?.debug?.(`[${this.__entityTag}] Mise à jour liée à userContext : ${this.userContext.id}`);
     }
 
     const transformed = this._transformServerData(newData);
@@ -718,13 +718,31 @@ export class BaseEntity<TServerData = any> {
    *
    * @returns Représentation JSON de l'instance.
    */
-  toJSON(): { __entityTag: string; __isSerializedEntity: boolean; serverData: any; parent: { id?: string; type?: string; __entityTag?: string; slug?: string } | null } {
-    const parentMeta: { id?: string; type?: string; __entityTag?: string; slug?: string } = {};
+  toJSON(): { __entityTag: string; __isSerializedEntity: boolean; serverData: any; parent: any } {
+    const parentMeta: any = {};
     if (this.parent?.id) parentMeta.id = this.parent.id;
-    if (typeof this.parent?.getEntityType === "function") parentMeta.type = this.parent.getEntityType();
+    if (typeof this.parent?.getEntityType === "function") {
+      parentMeta.type = this.parent.getEntityType();
+    }
     if (this.parent?.__entityTag) parentMeta.__entityTag = this.parent.__entityTag;
     if (this.parent?.slug) parentMeta.slug = this.parent.slug;
 
+    // Ajouter serverData minimales si présentes
+    if (this.parent?.serverData) {
+      parentMeta.serverData = {
+        id: this.parent.serverData.id,
+        collection: this.parent.serverData.collection,
+        slug: this.parent.serverData.slug,
+        // Inclure le name si présent
+        ...(this.parent.serverData.name && { name: this.parent.serverData.name }),
+        // Inclure parent et organizer si présents (pour la hiérarchie)
+        ...(this.parent.serverData.parent && { parent: this.parent.serverData.parent }),
+        ...(this.parent.serverData.organizer && { organizer: this.parent.serverData.organizer }),
+        // Inclure les liens nécessaires pour isAdmin()
+        ...(this.parent.serverData.links && { links: this.parent.serverData.links })
+      };
+    }
+    
     return {
       __entityTag: this.__entityTag,
       __isSerializedEntity: true,
@@ -2139,6 +2157,10 @@ export class BaseEntity<TServerData = any> {
 
       if(data.contextId && data.contextType) {
         const entity = await this.entity(data.contextType, { id: data.contextId });
+
+        // Corriger le userContext si nécessaire
+        await this._fixEntityUserContext(entity);
+
         return entity;
       } else {
         throw new ApiResponseError(`Le slug ${slug} n'est pas valide`, 200, data as object);
@@ -2152,6 +2174,202 @@ export class BaseEntity<TServerData = any> {
     }
   }
 
+  /**
+   * Corriger le userContext d'une entité si elle a un vrai parent différent
+   * @param entity - L'entité à corriger
+   * @private
+   */
+  private async _fixEntityUserContext(entity: AnyEntity): Promise<void> {
+    const entityType = entity.getEntityType();
+
+    // Seulement pour les entités qui peuvent avoir des parents
+    if (!["events", "projects", "poi"].includes(entityType)) {
+      return;
+    }
+
+    const realParentInfo = this._extractRealParent(entity);
+    if (!realParentInfo) {
+      return; // Pas de parent réel détecté, garder le parent actuel
+    }
+
+    // Essayer de trouver le vrai parent dans le cache/contexte actuel
+    const realParent = await this._findOrCreateParent(realParentInfo);
+    if (realParent && realParent !== entity.parent) {
+      // Corriger le userContext sans recréer l'entité
+      entity.userContext = this._extractUserContext(realParent);
+      entity.parent = realParent;
+    }
+  }
+
+  /**
+   * Extraire l'info du vrai parent depuis les serverData
+   * @param entity - L'entité à analyser
+   * @private
+   */
+  private _extractRealParent(entity: AnyEntity): { type: string; id: string } | null {
+    const serverData = entity.serverData;
+
+    // Pour les events : chercher dans organizer avec priorité project > organization > user
+    if (entity.getEntityType() === "events") {
+      const eventData = serverData as { organizer?: Record<string, { type: string; name?: string }> };
+      if (eventData.organizer) {
+        const organizers = Object.entries(eventData.organizer);
+
+        // Priorité 1: projects
+        const projectOrganizer = organizers.find(([_, org]) => org.type === "projects");
+        if (projectOrganizer) {
+          return { type: "projects", id: projectOrganizer[0] };
+        }
+
+        // Priorité 2: organizations
+        const orgOrganizer = organizers.find(([_, org]) => org.type === "organizations");
+        if (orgOrganizer) {
+          return { type: "organizations", id: orgOrganizer[0] };
+        }
+
+        // Priorité 3: users
+        const userOrganizer = organizers.find(([_, org]) => org.type === "citoyens");
+        if (userOrganizer) {
+          return { type: "citoyens", id: userOrganizer[0] };
+        }
+
+        // Fallback: premier organizer trouvé (autre type)
+        const firstOrganizer = organizers[0];
+        if (firstOrganizer && firstOrganizer[1]) {
+          return { type: firstOrganizer[1].type, id: firstOrganizer[0] };
+        }
+      }
+    }
+
+    // Pour projects, poi : chercher dans parent
+    const entityDataWithParent = serverData as { parent?: Record<string, { type: string; name?: string }> };
+    if (entityDataWithParent.parent) {
+      const firstParent = Object.entries(entityDataWithParent.parent)[0];
+      if (firstParent && firstParent[1]) {
+        return { type: firstParent[1].type, id: firstParent[0] };
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Trouver ou créer le parent réel avec ses données complètes
+   * @param parentInfo - Info du parent à créer
+   * @private
+   */
+  private async _findOrCreateParent(parentInfo: { type: string; id: string }): Promise<AnyEntity | null> {
+    try {
+      // Vérifier si le parent existe déjà dans la hiérarchie actuelle
+      let current = this.parent;
+      while (current) {
+        if (current.id === parentInfo.id && current.getEntityType() === parentInfo.type) {
+          return current as AnyEntity;
+        }
+        current = current.parent;
+      }
+
+      // Créer une instance du parent et appeler get() pour avoir les données complètes
+      const entityTypeMap: Record<string, string> = {
+        "citoyens": "citoyens",
+        "organizations": "organizations",
+        "projects": "projects"
+      };
+
+      const entityType = entityTypeMap[parentInfo.type];
+      if (entityType) {
+        const parentEntity = this._entityInstanceData(entityType as any, { id: parentInfo.id });
+        await parentEntity.get(); // Récupérer les données complètes du parent
+        return parentEntity;
+      }
+
+      return null;
+    } catch (error) {
+      this.apiClient._logger?.warn?.("Impossible de créer le parent réel:", error);
+      return null;
+    }
+  }
+
+  /**
+   * Extraire le bon userContext du parent
+   * @param parent - Le parent dont on veut extraire le userContext
+   * @private
+   */
+  private _extractUserContext(parent: AnyEntity): User | null {
+    return this.getEntityTag(parent?.__entityTag) === "User" ? (parent as User) : (parent.userContext || null);
+  }
+
+  /**
+   * Vérifie si l'utilisateur est admin via la hiérarchie parent (logique généraliste)
+   * @private
+   */
+  private _isAdminViaHierarchy(): boolean {
+    const entityType = this.getEntityType();
+    const entityData = this.serverData as any;
+
+    // Déterminer le champ de hiérarchie selon le type d'entité
+    let hierarchyField: Record<string, any> | undefined;
+    if (entityType === "events") {
+      hierarchyField = entityData?.organizer;
+    } else if (entityType === "projects" || entityType === "poi") {
+      hierarchyField = entityData?.parent;
+    } else {
+      // Organizations et autres types n'ont pas de hiérarchie parent
+      return false;
+    }
+
+    if (!hierarchyField || typeof hierarchyField !== "object") {
+      return false;
+    }
+
+    // Vérifier chaque parent dans la hiérarchie
+    for (const [parentId, parentInfo] of Object.entries(hierarchyField)) {
+      if (!parentInfo || typeof parentInfo !== "object") continue;
+
+      const parentRef = parentInfo as { type: string; name?: string };
+      const parentType = parentRef.type;
+      if (!parentType) continue;
+
+      // Vérifier les droits admin selon le type de parent
+      if (this._isAdminOfParent(parentId, parentType)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Vérifie si l'utilisateur est admin d'un parent spécifique
+   * @private
+   */
+  private _isAdminOfParent(parentId: string, parentType: string): boolean {
+    const userLinks = this.userContext?.serverData?.links;
+    if (!userLinks) return false;
+
+    // Déterminer le type de lien selon le type de parent
+    let linkType: string;
+    if (parentType === "citoyens") {
+      // Les citoyens ne peuvent pas être des parents admin (logique métier)
+      return false;
+    } else if (parentType === "organizations") {
+      linkType = "memberOf";
+    } else if (parentType === "projects") {
+      linkType = "projects";
+    } else {
+      // Type de parent non supporté
+      return false;
+    }
+
+    const parentLinks = userLinks[linkType] as Record<string, any> | undefined;
+    if (!parentLinks) return false;
+
+    const parentLink = parentLinks[parentId];
+    return this._validateUserLink(parentLink) &&
+           parentLink?.isAdmin === true &&
+           !parentLink?.isAdminPending;
+  }
+
   /**
    * Construit dynamiquement des filtres sur un lien entre entités
    *
@@ -3063,8 +3281,7 @@ export class BaseEntity<TServerData = any> {
           "$or": {
             [`links.attendees.${this.id}`]: { "$exists": true },
             [`organizer.${this.id}`]: { "$exists": true }
-          },
-          [`links.attendees.${this.id}`]: { "$exists": true }
+          }
         };
 
         return this.endpointApi.getEvents(finalData);
@@ -3538,8 +3755,15 @@ export class BaseEntity<TServerData = any> {
   isAdmin(): boolean {
     this._checkAccess("vérifier l'administrateur.");
     this._assertEntityType("organizations", "projects", "events");
+
+    // 1. Vérifier lien direct sur l'entité courante
     const userLink = this._getLinkFromConnectedUser();
-    return this._validateUserLink(userLink) && userLink?.isAdmin === true && !userLink?.isAdminPending;
+    if (this._validateUserLink(userLink) && userLink?.isAdmin === true && !userLink?.isAdminPending) {
+      return true;
+    }
+
+    // 2. Si pas de lien direct, remonter la hiérarchie parent
+    return this._isAdminViaHierarchy();
   }
 
   /**

package/src/api/EntityRegistry.ts

@@ -57,6 +57,27 @@ export function fromEntityJSON(json: unknown, parent: ApiClient | BaseEntity | n
   // On gère null / non-objet / pas une entité → on renvoie tel quel (ou null si tu préfères)
   if (!isEntityJSON(json)) return json;
 
+  // Vérifier si l'entité a son propre parent sérialisé
+  let actualParent = parent;
+  const entityJson = json as any;
+  if (entityJson.parent && typeof entityJson.parent === "object") {
+    // Vérifier si le parent passé correspond déjà au parent sérialisé
+    const serializedParent = entityJson.parent;
+    const parentId = serializedParent.serverData?.id || serializedParent.id;
+
+    if (parent && "id" in parent && parent.id === parentId) {
+      // Le parent passé est déjà le bon, on l'utilise directement
+      actualParent = parent as BaseEntity;
+    } else {
+      // Reconstruire le parent depuis les données sérialisées en transmettant le parent original
+      const reconstructedParent = fromEntityJSON(entityJson.parent, parent);
+      // Vérifier que c'est bien une BaseEntity avant de l'utiliser
+      if (reconstructedParent && typeof reconstructedParent === "object" && "id" in reconstructedParent) {
+        actualParent = reconstructedParent as BaseEntity;
+      }
+    }
+  }
+
   // Récupérer la collection depuis serverData, ou la dériver depuis __entityTag
   let collection: CollectionKey | null | undefined = json.serverData?.collection;
 
@@ -74,7 +95,7 @@ export function fromEntityJSON(json: unknown, parent: ApiClient | BaseEntity | n
   if (!meta.entityClass?.fromJSON) {
     throw new Error(`Classe inconnue ou fromJSON manquant pour ${json.__entityTag}`);
   }
-  return meta.entityClass.fromJSON(json, parent, meta.deps);
+  return meta.entityClass.fromJSON(json, actualParent, meta.deps);
 }
 
 /**

package/types/api/BaseEntity.d.ts

@@ -316,12 +316,7 @@ export declare class BaseEntity<TServerData = any> {
         __entityTag: string;
         __isSerializedEntity: boolean;
         serverData: any;
-        parent: {
-            id?: string;
-            type?: string;
-            __entityTag?: string;
-            slug?: string;
-        } | null;
+        parent: any;
     };
     _serialize(obj: any): any;
     /**
@@ -776,6 +771,40 @@ export declare class BaseEntity<TServerData = any> {
      * @throws {ApiResponseError} Si le slug n'existe pas ou est invalide.
      */
     entityBySlug(slug: string): Promise<AnyEntity>;
+    /**
+     * Corriger le userContext d'une entité si elle a un vrai parent différent
+     * @param entity - L'entité à corriger
+     * @private
+     */
+    private _fixEntityUserContext;
+    /**
+     * Extraire l'info du vrai parent depuis les serverData
+     * @param entity - L'entité à analyser
+     * @private
+     */
+    private _extractRealParent;
+    /**
+     * Trouver ou créer le parent réel avec ses données complètes
+     * @param parentInfo - Info du parent à créer
+     * @private
+     */
+    private _findOrCreateParent;
+    /**
+     * Extraire le bon userContext du parent
+     * @param parent - Le parent dont on veut extraire le userContext
+     * @private
+     */
+    private _extractUserContext;
+    /**
+     * Vérifie si l'utilisateur est admin via la hiérarchie parent (logique généraliste)
+     * @private
+     */
+    private _isAdminViaHierarchy;
+    /**
+     * Vérifie si l'utilisateur est admin d'un parent spécifique
+     * @private
+     */
+    private _isAdminOfParent;
     /**
      * Construit dynamiquement des filtres sur un lien entre entités
      *