@communecter/cocolight-api-client 1.0.116 → 1.0.118

package/src/api/News.ts

@@ -457,7 +457,8 @@ export class News extends BaseEntity<NewsItemNormalized> {
    * Cette méthode compare l'ID de l'utilisateur connecté avec l'ID de l'auteur
    * de l'actualité. L'auteur peut être soit un objet simple NewsAuthor, soit
    * une instance d'entité User ou Organization.
-   *
+   * @param options - Options de vérification.
+   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
    * @returns `true` si l'utilisateur connecté est l'auteur, `false` sinon
    * @throws {ApiError} Si l'utilisateur n'est pas connecté (401)
    * @throws {ApiError} Si l'actualité n'a pas d'ID - non enregistrée (404)
@@ -474,18 +475,25 @@ export class News extends BaseEntity<NewsItemNormalized> {
    * }
    * ```
    */
-  override isAuthor(): boolean {
-    if (!this.isMe) {
-      throw new ApiError("Vous devez être connecté pour vérifier l'auteur.", 401);
-    }
-    if (!this.id) {
-      throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
-    }
-    if (!this.serverData) {
-      throw new ApiError("Aucune donnée serveur disponible.", 404);
-    }
-    if (!this.userId) {
-      throw new ApiError("Utilisateur non connecté.", 401);
+  override isAuthor(options?: { silent?: boolean }): boolean {
+    const silent = options?.silent ?? true;
+
+    try {
+      if (!this.isMe) {
+        throw new ApiError("Vous devez être connecté pour vérifier l'auteur.", 401);
+      }
+      if (!this.id) {
+        throw new ApiError(`${this.constructor.name} non enregistrée.`, 404);
+      }
+      if (!this.serverData) {
+        throw new ApiError("Aucune donnée serveur disponible.", 404);
+      }
+      if (!this.userId) {
+        throw new ApiError("Utilisateur non connecté.", 401);
+      }
+    } catch (e) {
+      if (silent) return false;
+      throw e;
     }
 
     const author = this.serverData.author;

package/src/api/Organization.ts

@@ -500,6 +500,16 @@ export class Organization extends BaseEntity<OrganizationItemNormalized> {
     return super.acceptInvitation();
   }
 
+  /**
+   * {@inheritDoc BaseEntity#requestPromoteToAdmin}
+   *
+   * Envoie une demande de promotion en tant qu'administrateur de l'organisation.
+   * L'utilisateur doit déjà être membre de l'organisation.
+   */
+  override requestPromoteToAdmin() {
+    return super.requestPromoteToAdmin();
+  }
+
   /**
    * {@inheritDoc BaseEntity#leave}
    *

package/src/api/Project.ts

@@ -378,6 +378,16 @@ export class Project extends BaseEntity<ProjectItemNormalized> {
     return super.acceptInvitation();
   }
 
+  /**
+   * {@inheritDoc BaseEntity#requestPromoteToAdmin}
+   *
+   * Envoie une demande de promotion en tant qu'administrateur du projet.
+   * L'utilisateur doit déjà être contributeur du projet.
+   */
+  override requestPromoteToAdmin() {
+    return super.requestPromoteToAdmin();
+  }
+
   /**
    * {@inheritDoc BaseEntity#leave}
    *

package/src/api/User.ts

@@ -1033,6 +1033,32 @@ export class User extends BaseEntity<UserItemNormalized> {
     return this.parent?.serverData?.links?.[connectTypeDisconnect]?.[userId] || null;
   }
 
+  /**
+   * Valide les préconditions et retourne le lien parent.
+   *
+   * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
+   * @param expectedTypes - Types d'entité parent autorisés.
+   * @param options - Options de validation.
+   * @param options.silent - Si `true`, retourne `null` au lieu de lever une exception. Par défaut `true`.
+   * @returns - Le lien parent de l'utilisateur, ou `null` si validation échoue.
+   * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
+   * @private
+   */
+  private _getValidatedParentLink(
+    methodName: string,
+    expectedTypes: string[],
+    options?: { silent?: boolean }
+  ): ParentLink | null {
+    const silent = options?.silent ?? true;
+    try {
+      this._validateBasePreconditions(methodName, expectedTypes);
+    } catch (e) {
+      if (silent) return null;
+      throw e;
+    }
+    return this._getParentLinkForUser();
+  }
+
   /**
    * Rafraîchit l'utilisateur et l'entité parente après une action.
    * @private
@@ -1084,13 +1110,12 @@ export class User extends BaseEntity<UserItemNormalized> {
    *   }
    * }
    */
-  override isAdmin(): boolean {
-    try {
-      this._validateBasePreconditions("isAdmin", ["organizations", "projects"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
+  override isAdmin(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isAdmin",
+      ["organizations", "projects"],
+      { silent: options?.silent }
+    );
     return this._validateUserLink(parentLink) && parentLink?.isAdmin === true;
   }
 
@@ -1119,13 +1144,12 @@ export class User extends BaseEntity<UserItemNormalized> {
    *   }
    * }
    */
-  override isMember(): boolean {
-    try {
-      this._validateBasePreconditions("isMember", ["organizations"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
+  override isMember(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isMember",
+      ["organizations"],
+      { silent: options?.silent }
+    );
     return this._validateUserLink(parentLink);
   }
 
@@ -1154,13 +1178,12 @@ export class User extends BaseEntity<UserItemNormalized> {
    *   }
    * }
    */
-  override isContributor(): boolean {
-    try {
-      this._validateBasePreconditions("isContributor", ["projects"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
+  override isContributor(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isContributor",
+      ["projects"],
+      { silent: options?.silent }
+    );
     return this._validateUserLink(parentLink);
   }
 
@@ -1189,13 +1212,12 @@ export class User extends BaseEntity<UserItemNormalized> {
    *   }
    * }
    */
-  override isAttendee(): boolean {
-    try {
-      this._validateBasePreconditions("isAttendee", ["events"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
+  override isAttendee(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isAttendee",
+      ["events"],
+      { silent: options?.silent }
+    );
     return this._validateUserLink(parentLink);
   }
 
@@ -1216,31 +1238,31 @@ export class User extends BaseEntity<UserItemNormalized> {
    * console.log("Invitation en attente:", invitedUser?.data.name);
    * ```
    */
-  override isInviting(): boolean {
-    try {
-      this._validateBasePreconditions("isInviting", ["citoyens", "organizations", "projects", "events"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
+  override isInviting(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isInviting",
+      ["citoyens", "organizations", "projects", "events"],
+      { silent: options?.silent }
+    );
     if (!parentLink) return false;
-    return parentLink?.isInviting === true;
+    return parentLink.isInviting === true;
   }
 
   /**
    * Vérifie si l'utilisateur connecté a envoyé une invitation d'ami à cet utilisateur.
    *
+   * @param options - Options de vérification.
+   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
    * @returns - `true` si une invitation d'ami est en attente, `false` sinon.
    */
-  isInvitingFriend(): boolean {
-    try {
-      this._validateBasePreconditions("isInviting", ["citoyens", "organizations", "projects", "events"]);
-    } catch{
-      return false;
-    }
-    const userLink = this._getLinkFromConnectedUser();
+  isInvitingFriend(options?: { silent?: boolean }): boolean {
+    const userLink = this._getValidatedUserLink(
+      "isInvitingFriend",
+      ["citoyens", "organizations", "projects", "events"],
+      { silent: options?.silent }
+    );
     if (!userLink) return false;
-    return userLink?.isInviting === true;
+    return userLink.isInviting === true;
   }
 
   /**
@@ -1260,15 +1282,14 @@ export class User extends BaseEntity<UserItemNormalized> {
    * console.log("Invitation admin en attente:", invitedAdmin?.data.name);
    * ```
    */
-  override isInvitingAdmin(): boolean {
-    try {
-      this._validateBasePreconditions("isInvitingAdmin", ["organizations", "projects"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
+  override isInvitingAdmin(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isInvitingAdmin",
+      ["organizations", "projects"],
+      { silent: options?.silent }
+    );
     if (!parentLink) return false;
-    return (parentLink?.isAdminInviting === true || parentLink?.isInviting === true) && parentLink?.isAdmin === true;
+    return (parentLink.isAdminInviting === true || parentLink.isInviting === true) && parentLink.isAdmin === true;
   }
 
   /**
@@ -1290,14 +1311,14 @@ export class User extends BaseEntity<UserItemNormalized> {
    * }
    * ```
    */
-  override isAdminPending(): boolean {
-    try {
-      this._validateBasePreconditions("isAdminPending", ["organizations", "projects"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
-    return parentLink?.isAdmin === true && parentLink?.isAdminPending === true;
+  override isAdminPending(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isAdminPending",
+      ["organizations", "projects"],
+      { silent: options?.silent }
+    );
+    if (!parentLink) return false;
+    return parentLink.isAdmin === true && parentLink.isAdminPending === true;
   }
 
   /**
@@ -1319,31 +1340,31 @@ export class User extends BaseEntity<UserItemNormalized> {
    * }
    * ```
    */
-  override isToBeValidated(): boolean {
-    try {
-      this._validateBasePreconditions("isToBeValidated", ["citoyens", "organizations", "projects", "events"]);
-    } catch{
-      return false;
-    }
-    const parentLink = this._getParentLinkForUser();
+  override isToBeValidated(options?: { silent?: boolean }): boolean {
+    const parentLink = this._getValidatedParentLink(
+      "isToBeValidated",
+      ["citoyens", "organizations", "projects", "events"],
+      { silent: options?.silent }
+    );
     if (!parentLink) return false;
-    return parentLink?.toBeValidated === true;
+    return parentLink.toBeValidated === true;
   }
 
   /**
    * Vérifie si cet utilisateur a envoyé une demande d'ami en attente de validation.
    *
+   * @param options - Options de vérification.
+   * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
    * @returns - `true` si une demande d'ami est en attente de validation, `false` sinon.
    */
-  isToBeValidatedFriend(): boolean {
-    try {
-      this._validateBasePreconditions("isToBeValidated", ["citoyens", "organizations", "projects", "events"]);
-    } catch{
-      return false;
-    }
-    const userLink = this._getLinkFromConnectedUser();
+  isToBeValidatedFriend(options?: { silent?: boolean }): boolean {
+    const userLink = this._getValidatedUserLink(
+      "isToBeValidatedFriend",
+      ["citoyens", "organizations", "projects", "events"],
+      { silent: options?.silent }
+    );
     if (!userLink) return false;
-    return userLink?.toBeValidated === true;
+    return userLink.toBeValidated === true;
   }
 
   /**

package/types/api/BaseEntity.d.ts

@@ -161,6 +161,7 @@ interface MinimalUserLink {
     isInviting?: boolean;
     isAdminInviting?: boolean;
     isAdminPending?: boolean;
+    isAdmin?: boolean;
 }
 type EntityFilterValue = string | boolean | RegExp | ((value: any) => boolean);
 type EntityFilters = Record<string, EntityFilterValue>;
@@ -1273,6 +1274,32 @@ export declare class BaseEntity<TServerData = any> {
      * @protected
      */
     protected _assertEntityType(...types: string[]): void;
+    /**
+     * Vérifie que l'entité N'EST PAS d'un type spécifique.
+     *
+     * @param methodName - Nom de la méthode (pour le message d'erreur).
+     * @param excludedTypes - Types d'entité NON supportés (arguments individuels ou tableau).
+     * @throws {ApiError} - Si l'entité est d'un type exclu.
+     * @protected
+     * @example
+     * this._assertNotEntityType("method", "poi", "badges", "news");
+     * this._assertNotEntityType("method", ["poi", "badges", "news"]);
+     */
+    protected _assertNotEntityType(methodName: string, ...excludedTypes: (string | string[])[]): void;
+    /**
+     * Valide les préconditions et retourne le lien utilisateur.
+     *
+     * @param methodName - Nom de la méthode appelante (pour les messages d'erreur).
+     * @param expectedTypes - Types d'entité autorisés.
+     * @param options - Options de validation.
+     * @param options.silent - Si `true`, retourne `null` au lieu de lever une exception. Par défaut `true`.
+     * @returns - Le lien de l'utilisateur connecté avec l'entité, ou `null` si validation échoue.
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
+     * @protected
+     */
+    protected _getValidatedUserLink(methodName: string, expectedTypes: string[], options?: {
+        silent?: boolean;
+    }): MinimalUserLink | null;
     /**
      * Vérifie si l'entité est liée à un type de lien spécifique.
      *
@@ -1283,92 +1310,137 @@ export declare class BaseEntity<TServerData = any> {
     protected _isLinked(linkType: string): boolean;
     /**
      * Vérifie si l'utilisateur est l'auteur de l'entité.
-     *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est l'auteur, `false` sinon.
      * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si les données du serveur ne sont pas disponibles.
      */
-    isAuthor(): boolean;
+    isAuthor(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur est administrateur de l'entité.
      *
      * @param options - Options de vérification.
      * @param options.checkHierarchy - Si `true`, vérifie également si l'utilisateur est admin via la hiérarchie parent. Par défaut `false`.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est administrateur, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
     isAdmin(options?: {
         checkHierarchy?: boolean;
+        silent?: boolean;
     }): boolean;
     /**
      * Vérifie si l'utilisateur est soit l'auteur, soit administrateur de l'entité.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est l'auteur ou administrateur, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isAuthorOrAdmin(): boolean;
+    isAuthorOrAdmin(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur est membre de l'entité.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est membre, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isMember(): boolean;
+    isMember(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur est contributeur de l'entité.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est contributeur, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isContributor(): boolean;
+    isContributor(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur est participant de l'entité.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est participant, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isAttendee(): boolean;
+    isAttendee(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur suit l'entité.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur suit l'entité, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isFollower(): boolean;
+    isFollower(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur est abonné à l'entité.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est abonné, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isFollowing(): boolean;
+    isFollowing(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si le lien de l'utilisateur connecté est en attente de validation.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si le lien est à valider, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isToBeValidated(): boolean;
+    isToBeValidated(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur connecté a été invité à rejoindre l'entité.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est invité, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isInviting(): boolean;
+    isInviting(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur connecté a été invité en tant qu'administrateur.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est invité admin, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isInvitingAdmin(): boolean;
+    isInvitingAdmin(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Vérifie si l'utilisateur connecté est administrateur en attente de confirmation.
      *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns - `true` si l'utilisateur est admin en attente, `false` sinon.
-     * @throws {ApiError}
+     * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
      */
-    isAdminPending(): boolean;
+    isAdminPending(options?: {
+        silent?: boolean;
+    }): boolean;
     /**
      * Récupère le JSON personnalisé de l'entité
      *

package/types/api/News.d.ts

@@ -120,7 +120,8 @@ export declare class News extends BaseEntity<NewsItemNormalized> {
      * Cette méthode compare l'ID de l'utilisateur connecté avec l'ID de l'auteur
      * de l'actualité. L'auteur peut être soit un objet simple NewsAuthor, soit
      * une instance d'entité User ou Organization.
-     *
+     * @param options - Options de vérification.
+     * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
      * @returns `true` si l'utilisateur connecté est l'auteur, `false` sinon
      * @throws {ApiError} Si l'utilisateur n'est pas connecté (401)
      * @throws {ApiError} Si l'actualité n'a pas d'ID - non enregistrée (404)
@@ -137,5 +138,7 @@ export declare class News extends BaseEntity<NewsItemNormalized> {
      * }
      * ```
      */
-    isAuthor(): boolean;
+    isAuthor(options?: {
+        silent?: boolean;
+    }): boolean;
 }

package/types/api/Organization.d.ts

@@ -246,6 +246,13 @@ export declare class Organization extends BaseEntity<OrganizationItemNormalized>
      * Cette action valide un lien en attente avec l'option `isInviting`.
      */
     acceptInvitation(): Promise<unknown>;
+    /**
+     * {@inheritDoc BaseEntity#requestPromoteToAdmin}
+     *
+     * Envoie une demande de promotion en tant qu'administrateur de l'organisation.
+     * L'utilisateur doit déjà être membre de l'organisation.
+     */
+    requestPromoteToAdmin(): Promise<unknown>;
     /**
      * {@inheritDoc BaseEntity#leave}
      *

package/types/api/Project.d.ts

@@ -162,6 +162,13 @@ export declare class Project extends BaseEntity<ProjectItemNormalized> {
      * Cette action valide un lien en attente avec l'option `isInviting`.
      */
     acceptInvitation(): Promise<unknown>;
+    /**
+     * {@inheritDoc BaseEntity#requestPromoteToAdmin}
+     *
+     * Envoie une demande de promotion en tant qu'administrateur du projet.
+     * L'utilisateur doit déjà être contributeur du projet.
+     */
+    requestPromoteToAdmin(): Promise<unknown>;
     /**
      * {@inheritDoc BaseEntity#leave}
      *