@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/api/EntityRegistry.ts

@@ -0,0 +1,203 @@
+// TypeScript native types
+import type { CollectionType } from "../types/entities.js";
+
+export type EntityTag = "User" | "Organization" | "Project" | "Event" | "Poi" | "Badge" | "News" | "Comment";
+export type CollectionKey = CollectionType; // Alias pour compatibilité
+type BaseEntity = import("./BaseEntity.js").BaseEntity<any>;
+type ApiClient = import("../ApiClient.js").default;
+
+type EndpointApiClass = typeof import("./EndpointApi.js").default;
+type EntityConstructor = new (...args: any[]) => BaseEntity;
+type EntityClass = EntityConstructor & {
+  fromJSON?: (json: unknown, parent?: ApiClient | BaseEntity | null, deps?: EntityDeps) => BaseEntity;
+};
+type EntityDeps = Partial<Record<EntityTag | "EndpointApi", EntityClass | EndpointApiClass | undefined>>;
+
+/**
+ * Métadonnées de construction d'entité.
+ */
+type EntityMeta = {
+  entityClass: EntityClass;
+  deps: EntityDeps;
+};
+
+/**
+ * Types minimaux pour le JSON d'entité
+ */
+type MinimalEntityJSON = {
+  __entityTag: EntityTag;
+  serverData?: {
+    collection?: CollectionKey;
+  };
+};
+
+export const EntityRegistry: Map<EntityTag | "EndpointApi", EntityClass | EndpointApiClass> = new Map();
+
+// Overloads for registerEntity
+export function registerEntity(tag: "EndpointApi", EntityClass: EndpointApiClass): void;
+export function registerEntity(tag: EntityTag, EntityClass: EntityClass): void;
+export function registerEntity(tag: EntityTag | "EndpointApi", EntityClass: EntityClass | EndpointApiClass): void {
+  EntityRegistry.set(tag, EntityClass);
+}
+
+
+/**
+ * Type guard: vérifie si la valeur ressemble à un JSON d'entité.
+ */
+function isEntityJSON(v: unknown): v is MinimalEntityJSON {
+  return !!v && typeof v === "object"
+    && "__entityTag" in (v as any);
+}
+
+/**
+ * Récupère une instance depuis un JSON générique.
+ * Si la collection ou la métadonnée d'entité est absente, renvoie l'objet d'origine.
+ */
+export function fromEntityJSON(json: unknown, parent: ApiClient | BaseEntity | null = null): BaseEntity | unknown | null {
+  // 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;
+
+  // Ici, TS sait que json.__entityTag existe
+  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);
+}
+
+/**
+ * Récupère la classe d'entité et ses dépendances à partir du type d'entité.
+ */
+function _getEntityMeta(entityType: CollectionKey, __entityTag: EntityTag): EntityMeta | null {
+  const selfClass = EntityRegistry.get(__entityTag);
+  const selfTag = __entityTag;
+
+  const commonDeps: EntityDeps = {
+    EndpointApi: EntityRegistry.get("EndpointApi"),
+    User: selfTag === "User" ? selfClass : EntityRegistry.get("User"),
+    Organization: selfTag === "Organization" ? selfClass : EntityRegistry.get("Organization"),
+    Project: selfTag === "Project" ? selfClass : EntityRegistry.get("Project"),
+    Event: selfTag === "Event" ? selfClass : EntityRegistry.get("Event"),
+    Poi: selfTag === "Poi" ? selfClass : EntityRegistry.get("Poi"),
+    Badge: selfTag === "Badge" ? selfClass : EntityRegistry.get("Badge"),
+    News: selfTag === "News" ? selfClass : EntityRegistry.get("News"),
+    Comment: selfTag === "Comment" ? selfClass : EntityRegistry.get("Comment"),
+  };
+
+  const map: Record<CollectionKey, EntityMeta> = {
+    citoyens:     { entityClass: commonDeps.User as EntityClass,         deps: commonDeps },
+    organizations:{ entityClass: commonDeps.Organization as EntityClass, deps: commonDeps },
+    projects:     { entityClass: commonDeps.Project as EntityClass,      deps: commonDeps },
+    events:       { entityClass: commonDeps.Event as EntityClass,        deps: { ...commonDeps, Badge: undefined } },
+    poi:          { entityClass: commonDeps.Poi as EntityClass,          deps: { ...commonDeps, Badge: undefined, News: undefined } },
+    news:         { entityClass: commonDeps.News as EntityClass,         deps: { ...commonDeps } },
+    badges:       { entityClass: commonDeps.Badge as EntityClass,        deps: { 
+      EndpointApi: commonDeps.EndpointApi, 
+      User: commonDeps.User, 
+      Organization: commonDeps.Organization, 
+      Project: commonDeps.Project 
+    } },
+    comments:     { entityClass: commonDeps.Comment as EntityClass,      deps: { ...commonDeps } }
+  };
+  
+  return map[entityType] || null;
+}
+
+type CollectionMapEntry = {
+  entityTag: EntityTag;
+  meta: (tag: EntityTag) => EntityMeta;
+};
+
+/**
+ * Crée une instance d'entité basée sur le seul nom de la collection.
+ */
+export function createFromCollection(collection: CollectionKey, parent: ApiClient | BaseEntity | null = null, data: object = {}): BaseEntity | null {
+  const _collectionMap: Record<CollectionKey, CollectionMapEntry> = {
+    citoyens: {
+      entityTag: "User",
+      meta: tag => _buildMeta(tag, { remove: [] })
+    },
+    organizations: {
+      entityTag: "Organization",
+      meta: tag => _buildMeta(tag, { remove: [] })
+    },
+    projects: {
+      entityTag: "Project",
+      meta: tag => _buildMeta(tag, { remove: [] })
+    },
+    events: {
+      entityTag: "Event",
+      meta: tag => _buildMeta(tag, { remove: ["Badge"] })
+    },
+    poi: {
+      entityTag: "Poi",
+      meta: tag => _buildMeta(tag, { remove: ["Badge","News"] })
+    },
+    news: {
+      entityTag: "News",
+      meta: tag => _buildMeta(tag, { remove: [] })
+    },
+    badges: {
+      entityTag: "Badge",
+      meta: () => _buildCustomMeta("Badge")
+    },
+    comments: {
+      entityTag: "Comment",
+      meta: tag => _buildMeta(tag, { remove: [] })
+    }
+  };
+  const entry = _collectionMap[collection];
+  if (!entry) {
+    console.warn(`Collection inconnue : '${collection}'`);
+    return null;
+  }
+  const { entityTag, meta } = entry;
+  const { entityClass, deps } = meta(entityTag);
+  if (!entityClass) {
+    throw new Error(`EntityClass introuvable pour ${entityTag}`);
+  }
+  const Ctor = entityClass as EntityConstructor;
+  return new Ctor(parent, data, deps);
+}
+
+/**
+ * Construit entityClass et deps pour une collection standard.
+ */
+function _buildMeta(tag: EntityTag, options: { remove: string[] }): EntityMeta {
+  const EntityClass = EntityRegistry.get(tag) as EntityClass;
+  const allDeps: EntityDeps = {
+    EndpointApi: EntityRegistry.get("EndpointApi"),
+    User: EntityRegistry.get("User"),
+    Organization: EntityRegistry.get("Organization"),
+    Project: EntityRegistry.get("Project"),
+    Event: EntityRegistry.get("Event"),
+    Poi: EntityRegistry.get("Poi"),
+    Badge: EntityRegistry.get("Badge"),
+    News: EntityRegistry.get("News"),
+    Comment: EntityRegistry.get("Comment"),
+  };
+  // inject self
+  (allDeps as any)[tag] = EntityClass;
+  // remove undesired
+  options.remove.forEach(dep => delete (allDeps as any)[dep]);
+  return { entityClass: EntityClass, deps: allDeps };
+}
+
+/**
+ * Cas spécifique des badges : seules certaines dépendances.
+ */
+function _buildCustomMeta(tag: "Badge"): EntityMeta {
+  const EntityClass = EntityRegistry.get(tag) as EntityClass;
+  const deps: EntityDeps = {
+    EndpointApi: EntityRegistry.get("EndpointApi"),
+    User: EntityRegistry.get("User"),
+    Organization: EntityRegistry.get("Organization"),
+    Project: EntityRegistry.get("Project")
+  };
+  (deps as any)[tag] = EntityClass;
+  return { entityClass: EntityClass, deps };
+}

