fix(audit-log) : address code review findings

Blocker
- Frontend attendait `hydra:member` / `hydra:totalItems` / `hydra:view` mais
  API Platform 4 sert `member` / `totalItems` / `view` (sans prefixe) sous
  ld+json, et un tableau plat sous json. Consequence : tableau admin et
  timeline silencieusement vides.
  Fix : `useAuditLog` force `Accept: application/ld+json` (necessaire pour
  obtenir l'objet Hydra avec pagination), types `HydraCollection`/`HydraView`
  renommes, composants accedent aux proprietes sans prefixe. Nouveau test
  fonctionnel verrouille le format.

Should-fix
- `AuditLogWriter` : ajout de `'id' => Types::GUID` pour expliciter le type
  natif PG `uuid` (fonctionnait par cast implicite mais l'intention etait
  floue).
- `AuditListener` docblock : documente que le DQL bulk DELETE/UPDATE et
  `Connection::executeStatement()` bypassent le listener (onFlush non
  appele). Piege pour les futures commandes de purge.
- `AuditLogResource` : ajout d'une regex UUID dans `requirements` de
  l'operation Get — un `GET /api/audit-logs/not-a-uuid` produisait un 500
  (cast PG rejete) au lieu d'un 404.
- `audit-log.vue` : le watcher des filtres faisait `filters.page = 1` ce
  qui declenchait le watcher de `page`, causant deux `loadEntries()` en
  parallele. Fusionne : la navigation page appelle `loadEntries()`
  directement depuis `goPrevious`/`goNext`, plus de watcher dedie.
- `useAuditLog.fetchEntityLogs` : bypass du cache `lastCollection` pour ne
  pas polluer la reference page-level quand la timeline est ouverte.
- `AuditTimeline.vue` : remplacement du `<div v-if="!canView"/>` vide par
  un `v-if` sur le wrapper — aucun DOM quand l'utilisateur n'a pas le droit.
- `AuditListenerTest` tag : retire le `_` (wildcard LIKE SQL) du prefix
  pour eviter un faux negatif de match cross-test.
- `AuditLogApiTest` : proprietes `auditConnection` / `runTag` nullable et
  tearDown guarde, sinon un echec setUp provoquait un fatal typed-property
  au lieu de propager l'exception d'origine.

Stabilite suite de tests
- `doctrine.yaml when@test` : `idle_connection_ttl: 1` sur les deux
  connexions pour eviter l'accumulation de connexions orphelines.
- tearDown des tests audit : `close()` explicite sur la connexion audit
  apres chaque test.
- `docker-compose.yml` : `max_connections=300` sur la DB dev (defaut PG=100
  insuffisant pour 220+ tests * 2 connexions/test).

frontend/modules/core/pages/admin/audit-log.vue

@@ -159,7 +159,7 @@
             </table>
         </section>
 
-        <!-- Pagination via hydra:view -->
+        <!-- Pagination via hydra (view.next / view.previous) -->
         <nav class="mt-3 flex items-center justify-between text-sm">
             <span class="text-gray-600">
                 {{ totalItems }} entrée{{ totalItems > 1 ? 's' : '' }}
@@ -270,11 +270,11 @@ async function loadEntries(): Promise<void> {
             performedAtAfter:  filters.performedAtAfter ? toIso(filters.performedAtAfter) : undefined,
             performedAtBefore: filters.performedAtBefore ? toIso(filters.performedAtBefore) : undefined,
         })
-        entries.value = data['hydra:member'] ?? []
-        totalItems.value = data['hydra:totalItems'] ?? 0
-        const view = data['hydra:view']
-        hasPrevious.value = Boolean(view?.['hydra:previous'])
-        hasNext.value = Boolean(view?.['hydra:next'])
+        entries.value = data.member ?? []
+        totalItems.value = data.totalItems ?? 0
+        const view = data.view
+        hasPrevious.value = Boolean(view?.previous)
+        hasNext.value = Boolean(view?.next)
     } finally {
         loading.value = false
     }
@@ -317,12 +317,14 @@ function goPrevious(): void {
     if (!hasPrevious.value || !filters.page) return
     filters.page = Math.max(1, filters.page - 1)
     syncQuery()
+    loadEntries()
 }
 
 function goNext(): void {
     if (!hasNext.value) return
     filters.page = (filters.page ?? 1) + 1
     syncQuery()
+    loadEntries()
 }
 
 // Persiste les filtres dans les query params URL pour que le reload ou le
@@ -339,7 +341,11 @@ function syncQuery(): void {
 }
 
 // Synchronisation reactive : tout changement de filtre declenche un fetch
