chore: bump version to v0.1.50

## Contexte
Ticket Lesstime : [#49](https://lesstime.malio.fr/tasks/460) — premier ticket front du M0 (Gestion des catégories).
Suit la chaîne back ERP-43..48 mergée sur develop.

## Contenu first draft (Claude Code)
- Page Nuxt `/admin/categories` (`MalioDataTable` + bouton `+ Ajouter`)
- Composant `<CategoryDrawer>` : modes création / consultation / édition, transition auto view → edit à la première modification, validation client miroir RG-1.02 (name requis) / RG-1.04 (longueur 2-120) / RG-1.05 (type requis), mapping erreurs 409 (doublon) et 422 (violations)
- Composant `<CategoryDeleteModal>` : confirmation suppression (soft delete RG-1.12)
- Types TS `Category`, `CategoryType`, `User`
- i18n `admin.categories.*` ajouté dans `fr.json`
- Fix latent en passant : ajout de `'categories'` à `AdminLinkSlug` du Page Object e2e (oublié lors d'ERP-47 quand l'item sidebar a été ajouté)

## Décisions marquantes
- Logique `fetch` inline dans `categories.vue` (sera extraite en composables `useCategoriesAdmin` + `useCategoryForm` au ticket ERP-50 / 0.8)
- Drawer dans composant séparé pour réutilisabilité
- Aucun état de tableau persisté dans l'URL (règle ABSOLUE n°6)
- Tous les composants formulaires sont `Malio*` (`MalioDataTable`, `MalioInputText`, `MalioSelect`, `MalioButton`, `MalioDrawer`)

## Polish à venir (Tristan)
Tristan testera en navigateur et peaufinera : UX, classes Tailwind, animations, icônes, wording de toasts.
Les commits de polish suivront sur la même branche.

## Tests
- `npx nuxi typecheck` : net 0 nouvelle erreur (mêmes erreurs pré-existantes que sur `develop`, infrastructure auto-import) + 1 latente corrigée (AdminLinkSlug)
- `make nuxt-test` : 43/43 passent (0 régression)
- Tests manuels navigateur : voir cahier de test du ticket Lesstime #49

## Note pre-commit hook
Le hook a remonté un échec PHPUnit pré-existant sur `develop` (`CategoryDeleteTest::testPatchOnSoftDeletedReturns404` → 401 au lieu de 404, JWT non initialisé en test runner). Aucun PHP touché dans cette MR. Commit avec `--no-verify` autorisé par Tristan.

## Reviewer suggéré
Matthieu (back ↔ front + permissions).

---------

Co-authored-by: Matthieu <mtholot19@gmail.com>
Reviewed-on: #22
Co-authored-by: tristan <tristan@yuno.malio.fr>
Co-committed-by: tristan <tristan@yuno.malio.fr>

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.49'
+    app.version: '0.1.50'

frontend/modules/catalog/components/CategoryDrawer.vue

@@ -7,7 +7,7 @@
         @update:model-value="emit('update:modelValue', $event)"
     >
         <template #header>
-            <h2 class="text-[24px] font-bold">
+            <h2 class="text-2xl font-bold">
                 {{ headerLabel }}
             </h2>
         </template>
@@ -16,30 +16,29 @@
             <!-- Nom (RG-1.02 obligatoire / RG-1.04 longueur 2-120 apres trim).
                  Erreur miroir client + erreurs server-side (422) mappees sur ce champ. -->
             <MalioInputText
-                v-model="form.name.value"
+                v-model="form.name"
                 :label="t('admin.categories.form.name')"
                 input-class="w-full"
                 :max-length="120"
-                :error="form.errors.value.name"
+                :error="errors.name"
                 required
             />
 
             <!-- Type (RG-1.05 obligatoire). MalioSelect porte la valeur en
-                 number (categoryType id) ; conversion en IRI au moment du save
-                 par le composable useCategoryForm. -->
+                 number (categoryType id) ; conversion en IRI au moment du save. -->
             <MalioSelect
-                v-model="form.categoryTypeId.value"
-                :options="typeOptions"
+                v-model="form.categoryTypeId"
+                :options="categoryTypeOptions"
                 :label="t('admin.categories.form.type')"
                 :empty-option-label="t('admin.categories.form.typePlaceholder')"
-                :error="form.errors.value.categoryType"
+                :error="errors.categoryType"
                 :disabled="loadingTypes"
             />
 
             <!-- Erreur transverse (typiquement reseau / 5xx) — separe des
                  erreurs de validation par champ. -->
-            <p v-if="form.errors.value._global" class="text-sm text-red-600">
-                {{ form.errors.value._global }}
+            <p v-if="errors._global" class="text-sm text-red-600">
+                {{ errors._global }}
             </p>
         </form>
 
@@ -67,7 +66,7 @@
                 :label="t('common.save')"
                 variant="primary"
                 button-class="w-[150px]"
-                :disabled="form.submitting.value || loadingTypes"
+                :disabled="saving || loadingTypes"
                 @click="handleSave"
             />
         </template>
@@ -75,14 +74,12 @@
 </template>
 
 <script setup lang="ts">
-import type { Category } from '~/modules/catalog/types/category'
+import type { Category, CategoryType } from '~/modules/catalog/types/category'
+import type { HydraCollection } from '~/shared/utils/api'
 
 const { t } = useI18n()
+const api = useApi()
 const { can } = usePermissions()
-const { types, loadingTypes, fetchTypes } = useCategoriesAdmin()
-// Instance dediee de form pour ce drawer — state isole (cf. useCategoryForm
-// n'est pas singleton, contrairement a useCategoriesAdmin).
-const form = useCategoryForm()
 
 const props = defineProps<{
     modelValue: boolean
@@ -96,20 +93,56 @@ const emit = defineEmits<{
 }>()
 
 /**
- * Mode du drawer (dérivé du composable `useCategoryForm`) :
+ * Mode du drawer :
  *  - 'create' : pas de category prop, formulaire vide, POST au save.
  *  - 'view'   : category prop set, formulaire pre-rempli, save MASQUE
  *               jusqu'a ce que l'utilisateur modifie un champ.
  *  - 'edit'   : category prop set et formulaire « dirty » (au moins un
  *               champ different de l'original), PATCH au save.
+ *
+ * La bascule view → edit est automatique des qu'un champ change (cf. watch
+ * sur form). Le label du header suit le mode courant.
  */
 type DrawerMode = 'create' | 'view' | 'edit'
 
+const saving = ref(false)
+const loadingTypes = ref(false)
+const categoryTypes = ref<CategoryType[]>([])
+
+const form = ref({
+    name: '',
+    categoryTypeId: null as number | null,
+})
+
+// Snapshot des valeurs initiales pour detecter le « dirty » (view → edit).
+const initial = ref({
+    name: '',
+    categoryTypeId: null as number | null,
+})
+
+// Erreurs par champ + erreur transverse globale. Pattern propre pour mapper
+// les violations 422 sur les MalioInputText / MalioSelect.
+const errors = ref<{
+    name: string
+    categoryType: string
+    _global: string
+}>({
+    name: '',
+    categoryType: '',
+    _global: '',
+})
+
 const isCreateMode = computed(() => props.category === null)
 
+const isDirty = computed(
+    () =>
+        form.value.name !== initial.value.name
+        || form.value.categoryTypeId !== initial.value.categoryTypeId,
+)
+
 const mode = computed<DrawerMode>(() => {
     if (isCreateMode.value) return 'create'
-    return form.isDirty.value ? 'edit' : 'view'
+    return isDirty.value ? 'edit' : 'view'
 })
 
 const headerLabel = computed(() => {
@@ -131,48 +164,207 @@ const canShowSave = computed(
     () => mode.value === 'create' || mode.value === 'edit',
 )
 
-const typeOptions = computed(() =>
-    types.value.map(ct => ({
+const categoryTypeOptions = computed(() =>
+    categoryTypes.value.map(ct => ({
         label: ct.label,
         value: ct.id,
     })),
 )
 
-// Re-initialise le form quand la categorie selectionnee change (clic sur une
-// autre ligne sans fermer le drawer entre-temps).
-watch(() => props.category, (cat) => {
-    form.loadFrom(cat)
-}, { immediate: true })
+/**
+ * Charge le referentiel CategoryType. Appele a chaque ouverture du drawer
+ * (pas seulement au mount) pour rester a jour si un type est ajoute en
+ * arriere-plan. Volontairement sans toast en cas d'echec : on affiche un
+ * message inline via `errors._global` pour ne pas spammer.
+ */
+async function loadCategoryTypes(): Promise<void> {
+    loadingTypes.value = true
+    try {
+        const data = await api.get<HydraCollection<CategoryType>>(
+            '/category_types',
+            { itemsPerPage: 999 },
+            { toast: false },
+        )
+        categoryTypes.value = data.member ?? []
+    } catch {
+        categoryTypes.value = []
+        errors.value._global = t('admin.categories.toast.typesLoadFailed')
+    } finally {
+        loadingTypes.value = false
+    }
+}
 
-// A chaque ouverture du drawer : reload du form + refresh des types (au cas
-// ou un type aurait ete ajoute en arriere-plan depuis le dernier fetch — pas
-// d'optimisation cache au M0, le referentiel est petit).
+/**
+ * Re-initialise le formulaire a partir de la prop `category`. Aussi appele
+ * a l'ouverture du drawer pour repartir d'un etat propre.
+ */
+function resetForm(): void {
+    errors.value = { name: '', categoryType: '', _global: '' }
+    if (props.category) {
+        form.value.name = props.category.name
+        form.value.categoryTypeId = props.category.categoryType.id
+        initial.value.name = props.category.name
+        initial.value.categoryTypeId = props.category.categoryType.id
+    } else {
+        form.value.name = ''
+        form.value.categoryTypeId = null
+        initial.value.name = ''
+        initial.value.categoryTypeId = null
+    }
+}
+
+// Re-initialiser quand la categorie selectionnee change (clic sur une autre
+// ligne sans fermer le drawer entre-temps).
+watch(() => props.category, resetForm, { immediate: true })
+
+// A chaque ouverture du drawer : reset + chargement frais des types. Pas
+// d'optimisation cache au M0 — le referentiel est petit et statique.
 watch(
     () => props.modelValue,
     (open) => {
         if (open) {
-            form.loadFrom(props.category)
-            fetchTypes()
+            resetForm()
+            loadCategoryTypes()
         }
     },
 )
 
 /**
- * Sauvegarde : delegue au composable (POST en mode create, PATCH en mode
- * edit). Le toast succes + mapping erreur 409/422 est gere par le composable.
- * En cas de succes, on ferme le drawer et on previent le parent pour qu'il
- * refresh la liste.
+ * Validation client-side miroir des RG back. Renvoie true si tout passe et
+ * peuple `errors` sinon. Le serveur valide aussi (defense en profondeur) ;
+ * la validation client sert juste a eviter l'aller-retour evitable.
+ */
+function validate(): boolean {
+    errors.value = { name: '', categoryType: '', _global: '' }
+    const trimmedName = form.value.name.trim()
+
+    // RG-1.02 — name obligatoire (vide / whitespace-only).
+    if (trimmedName === '') {
+        errors.value.name = t('admin.categories.validation.nameRequired')
+    } else if (trimmedName.length < 2 || trimmedName.length > 120) {
+        // RG-1.04 — longueur 2-120 apres trim.
+        errors.value.name = t('admin.categories.validation.nameLength')
+    }
+
+    // RG-1.05 — categoryType obligatoire.
+    if (form.value.categoryTypeId === null) {
+        errors.value.categoryType = t('admin.categories.validation.typeRequired')
+    }
+
+    return errors.value.name === '' && errors.value.categoryType === ''
+}
+
+/**
+ * Mappe une reponse 422 d'API Platform sur le state `errors`. API Platform 4
+ * retourne soit `violations: [{ propertyPath, message }]` soit
+ * `hydra:violations` selon la negociation de format.
+ */
+function mapServerViolations(data: unknown): boolean {
+    if (!data || typeof data !== 'object') return false
+    const record = data as Record<string, unknown>
+    const rawViolations = record.violations ?? record['hydra:violations']
+    if (!Array.isArray(rawViolations)) return false
+
+    let mapped = false
+    for (const v of rawViolations) {
+        if (!v || typeof v !== 'object') continue
+        const violation = v as Record<string, unknown>
+        const path = String(violation.propertyPath ?? '')
+        const message = String(violation.message ?? '')
+        if (path === 'name') {
+            errors.value.name = message
+            mapped = true
+        } else if (path === 'categoryType') {
+            errors.value.categoryType = message
+            mapped = true
+        }
+    }
+    return mapped
+}
+
+/**
+ * Extrait un message d'erreur HTTP au format API Platform / Hydra.
+ */
+function extractErrorMessage(data: unknown): string {
+    if (!data || typeof data !== 'object') return ''
+    const record = data as Record<string, unknown>
+    return (
+        (record['hydra:description'] as string)
+        ?? (record.detail as string)
+        ?? (record.description as string)
+        ?? ''
+    )
+}
+
+/**
+ * Sauvegarde la categorie (POST en mode create, PATCH en mode edit).
+ * Trim cote client (miroir RG-1.03), conversion ID → IRI pour categoryType,
+ * mapping des erreurs server.
  */
 async function handleSave(): Promise<void> {
-    let result: Category | null = null
-    if (mode.value === 'create') {
-        result = await form.submitCreate()
-    } else if (mode.value === 'edit' && props.category) {
-        result = await form.submitUpdate(props.category.id)
+    if (!validate()) return
+    saving.value = true
+    errors.value._global = ''
+
+    // Trim cote client (miroir RG-1.03). Le serveur retrim de toute facon.
+    const payload = {
+        name: form.value.name.trim(),
+        categoryType: `/api/category_types/${form.value.categoryTypeId}`,
     }
-    if (result) {
+
+    try {
+        if (mode.value === 'create') {
+            await api.post('/categories', payload, {
+                toastSuccessMessage: t('admin.categories.toast.created'),
+                toast: false, // gestion fine des erreurs ci-dessous
+            })
+        } else if (mode.value === 'edit' && props.category) {
+            await api.patch(`/categories/${props.category.id}`, payload, {
+                toastSuccessMessage: t('admin.categories.toast.updated'),
+                toast: false,
+            })
+        }
+
+        // Succes : toast manuel (car on a desactive le toast du composable
+        // pour gerer finement les erreurs) + propagation au parent.
+        useToast().success({
+            title: 'Succès',
+            message:
+                mode.value === 'create'
+                    ? t('admin.categories.toast.created')
+                    : t('admin.categories.toast.updated'),
+        })
         emit('saved')
         emit('update:modelValue', false)
+    } catch (err: unknown) {
+        const error = err as { response?: { status?: number, _data?: unknown } }
+        const status = error?.response?.status
+        const data = error?.response?._data
+
+        if (status === 409) {
+            // RG-1.07 — doublon (name, categoryType). Toast custom + erreur
+            // mappee sur le champ name (origine du conflit).
+            const duplicateMessage = t('admin.categories.toast.duplicate', {
+                name: payload.name,
+            })
+            errors.value.name = duplicateMessage
+            useToast().error({
+                title: 'Erreur',
+                message: duplicateMessage,
+            })
+        } else if (status === 422 && mapServerViolations(data)) {
+            // Violations mappees sur les champs concernes — pas de toast,
+            // l'utilisateur voit l'erreur directement sous le champ.
+        } else {
+            const extracted = extractErrorMessage(data)
+            errors.value._global = extracted || 'Une erreur est survenue.'
+            useToast().error({
+                title: 'Erreur',
+                message: errors.value._global,
+            })
+        }
+    } finally {
+        saving.value = false
     }
 }
 </script>

frontend/modules/catalog/composables/__tests__/useCategoriesAdmin.spec.ts

@@ -1,250 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import type { Category, CategoryType } from '~/modules/catalog/types/category'
-import type { HydraCollection } from '~/shared/utils/api'
-
-// Mock du store auth : useCategoriesAdmin s'auto-enregistre via
-// `onAuthSessionCleared(...)` au chargement du module. On stubbe pour
-// eviter de charger Pinia et la vraie store (pas necessaire ici).
-vi.mock('~/shared/stores/auth', () => ({
-    onAuthSessionCleared: vi.fn(),
-}))
-
-// Le client API est un auto-import Nuxt. On le remplace par un stub
-// global pour intercepter les appels et controler les reponses dans
-// chaque test (cf. pattern utilise dans useCurrentSite.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 vi.mock / vi.stubGlobal : le module n'est evalue qu'a
-// ce moment-la, donc le mock auth est bien actif au top-level.
-const { useCategoriesAdmin } = await import('../useCategoriesAdmin')
-
-const TYPE_VENTE: CategoryType = { id: 1, code: 'VENTE', label: 'Vente' }
-const TYPE_ACHAT: CategoryType = { id: 2, code: 'ACHAT', label: 'Achat' }
-
-const CAT_A: Category = {
-    id: 10,
-    name: 'Vis',
-    categoryType: TYPE_VENTE,
-    deletedAt: null,
-    createdAt: '2026-01-01T10:00:00+00:00',
-    updatedAt: '2026-01-01T10:00:00+00:00',
-    createdBy: null,
-    updatedBy: null,
-}
-const CAT_B: Category = {
-    id: 11,
-    name: 'Boulons',
-    categoryType: TYPE_VENTE,
-    deletedAt: null,
-    createdAt: '2026-01-02T10:00:00+00:00',
-    updatedAt: '2026-01-02T10:00:00+00:00',
-    createdBy: null,
-    updatedBy: null,
-}
-
-function makeHydra<T>(items: T[]): HydraCollection<T> {
-    return {
-        totalItems: items.length,
-        member: items,
-    }
-}
-
-describe('useCategoriesAdmin', () => {
-    beforeEach(() => {
-        mockGet.mockReset()
-        // Reset systematique du state singleton entre tests : sans ca,
-        // les categories chargees dans un test fuiteraient dans le suivant.
-        const { resetCategoriesAdmin } = useCategoriesAdmin()
-        resetCategoriesAdmin()
-    })
-
-    describe('fetchAll', () => {
-        it('appelle GET /categories avec itemsPerPage=999 par defaut', async () => {
-            mockGet.mockResolvedValueOnce(makeHydra<Category>([]))
-            const { fetchAll } = useCategoriesAdmin()
-
-            await fetchAll()
-
-            expect(mockGet).toHaveBeenCalledTimes(1)
-            expect(mockGet).toHaveBeenCalledWith(
-                '/categories',
-                { itemsPerPage: 999 },
-                { toast: false },
-            )
-        })
-
-        it('peuple categories.value depuis le champ Hydra member', async () => {
-            mockGet.mockResolvedValueOnce(makeHydra([CAT_A, CAT_B]))
-            const { fetchAll, categories } = useCategoriesAdmin()
-
-            await fetchAll()
-
-            expect(categories.value).toEqual([CAT_A, CAT_B])
-        })
-
-        it('exclut les soft-deleted par defaut (pas de query includeDeleted)', async () => {
-            mockGet.mockResolvedValueOnce(makeHydra<Category>([]))
-            const { fetchAll } = useCategoriesAdmin()
-
-            await fetchAll()
-
-            const queryArg = mockGet.mock.calls[0]?.[1] as Record<string, unknown>
-            expect(queryArg).not.toHaveProperty('includeDeleted')
-        })
-
-        it('ajoute includeDeleted=true quand demande explicitement', async () => {
-            mockGet.mockResolvedValueOnce(makeHydra<Category>([]))
-            const { fetchAll } = useCategoriesAdmin()
-
-            await fetchAll(true)
-
-            expect(mockGet).toHaveBeenCalledWith(
-                '/categories',
-                { itemsPerPage: 999, includeDeleted: 'true' },
-                { toast: false },
-            )
-        })
-
-        it('passe loading a true pendant la requete et false apres', async () => {
-            let resolveRequest: (v: HydraCollection<Category>) => void = () => {}
-            mockGet.mockImplementationOnce(
-                () => new Promise((resolve) => { resolveRequest = resolve }),
-            )
-            const { fetchAll, loading } = useCategoriesAdmin()
-
-            const pending = fetchAll()
-            expect(loading.value).toBe(true)
-
-            resolveRequest(makeHydra<Category>([]))
-            await pending
-
-            expect(loading.value).toBe(false)
-        })
-
-        it('peuple error.value et vide categories en cas d echec', async () => {
-            mockGet.mockRejectedValueOnce(new Error('Network down'))
-            const { fetchAll, categories, error, loading } = useCategoriesAdmin()
-            // Pre-charge volontairement quelque chose pour verifier la purge.
-            categories.value = [CAT_A]
-
-            await fetchAll()
-
-            expect(categories.value).toEqual([])
-            expect(error.value).toBe('Network down')
-            expect(loading.value).toBe(false)
-        })
-
-        it('gere une reponse sans champ member (fallback tableau vide)', async () => {
-            mockGet.mockResolvedValueOnce({
-                totalItems: 0,
-            } as unknown as HydraCollection<Category>)
-            const { fetchAll, categories } = useCategoriesAdmin()
-
-            await fetchAll()
-
-            expect(categories.value).toEqual([])
-        })
-    })
-
-    describe('fetchTypes', () => {
-        it('appelle GET /category_types avec itemsPerPage=999', async () => {
-            mockGet.mockResolvedValueOnce(makeHydra<CategoryType>([]))
-            const { fetchTypes } = useCategoriesAdmin()
-
-            await fetchTypes()
-
-            expect(mockGet).toHaveBeenCalledWith(
-                '/category_types',
-                { itemsPerPage: 999 },
-                { toast: false },
-            )
-        })
-
-        it('peuple types.value depuis le champ Hydra member', async () => {
-            mockGet.mockResolvedValueOnce(makeHydra([TYPE_VENTE, TYPE_ACHAT]))
-            const { fetchTypes, types } = useCategoriesAdmin()
-
-            await fetchTypes()
-
-            expect(types.value).toEqual([TYPE_VENTE, TYPE_ACHAT])
-        })
-
-        it('peuple error.value et vide types en cas d echec', async () => {
-            mockGet.mockRejectedValueOnce(new Error('500'))
-            const { fetchTypes, types, error, loadingTypes } = useCategoriesAdmin()
-            types.value = [TYPE_VENTE]
-
-            await fetchTypes()
-
-            expect(types.value).toEqual([])
-            expect(error.value).toContain('500')
-            expect(loadingTypes.value).toBe(false)
-        })
-
-        it('passe loadingTypes a true pendant la requete et false apres', async () => {
-            let resolveRequest: (v: HydraCollection<CategoryType>) => void = () => {}
-            mockGet.mockImplementationOnce(
-                () => new Promise((resolve) => { resolveRequest = resolve }),
-            )
-            const { fetchTypes, loadingTypes } = useCategoriesAdmin()
-
-            const pending = fetchTypes()
-            expect(loadingTypes.value).toBe(true)
-
-            resolveRequest(makeHydra<CategoryType>([]))
-            await pending
-
-            expect(loadingTypes.value).toBe(false)
-        })
-    })
-
-    describe('resetCategoriesAdmin', () => {
-        it('vide categories, types, loading, loadingTypes et error', () => {
-            const { resetCategoriesAdmin, categories, types, loading, loadingTypes, error }
-                = useCategoriesAdmin()
-            // Pre-peuple le state pour verifier la purge effective.
-            categories.value = [CAT_A]
-            types.value = [TYPE_VENTE]
-            loading.value = true
-            loadingTypes.value = true
-            error.value = 'oops'
-
-            resetCategoriesAdmin()
-
-            expect(categories.value).toEqual([])
-            expect(types.value).toEqual([])
-            expect(loading.value).toBe(false)
-            expect(loadingTypes.value).toBe(false)
-            expect(error.value).toBeNull()
-        })
-    })
-
-    describe('singleton', () => {
-        it('deux appels a useCategoriesAdmin() partagent la meme ref categories', () => {
-            const a = useCategoriesAdmin()
-            const b = useCategoriesAdmin()
-
-            // Les fonctions sont reinstanciees a chaque appel mais les refs
-            // doivent etre rigoureusement les memes (state au niveau module).
-            expect(a.categories).toBe(b.categories)
-            expect(a.types).toBe(b.types)
-            expect(a.loading).toBe(b.loading)
-        })
-
-        it('une mutation via une instance est visible depuis une autre instance', () => {
-            const a = useCategoriesAdmin()
-            const b = useCategoriesAdmin()
-
-            a.categories.value = [CAT_A]
-
-            expect(b.categories.value).toEqual([CAT_A])
-        })
-    })
-})

frontend/modules/catalog/composables/__tests__/useCategoryForm.spec.ts

@@ -1,454 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import type { Category, CategoryType } from '~/modules/catalog/types/category'
-import { useCategoryForm } from '../useCategoryForm'
-
-// Stubs des auto-imports Nuxt consommes par le composable.
-const mockGet = vi.hoisted(() => vi.fn())
-const mockPost = vi.hoisted(() => vi.fn())
-const mockPatch = vi.hoisted(() => vi.fn())
-const mockDelete = vi.hoisted(() => vi.fn())
-const mockToastSuccess = vi.hoisted(() => vi.fn())
-const mockToastError = vi.hoisted(() => vi.fn())
-
-vi.stubGlobal('useApi', () => ({
-    get: mockGet,
-    post: mockPost,
-    put: vi.fn(),
-    patch: mockPatch,
-    delete: mockDelete,
-}))
-vi.stubGlobal('useToast', () => ({
-    success: mockToastSuccess,
-    error: mockToastError,
-}))
-// useI18n.t : on renvoie la cle telle quelle (pratique pour asserter dessus).
-// Quand le composable passe des params (ex: doublon), on les serialise pour
-// pouvoir verifier que l'interpolation a bien recu le bon nom.
-vi.stubGlobal('useI18n', () => ({
-    t: (key: string, params?: Record<string, unknown>) =>
-        params ? `${key}::${JSON.stringify(params)}` : key,
-}))
-
-const TYPE_VENTE: CategoryType = { id: 1, code: 'VENTE', label: 'Vente' }
-const TYPE_ACHAT: CategoryType = { id: 2, code: 'ACHAT', label: 'Achat' }
-
-const CAT: Category = {
-    id: 42,
-    name: 'Vis',
-    categoryType: TYPE_VENTE,
-    deletedAt: null,
-    createdAt: '2026-01-01T10:00:00+00:00',
-    updatedAt: '2026-01-01T10:00:00+00:00',
-    createdBy: null,
-    updatedBy: null,
-}
-
-describe('useCategoryForm', () => {
-    beforeEach(() => {
-        mockGet.mockReset()
-        mockPost.mockReset()
-        mockPatch.mockReset()
-        mockDelete.mockReset()
-        mockToastSuccess.mockReset()
-        mockToastError.mockReset()
-    })
-
-    describe('loadFrom', () => {
-        it('pre-remplit le formulaire depuis une categorie existante', () => {
-            const form = useCategoryForm()
-
-            form.loadFrom(CAT)
-
-            expect(form.name.value).toBe('Vis')
-            expect(form.categoryTypeId.value).toBe(1)
-            expect(form.errors.value).toEqual({ name: '', categoryType: '', _global: '' })
-        })
-
-        it('vide le formulaire en mode creation (null)', () => {
-            const form = useCategoryForm()
-            form.name.value = 'old'
-            form.categoryTypeId.value = 99
-
-            form.loadFrom(null)
-
-            expect(form.name.value).toBe('')
-            expect(form.categoryTypeId.value).toBeNull()
-        })
-
-        it('reinitialise le snapshot initial → isDirty=false juste apres', () => {
-            const form = useCategoryForm()
-
-            form.loadFrom(CAT)
-
-            expect(form.isDirty.value).toBe(false)
-        })
-    })
-
-    describe('isDirty', () => {
-        it('passe a true des qu une valeur diverge du snapshot initial', () => {
-            const form = useCategoryForm()
-            form.loadFrom(CAT)
-            expect(form.isDirty.value).toBe(false)
-
-            form.name.value = 'Vis modifie'
-
-            expect(form.isDirty.value).toBe(true)
-        })
-    })
-
-    describe('validate', () => {
-        it('signale une erreur si name est vide (RG-1.02)', () => {
-            const form = useCategoryForm()
-            form.name.value = ''
-            form.categoryTypeId.value = 1
-
-            const ok = form.validate()
-
-            expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameRequired')
-        })
-
-        it('signale erreur si name est whitespace-only (trim → vide)', () => {
-            const form = useCategoryForm()
-            form.name.value = '   '
-            form.categoryTypeId.value = 1
-
-            const ok = form.validate()
-
-            expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameRequired')
-        })
-
-        it('signale erreur si name fait 1 caractere (< 2, RG-1.04)', () => {
-            const form = useCategoryForm()
-            form.name.value = 'A'
-            form.categoryTypeId.value = 1
-
-            const ok = form.validate()
-
-            expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameLength')
-        })
-
-        it('signale erreur si name fait 121 caracteres (> 120, RG-1.04)', () => {
-            const form = useCategoryForm()
-            form.name.value = 'A'.repeat(121)
-            form.categoryTypeId.value = 1
-
-            const ok = form.validate()
-
-            expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameLength')
-        })
-
-        it('signale erreur si categoryTypeId est null (RG-1.05)', () => {
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = null
-
-            const ok = form.validate()
-
-            expect(ok).toBe(false)
-            expect(form.errors.value.categoryType).toBe('admin.categories.validation.typeRequired')
-        })
-
-        it('passe quand name et categoryType sont valides', () => {
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            const ok = form.validate()
-
-            expect(ok).toBe(true)
-            expect(form.errors.value).toEqual({ name: '', categoryType: '', _global: '' })
-        })
-
-        it('reinitialise les erreurs avant chaque validation', () => {
-            const form = useCategoryForm()
-            // Erreur prealable.
-            form.errors.value._global = 'erreur ancienne'
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            form.validate()
-
-            expect(form.errors.value._global).toBe('')
-        })
-    })
-
-    describe('submitCreate', () => {
-        it('appelle POST /categories avec body { name trimme, categoryType en IRI }', async () => {
-            mockPost.mockResolvedValueOnce(CAT)
-            const form = useCategoryForm()
-            form.name.value = '  Vis  '
-            form.categoryTypeId.value = 1
-
-            const result = await form.submitCreate()
-
-            expect(mockPost).toHaveBeenCalledWith(
-                '/categories',
-                { name: 'Vis', categoryType: '/api/category_types/1' },
-                { toast: false },
-            )
-            expect(result).toEqual(CAT)
-        })
-
-        it('ne declenche aucun appel API si la validation client echoue', async () => {
-            const form = useCategoryForm()
-            form.name.value = ''
-            form.categoryTypeId.value = 1
-
-            const result = await form.submitCreate()
-
-            expect(mockPost).not.toHaveBeenCalled()
-            expect(result).toBeNull()
-        })
-
-        it('declenche un toast de succes en cas de creation reussie', async () => {
-            mockPost.mockResolvedValueOnce(CAT)
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            await form.submitCreate()
-
-            expect(mockToastSuccess).toHaveBeenCalledWith({
-                title: 'Succès',
-                message: 'admin.categories.toast.created',
-            })
-        })
-
-        it('mappe un 409 (RG-1.07) sur errors.name + toast erreur avec le nom', async () => {
-            mockPost.mockRejectedValueOnce({
-                response: { status: 409, _data: {} },
-            })
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            const result = await form.submitCreate()
-
-            expect(result).toBeNull()
-            // La cle est interpolee avec le nom soumis : on retrouve "Vis" dans
-            // les params i18n (stub serialise les params).
-            expect(form.errors.value.name).toContain('admin.categories.toast.duplicate')
-            expect(form.errors.value.name).toContain('"name":"Vis"')
-            expect(mockToastError).toHaveBeenCalledTimes(1)
-            const toastArg = mockToastError.mock.calls[0]?.[0] as { message: string }
-            expect(toastArg.message).toContain('Vis')
-        })
-
-        it('mappe un 422 violations sur les champs concernes (errors.name)', async () => {
-            mockPost.mockRejectedValueOnce({
-                response: {
-                    status: 422,
-                    _data: {
-                        violations: [
-                            { propertyPath: 'name', message: 'name should not be blank.' },
-                        ],
-                    },
-                },
-            })
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            const result = await form.submitCreate()
-
-            expect(result).toBeNull()
-            expect(form.errors.value.name).toBe('name should not be blank.')
-            // Pas de toast quand on a mappe les violations : l erreur est
-            // affichee inline sous le champ concerne.
-            expect(mockToastError).not.toHaveBeenCalled()
-        })
-
-        it('mappe aussi hydra:violations (negociation de format alternative)', async () => {
-            mockPost.mockRejectedValueOnce({
-                response: {
-                    status: 422,
-                    _data: {
-                        'hydra:violations': [
-                            { propertyPath: 'categoryType', message: 'Type invalide.' },
-                        ],
-                    },
-                },
-            })
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            await form.submitCreate()
-
-            expect(form.errors.value.categoryType).toBe('Type invalide.')
-        })
-
-        it('fallback en erreur globale + toast si le status n est ni 409 ni 422', async () => {
-            mockPost.mockRejectedValueOnce({
-                response: { status: 500, _data: { 'hydra:description': 'Boom server' } },
-            })
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            await form.submitCreate()
-
-            expect(form.errors.value._global).toBe('Boom server')
-            expect(mockToastError).toHaveBeenCalledWith({
-                title: 'Erreur',
-                message: 'Boom server',
-            })
-        })
-
-        it('passe submitting a true pendant la requete et a false apres', async () => {
-            let resolveRequest: (v: Category) => void = () => {}
-            mockPost.mockImplementationOnce(
-                () => new Promise((resolve) => { resolveRequest = resolve }),
-            )
-            const form = useCategoryForm()
-            form.name.value = 'Vis'
-            form.categoryTypeId.value = 1
-
-            const pending = form.submitCreate()
-            expect(form.submitting.value).toBe(true)
-
-            resolveRequest(CAT)
-            await pending
-
-            expect(form.submitting.value).toBe(false)
-        })
-    })
-
-    describe('submitUpdate', () => {
-        it('appelle PATCH /categories/{id} uniquement avec les champs modifies', async () => {
-            mockPatch.mockResolvedValueOnce({ ...CAT, name: 'Vis V2' })
-            const form = useCategoryForm()
-            form.loadFrom(CAT)
-            form.name.value = 'Vis V2' // categoryTypeId inchange
-
-            await form.submitUpdate(42)
-
-            expect(mockPatch).toHaveBeenCalledWith(
-                '/categories/42',
-                { name: 'Vis V2' }, // pas de categoryType car non modifie
-                { toast: false },
-            )
-        })
-
-        it('envoie categoryType en IRI quand seul le type a change', async () => {
-            mockPatch.mockResolvedValueOnce({ ...CAT, categoryType: TYPE_ACHAT })
-            const form = useCategoryForm()
-            form.loadFrom(CAT)
-            form.categoryTypeId.value = 2
-
-            await form.submitUpdate(42)
-
-            expect(mockPatch).toHaveBeenCalledWith(
-                '/categories/42',
-                { categoryType: '/api/category_types/2' },
-                { toast: false },
-            )
-        })
-
-        it('court-circuite l appel API si aucun champ n a change', async () => {
-            const form = useCategoryForm()
-            form.loadFrom(CAT)
-            // Aucune modification — isDirty=false, patch payload vide.
-
-            const result = await form.submitUpdate(42)
-
-            expect(mockPatch).not.toHaveBeenCalled()
-            expect(result).toBeNull()
-            expect(form.submitting.value).toBe(false)
-        })
-
-        it('declenche un toast de succes au PATCH reussi', async () => {
-            mockPatch.mockResolvedValueOnce({ ...CAT, name: 'Vis V2' })
-            const form = useCategoryForm()
-            form.loadFrom(CAT)
-            form.name.value = 'Vis V2'
-
-            await form.submitUpdate(42)
-
-            expect(mockToastSuccess).toHaveBeenCalledWith({
-                title: 'Succès',
-                message: 'admin.categories.toast.updated',
-            })
-        })
-
-        it('mappe le 409 sur errors.name en mode update aussi', async () => {
-            mockPatch.mockRejectedValueOnce({
-                response: { status: 409, _data: {} },
-            })
-            const form = useCategoryForm()
-            form.loadFrom(CAT)
-            form.name.value = 'Doublon'
-
-            const result = await form.submitUpdate(42)
-
-            expect(result).toBeNull()
-            expect(form.errors.value.name).toContain('admin.categories.toast.duplicate')
-            expect(form.errors.value.name).toContain('"name":"Doublon"')
-        })
-    })
-
-    describe('submitDelete', () => {
-        it('appelle DELETE /categories/{id} et declenche un toast succes', async () => {
-            mockDelete.mockResolvedValueOnce(undefined)
-            const form = useCategoryForm()
-
-            const ok = await form.submitDelete(42)
-
-            expect(mockDelete).toHaveBeenCalledWith('/categories/42', {}, { toast: false })
-            expect(ok).toBe(true)
-            expect(mockToastSuccess).toHaveBeenCalledWith({
-                title: 'Succès',
-                message: 'admin.categories.toast.deleted',
-            })
-        })
-
-        it('retourne false et toast erreur en cas d echec', async () => {
-            mockDelete.mockRejectedValueOnce({
-                response: { status: 500, _data: { detail: 'down' } },
-            })
-            const form = useCategoryForm()
-
-            const ok = await form.submitDelete(42)
-
-            expect(ok).toBe(false)
-            expect(form.errors.value._global).toBe('down')
-            expect(mockToastError).toHaveBeenCalled()
-        })
-    })
-
-    describe('reset', () => {
-        it('vide le formulaire et les erreurs', () => {
-            const form = useCategoryForm()
-            form.loadFrom(CAT)
-            form.name.value = 'edit'
-            form.errors.value._global = 'erreur'
-            form.submitting.value = true
-
-            form.reset()
-
-            expect(form.name.value).toBe('')
-            expect(form.categoryTypeId.value).toBeNull()
-            expect(form.errors.value).toEqual({ name: '', categoryType: '', _global: '' })
-            expect(form.submitting.value).toBe(false)
-        })
-    })
-
-    describe('isolation', () => {
-        it('deux instances useCategoryForm() ont des states independants', () => {
-            const a = useCategoryForm()
-            const b = useCategoryForm()
-
-            a.name.value = 'A'
-            b.name.value = 'B'
-
-            expect(a.name.value).toBe('A')
-            expect(b.name.value).toBe('B')
-            // Les refs sont distinctes (pas singleton — chaque drawer son state).
-            expect(a.name).not.toBe(b.name)
-        })
-    })
-})

frontend/modules/catalog/composables/useCategoriesAdmin.ts

@@ -1,126 +0,0 @@
-/**
- * Composable d'administration des categories (M0 — Gestion des categories).
- *
- * Centralise le chargement et le state des deux ressources lues par la page
- * `/admin/categories` : la liste des categories et le referentiel
- * CategoryType (utilise dans le select du drawer).
- *
- * State singleton au niveau module (meme convention que `useSidebar` /
- * `useModules` / `useAuditLog`) : reset automatique au logout via
- * `onAuthSessionCleared` (cf. CLAUDE.md regle frontend.md : « composables
- * avec state singleton doivent etre reinitialises au logout »), et reset
- * explicite expose via `resetCategoriesAdmin()` appele depuis
- * `modules/core/pages/logout.vue`.
- */
-import { ref } from 'vue'
-import type { Category, CategoryType } from '~/modules/catalog/types/category'
-import type { HydraCollection } from '~/shared/utils/api'
-import { onAuthSessionCleared } from '~/shared/stores/auth'
-
-// State singleton — partage entre tous les composants qui appellent le
-// composable dans la meme session. Les refs sont declarees au niveau module
-// (pas dans la fonction `useCategoriesAdmin()`) pour eviter qu'une nouvelle
-// instance soit creee a chaque appel.
-const categories = ref<Category[]>([])
-const types = ref<CategoryType[]>([])
-const loading = ref(false)
-const loadingTypes = ref(false)
-const error = ref<string | null>(null)
-
-function resetCategoriesAdminState(): void {
-    categories.value = []
-    types.value = []
-    loading.value = false
-    loadingTypes.value = false
-    error.value = null
-}
-
-// Auto-enregistrement singleton : purge le state sur 401/clearSession pour
-// eviter qu'un user suivant (connecte sur le meme onglet) voie l'etat de
-// l'ancien. Le logout volontaire (page logout.vue) appelle directement
-// `resetCategoriesAdmin()` ci-dessous.
-onAuthSessionCleared(resetCategoriesAdminState)
-
-export function useCategoriesAdmin() {
-    const api = useApi()
-
-    /**
-     * Charge la liste des categories. Le serveur exclut les soft-deleted par
-     * defaut (RG-1.08) et trie par name ASC (RG-1.10). Pas de pagination
-     * serveur (volumetrie ≤ 300, pagination front via MalioDataTable).
-     *
-     * `includeDeleted=true` permet a un user avec `catalog.categories.manage`
-     * de voir les soft-deleted (RG-1.09) — au M0 la page n'utilise pas cette
-     * option mais on l'expose pour la suite (corbeille future).
-     *
-     * Swallow volontaire : un 403 (user sans permission view) ne doit pas
-     * toaster — la sidebar masque deja l'entree pour ces users, on tombe sur
-     * la page seulement par URL directe et on affiche un tableau vide propre.
-     */
-    async function fetchAll(includeDeleted = false): Promise<void> {
-        loading.value = true
-        error.value = null
-        try {
-            const query: Record<string, unknown> = { itemsPerPage: 999 }
-            if (includeDeleted) {
-                query.includeDeleted = 'true'
-            }
-            const data = await api.get<HydraCollection<Category>>(
-                '/categories',
-                query,
-                { toast: false },
-            )
-            categories.value = data.member ?? []
-        } catch (e) {
-            categories.value = []
-            error.value = (e as Error)?.message ?? 'Erreur de chargement'
-        } finally {
-            loading.value = false
-        }
-    }
-
-    /**
-     * Charge le referentiel CategoryType (lecture seule, RG-1.06). Appele a
-     * l'ouverture de la page admin pour que le select du drawer ait deja les
-     * options pretes au moment de la creation/edition.
-     *
-     * Toast desactive : on stocke l'erreur dans `error` plutot que de
-     * spammer un toast — le drawer affichera l'erreur inline s'il y a lieu.
-     */
-    async function fetchTypes(): Promise<void> {
-        loadingTypes.value = true
-        try {
-            const data = await api.get<HydraCollection<CategoryType>>(
-                '/category_types',
-                { itemsPerPage: 999 },
-                { toast: false },
-            )
-            types.value = data.member ?? []
-        } catch (e) {
-            types.value = []
-            error.value = (e as Error)?.message ?? 'Erreur de chargement des types'
-        } finally {
-            loadingTypes.value = false
-        }
-    }
-
-    /**
-     * Reset explicite — appele depuis `logout.vue` apres `auth.logout()` pour
-     * garantir que la prochaine session reparte sur un state propre meme si
-     * `clearSession()` n'a pas ete declenche (cas logout volontaire).
-     */
-    function resetCategoriesAdmin(): void {
-        resetCategoriesAdminState()
-    }
-
-    return {
-        categories,
-        types,
-        loading,
-        loadingTypes,
-        error,
-        fetchAll,
-        fetchTypes,
-        resetCategoriesAdmin,
-    }
-}

frontend/modules/catalog/composables/useCategoryForm.ts

@@ -1,342 +0,0 @@
-/**
- * Composable de formulaire categorie (M0 — Gestion des categories).
- *
- * Centralise la logique de validation client + appels API (POST / PATCH /
- * DELETE) du drawer de creation/edition. Contrairement a
- * `useCategoriesAdmin` qui porte un state singleton partage entre composants,
- * ce composable est instancie par formulaire (les refs vivent dans la
- * fonction `useCategoryForm()`) — chaque drawer ouvert a son propre state
- * isole.
- *
- * Validations client en miroir des regles back (RG-1.02 / RG-1.04 / RG-1.05) :
- * elles servent juste a eviter l'aller-retour reseau evitable. Le serveur
- * revalide toujours (defense en profondeur).
- *
- * Mapping erreurs API :
- *   - 409 (RG-1.07 doublon) → toast + erreur sur le champ `name`
- *   - 422 (violations API Platform) → mapping sur les champs concernes
- *   - autre → erreur globale `_global` + toast generique
- */
-import { computed, ref } from 'vue'
-import type { Category } from '~/modules/catalog/types/category'
-
-/**
- * Forme des violations renvoyees par API Platform 4 en 422. La cle peut etre
- * `violations` ou `hydra:violations` selon la negociation de format — on
- * tente les deux.
- */
-interface ApiViolation {
-    propertyPath?: string
-    message?: string
-}
-
-/**
- * Erreur HTTP capturee par ofetch. On expose juste les champs utilises ici
- * (status et payload data) pour eviter de typer toute la lib.
- */
-interface ApiFetchError {
-    response?: {
-        status?: number
-        _data?: unknown
-    }
-}
-
-export function useCategoryForm() {
-    const api = useApi()
-    const { t } = useI18n()
-    const toast = useToast()
-
-    // State local du formulaire — pas singleton, chaque appel a useCategoryForm
-    // cree son propre state (cohérent avec le pattern « un drawer = un form »).
-    const name = ref('')
-    const categoryTypeId = ref<number | null>(null)
-
-    // Snapshot des valeurs initiales : sert a calculer `isDirty` pour le
-    // pattern view → edit du drawer (le bouton Enregistrer reste masque tant
-    // que rien n'a change en mode consultation).
-    const initialName = ref('')
-    const initialCategoryTypeId = ref<number | null>(null)
-
-    const errors = ref<{
-        name: string
-        categoryType: string
-        _global: string
-    }>({
-        name: '',
-        categoryType: '',
-        _global: '',
-    })
-
-    const submitting = ref(false)
-
-    const isDirty = computed(
-        () =>
-            name.value !== initialName.value
-            || categoryTypeId.value !== initialCategoryTypeId.value,
-    )
-
-    /**
-     * Pre-remplit le formulaire a partir d'une categorie existante (mode
-     * consultation/edition) ou vide (mode creation). Reinitialise les
-     * erreurs et le snapshot initial pour repartir d'un etat propre.
-     */
-    function loadFrom(category: Category | null): void {
-        errors.value = { name: '', categoryType: '', _global: '' }
-        if (category) {
-            name.value = category.name
-            categoryTypeId.value = category.categoryType.id
-            initialName.value = category.name
-            initialCategoryTypeId.value = category.categoryType.id
-        } else {
-            name.value = ''
-            categoryTypeId.value = null
-            initialName.value = ''
-            initialCategoryTypeId.value = null
-        }
-    }
-
-    /**
-     * Validation client miroir des RG back. Renvoie true si tout passe et
-     * peuple `errors` sinon. Le trim est applique cote client (miroir RG-1.03)
-     * mais le serveur retrim de toute facon — pas de risque de divergence.
-     */
-    function validate(): boolean {
-        errors.value = { name: '', categoryType: '', _global: '' }
-        const trimmedName = name.value.trim()
-
-        // RG-1.02 — name obligatoire (vide / whitespace-only).
-        if (trimmedName === '') {
-            errors.value.name = t('admin.categories.validation.nameRequired')
-        } else if (trimmedName.length < 2 || trimmedName.length > 120) {
-            // RG-1.04 — longueur 2-120 apres trim.
-            errors.value.name = t('admin.categories.validation.nameLength')
-        }
-
-        // RG-1.05 — categoryType obligatoire.
-        if (categoryTypeId.value === null) {
-            errors.value.categoryType = t('admin.categories.validation.typeRequired')
-        }
-
-        return errors.value.name === '' && errors.value.categoryType === ''
-    }
-
-    /**
-     * Construit le payload POST a partir du state. Le `categoryType` est
-     * envoye en IRI Hydra (`/api/category_types/{id}`) — convention API
-     * Platform pour referencer une ressource liee. Retourne un object literal
-     * compatible avec `AnyObject` de `useApi()` (un type nomme strict comme
-     * `CategoryCreateInput` ne serait pas assignable a `Record<string, unknown>`
-     * en TS strict).
-     */
-    function buildCreatePayload(): Record<string, unknown> {
-        return {
-            name: name.value.trim(),
-            categoryType: `/api/category_types/${categoryTypeId.value}`,
-        }
-    }
-
-    /**
-     * Mappe une reponse 422 API Platform sur le state `errors`. API Platform 4
-     * retourne `violations: [{ propertyPath, message }]` (ou
-     * `hydra:violations` selon negociation). On ne mappe que les chemins
-     * connus (`name`, `categoryType`) ; le reste fallback en erreur globale.
-     */
-    function mapServerViolations(data: unknown): boolean {
-        if (!data || typeof data !== 'object') return false
-        const record = data as Record<string, unknown>
-        const rawViolations = record.violations ?? record['hydra:violations']
-        if (!Array.isArray(rawViolations)) return false
-
-        let mapped = false
-        for (const v of rawViolations as ApiViolation[]) {
-            if (!v || typeof v !== 'object') continue
-            const path = String(v.propertyPath ?? '')
-            const message = String(v.message ?? '')
-            if (path === 'name') {
-                errors.value.name = message
-                mapped = true
-            } else if (path === 'categoryType') {
-                errors.value.categoryType = message
-                mapped = true
-            }
-        }
-        return mapped
-    }
-
-    /**
-     * Extrait un message d'erreur lisible depuis un payload Hydra (champs
-     * `hydra:description`, `detail`, `description`).
-     */
-    function extractErrorMessage(data: unknown): string {
-        if (!data || typeof data !== 'object') return ''
-        const record = data as Record<string, unknown>
-        return (
-            (record['hydra:description'] as string)
-            ?? (record.detail as string)
-            ?? (record.description as string)
-            ?? ''
-        )
-    }
-
-    /**
-     * Traite une erreur API : mappe selon le status, declenche les toasts
-     * appropries. Centralise la logique entre create/update.
-     *
-     * Retourne true si l'erreur a ete reconnue et traitee, false sinon
-     * (utile pour les tests).
-     */
-    function handleApiError(e: unknown, attemptedName: string): boolean {
-        const status = (e as ApiFetchError)?.response?.status
-        const data = (e as ApiFetchError)?.response?._data
-
-        if (status === 409) {
-            // RG-1.07 — doublon (name, categoryType). Toast custom +
-            // erreur mappee sur le champ name (origine du conflit).
-            const duplicateMessage = t('admin.categories.toast.duplicate', {
-                name: attemptedName,
-            })
-            errors.value.name = duplicateMessage
-            toast.error({
-                title: 'Erreur',
-                message: duplicateMessage,
-            })
-            return true
-        }
-
-        if (status === 422 && mapServerViolations(data)) {
-            // Violations mappees sur les champs — pas de toast, l'utilisateur
-            // voit l'erreur directement sous le champ concerne.
-            return true
-        }
-
-        const extracted = extractErrorMessage(data)
-        errors.value._global = extracted || 'Une erreur est survenue.'
-        toast.error({
-            title: 'Erreur',
-            message: errors.value._global,
-        })
-        return false
-    }
-
-    /**
-     * POST /api/categories. Renvoie la categorie creee, ou `null` si la
-     * validation client a echoue ou si le serveur a renvoye une erreur. Le
-     * caller (drawer) decide quoi faire en fonction (fermer ou rester ouvert).
-     */
-    async function submitCreate(): Promise<Category | null> {
-        if (!validate()) return null
-        submitting.value = true
-        errors.value._global = ''
-        const payload = buildCreatePayload()
-        try {
-            const created = await api.post<Category>('/categories', payload, {
-                toast: false,
-            })
-            toast.success({
-                title: 'Succès',
-                message: t('admin.categories.toast.created'),
-            })
-            return created
-        } catch (e) {
-            handleApiError(e, String(payload.name))
-            return null
-        } finally {
-            submitting.value = false
-        }
-    }
-
-    /**
-     * PATCH /api/categories/{id}. Envoie uniquement les champs modifies pour
-     * coller a la semantique merge-patch (Content-Type pose par useApi).
-     * Renvoie la categorie mise a jour, ou `null` en cas d'echec.
-     */
-    async function submitUpdate(id: number): Promise<Category | null> {
-        if (!validate()) return null
-        submitting.value = true
-        errors.value._global = ''
-        const payload: Record<string, unknown> = {}
-        if (name.value !== initialName.value) {
-            payload.name = name.value.trim()
-        }
-        if (categoryTypeId.value !== initialCategoryTypeId.value) {
-            payload.categoryType = `/api/category_types/${categoryTypeId.value}`
-        }
-        // Garde-fou : un PATCH sans changement ne sert a rien. Theoriquement
-        // empeche par le drawer (bouton Enregistrer masque si !isDirty) mais
-        // on protege le composable contre un appel direct mal utilise.
-        if (Object.keys(payload).length === 0) {
-            submitting.value = false
-            return null
-        }
-        try {
-            const updated = await api.patch<Category>(`/categories/${id}`, payload, {
-                toast: false,
-            })
-            toast.success({
-                title: 'Succès',
-                message: t('admin.categories.toast.updated'),
-            })
-            return updated
-        } catch (e) {
-            const attemptedName = typeof payload.name === 'string'
-                ? payload.name
-                : name.value.trim()
-            handleApiError(e, attemptedName)
-            return null
-        } finally {
-            submitting.value = false
-        }
-    }
-
-    /**
-     * DELETE /api/categories/{id} → soft delete (RG-1.12). Le serveur pose
-     * `deleted_at = now()` et retourne 204. Renvoie true en cas de succes,
-     * false sinon (avec toast erreur deja affiche).
-     */
-    async function submitDelete(id: number): Promise<boolean> {
-        submitting.value = true
-        errors.value._global = ''
-        try {
-            await api.delete(`/categories/${id}`, {}, { toast: false })
-            toast.success({
-                title: 'Succès',
-                message: t('admin.categories.toast.deleted'),
-            })
-            return true
-        } catch (e) {
-            handleApiError(e, name.value)
-            return false
-        } finally {
-            submitting.value = false
-        }
-    }
-
-    /**
-     * Reset complet du formulaire — utilise par le drawer apres save ou
-     * fermeture pour ne pas garder de donnees stale entre deux ouvertures.
-     */
-    function reset(): void {
-        name.value = ''
-        categoryTypeId.value = null
-        initialName.value = ''
-        initialCategoryTypeId.value = null
-        errors.value = { name: '', categoryType: '', _global: '' }
-        submitting.value = false
-    }
-
-    return {
-        // State
-        name,
-        categoryTypeId,
-        errors,
-        submitting,
-        isDirty,
-        // Methods
-        loadFrom,
-        validate,
-        submitCreate,
-        submitUpdate,
-        submitDelete,
-        reset,
-    }
-}

frontend/modules/catalog/pages/admin/categories.vue

@@ -13,9 +13,12 @@
             </template>
         </PageHeader>
 
-        <!-- Table des categories : tri par defaut sur Nom ASC (RG-1.10).
-             Tri serveur applique a la requete + pagination front via
-             MalioDataTable (volumetrie cible <= 300, cf. spec § 4.1). -->
+        <!-- Table des categories. Affichage exhaustif (volumetrie cible
+             <= 300, cf. spec § 4.1) — tri 100% serveur via CategoryProvider
+             (name ASC, RG-1.10). La barre de pagination du MalioDataTable
+             reste cosmetique tant qu'aucun slice client n'est cable : a
+             traiter cote @malio/layer-ui le jour ou la volumetrie monte. -->
+
         <MalioDataTable
             :columns="columns"
             :items="categoryItems"
@@ -45,16 +48,18 @@
 
 <script setup lang="ts">
 import type { Category } from '~/modules/catalog/types/category'
+import type { HydraCollection } from '~/shared/utils/api'
 
 const { t } = useI18n()
+const api = useApi()
 const { can } = usePermissions()
-const { categories, fetchAll, fetchTypes } = useCategoriesAdmin()
-const { submitDelete } = useCategoryForm()
 
 useHead({ title: t('admin.categories.title') })
 
 const canManage = computed(() => can('catalog.categories.manage'))
 
+const categories = ref<Category[]>([])
+const loading = ref(false)
 const drawerOpen = ref(false)
 const selectedCategory = ref<Category | null>(null)
 const deleteModalOpen = ref(false)
@@ -85,6 +90,35 @@ function onRowClick(item: Record<string, unknown>) {
     if (category) openEditDrawer(category)
 }
 
+/**
+ * Charge la liste des categories. Le serveur exclut les soft-deleted par
+ * defaut (RG-1.08) et trie par name ASC (RG-1.10). Pas de pagination
+ * serveur (volumetrie cible <= 300) ni de slice client — toute la liste
+ * est rendue d'un coup ; la barre du MalioDataTable est donc cosmetique
+ * jusqu'a la mise a jour layer-ui (ticket ERP-70).
+ *
+ * Logique inline volontaire au M0 (decision prompt ERP-49) : extraction
+ * en composable `useCategoriesAdmin` au ticket 0.8 (ERP-50).
+ */
+async function loadCategories(): Promise<void> {
+    loading.value = true
+    try {
+        const data = await api.get<HydraCollection<Category>>(
+            '/categories',
+            { itemsPerPage: 999 },
+            { toast: false },
+        )
+        categories.value = data.member ?? []
+    } catch {
+        // Reset sur echec pour ne pas afficher de donnees stale. Pas de
+        // toast : un user sans permission view recoit 403 et voit une
+        // liste vide propre — le mecanisme de gating se fait cote sidebar.
+        categories.value = []
+    } finally {
+        loading.value = false
+    }
+}
+
 function openCreateDrawer() {
     selectedCategory.value = null
     drawerOpen.value = true
@@ -102,36 +136,32 @@ function onDeleteRequest() {
 }
 
 /**
- * Soft delete via le composable de form (qui gere toast + erreur). Refresh
- * de la liste a la fin pour retirer la ligne. L'index unique partiel
- * autorise une recreation ulterieure avec le meme couple (name, type) —
- * RG-1.07.
+ * DELETE /api/categories/{id} → soft delete (RG-1.12). Le serveur pose
+ * `deleted_at = now()` et retourne 204. Refresh de la liste a la fin
+ * pour retirer la ligne (l'index unique partiel autorise une recreation
+ * ulterieure avec le meme couple (name, type) — RG-1.07).
  */
 async function handleDelete(): Promise<void> {
     if (!categoryToDelete.value) return
     deleting.value = true
     try {
-        const ok = await submitDelete(categoryToDelete.value.id)
-        if (ok) {
-            deleteModalOpen.value = false
-            categoryToDelete.value = null
-            drawerOpen.value = false
-            await fetchAll()
-        }
+        await api.delete(`/categories/${categoryToDelete.value.id}`, {}, {
+            toastSuccessMessage: t('admin.categories.toast.deleted'),
+        })
+        deleteModalOpen.value = false
+        categoryToDelete.value = null
+        drawerOpen.value = false
+        await loadCategories()
     } finally {
         deleting.value = false
     }
 }
 
 function onCategorySaved() {
-    fetchAll()
+    loadCategories()
 }
 
-// Chargement initial des deux ressources (liste + referentiel des types).
-// Le referentiel est pre-charge ici (et pas dans le drawer) pour que le
-// select soit pret au moment ou l'utilisateur clique sur « + Ajouter ».
 onMounted(() => {
-    fetchAll()
-    fetchTypes()
+    loadCategories()
 })
 </script>

frontend/modules/core/pages/logout.vue

@@ -12,7 +12,6 @@ const { resetSidebar } = useSidebar()
 const { resetModules } = useModules()
 const { resetCurrentSite } = useCurrentSite()
 const { resetAuditLog } = useAuditLog()
-const { resetCategoriesAdmin } = useCategoriesAdmin()
 
 onMounted(async () => {
     try {
@@ -28,7 +27,6 @@ onMounted(async () => {
         resetModules()
         resetCurrentSite()
         resetAuditLog()
-        resetCategoriesAdmin()
         await navigateTo('/login')
     }
 })