package/src/api/Event.ts

@@ -0,0 +1,332 @@
+import { ApiError } from "../error.js";
+import { BaseEntity, PaginatorPage } from "./BaseEntity.js";
+import { transformEntityRefs } from "../types/transforms.js";
+
+import type { AddEventData, GetAttendeesAdminData, GetAttendeesNoAdminData } from "./EndpointApi.types.js";
+import type { User } from "./User.js";
+import type { EventTransforms } from "../types/transforms.js";
+
+type EventItemNormalized = import("./serverDataType/Event.js").EventItemNormalized;
+
+export class Event extends BaseEntity<EventItemNormalized> {
+  static override entityType = "events";
+  static override entityTag = "Event";
+
+  static override SCHEMA_CONSTANTS: string[] = [
+    "ADD_EVENT",
+    // "UPDATE_BLOCK_DESCRIPTION",
+    // "UPDATE_BLOCK_INFO",
+    // "UPDATE_BLOCK_SOCIAL",
+    // "UPDATE_BLOCK_LOCALITY",
+    "UPDATE_BLOCK_SLUG",
+    "PROFIL_IMAGE"
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_EVENT", "addEvent"],
+    ["PROFIL_IMAGE", "updateImageProfil"]
+  ] as const);
+
+  static UPDATE_BLOCKS = new Map([
+    // ["UPDATE_BLOCK_DESCRIPTION", "updateDescription"],
+    // ["UPDATE_BLOCK_SOCIAL", "updateSocial"],
+    // ["UPDATE_BLOCK_LOCALITY", "updateLocality"],
+    // ["UPDATE_BLOCK_INFO", "updateInfo"],
+    ["UPDATE_BLOCK_SLUG", "updateSlug"],
+    ["PROFIL_IMAGE", "updateImageProfil"]
+  ] as const);
+
+  override defaultFields: Record<string, any> = {
+    typeElement: this.getEntityType()
+  };
+
+  override removeFields: string[] = [
+    "typeElement"
+  ];
+
+  override transforms: EventTransforms = {
+    parent: transformEntityRefs,
+    organizer: transformEntityRefs
+  };
+
+  override _add = async (payload: Record<string, any>): Promise<void> => {
+    if (!this._calledFromSave) {
+      throw new ApiError("utilisation invalide de _add, utilisez save", 400);
+    }
+
+    payload.id = this._newId?.();
+    if (payload.slug) delete payload.slug;
+
+    for (const [constant, methodName] of Array.from(Event.ADD_BLOCKS)) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => {}
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await this._invokeBlockMethod(Event.ADD_BLOCKS, methodName, blockData);
+        if (!this.id && data?.map?.id) {
+          this._draftData.id = data.map.id;
+          this._draftData.slug = data.map.slug;
+        }
+      }
+    }
+  };
+
+  override _update = async (payload: Record<string, any>): Promise<boolean> => {
+    if(!this.isAdmin()){
+      throw new ApiError("Vous n'avez pas les droits pour modifier cet événement", 403);
+    }
+
+    if (!this._calledFromSave) {
+      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
+    }
+
+    let hasChanged = false;
+
+    const blockData = this._extractAllValidFieldsFromSchema(
+      this.apiClient,
+      "ADD_EVENT",
+      { ...payload, ...this.defaultFields },
+      () => this.initialDraftData,
+      this.removeFields
+    );
+    if (blockData && Object.keys(blockData).length > 0) {
+      await this["addEvent"](blockData);
+      hasChanged = true;
+    }
+
+    if (payload.id) delete payload.id;
+
+    for (const [constant, methodName] of Array.from(Event.UPDATE_BLOCKS)) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => this.initialDraftData,
+        this.removeFields
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        await this._invokeBlockMethod(Event.UPDATE_BLOCKS, methodName, blockData);
+        hasChanged = true;
+      }
+    }
+
+    return hasChanged;
+  };
+
+  async addEvent(data: Partial<AddEventData> = {}): Promise<unknown> {
+
+    if (!this.isMe && !data.organizer && this.parent) {
+      (data as any).organizer = {};
+      (data as any).organizer[`${this.parent.id}`] = {
+        type: this.parent.getEntityType(),
+        name: (this.parent as any).name
+      };
+    }
+
+    return this.callIsConnected(() => this.endpointApi.addEvent(data as AddEventData));
+  }
+
+
+  override async getOrganizations(): Promise<never> {
+    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async getProjects(): Promise<never> {
+    throw new ApiError(`getProjects n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  async getEvents(): Promise<never> {
+    throw new ApiError(`getEvents - les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async getPois(): Promise<never> {
+    throw new ApiError(`getPois n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async getBadgesIssuer(): Promise<never> {
+    throw new ApiError(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#getNews}
+   *
+   * Récupère les actualités de l'événement.
+   */
+  override async getNews(data: Parameters<BaseEntity<EventItemNormalized>["getNews"]>[0] = {}) {
+    return super.getNews(data);
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#getSubscribers}
+   *
+   * Récupère les abonnés de l'événement.
+   */
+  override async getSubscribers(data: Parameters<BaseEntity<EventItemNormalized>["getSubscribers"]>[0] = {}) {
+    return super.getSubscribers(data);
+  }
+
+  /**
+   * Récupérer les participants d'un événement.
+   * Constant : GET_ATTENDEES_NO_ADMIN
+   * @param data - Paramètres (partiels) de recherche/pagination.
+   * @param options - Options supplémentaires.
+   * @param options.toBeValidated - Indique si les participants doivent être validés.
+   * @param options.isAdmin - Indique si l'utilisateur est admin.
+   * @param options.isInviting - Indique si l'utilisateur est en attente d'invitation.
+   * @param options.roles - Liste des rôles à filtrer.
+   * @param isNext - Indique si c'est une recherche suivante (pagination).
+   * @returns - Un objet contenant le nombre de participants et la liste des participants.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de la récupération des participants.
+   *
+   * @example
+   * // Récupérer tous les participants
+   * const participants = await project.getAttendees();
+   *
+   * // Récupérer les participants avec validation en attente
+   * const participantsToBeValidated = await project.getAttendees({}, { toBeValidated: true });
+   *
+   * // Récupérer les participants avec un rôle spécifique
+   * const contributorsWithRole = await project.getAttendees({}, { roles: ["admin"] });
+   *
+   * // Récupérer les participants administrateurs
+   * const adminParticipants = await project.getAttendees({}, { isAdmin: true });
+   *
+   * // Récupérer les participants en attente d'invitation
+   * const invitingParticipants = await project.getAttendees({}, { isInviting: true });
+   *
+   */
+  async getAttendees(
+    data: Partial<GetAttendeesNoAdminData | GetAttendeesAdminData> = {},
+    options: {
+      toBeValidated?: boolean;
+      isAdmin?: boolean;
+      isAdminPending?: boolean;
+      isInviting?: boolean;
+      roles?: any[];
+    } = {}
+  ): Promise<PaginatorPage<User>> {
+    data.searchType = this._getDefaultFromEndpoint("GET_ATTENDEES_NO_ADMIN", "searchType") as GetAttendeesNoAdminData["searchType"];
+    // data.searchBy = "ALL";
+
+    const paginator = this._createPaginatorEngine({
+      initialData: data,
+      finalizer: async (finalData) => {
+
+        const { toBeValidated, isAdmin, isInviting, isAdminPending, roles = [] } = options;
+
+        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.events.${this.id}`]: { "$exists": true },
+          //   [`links.events.${this.id}.toBeValidated`]: { "$exists": false },
+          //   [`links.events.${this.id}.isInviting`]: { "$exists": false }
+          // };
+          finalData.filters = this._buildLinkFilters(this.id, { linkType: "events", toBeValidated, isAdmin, isAdminPending, isInviting, roles });
+        } else {
+          delete finalData?.pathParams;
+          finalData.filters = this._buildLinkFilters(this.id, { linkType: "events", toBeValidated: false, isAdmin, isInviting, roles });
+        }
+  
+        const fetchFn = this.isMe
+          ? () => this.callIsMe(() => this.endpointApi.getAttendeesAdmin(finalData))
+          : () => this.endpointApi.getAttendeesNoAdmin(finalData);
+
+        return fetchFn();
+      }
+    });
+
+    return paginator.next() as Promise<PaginatorPage<User>>;
+  }
+
+  override async project(): Promise<never> {
+    throw new ApiError(`project n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async poi(): Promise<never> {
+    throw new ApiError(`poi n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async event(): Promise<never> {
+    throw new ApiError(`les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`, 501);
+  }
+
+
+  override async badge(): Promise<never> {
+    throw new ApiError(`badge n'existe pas dans ${this.constructor.name}`, 501);
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#news}
+   *
+   * Crée une instance de news et la récupère si nécessaire.
+   */
+  override async news(newsData: Parameters<BaseEntity<EventItemNormalized>["news"]>[0] = {}) {
+    return super.news(newsData);
+  }
+
+  /**
+   * ───────────────────────────────
+   *  Lien utilisateur ↔ event
+   *  (participation, abonnement)
+   * ───────────────────────────────
+   */
+
+  /**
+   * {@inheritDoc BaseEntity#requestToJoin}
+   *
+   * Rejoindre l'événement en tant que participant.
+   */
+  override async requestToJoin() {
+    return super.requestToJoin();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#acceptInvitation}
+   *
+   * Accepte une invitation à rejoindre l'événement.
+   * Cette action valide un lien en attente avec l'option `isInviting`.
+   */
+  override async acceptInvitation() {
+    return super.acceptInvitation();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#leave}
+   *
+   * Quitte l'événement, que ce soit en tant que participant ou administrateur.
+   * Cette action supprime le lien entre l'utilisateur et l'événement.
+   */
+  override async leave() {
+    return super.leave();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#follow}
+   *
+   * Suivre un événement.
+   * Cette action permet à l'utilisateur de suivre un événement.
+   */
+  override async follow() {
+    return super.follow();
+  }
+
+  /**
+   * {@inheritDoc BaseEntity#unfollow}
+   *
+   * Se désabonne d'un événement.
+   */
+  override async unfollow() {
+    return super.unfollow();
+  }
+  
+}