@communecter/cocolight-api-client 1.0.33 → 1.0.35

package/package.json

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

package/src/Api.js

@@ -186,6 +186,20 @@ export default class Api {
     }
   }
 
+  async event(eventData) {
+    try {
+      const event = new Event(this._client, eventData, { EndpointApi, User, Organization, Project, Poi, Badge, News });
+      if (!eventData.id && !eventData.slug) {
+        throw new Error("Vous devez fournir un id ou un slug pour créer une instance Event.");
+      }
+      await event.get();
+      return event;
+    } catch (error) {
+      console.error("[Api.event] Erreur lors de la création d'un objet événement :", error.message);
+      throw error;
+    }
+  }
+
   /**
    * Retourne l'instance d'ApiClient.
    *

package/src/api/BaseEntity.js

@@ -1,6 +1,7 @@
 // BaseEntity.js
 import ObjectID from "bson-objectid";
 // import { fileTypeFromBuffer } from "file-type";
+import EJSON from "ejson";
 import pkg from "file-type";
 
 import { ApiAuthenticationError, ApiError, ApiResponseError, ApiValidationError } from "../error.js";
@@ -282,75 +283,80 @@ export class BaseEntity {
     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;
+    if (this.parent?.slug) parentMeta.slug = this.parent.slug;
 
     return {
       __entityTag: this.__entityTag,
-      _serverData: this._serialize(this._serverData),
+      __isSerializedEntity: true,
+      serverData: this._serialize(this._serverData),
       parent: Object.keys(parentMeta).length > 0 ? parentMeta : null
     };
   }
 
-  _serialize(obj, seen = new WeakSet()) {
+
+  _serialize(obj) {
+    try {
+      return JSON.parse(EJSON.stringify(this._removeUnserializables(obj)));
+    } catch (e) {
+      this.apiClient?._logger?.error?.("Erreur de sérialisation EJSON", e);
+      return null;
+    }
+  }
+
+  /**
+   * Supprime les propriétés non sérialisables d'un objet.
+   * 
+   * @param {Object} obj - L'objet à nettoyer.
+   * @param {WeakSet} [seen] - Ensemble pour éviter les références circulaires.
+   * @returns {Object} L'objet nettoyé.
+   * @private
+   */
+  _removeUnserializables(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
+    // Ignore les proxys réactifs
     if (obj.__isReactive && typeof obj.__raw === "object") {
-      return this._serialize(obj.__raw, seen);
+      return this._removeUnserializables(obj.__raw, seen);
     }
 
-    // Tableaux
     if (Array.isArray(obj)) {
-      return obj.map((item) => this._serialize(item, seen));
+      return obj.map((el) => this._removeUnserializables(el, seen));
     }
 
-    // Objets simples
-    const result = {};
+    const clean = {};
     for (const key of Object.keys(obj)) {
-      const value = obj[key];
+      const val = obj[key];
 
-      // Ignore les fonctions, symboles, ou undefined
-      if (typeof value === "function" || typeof value === "symbol" || typeof value === "undefined") {
+      if (
+        typeof val === "function" ||
+      typeof val === "symbol" ||
+      typeof val === "undefined"
+      ) {
         continue;
       }
 
       try {
-        result[key] = this._serialize(value, seen);
+        clean[key] = this._removeUnserializables(val, seen);
       // eslint-disable-next-line no-unused-vars
       } catch (e) {
-        result[key] = null;
+        clean[key] = null;
       }
     }
 
-    return result;
+    return clean;
   }
 
+  /**
+   * Restaure les données sérialisées en un objet d'origine.
+   *
+   * @param {Object} obj - L'objet à restaurer.
+   * @returns {Object} L'objet restauré.
+   */
   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;
+    return EJSON.fromJSONValue(obj);
   }
 
   /**
@@ -363,9 +369,9 @@ export class BaseEntity {
    */
   static fromJSON(json, parent, deps) {
 
-    const { _serverData } = json;
+    const { serverData } = json;
 
-    const instance = this.fromServerData(this._revive(_serverData), parent, deps);
+    const instance = this.fromServerData(this._revive(serverData), parent, deps);
 
     return instance;
   }

