fix(rbac) : referentiels /categories et /sites lisibles par les roles metier (ERP-102)

Les roles metier (bureau / compta / commerciale) prenaient un 403 sur
GET /api/categories et GET /api/sites : la security des GetCollection/Get
exigeait catalog.categories.view / sites.view, permissions reservees a
l'administration du Catalogue et des Sites. Or ces referentiels sont
transverses (selects de creation/filtre client) : creation de client
cassee et filtres vides pour ces roles.

Correctif back (Option C — permission de lecture-referentiel dediee) :
- Nouvelles permissions catalog.categories.read_ref et sites.read_ref,
  distinctes de .view (pas d'item sidebar admin) et de .manage. Chaque
  permission appartient a son propre module -> aucun couplage inter-module
  (regle ABSOLUE n°1) et reutilisable tel quel par M2 Fournisseurs.
- Security lecture (liste + item) elargie : view OR read_ref sur Category
  et Site.
- Matrice RBAC § 2.7 (RbacSeeder) : read_ref attache a bureau / compta /
  commerciale. Usine reste sans acces.

Durcissement front (resilience, requis dans tous les cas) :
- useClientReferentials.loadCommon passe de Promise.all a Promise.allSettled
  avec affectation isolee par referentiel : l'echec d'un endpoint ne vide
  que SON select, plus la totalite du formulaire.

Tests :
- ClientRBACMatrixTest : les roles metier listent /categories et /sites (200),
  usine reste a 403.
- SitesModuleTest : set de permissions porte a 4 codes.
- useClientReferentials.spec : resilience d'un referentiel en echec.

Miroirs E2E (personas.ts / SeedE2ECommand) non touches : read_ref n'ajoute
aucun lien sidebar, le persona user-full lit deja via .view, et aucun
persona ne modelise un role metier seul ; pas de nouveau test E2E (regle n°7).

frontend/modules/commercial/composables/__tests__/useClientReferentials.spec.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// `useApi` est un auto-import Nuxt : on le stubbe globalement pour intercepter
+// les appels de chargement des referentiels et simuler un endpoint en echec
+// (ex: 403 sur /categories pour un role sans la permission de lecture).
+// Meme pattern que useClientsRepository.spec.ts.
+const mockGet = vi.hoisted(() => vi.fn())
+vi.stubGlobal('useApi', () => ({
+    get: mockGet,
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+}))
+
+// Import APRES le stub pour que useApi soit bien resolu au top-level du module.
+const { useClientReferentials } = await import('../useClientReferentials')
+
+describe('useClientReferentials.loadCommon (resilience ERP-102)', () => {
+    beforeEach(() => {
+        mockGet.mockReset()
+    })
+
+    it('un referentiel en echec (403) ne vide QUE son select, pas les autres', async () => {
+        // /categories rejette (simulateur d'un 403), tous les autres repondent.
+        mockGet.mockImplementation((url: string) => {
+            if (url === '/categories') {
+                return Promise.reject(new Error('403 Forbidden'))
+            }
+            if (url === '/sites') {
+                return Promise.resolve({ member: [{ '@id': '/api/sites/1', name: 'Chatellerault' }] })
+            }
+            return Promise.resolve({
+                member: [{ '@id': '/api/x/1', code: 'X', label: 'Libelle X' }],
+            })
+        })
+
+        const refs = useClientReferentials()
+        // loadCommon ne doit JAMAIS rejeter : l'echec d'un referentiel est isole.
+        await refs.loadCommon()
+
+        // Resilience : les referentiels OK sont peuples malgre l'echec de /categories.
+        expect(refs.sites.value).toEqual([{ value: '/api/sites/1', label: 'Chatellerault' }])
+        expect(refs.tvaModes.value).toEqual([{ value: '/api/x/1', label: 'Libelle X' }])
+        expect(refs.banks.value).toEqual([{ value: '/api/x/1', label: 'Libelle X' }])
+
+        // Seul le select en echec reste vide.
+        expect(refs.categories.value).toEqual([])
+    })
+
+    it('charge tous les referentiels quand tout repond', async () => {
+        mockGet.mockImplementation((url: string) => {
+            if (url === '/categories') {
+                return Promise.resolve({
+                    member: [{ '@id': '/api/categories/1', code: 'SECTEUR', name: 'Secteur' }],
+                })
+            }
+            if (url === '/sites') {
+                return Promise.resolve({ member: [{ '@id': '/api/sites/1', name: 'Chatellerault' }] })
+            }
+            return Promise.resolve({ member: [] })
+        })
+
+        const refs = useClientReferentials()
+        await refs.loadCommon()
+
+        expect(refs.categories.value).toEqual([
+            { value: '/api/categories/1', label: 'Secteur', code: 'SECTEUR' },
+        ])
+        expect(refs.sites.value).toEqual([{ value: '/api/sites/1', label: 'Chatellerault' }])
+    })
+})

frontend/modules/commercial/composables/useClientReferentials.ts

@@ -88,23 +88,35 @@ export function useClientReferentials() {
      * charges a la demande selon la relation choisie). Les selects compta ne sont
      * pertinents que si l'utilisateur a acces a l'onglet, mais le cout est
      * negligeable et simplifie l'orchestration.
+     *
+     * Resilience (ERP-102) : chaque referentiel est charge et affecte
+     * independamment via `Promise.allSettled`. Si UN endpoint echoue (ex: 403,
+     * coupure reseau), seul SON select reste vide — les autres sont peuples
+     * normalement. Un `Promise.all` rejetterait au premier echec et viderait la
+     * TOTALITE des selects, rendant le formulaire de creation client inutilisable.
+     * `loadCommon` ne rejette donc jamais.
      */
     async function loadCommon(): Promise<void> {
-        const [cats, sitesList, tva, delays, types, banksList] = await Promise.all([
-            fetchAll<CategoryMember>('/categories'),
-            fetchAll<SiteMember>('/sites'),
-            fetchAll<ReferentialMember>('/tva_modes'),
-            fetchAll<ReferentialMember>('/payment_delays'),
-            fetchAll<ReferentialMember>('/payment_types'),
-            fetchAll<ReferentialMember>('/banks'),
+        await Promise.allSettled([
+            fetchAll<CategoryMember>('/categories').then(cats => {
+                categories.value = cats.map(c => ({ value: c['@id'], label: c.name, code: c.code }))
+            }),
+            fetchAll<SiteMember>('/sites').then(sitesList => {
+                sites.value = sitesList.map(s => ({ value: s['@id'], label: s.name }))
+            }),
+            fetchAll<ReferentialMember>('/tva_modes').then(tva => {
+                tvaModes.value = tva.map(t => ({ value: t['@id'], label: t.label }))
+            }),
+            fetchAll<ReferentialMember>('/payment_delays').then(delays => {
+                paymentDelays.value = delays.map(d => ({ value: d['@id'], label: d.label }))
+            }),
+            fetchAll<ReferentialMember>('/payment_types').then(types => {
+                paymentTypes.value = types.map(t => ({ value: t['@id'], label: t.label, code: t.code }))
+            }),
+            fetchAll<ReferentialMember>('/banks').then(banksList => {
+                banks.value = banksList.map(b => ({ value: b['@id'], label: b.label }))
+            }),
         ])
-
-        categories.value = cats.map(c => ({ value: c['@id'], label: c.name, code: c.code }))
-        sites.value = sitesList.map(s => ({ value: s['@id'], label: s.name }))
-        tvaModes.value = tva.map(t => ({ value: t['@id'], label: t.label }))
-        paymentDelays.value = delays.map(d => ({ value: d['@id'], label: d.label }))
-        paymentTypes.value = types.map(t => ({ value: t['@id'], label: t.label, code: t.code }))
-        banks.value = banksList.map(b => ({ value: b['@id'], label: b.label }))
     }
 
     /** Liste des clients pouvant etre choisis comme distributeur (code DISTRIBUTEUR). */