-// + reset de la pagination a la page 1 (sauf si seul `page` a change).
+// + reset de la pagination a la page 1. La navigation page (prev/next) ne
+// passe PAS par un watcher : elle appelle `loadEntries()` directement dans
+// `goPrevious`/`goNext`. Cette separation evite un double-fetch concurrent
+// quand une filtre reset la page a 1 (sinon le watch de `filters.page`
+// serait declenche une seconde fois en parallele).
 watch(
     () => [filters.performedAtAfter, filters.performedAtBefore, filters.entityType, filters.performedBy, filters.action],
     () => {
@@ -348,7 +354,6 @@ watch(
         loadEntries()
     },
 )
-watch(() => filters.page, () => { loadEntries() })
 
 onMounted(() => {
     loadEntries()

frontend/shared/components/audit/AuditTimeline.vue

@@ -1,8 +1,11 @@
 <template>
-    <!-- Garde permission : aucun rendu ni appel API si l'utilisateur n'a pas le droit. -->
-    <div v-if="!canView" />
-
-    <div v-else class="audit-timeline">
+    <!--
+        Garde permission : aucun rendu DOM ni appel API si l'utilisateur n'a
+        pas le droit. On wrappe le contenu dans un bloc v-if plutot qu'un div
+        vide pour eviter de polluer la layout quand le composant est embarque
+        dans une page qui rend deja sa propre structure.
+    -->
+    <div v-if="canView" class="audit-timeline">
         <!-- Skeleton loader initial -->
         <ul v-if="loading && entries.length === 0" class="space-y-3">
             <li v-for="i in 3" :key="i" class="flex gap-3">
@@ -115,9 +118,9 @@ async function loadPage(targetPage: number, append: boolean): Promise<void> {
     loading.value = true
     try {
         const data = await fetchEntityLogs(entityType.value, entityId.value, targetPage)
-        const slice = (data['hydra:member'] ?? []).slice(0, append ? undefined : INITIAL_LIMIT)
+        const slice = (data.member ?? []).slice(0, append ? undefined : INITIAL_LIMIT)
         entries.value = append ? [...entries.value, ...slice] : slice
-        totalItems.value = data['hydra:totalItems'] ?? entries.value.length
+        totalItems.value = data.totalItems ?? entries.value.length
         page.value = targetPage
     } catch {
         // Erreur silencieuse (timeline secondaire) — useApi n'affiche pas de toast avec toast: false.

frontend/shared/composables/useAuditLog.ts

@@ -50,21 +50,38 @@ function buildQuery(filters: AuditLogFilters | undefined): Record<string, string
  * pour purger le cache (conforme a la regle CLAUDE.md sur les composables
  * singletons, cf. `useSidebar.resetSidebar`).
  */
+// Accept explicitement JSON-LD : API Platform 4 retourne un tableau PLAT (liste
+// d'items, sans envelope de pagination) sous `application/json`, et un objet
+// Hydra complet avec `member`, `totalItems` et `view` (first/last/next/previous)
+// sous `application/ld+json`. Pour obtenir `view` cote front — indispensable
+// a la pagination prev/next — on force donc ld+json.
+const JSONLD_HEADERS = { Accept: 'application/ld+json' } as const
+
 export function useAuditLog() {
     const api = useApi()
 
     async function fetchLogs(filters?: AuditLogFilters): Promise<HydraCollection<AuditLogEntry>> {
-        const data = await api.get<HydraCollection<AuditLogEntry>>(
+        return api.get<HydraCollection<AuditLogEntry>>(
             '/audit-logs',
             buildQuery(filters),
-            { toast: false },
+            { toast: false, headers: JSONLD_HEADERS },
         )
+    }
+
+    /**
+     * Variante de `fetchLogs` qui met a jour le cache `lastCollection`.
+     * N'est utilisee que par la page admin — le composant Timeline appelle
+     * `fetchEntityLogs` qui bypass le cache pour ne pas polluer la reference
+     * page-level quand plusieurs timelines sont ouvertes.
+     */
+    async function fetchLogsCached(filters?: AuditLogFilters): Promise<HydraCollection<AuditLogEntry>> {
+        const data = await fetchLogs(filters)
         lastCollection.value = data
         return data
     }
 
     async function fetchLogById(id: string): Promise<AuditLogEntry> {
-        return api.get<AuditLogEntry>(`/audit-logs/${id}`, {}, { toast: false })
+        return api.get<AuditLogEntry>(`/audit-logs/${id}`, {}, { toast: false, headers: JSONLD_HEADERS })
     }
 
     async function fetchEntityLogs(
@@ -72,6 +89,9 @@ export function useAuditLog() {
         entityId: string | number,
         page: number = 1,
     ): Promise<HydraCollection<AuditLogEntry>> {
+        // Volontairement via `fetchLogs` (sans cache) pour ne pas ecraser
+        // `lastCollection` — la timeline peut etre rendue simultanement a
+        // la page globale et doit rester independante.
         return fetchLogs({
             entityType,
             entityId: String(entityId),
@@ -81,7 +101,7 @@ export function useAuditLog() {
 
     return {
         lastCollection,
-        fetchLogs,
+        fetchLogs: fetchLogsCached,
         fetchLogById,
         fetchEntityLogs,
         resetAuditLog,

frontend/shared/utils/api.ts

@@ -1,18 +1,33 @@
+/**
+ * Schemas Hydra / API Platform 4.
+ *
+ * Important : API Platform 4 abandonne le prefixe `hydra:` dans les noms de
+ * proprietes (compare a la version 3). Un GET /api/audit-logs renvoie :
+ *   { "@context": ..., "@id": ..., "@type": "...",
+ *     "member": [...],
+ *     "totalItems": 30,
+ *     "view": { "@id": ..., "@type": "...", "first": ..., "next": ..., ... } }
+ *
+ * En `application/json` (sans ld), API Platform retourne un simple tableau
+ * plat sans ces metadonnees — on doit donc explicitement demander
+ * `application/ld+json` (via l'option `headers: { Accept: ... }` de useApi)
+ * pour avoir acces a la pagination.
+ */
 export interface HydraView {
     '@id'?: string
     '@type'?: string
-    'hydra:first'?: string
-    'hydra:last'?: string
-    'hydra:next'?: string
-    'hydra:previous'?: string
+    first?: string
+    last?: string
+    next?: string
+    previous?: string
 }
 
 export interface HydraCollection<T> {
-    'hydra:member': T[]
-    'hydra:totalItems': number
-    'hydra:view'?: HydraView
+    member: T[]
+    totalItems: number
+    view?: HydraView
 }
 
 export function extractHydraMembers<T>(collection: HydraCollection<T>): T[] {
-    return collection['hydra:member'] ?? []
+    return collection.member ?? []
 }