package/src/api/EndpointApi.js

@@ -1378,6 +1378,126 @@ class EndpointApi {
     return this.call("GLOBAL_AUTOCOMPLETE_COSTUM", data);
   }
     
+  /**
+   * Récupérer les acteurs d'événement : Récupérer les acteurs (organizers, attendees, creators, animators) d'une entité événement.
+   * Constant : COSTUM_EVENT_REQUEST_ACTORS
+   * @param {import("./EndpointApi.types").CostumEventRequestActorsData} 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 costumEventRequestActors(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_ACTORS", data);
+  }
+    
+  /**
+   * Récupérer les sous-événements d’un événement parent : Retourne les sous-événements filtrés par date, type, tags, région, timezone.
+   * Constant : COSTUM_EVENT_REQUEST_SUBEVENTS
+   * @param {import("./EndpointApi.types").CostumEventRequestSubeventsData} 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 costumEventRequestSubevents(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_SUBEVENTS", data);
+  }
+    
+  /**
+   * Récupérer les événements liés à un élément : Retourne les événements liés à une entité (via links.events ou parent).
+   * Constant : COSTUM_EVENT_REQUEST_ELEMENT_EVENT
+   * @param {import("./EndpointApi.types").CostumEventRequestElementEventData} 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 costumEventRequestElementEvent(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_ELEMENT_EVENT", data);
+  }
+    
+  /**
+   * Récupérer les catégories d’événements : Retourne la liste des types (catégories) d’événements enfants liés à l'entité.
+   * Constant : COSTUM_EVENT_REQUEST_CATEGORIES
+   * @param {import("./EndpointApi.types").CostumEventRequestCategoriesData} 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 costumEventRequestCategories(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_CATEGORIES", data);
+  }
+    
+  /**
+   * Récupérer les dates de sous-événements : Retourne les dates des sous-événements à venir et passés, groupées par jour.
+   * Constant : COSTUM_EVENT_REQUEST_DATES
+   * @param {import("./EndpointApi.types").CostumEventRequestDatesData} 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 costumEventRequestDates(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_DATES", data);
+  }
+    
+  /**
+   * Récupérer un événement par ID : Retourne les informations détaillées d’un événement par son ID.
+   * Constant : COSTUM_EVENT_REQUEST_EVENT
+   * @param {import("./EndpointApi.types").CostumEventRequestEventData} 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 costumEventRequestEvent(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_EVENT", data);
+  }
+    
+  /**
+   * Associer une structure à un événement (adresse) : Associe une structure existante à un événement en copiant son adresse.
+   * Constant : COSTUM_EVENT_REQUEST_LINK_TL_TO_EVENT
+   * @param {import("./EndpointApi.types").CostumEventRequestLinkTlToEventData} 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 costumEventRequestLinkTlToEvent(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_LINK_TL_TO_EVENT", data);
+  }
+    
+  /**
+   * Charger les tags de contexte d’un événement : Retourne les tags des sous-événements et des parents d’un événement, avec filtre optionnel.
+   * Constant : COSTUM_EVENT_REQUEST_LOAD_CONTEXT_TAG
+   * @param {import("./EndpointApi.types").CostumEventRequestLoadContextTagData} 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 costumEventRequestLoadContextTag(data) {
+    if (!data || typeof data !== "object") {
+      throw new TypeError("Le paramètre data doit être un objet.");
+    }
+    return this.call("COSTUM_EVENT_REQUEST_LOAD_CONTEXT_TAG", data);
+  }
+    
 }
 
 export default EndpointApi;

package/src/api/EndpointApi.types.d.ts

@@ -4023,3 +4023,380 @@ export interface GlobalAutocompleteCostumData {
   };
   [k: string]: unknown;
 }
+
+
+export interface CostumEventRequestActorsData {
+  /**
+   * Types de liens à inclure (ex: organizer, attendees, creator, animator)
+   */
+  types?: (
+    | "organizer"
+    | "links.attendees"
+    | "creator"
+    | "links.creator"
+    | "links.organizer"
+    | "organizerName"
+    | "animator"
+  )[];
+  /**
+   * Limiter aux sous-événements liés directement
+   */
+  parent_only?: boolean;
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+
+export interface CostumEventRequestSubeventsData {
+  /**
+   * Filtrage par type d’événement
+   */
+  type?: string;
+  /**
+   * Liste de tags à filtrer
+   */
+  tags?: string[];
+  /**
+   * Régions à filtrer
+   */
+  regions?: {
+    /**
+     * ID de la région
+     */
+    id: string;
+    [k: string]: unknown;
+  }[];
+  /**
+   * Si vrai, ne renvoie que les événements à venir
+   */
+  fromToday?: boolean;
+  /**
+   * Filtrage par date unique ou intervalle
+   */
+  date?:
+    | string
+    | {
+        between: {
+          start: string;
+          end: string;
+          [k: string]: unknown;
+        };
+        [k: string]: unknown;
+      };
+  /**
+   * Timezone à appliquer sur les dates
+   */
+  timezone?: string;
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+
+export interface CostumEventRequestElementEventData {
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+
+export interface CostumEventRequestCategoriesData {
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+
+export interface CostumEventRequestDatesData {
+  /**
+   * Filtrage par type
+   */
+  type?: string;
+  /**
+   * Tags à filtrer
+   */
+  tags?: string[];
+  /**
+   * Régions géographiques à filtrer
+   */
+  regions?: {
+    /**
+     * ID de la région
+     */
+    id: string;
+    [k: string]: unknown;
+  }[];
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+
+export interface CostumEventRequestEventData {
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+
+export interface CostumEventRequestLinkTlToEventData {
+  /**
+   * ID de la structure à copier
+   */
+  tl: string;
+  /**
+   * ID de l’événement cible
+   */
+  event: string;
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+
+export interface CostumEventRequestLoadContextTagData {
+  /**
+   * ID de l’événement
+   */
+  event: string;
+  /**
+   * Recherche textuelle dans les tags
+   */
+  search?: string;
+  /**
+   * ID du contexte de recherche (actuellement vide)
+   */
+  contextId?: string;
+  /**
+   * Type de contexte de recherche (actuellement vide)
+   */
+  contextType?: "projects" | "organizations";
+  /**
+   * Slug du costume utilisé pour la recherche
+   */
+  costumSlug?: string;
+  /**
+   * Clés de source pour la recherche
+   */
+  sourceKey?: string[];
+  /**
+   * Indique si le mode d'édition du costume est activé (toujours désactivé)
+   */
+  costumEditMode?: boolean;
+  pathParams?: {
+    /**
+     * ID de l'entité
+     */
+    id: string;
+    /**
+     * Type d'entité (ex: events)
+     */
+    type: string;
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}

package/src/api/EntityRegistry.js

@@ -18,8 +18,8 @@ export function registerEntity(tag, EntityClass) {
  */
 export function fromEntityJSON(json, parent = null) {
   if (!json?.__entityTag) return null;
-  if (!json._serverData?.collection) return json;
-  const meta = _getEntityMeta(json._serverData.collection, json.__entityTag);
+  if (!json.serverData?.collection) return json;
+  const meta = _getEntityMeta(json.serverData.collection, json.__entityTag);
   if (!meta) return json;
   if (!meta?.entityClass?.fromJSON) throw new Error(`Classe inconnue ou fromJSON manquant pour ${json.__entityTag}`);
   return meta.entityClass.fromJSON(json, parent, meta.deps);