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). */

src/Module/Catalog/CatalogModule.php

@@ -38,6 +38,11 @@ final class CatalogModule
         return [
             ['code' => 'catalog.categories.view', 'label' => 'Voir les categories'],
             ['code' => 'catalog.categories.manage', 'label' => 'Gerer les categories (creer, editer, supprimer)'],
+            // Lecture-referentiel transverse (ERP-102) : permet de LISTER les categories
+            // pour alimenter les selects des modules Tiers (clients, fournisseurs...),
+            // sans donner l'acces d'administration `.view` (qui ouvre la page Catalogue
+            // dans la sidebar). Accordee aux roles metier via la matrice RBAC § 2.7.
+            ['code' => 'catalog.categories.read_ref', 'label' => 'Lire le referentiel categories (transverse, lecture seule)'],
         ];
     }
 }

src/Module/Catalog/Domain/Entity/Category.php

@@ -42,13 +42,19 @@ use Symfony\Component\Validator\Constraints as Assert;
  */
 #[ApiResource(
     operations: [
+        // Lecture (liste + item) : permission d'administration `view` OU permission
+        // de lecture-referentiel transverse `read_ref` (ERP-102). Les referentiels
+        // categories sont consommes par les modules Tiers (selects creation/filtre
+        // client) : tout role qui gere des tiers doit pouvoir les lire sans porter
+        // l'acces admin du Catalogue. `read_ref` est une permission Catalog (pas un
+        // code d'un autre module) -> isolement inter-module preserve.
         new GetCollection(
-            security: "is_granted('catalog.categories.view')",
+            security: "is_granted('catalog.categories.view') or is_granted('catalog.categories.read_ref')",
             normalizationContext: ['groups' => ['category:read', 'default:read']],
             provider: CategoryProvider::class,
         ),
         new Get(
-            security: "is_granted('catalog.categories.view')",
+            security: "is_granted('catalog.categories.view') or is_granted('catalog.categories.read_ref')",
             normalizationContext: ['groups' => ['category:read', 'default:read']],
             provider: CategoryProvider::class,
         ),

src/Module/Core/Application/Rbac/RbacSeeder.php

@@ -62,6 +62,9 @@ final class RbacSeeder
             'permissions' => [
                 'commercial.clients.view',
                 'commercial.clients.manage',
+                // Lecture des referentiels transverses pour les selects client (ERP-102).
+                'catalog.categories.read_ref',
+                'sites.read_ref',
             ],
         ],
         self::ROLE_COMPTA => [
@@ -70,6 +73,9 @@ final class RbacSeeder
                 'commercial.clients.view',
                 'commercial.clients.accounting.view',
                 'commercial.clients.accounting.manage',
+                // Lecture des referentiels transverses pour les selects client (ERP-102).
+                'catalog.categories.read_ref',
+                'sites.read_ref',
             ],
         ],
         self::ROLE_COMMERCIALE => [
@@ -77,6 +83,9 @@ final class RbacSeeder
             'permissions' => [
                 'commercial.clients.view',
                 'commercial.clients.manage',
+                // Lecture des referentiels transverses pour les selects client (ERP-102).
+                'catalog.categories.read_ref',
+                'sites.read_ref',
             ],
         ],
         self::ROLE_USINE => [

src/Module/Sites/Domain/Entity/Site.php

@@ -40,13 +40,18 @@ use Symfony\Component\Validator\Constraints as Assert;
  */
 #[ApiResource(
     operations: [
+        // Lecture (liste + item) : permission d'administration `sites.view` OU
+        // permission de lecture-referentiel transverse `sites.read_ref` (ERP-102).
+        // Le referentiel sites alimente les selects d'adresse des modules Tiers :
+        // tout role qui gere des tiers doit pouvoir le lire sans porter l'acces
+        // admin des Sites.
         new GetCollection(
             normalizationContext: ['groups' => ['site:read']],
-            security: "is_granted('sites.view')",
+            security: "is_granted('sites.view') or is_granted('sites.read_ref')",
         ),
         new Get(
             normalizationContext: ['groups' => ['site:read']],
-            security: "is_granted('sites.view')",
+            security: "is_granted('sites.view') or is_granted('sites.read_ref')",
         ),
         new Post(
             normalizationContext: ['groups' => ['site:read']],

src/Module/Sites/SitesModule.php

@@ -33,6 +33,11 @@ final class SitesModule
             ['code' => 'sites.view', 'label' => 'Voir les sites'],
             ['code' => 'sites.manage', 'label' => 'Gerer les sites (creer, editer, supprimer)'],
             ['code' => 'sites.bypass_scope', 'label' => 'Voir les donnees site-scoped de tous les sites (bypass du filtrage)'],
+            // Lecture-referentiel transverse (ERP-102) : permet de LISTER les sites
+            // pour alimenter les selects des modules Tiers (adresses client...), sans
+            // donner l'acces d'administration `.view` (qui ouvre la page Sites dans la
+            // sidebar). Accordee aux roles metier via la matrice RBAC § 2.7.
+            ['code' => 'sites.read_ref', 'label' => 'Lire le referentiel sites (transverse, lecture seule)'],
         ];
     }
 }

