@communecter/cocolight-api-client 1.0.133 → 1.0.135

package/package.json

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

package/src/api/Answer.ts

@@ -1,7 +1,7 @@
 import { BaseEntity } from "./BaseEntity.js";
 import { ApiError } from "../error.js";
 
-import type { CoformUploadAnswerFileData, DeleteElementData, SaveCoformAnswerData } from "./EndpointApi.types.js";
+import type { CoformAnswersByIdData, CoformGetAnswerFilesData, CoformUploadAnswerFileData, DeleteElementData, SaveCoformAnswerData } from "./EndpointApi.types.js";
 import type { AnswerItemNormalized } from "./serverDataType/Answer.js";
 import type { FormItemNormalized } from "./serverDataType/Form.js";
 
@@ -45,6 +45,26 @@ export interface ProcessUploadsOptions {
   batchSize?: number;
 }
 
+/**
+ * Options de `Answer.get()` — params optionnels du endpoint `COFORM_ANSWERS_BY_ID`.
+ */
+export interface AnswerGetOptions {
+  /**
+   * Liste de champs à retourner côté backend (filtrage). Si absent, tous les
+   * champs sont renvoyés. Utile pour optimiser la taille de la réponse.
+   */
+  fields?: string[];
+  /**
+   * ID du formulaire parent. Utilisé côté backend pour calculer `canEdit` et
+   * `editDeniedReason` (droits d'édition contextuels). Si absent, **auto-injecté
+   * via `this.parent.id`** quand le parent est un `Form` (cas typique
+   * `form.answer({id})`).
+   */
+  formId?: string;
+  /** Chemin Finder (rarement utilisé). */
+  finderPath?: string;
+}
+
 /**
  * Options pour `Answer.uploadFile()`. Tous les champs sont optionnels — les
  * défauts reproduisent les valeurs backend (`docType: "image"`, `contentKey: "slider"`).
@@ -83,6 +103,40 @@ export interface UploadAnswerFileResult {
   answerId: string;
 }
 
+/**
+ * Options de `Answer.getFiles()`.
+ */
+export interface GetFilesOptions {
+  /** Clé d'identification de l'input (ex: `"subFormId.inputId"`). Requise. */
+  subKey: string;
+  /** Type de document attendu. Défaut backend : `"file"`. */
+  docType?: "image" | "file";
+  /** Clé de contenu utilisée lors de l'upload. Défaut backend : `"presentation"`. */
+  contentKey?: string;
+}
+
+/**
+ * Élément renvoyé par `Answer.getFiles()` — un document attaché à l'Answer.
+ * Les champs `imagePath`/`imageThumbPath`/`imageMediumPath` ne sont présents
+ * que pour `docType: "image"`.
+ */
+export interface AnswerFileItem {
+  /** ID MongoDB du document (utilisable pour suppression via `deleteDocumentById`). */
+  docId: string;
+  /** Chemin relatif du document côté backend. */
+  docPath: string;
+  /** Nom original du fichier. */
+  name?: string;
+  /** Taille en octets. */
+  size?: number;
+  /** Chemin de l'image (uniquement si `docType: "image"`). */
+  imagePath?: string | null;
+  /** Chemin du thumbnail (uniquement si `docType: "image"`). */
+  imageThumbPath?: string | null;
+  /** Chemin de la version medium (uniquement si `docType: "image"`). */
+  imageMediumPath?: string | null;
+}
+
 export class Answer extends BaseEntity<AnswerItemNormalized> {
   static override entityType = "answers";
 
@@ -113,6 +167,79 @@ export class Answer extends BaseEntity<AnswerItemNormalized> {
     "voteCount", "vote", "project"
   ];
 
+  /**
+   * {@inheritDoc BaseEntity#isAuthor}
+   *
+   * Override Answer : le champ d'autorité est `serverData.user` (pas `creator`
+   * comme la version par défaut de BaseEntity). Le `user` peut être :
+   *  - un `string` (ID MongoDB brut renvoyé par le backend)
+   *  - une instance `User` (après `_transformServerData` qui le link en entité)
+   *
+   * Les pré-conditions (connexion, id, serverData) sont vérifiées comme dans
+   * la version de base — `silent: true` (défaut) renvoie `false` au lieu de throw.
+   */
+  /**
+   * {@inheritDoc BaseEntity#_isAdminViaHierarchy}
+   *
+   * Override Answer : la hiérarchie d'Answer passe par son **parent instance
+   * Form** (pas par `serverData.parent` direct comme pour `events`/`projects`/`poi`).
+   *
+   * Chaîne : `Answer → parent (Form) → form.serverData.parent ({[orgId]: {type, name}}) → check userContext.links`.
+   *
+   * Si le parent n'est pas un Form (cas `api.answer({id})` direct sans contexte),
+   * renvoie `false` — impossible de vérifier la hiérarchie sans le Form.
+   *
+   * @protected
+   */
+  protected override _isAdminViaHierarchy(): boolean {
+    const form = this.parent;
+    if (!form || typeof (form as any).getEntityType !== "function"
+        || (form as any).getEntityType() !== "forms") {
+      return false;
+    }
+
+    const formParents = (form as { serverData?: { parent?: Record<string, unknown> } }).serverData?.parent;
+    if (!formParents || typeof formParents !== "object") {
+      return false;
+    }
+
+    for (const [parentId, parentRef] of Object.entries(formParents)) {
+      if (!parentRef || typeof parentRef !== "object") continue;
+      const ref = parentRef as { type?: string };
+      if (!ref.type) continue;
+      if (this._isAdminOfParent(parentId, ref.type)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  override isAuthor(options?: { silent?: boolean }): boolean {
+    const silent = options?.silent ?? true;
+    try {
+      // Note : on utilise `isConnected` (user logged in) au lieu de `isMe`
+      // (l'entité IS le user logged in) qui est sémantiquement faux sur Answer.
+      // `_checkAccess` du parent est private et utilise isMe — non réutilisable ici.
+      if (!this.isConnected) 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 user = this._serverData.user;
+    if (!user) return false;
+
+    const authorId = typeof user === "string" ? user : (user as { id?: string }).id;
+    return Boolean(
+      this.userId
+      && typeof authorId === "string"
+      && authorId === this.userId
+    );
+  }
+
   /**
    * Transforme les champs imbriqués (user, context etc.) en instances d'entités.
    * @param data - Les données brutes du serveur.
@@ -126,33 +253,61 @@ export class Answer extends BaseEntity<AnswerItemNormalized> {
       data.user = this._linkNestedEntity({ type: "citoyens", collection: "citoyens", ...data.user });
     }
 
-    // Transformer context en instance Organization/Project
-    // if (data.context && typeof data.context === "object" && !("id" in data.context)) {
-    //   // context est un ParentsMap: { "id1": {type: "organizations", name: "..."}, "id2": {...} }
-    //   // On transforme chaque entrée en instance d'entité
-    //   const transformedContext: Record<string, any> = {};
-    //   for (const [id, parentRef] of Object.entries(data.context)) {
-    //     if (parentRef && typeof parentRef === "object" && "type" in parentRef) {
-    //       transformedContext[id] = this._linkNestedEntity({ id, type: parentRef.type });
-    //     }
-    //   }
-    //   data.context = transformedContext;
-    // }
+    // Normalisation legacy uploader : si parent Form connu, convertit les valeurs
+    // d'inputs `*.uploader` du format Array `[{docId, docPath}]` vers le format
+    // canonique `{updateDate, files: {docId: docPath}}`. Symétrique de ce que
+    // `processUploads()` écrit. Si parent pas Form → skip (pas de schéma pour
+    // identifier les inputs uploader).
+    const formData = this._resolveFormData();
+    if (formData && data.answers && typeof data.answers === "object") {
+      data.answers = this._normalizeLegacyUploaderInAnswers(
+        data.answers as Record<string, Record<string, unknown>>,
+        formData,
+      );
+    }
 
     return data;
   }
 
   /**
-     * Rafraîchit les données de l'entité depuis l'API.
-     * Constant : COFORM_ANSWERS_BY_ID
-     */
-  override async get(): Promise<Record<string, any>> {
+   * Rafraîchit les données de l'entité depuis l'API (`COFORM_ANSWERS_BY_ID`).
+   *
+   * **Auto-injection du `formId`** : si le parent est un `Form` (cas typique
+   * `form.answer({id})`), le param `formId` est automatiquement envoyé pour
+   * que le backend calcule `canEdit` et `editDeniedReason` dans la réponse.
+   * Le caller peut override via `opts.formId` ou couper avec `opts.formId: ""`.
+   *
+   * @param opts - Params optionnels :
+   *  - `fields` : filtrage des champs côté backend
+   *  - `formId` : override de l'auto-injection (utile pour disable ou forcer un autre form)
+   *  - `finderPath` : chemin Finder (rare)
+   *
+   * @example
+   * // Cas commun : form.answer({id}) → get() auto avec formId
+   * const answer = await form.answer({ id: answerId });
+   * answer.serverData.canEdit;            // true/false calculé backend
+   * answer.serverData.editDeniedReason;   // raison si false
+   *
+   * @example
+   * // Cas avancé : filtrage de champs pour optim perf
+   * const answer = await form.answer();
+   * answer._id(answerId);
+   * await answer.get({ fields: ["answers", "canEdit", "editDeniedReason"] });
+   */
+  override async get(opts: AnswerGetOptions = {}): Promise<Record<string, any>> {
     if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.", 400);
     const answerId = this.id; // Type narrowing
 
-    const answer = await this.endpointApi.coformAnswersById({
-      answerId
-    });
+    // Auto-injection du formId via parent Form (sauf si caller a explicitement
+    // passé opts.formId — même chaîne vide pour disable).
+    const formId = "formId" in opts ? opts.formId : this._autoFormIdFromParent();
+
+    const payload: CoformAnswersByIdData = { answerId };
+    if (opts.fields && opts.fields.length > 0) payload.fields = opts.fields;
+    if (typeof formId === "string" && formId.length > 0) payload.formId = formId;
+    if (opts.finderPath) payload.finderPath = opts.finderPath;
+
+    const answer = await this.endpointApi.coformAnswersById(payload);
 
     if (answer?.data?.id) {
       this._setData(answer.data as AnswerItemNormalized, { forceInitialDraftReset: true });
@@ -161,6 +316,20 @@ export class Answer extends BaseEntity<AnswerItemNormalized> {
     throw new ApiError(`Aucune réponse trouvée pour l'ID ${this.id}`, 404);
   }
 
+  /**
+   * Récupère l'ID du parent Form si applicable, pour l'auto-injection dans `get()`.
+   * @private
+   */
+  private _autoFormIdFromParent(): string | undefined {
+    const parent = this.parent;
+    if (parent && typeof (parent as any).getEntityType === "function"
+        && (parent as any).getEntityType() === "forms"
+        && typeof (parent as any).id === "string") {
+      return (parent as any).id as string;
+    }
+    return undefined;
+  }
+
   override async form(): Promise<never> {
     throw new ApiError(`form n'existe pas dans ${this.constructor.name}`, 501);
   }
@@ -173,12 +342,26 @@ export class Answer extends BaseEntity<AnswerItemNormalized> {
    *  - `serverData` et `draftData` sont vidés (sans casser la réactivité)
    *  - `_isDeleted = true` → toute mutation ultérieure (`save`, `get`, etc.) throw
    *
+   * **Guard** : autorisation côté client si l'utilisateur courant est :
+   *  - l'**auteur** de l'Answer (`serverData.user === userId`), OU
+   *  - **admin** d'un parent du Form (org/project) via la hiérarchie
+   *    (`form.serverData.parent[orgId]` × `userContext.links.memberOf[orgId].isAdmin`).
+   *
+   * Le check utilise `isAuthorOrAdmin({checkHierarchy: true})` qui s'appuie sur
+   * l'override `Answer._isAdminViaHierarchy` (remonte via parent instance Form).
+   *
+   * **Pré-requis** :
+   *  - `this.parent` doit être un Form (cas `form.answer({id})`)
+   *  - `userContext` (User connecté) doit avoir `serverData.links` chargés (cas `api.me()`)
+   * Sans ces pré-requis, seul `isAuthor` peut autoriser.
+   *
    * @param reason - Raison libre transmise au backend (audit). Défaut : `"delete coform answer"`.
    * @throws {ApiError} 400 si l'Answer n'a pas d'id (jamais sauvegardée).
+   * @throws {ApiError} 403 si ni auteur ni admin du parent.
    *
    * @example
    * const answer = await form.answer({ id: "..." });
-   * await answer.delete();
+   * await answer.delete();   // OK si auteur OU admin org/project parent du Form
    * answer._isDeleted; // true
    */
   async delete(reason: string = "delete coform answer"): Promise<void> {
@@ -186,6 +369,15 @@ export class Answer extends BaseEntity<AnswerItemNormalized> {
       throw new ApiError("Vous devez fournir un id pour supprimer une Answer.", 400);
     }
 
+    // Guard : auteur OU admin du parent Form (org/project).
+    if (!this.isAuthorOrAdmin({ checkHierarchy: true })) {
+      throw new ApiError(
+        "Suppression refusée — vous devez être l'auteur de l'Answer "
+        + "ou administrateur du parent (organisation/projet) du Form.",
+        403
+      );
+    }
+
     const data: DeleteElementData = {
       reason,
       pathParams: { type: "answers", id: this.id },
@@ -200,9 +392,141 @@ export class Answer extends BaseEntity<AnswerItemNormalized> {
     this._isDeleted = true;
   }
 
+  /**
+   * {@inheritDoc BaseEntity#deleteFile}
+   *
+   * Override avec **cleanup local** : après suppression backend, retire le
+   * `docId` des structures uploader normalisées dans `serverData.answers` et
+   * `_draftData.answers` (format `{updateDate, files: {docId: docPath}}`
+   * produit par `processUploads()` et `_transformServerData`).
+   *
+   * Le caller n'a pas besoin de refetch — `answer.serverData.answers[*][*].files`
+   * reflète directement l'état post-suppression.
+   *
+   * @example
+   * const files = await answer.getFiles({ subKey: "sf.input", docType: "image" });
+   * await answer.deleteFile(files[0].docId);
+   * // answer.serverData.answers[sf][input].files[files[0].docId] === undefined
+   */
+  override async deleteFile(docId: string): Promise<void> {
+    await super.deleteFile(docId);
+
+    // Cleanup local : retire le docId des structures uploader normalisées
+    this._removeDocIdFromUploaderFields(this._serverData.answers, docId);
+    this._removeDocIdFromUploaderFields(this._draftData.answers as Record<string, unknown> | undefined, docId);
+  }
+
+  /**
+   * Walk `answers[subFormId][inputId]` et retire `docId` des structures
+   * `{updateDate, files: {docId: docPath}}` (format canonique uploader).
+   * Mutation in-place pour préserver la réactivité.
+   * @private
+   */
+  private _removeDocIdFromUploaderFields(
+    answers: Record<string, unknown> | undefined,
+    docId: string,
+  ): void {
+    if (!answers || typeof answers !== "object") return;
+
+    for (const subFormData of Object.values(answers)) {
+      if (!this._isObjectRecord(subFormData)) continue;
+      for (const inputValue of Object.values(subFormData)) {
+        if (!this._isObjectRecord(inputValue)) continue;
+        const files = (inputValue as { files?: unknown }).files;
+        if (this._isObjectRecord(files) && docId in files) {
+          delete (files as Record<string, unknown>)[docId];
+        }
+      }
+    }
+  }
+
+  /**
+   * Récupère la liste des fichiers attachés à un input précis de cette Answer
+   * via `COFORM_GET_ANSWER_FILES`.
+   *
+   * **Cas d'usage principal** : récupérer les fichiers d'inputs uploader stockés
+   * en **format legacy** `{updateDate: [...]}` (sans la clé `files`). Le backend
+   * recherche alors les documents MongoDB liés à `{answerId, subKey, docType}`.
+   *
+   * Pour les Answer en format moderne `{updateDate, files: {<docId>: <path>}}`,
+   * les fichiers sont déjà dans `answer.serverData.answers[subFormId][inputId].files`
+   * — pas besoin d'appel réseau.
+   *
+   * @param opts - `subKey` (requis, ex: `"subFormId.inputId"`), `docType`, `contentKey`
+   * @returns Liste normalisée des fichiers `{docId, docPath, name?, size?, imagePath?, imageThumbPath?, imageMediumPath?}`.
+   *          Tableau vide si aucun fichier trouvé.
+   * @throws {ApiError} 400 si pas d'id Answer. Throws aussi si le backend renvoie `result: false`.
+   *
+   * @example
+   * const form = await org.form({ id: formId });
+   * const answer = await form.answer({ id: answerId });
+   * const files = await answer.getFiles({
+   *   subKey: `${subFormId}.${inputId}`,
+   *   docType: "image",
+   * });
+   * files[0].docId;     // ID du document (pour suppression future)
+   * files[0].docPath;   // Chemin relatif (à concaténer avec baseURL pour affichage)
+   */
+  async getFiles(opts: GetFilesOptions): Promise<AnswerFileItem[]> {
+    if (!this.id) {
+      throw new ApiError("Answer sans id, impossible de lister ses fichiers.", 400);
+    }
+    if (!opts.subKey || opts.subKey.length === 0) {
+      throw new ApiError("`subKey` requis pour lister les fichiers d'un input.", 400);
+    }
+
+    const payload: CoformGetAnswerFilesData = {
+      answerId: this.id,
+      subKey: opts.subKey,
+    };
+    if (opts.docType) payload.docType = opts.docType;
+    if (opts.contentKey) payload.contentKey = opts.contentKey;
+
+    // Forme observée du backend (cf. site-json useCoFormAnswerFiles.tsx
+    // et schema COFORM_GET_ANSWER_FILES) :
+    // { result, answerId, subKey, contentKey, count, files: [{ id, name, size,
+    //   docPath, imagePath, imageThumbPath, imageMediumPath }] }
+    const response = await this.callIsConnected(() =>
+      this.endpointApi.coformGetAnswerFiles(payload)
+    ) as {
+      result?: boolean;
+      msg?: string;
+      count?: number;
+      files?: Array<{
+        id?: string | null;
+        name?: string | null;
+        size?: number | null;
+        docPath?: string;
+        imagePath?: string | null;
+        imageThumbPath?: string | null;
+        imageMediumPath?: string | null;
+      }>;
+    };
+
+    // Filtre les entrées invalides (id + docPath requis) et normalise.
+    return (response.files ?? [])
+      .filter(f => typeof f.id === "string" && typeof f.docPath === "string")
+      .map(f => ({
+        docId: f.id!,
+        docPath: f.docPath!,
+        name: f.name ?? undefined,
+        size: f.size ?? undefined,
+        imagePath: f.imagePath ?? undefined,
+        imageThumbPath: f.imageThumbPath ?? undefined,
+        imageMediumPath: f.imageMediumPath ?? undefined,
+      }));
+  }
+
   /**
    * Upload un fichier rattaché à cette Answer via `COFORM_UPLOAD_ANSWER_FILE`.
    *
+   * **Building block du pipeline** : conçu pour être utilisé via
+   * `processUploads()` suivi de `save()`. L'Answer créée par le premier upload
+   * est en état "placeholder" côté backend (champ `user` non posé) — `save()`
+   * finalise. Appeler `get()` ou `delete()` (via l'entité) sur une Answer
+   * upload-only sans save échouera : le backend la considère comme orpheline
+   * (`editDeniedReason: "not_owner"`, stub sans `data.id`).
+   *
    * **Cas premier upload (Answer sans id)** : le backend crée l'Answer et
    * renvoie `answerId`. La méthode pose alors `this._draftData.id = answerId`
    * — les uploads suivants utiliseront cet id, et un `save()` ultérieur passera
@@ -738,6 +1062,52 @@ export class Answer extends BaseEntity<AnswerItemNormalized> {
     return obj;
   }
 
+  /**
+   * Walk les `answers[subFormId][inputId]` pour normaliser les valeurs des
+   * inputs `*.uploader` vers le format canonique `{updateDate, files: {docId: docPath}}`.
+   *
+   * Utilisé par `_transformServerData()` pour harmoniser les Answer en format
+   * legacy Array `[{docId, docPath}]` avec le format moderne (ce que
+   * `processUploads()` écrit).
+   *
+   * Skip si le schéma `formData` n'a pas l'inputType pour un champ donné.
+   * @private
+   */
+  private _normalizeLegacyUploaderInAnswers(
+    answers: Record<string, Record<string, unknown>>,
+    formData: FormItemNormalized,
+  ): Record<string, Record<string, unknown>> {
+    const normalized: Record<string, Record<string, unknown>> = {};
+
+    for (const [subFormId, subFormData] of Object.entries(answers)) {
+      if (!this._isObjectRecord(subFormData)) {
+        normalized[subFormId] = subFormData as any;
+        continue;
+      }
+
+      const subForm = formData.inputs?.[subFormId];
+      if (!subForm) {
+        normalized[subFormId] = subFormData;
+        continue;
+      }
+
+      const cleanedSubForm: Record<string, unknown> = {};
+      for (const [inputId, inputValue] of Object.entries(subFormData)) {
+        const input = subForm.inputs?.[inputId];
+        const inputType = input && typeof input === "object" && "type" in input
+          ? (input.type as string | undefined)
+          : undefined;
+
+        cleanedSubForm[inputId] = inputType?.endsWith(".uploader")
+          ? this._normalizeUploaderValue(inputValue)
+          : inputValue;
+      }
+      normalized[subFormId] = cleanedSubForm;
+    }
+
+    return normalized;
+  }
+
   /**
    * Normalise une valeur d'input uploader vers le format legacy backend :
    *   `{ updateDate: ["DD/MM/YYYY"], files: { "<docId>": "<docPath>", ... } }`

package/src/api/BaseEntity.ts

@@ -58,7 +58,8 @@ import type {
   LinkMediawikiAccountData,
   UnlinkMediawikiAccountData,
   GetMediawikiContributionsData,
-  CoremuOperationData
+  CoremuOperationData,
+  DeleteDocumentByIdData
 } from "./EndpointApi.types.js";
 import type { GetElementsKeyResponse } from "../types/api-responses.js";
 import type { TransformsMap } from "../types/entities.js";
@@ -1225,6 +1226,39 @@ export class BaseEntity<TServerData = any> {
     throw new ApiError("Type de fichier non reconnu pour l'upload.", 400);
   }
 
+  /**
+   * Supprime un document (fichier ou image) par son `docId` MongoDB via
+   * `DELETE_DOCUMENT_BY_ID`.
+   *
+   * Méthode générique exposée sur toutes les entités — le endpoint backend
+   * opère par docId seul, sans contexte parent requis. Disponible ici pour
+   * être découvrable et **override-able** par les entités qui veulent un
+   * cleanup local après suppression (ex: `News.deleteFile` pourrait retirer
+   * l'id de `mediaImg.images` côté serverData).
+   *
+   * Ne met PAS à jour `serverData` après suppression — le caller doit
+   * invalider son cache local s'il en a un (cas typique : React Query).
+   *
+   * @param docId - ID MongoDB du document (24 hex)
+   * @throws {ApiError} 400 si `docId` invalide.
+   *
+   * @example
+   * // Depuis une Answer (suppression d'un fichier uploader)
+   * const files = await answer.getFiles({ subKey: "sf.input", docType: "image" });
+   * await answer.deleteFile(files[0].docId);
+   *
+   * @example
+   * // Depuis n'importe quelle entité qui possède un docId
+   * await news.deleteFile(imageDocId);
+   */
+  async deleteFile(docId: string): Promise<void> {
+    if (typeof docId !== "string" || docId.length !== 24) {
+      throw new ApiError("docId requis (24 hex) pour supprimer un document.", 400);
+    }
+    const payload: DeleteDocumentByIdData = { pathParams: { id: docId } };
+    await this.callIsConnected(() => this.endpointApi.deleteDocumentById(payload));
+  }
+
   /**
    * Valide les entrées d'upload de fichiers.
    *
@@ -2505,10 +2539,15 @@ export class BaseEntity<TServerData = any> {
   }
 
   /**
-   * Vérifie si l'utilisateur est admin via la hiérarchie parent (logique généraliste)
-   * @private
+   * Vérifie si l'utilisateur est admin via la hiérarchie parent (logique généraliste).
+   *
+   * Note : passé `protected` pour permettre l'override par les entités dont la
+   * hiérarchie n'est pas un simple champ `serverData.parent` ou `.organizer`
+   * (cf. `Answer._isAdminViaHierarchy` qui remonte via son parent instance Form).
+   *
+   * @protected
    */
-  private _isAdminViaHierarchy(): boolean {
+  protected _isAdminViaHierarchy(): boolean {
     const entityType = this.getEntityType();
     const entityData = this.serverData as any;
 
@@ -2545,10 +2584,14 @@ export class BaseEntity<TServerData = any> {
   }
 
   /**
-   * Vérifie si l'utilisateur est admin d'un parent spécifique
-   * @private
+   * Vérifie si l'utilisateur est admin d'un parent spécifique.
+   *
+   * Note : passé `protected` pour être utilisable par les overrides de
+   * `_isAdminViaHierarchy()` (cf. `Answer._isAdminViaHierarchy`).
+   *
+   * @protected
    */
-  private _isAdminOfParent(parentId: string, parentType: string): boolean {
+  protected _isAdminOfParent(parentId: string, parentType: string): boolean {
     const userLinks = this.userContext?.serverData?.links;
     if (!userLinks) return false;
 
@@ -4152,10 +4195,13 @@ export class BaseEntity<TServerData = any> {
    *
    * @param options - Options de vérification.
    * @param options.silent - Si `true`, retourne `false` au lieu de lever une exception. Par défaut `true`.
+   * @param options.checkHierarchy - Si `true`, propagé à `isAdmin` pour vérifier
+   *   également la hiérarchie parent (ex: `Answer.isAdmin({checkHierarchy: true})`
+   *   remonte vers org/project du Form parent).
    * @returns - `true` si l'utilisateur est l'auteur ou administrateur, `false` sinon.
    * @throws {ApiError} - Si `silent` est `false` et que les préconditions ne sont pas remplies.
    */
-  isAuthorOrAdmin(options?: { silent?: boolean }): boolean {
+  isAuthorOrAdmin(options?: { silent?: boolean; checkHierarchy?: boolean }): boolean {
     return this.isAuthor() || this.isAdmin(options);
   }
 

package/src/api/serverDataType/Answer.ts

@@ -64,6 +64,17 @@ export interface AnswerItemJson {
     [key: string]: unknown;
 }
 
+/**
+ * Raisons de refus d'édition côté backend, calculées par `coformAnswersById`
+ * et présentes dans la réponse normalisée. Utilisé par les UI pour distinguer
+ * les modes readonly/edit et afficher des messages contextuels.
+ */
+export type AnswerEditDeniedReason =
+    | "not_logged_in"
+    | "not_owner"
+    | "form_inactive"
+    | "form_closed";
+
 export interface AnswerItemNormalized {
     id: string;
     _id: ObjectID;
@@ -73,6 +84,7 @@ export interface AnswerItemNormalized {
     user?: string | User;
     links?: AnswerLinksBlock;
     draft?: boolean;
+    finished?: boolean;
     answers?: Record<string, unknown>;
     context?: ParentsMap | Record<string, Organization | Project>;
     form?: string;
@@ -83,5 +95,12 @@ export interface AnswerItemNormalized {
         date: Date;
     }>;
     project?: AnswerProjectRef;
+    /**
+     * L'utilisateur courant peut-il éditer cette réponse ? Calculé côté backend.
+     * Présent par défaut, ou enrichi avec le contexte si `formId` est fourni.
+     */
+    canEdit?: boolean;
+    /** Raison si `canEdit === false`. `null` si `canEdit === true`. */
+    editDeniedReason?: AnswerEditDeniedReason | null;
     [key: string]: unknown;
 }