tests/Module/Commercial/Api/ClientRBACMatrixTest.php

@@ -272,6 +272,33 @@ final class ClientRBACMatrixTest extends AbstractCommercialApiTestCase
         self::assertResponseStatusCodeSame(200);
     }
 
+    public function testBusinessRolesCanReadCategoriesAndSitesReferentials(): void
+    {
+        // ERP-102 : /categories et /sites sont des referentiels TRANSVERSES.
+        // Tout role qui gere des clients (bureau / compta / commerciale) doit
+        // pouvoir les LISTER pour alimenter les selects de creation/filtre client,
+        // via la permission de lecture-referentiel dediee (catalog.categories.read_ref
+        // / sites.read_ref) attachee par la matrice § 2.7 — sans pour autant porter
+        // la permission d'administration `.view`. Usine, sans aucune permission,
+        // reste interdit.
+        foreach (['bureau', 'compta', 'commerciale'] as $role) {
+            $client = $this->authAs($role);
+
+            $client->request('GET', '/api/categories', ['headers' => ['Accept' => self::LD]]);
+            self::assertResponseStatusCodeSame(200, sprintf('Le role %s doit pouvoir lister /categories', $role));
+
+            $client->request('GET', '/api/sites', ['headers' => ['Accept' => self::LD]]);
+            self::assertResponseStatusCodeSame(200, sprintf('Le role %s doit pouvoir lister /sites', $role));
+        }
+
+        // Usine : aucune permission -> reste a 403 sur les referentiels.
+        $usine = $this->authAs('usine');
+        $usine->request('GET', '/api/categories', ['headers' => ['Accept' => self::LD]]);
+        self::assertResponseStatusCodeSame(403, 'Usine ne doit pas pouvoir lister /categories');
+        $usine->request('GET', '/api/sites', ['headers' => ['Accept' => self::LD]]);
+        self::assertResponseStatusCodeSame(403, 'Usine ne doit pas pouvoir lister /sites');
+    }
+
     private function authAs(string $role): Client
     {
         return $this->authenticatedClient($role, self::PWD);

tests/Module/Sites/SitesModuleTest.php

@@ -16,17 +16,18 @@ use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
  */
 final class SitesModuleTest extends KernelTestCase
 {
-    public function testPermissionsSetContainsExactlyThreeCodes(): void
+    public function testPermissionsSetContainsExactlyFourCodes(): void
     {
         // Garde-fou : si quelqu'un ajoute une permission sans ajuster les
         // tests ou la doc, ce test casse explicitement. Si au contraire une
         // permission disparait (ex: bypass_scope retire par erreur), meme
-        // effet. Le set de 3 permissions est fige par ce test.
+        // effet. Le set de permissions est fige par ce test.
+        // `sites.read_ref` ajoutee en ERP-102 (lecture-referentiel transverse).
         $codes = array_column(SitesModule::permissions(), 'code');
         sort($codes);
 
         self::assertSame(
-            ['sites.bypass_scope', 'sites.manage', 'sites.view'],
+            ['sites.bypass_scope', 'sites.manage', 'sites.read_ref', 'sites.view'],
             $codes,
         );
     }