feat(audit) : extend audit logging to machines, constructeurs, model types, documents and conversions

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

DEPLOY.md

@@ -0,0 +1,328 @@
+# Inventory - Guide de Déploiement & Release
+
+## Architecture
+
+```
+inventory.malio-dev.fr/     → Frontend Nuxt (statique)
+inventory.malio-dev.fr/api  → Backend Symfony (PHP-FPM)
+```
+
+| Composant | Technologie | Emplacement serveur |
+|-----------|-------------|---------------------|
+| Backend | Symfony 8 + API Platform | `/var/www/Inventory/` |
+| Frontend | Nuxt 4 (statique) | `/var/www/Inventory/Inventory_frontend/.output/public/` |
+| Base de données | PostgreSQL 16 | `inventory` |
+
+---
+
+## Prérequis serveur
+
+- **OS** : Ubuntu/Debian
+- **PHP** : 8.4 avec extensions : pgsql, intl, zip, gd, mbstring, curl
+- **Node.js** : 20+
+- **Nginx**
+- **PostgreSQL** : 16
+- **Composer**
+
+Vérifier :
+```bash
+php -v                    # PHP 8.4+
+php -m | grep -E 'pgsql|intl|zip|gd|mbstring'
+node -v                   # Node 20+
+nginx -v
+psql --version
+composer --version
+```
+
+---
+
+## Déploiement initial
+
+### 1. Cloner le projet
+
+```bash
+cd /var/www
+sudo git clone --recurse-submodules gitea@gitea.malio.fr:MALIO-DEV/Inventory.git Inventory
+sudo chown -R malio:malio Inventory
+cd Inventory
+git checkout master
+git submodule update --init --recursive
+```
+
+### 2. Créer la base de données
+
+```bash
+sudo -u postgres psql
+
+CREATE DATABASE inventory OWNER ferme_user;
+GRANT ALL PRIVILEGES ON DATABASE inventory TO ferme_user;
+\q
+```
+
+Importer le dump :
+```bash
+# Copier le dump depuis le PC local
+scp backup_v1.0.0_clean.sql malio@192.168.0.159:/tmp/
+
+# Importer
+psql -U ferme_user -h 127.0.0.1 -d inventory -f /tmp/backup_v1.0.0_clean.sql
+```
+
+### 3. Configurer le backend Symfony
+
+```bash
+cd /var/www/Inventory
+
+# Installer les dépendances
+composer install --no-dev --optimize-autoloader
+
+# Créer .env.local
+cat > .env.local << 'EOF'
+APP_ENV=prod
+APP_DEBUG=0
+APP_SECRET=CHANGE_ME
+
+DATABASE_URL="postgresql://ferme_user:fermerecette@127.0.0.1:5432/inventory?serverVersion=16"
+
+CORS_ALLOW_ORIGIN='^https?://inventory\.malio-dev\.fr$'
+
+JWT_SECRET_KEY=%kernel.project_dir%/config/jwt/private.pem
+JWT_PUBLIC_KEY=%kernel.project_dir%/config/jwt/public.pem
+JWT_PASSPHRASE=inventoryjwt
+EOF
+
+# Générer APP_SECRET
+sed -i "s/CHANGE_ME/$(openssl rand -hex 32)/" .env.local
+
+# Générer les clés JWT
+mkdir -p config/jwt
+openssl genrsa -out config/jwt/private.pem -aes256 4096
+# Passphrase : inventoryjwt
+openssl rsa -pubout -in config/jwt/private.pem -out config/jwt/public.pem
+chmod 600 config/jwt/private.pem
+
+# Permissions
+sudo chown -R www-data:www-data var/
+sudo chmod -R 775 var/
+
+# Vider le cache
+php bin/console cache:clear --env=prod
+```
+
+### 4. Configurer le frontend Nuxt
+
+```bash
+cd /var/www/Inventory/Inventory_frontend
+
+# Permissions
+sudo chown -R malio:malio .
+
+# Installer les dépendances
+npm install
+
+# Créer .env
+cat > .env << 'EOF'
+NUXT_PUBLIC_API_BASE_URL=http://inventory.malio-dev.fr/api
+EOF
+
+# Générer le site statique
+npx nuxi generate
+```
+
+### 5. Configurer Nginx
+
+```bash
+sudo nano /etc/nginx/sites-available/inventory
+```
+
+Contenu :
+```nginx
+server {
+    listen 80;
+    server_name inventory.malio-dev.fr;
+
+    # Gros fichiers (100MB max)
+    client_max_body_size 100M;
+    client_body_timeout 300s;
+    send_timeout 300s;
+
+    access_log /var/log/nginx/inventory-access.log;
+    error_log /var/log/nginx/inventory-error.log;
+
+    # Backend Symfony - /api
+    location /api {
+        root /var/www/Inventory/public;
+        try_files $uri /index.php$is_args$args;
+    }
+
+    location ~ ^/index\.php(/|$) {
+        fastcgi_pass unix:/run/php/php-fpm.sock;
+        fastcgi_split_path_info ^(.+\.php)(/.*)$;
+        include fastcgi_params;
+        fastcgi_param SCRIPT_FILENAME /var/www/Inventory/public/index.php;
+        fastcgi_param DOCUMENT_ROOT /var/www/Inventory/public;
+        fastcgi_read_timeout 300s;
+        internal;
+    }
+
+    # Frontend statique
+    location / {
+        root /var/www/Inventory/Inventory_frontend/.output/public;
+        index index.html;
+        try_files $uri $uri/ /index.html;
+    }
+}
+```
+
+Activer :
+```bash
+sudo ln -s /etc/nginx/sites-available/inventory /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+### 6. Vérifier
+
+```bash
+curl http://inventory.malio-dev.fr
+curl http://inventory.malio-dev.fr/api
+```
+
+---
+
+## Mises à jour
+
+### Mettre à jour l'application
+
+```bash
+cd /var/www/Inventory
+
+# Pull les changements
+git pull
+git submodule update --init --recursive
+
+# Backend
+composer install --no-dev --optimize-autoloader
+php bin/console cache:clear --env=prod
+sudo chown -R www-data:www-data var/
+
+# Frontend
+cd Inventory_frontend
+npm install
+npx nuxi generate
+```
+
+---
+
+## Versioning & Releases
+
+### Source de vérité
+
+Le fichier `VERSION` à la racine contient le numéro de version (ex: `1.0.0`).
+
+Cette version est synchronisée avec :
+- Le footer de l'application
+- `config/packages/api_platform.yaml`
+
+### Créer une release
+
+```bash
+# Depuis le PC de dev
+./scripts/release.sh patch   # 1.0.0 → 1.0.1
+./scripts/release.sh minor   # 1.0.0 → 1.1.0
+./scripts/release.sh major   # 1.0.0 → 2.0.0
+./scripts/release.sh 2.0.0   # Version exacte
+```
+
+Le script :
+1. Vérifie/commit le submodule frontend
+2. Met à jour `VERSION` et `api_platform.yaml`
+3. Commit et tag les deux repos
+4. Affiche les commandes pour push
+
+### Pousser la release
+
+```bash
+# Frontend (submodule)
+cd Inventory_frontend && git push && git push --tags && cd ..
+
+# Backend
+git push && git push --tags
+```
+
+### Créer la release sur Gitea
+
+1. Aller sur le dépôt Gitea
+2. **Releases** > **New Release**
+3. Sélectionner le tag `vX.Y.Z`
+4. Ajouter les notes de release
+
+---
+
+## Commandes utiles
+
+```bash
+# Logs Nginx
+tail -f /var/log/nginx/inventory-error.log
+
+# Logs Symfony
+tail -f /var/www/Inventory/var/log/prod.log
+
+# Vider le cache Symfony
+php /var/www/Inventory/bin/console cache:clear --env=prod
+
+# Rebuild frontend
+cd /var/www/Inventory/Inventory_frontend && npx nuxi generate
+
+# Status PHP-FPM
+systemctl status php8.4-fpm
+
+# Reload Nginx
+sudo systemctl reload nginx
+```
+
+---
+
+## Backup base de données
+
+### Export
+```bash
+pg_dump -U ferme_user -h 127.0.0.1 -d inventory --no-owner --no-acl --inserts --column-inserts --clean --if-exists > backup_inventory_$(date +%Y%m%d).sql
+```
+
+### Import
+```bash
+psql -U ferme_user -h 127.0.0.1 -d inventory -f backup_inventory_YYYYMMDD.sql
+```
+
+---
+
+## Troubleshooting
+
+### Erreur 502 Bad Gateway
+```bash
+# Vérifier PHP-FPM
+systemctl status php8.4-fpm
+sudo systemctl restart php8.4-fpm
+```
+
+### Erreur 403 Forbidden
+```bash
+# Vérifier les permissions
+sudo chown -R www-data:www-data /var/www/Inventory/var/
+sudo chmod -R 775 /var/www/Inventory/var/
+```
+
+### Erreur API "No route found"
+```bash
+# Vider le cache
+php /var/www/Inventory/bin/console cache:clear --env=prod
+```
+
+### Frontend ne se met pas à jour
+```bash
+# Rebuild
+cd /var/www/Inventory/Inventory_frontend
+rm -rf .output
+npx nuxi generate
+```

README.md

@@ -44,6 +44,35 @@ make dev-nuxt
 ```
 Le front sera accessible sur http://localhost:3000
 
+## Compression automatique des PDFs
+
+Les documents PDF uploadés sont automatiquement compressés sans perte de qualité grâce à **qpdf**.
+
+### Prérequis
+```bash
+# Installation de qpdf (outil système)
+sudo apt install qpdf
+
+# Ou dans Docker
+docker exec -it php-inventory-apache apt update && apt install -y qpdf
+```
+
+### Fonctionnement
+- À chaque upload de PDF, le système compresse automatiquement le fichier
+- Compression lossless (sans perte de qualité)
+- Le PDF est compressé uniquement si la taille diminue
+- Si qpdf n'est pas installé, le système fonctionne normalement sans compression
+
+### Compresser les PDFs existants
+Pour compresser tous les PDFs déjà en base :
+```bash
+# Voir ce qui serait compressé (dry-run)
+php bin/console app:compress-pdf --dry-run
+
+# Compresser tous les PDFs
+php bin/console app:compress-pdf
+```
+
 ## Commandes utiles
 Pour restart le container
 ```bash

REFACTORING_PLAN.md

@@ -0,0 +1,786 @@
+# Plan de Refactoring - Inventory v1.2.0
+
+> **Date de creation :** 2026-02-03
+> **Branche de travail :** `refacto/v1.3.0`
+> **Base :** `develop` (commit `8d83076`)
+
+---
+
+## Legende des statuts
+
+| Statut | Signification          |
+| ------ | ---------------------- |
+| `[ ]`  | A faire                |
+| `[~]`  | En cours               |
+| `[x]`  | Termine                |
+| `[!]`  | Bloque / besoin d'info |
+
+---
+
+## Phase 1 - Securite (CRITIQUE)
+
+> **Priorite :** MAXIMALE - A traiter en premier
+
+### 1.1 Corriger la configuration de securite
+
+- **Statut :** `[ ]`
+- **Fichier :** `config/packages/security.yaml`
+- **Probleme :** `PUBLIC_ACCESS` applique a toutes les routes `/api` avant la regle `IS_AUTHENTICATED_FULLY`. Le pattern matching "first match wins" rend potentiellement tout public.
+- **Action :** Reordonner les regles `access_control` pour que les routes protegees soient listees AVANT les routes publiques.
+- **Agent :** -
+- **Notes :** -
+
+### 1.2 Ajouter les controles d'autorisation sur les controllers
+
+- **Statut :** `[ ]`
+- **Fichiers :**
+    - `src/Controller/MachineSkeletonController.php`
+    - `src/Controller/CustomFieldValueController.php`
+    - `src/Controller/DocumentQueryController.php`
+    - `src/Controller/SessionProfileController.php`
+    - `src/Controller/SessionProfilesController.php`
+    - Tous les `*HistoryController.php`
+- **Probleme :** Aucun attribut `#[IsGranted]` sur les controllers custom. Pas de RBAC.
+- **Action :** Ajouter `#[IsGranted('IS_AUTHENTICATED_FULLY')]` sur chaque controller (ou route). Definir des roles si necessaire.
+- **Agent :** -
+- **Notes :** -
+
+### 1.3 Securiser les secrets
+
+- **Statut :** `[ ]`
+- **Fichiers :**
+    - `.env` (JWT_PASSPHRASE en dur, APP_SECRET vide)
+    - `docker/.env.docker` (credentials `root:root`)
+- **Action :**
+    1. Deplacer `JWT_PASSPHRASE` dans `.env.local` (git-ignore)
+    2. Generer un `APP_SECRET` valide
+    3. Ajouter `.env.local` dans `.gitignore` si pas deja fait
+    4. Documenter la configuration des secrets pour les devs
+- **Agent :** -
+- **Notes :** -
+
+---
+
+## Phase 2 - Elimination de la duplication de code
+
+> **Priorite :** HAUTE - Impact direct sur la maintenabilite
+
+### 2.1 Refactorer les 3 Audit Subscribers en un seul generique
+
+- **Statut :** `[ ]`
+- **Fichiers concernes :**
+    - `src/EventSubscriber/ProductAuditSubscriber.php` (298 LOC)
+    - `src/EventSubscriber/PieceAuditSubscriber.php` (300 LOC)
+    - `src/EventSubscriber/ComposantAuditSubscriber.php` (300 LOC)
+- **Probleme :** ~900 LOC dupliquees a ~95%. Les methodes `onFlush()`, `buildDiffFromChangeSet()`, `resolveActorProfileId()`, `mergeDiffs()`, `normalizeCollection()` sont identiques. Seules les methodes `snapshot*()` different legerement.
+- **Action :**
+    1. Creer un `AbstractAuditSubscriber` ou un `GenericAuditSubscriber` parametrable
+    2. Extraire la logique commune (onFlush, buildDiff, resolveActor, mergeDiffs, normalizeCollection)
+    3. Utiliser un systeme de configuration par entite (map `entityClass => entityType + snapshotMethod`)
+    4. Supprimer les 3 fichiers redondants
+    5. Verifier que l'audit fonctionne toujours sur Product, Piece et Composant
+- **Agent :** -
+- **Notes :** Tester manuellement les logs d'audit apres refacto.
+
+### 2.2 Extraire un CuidGenerator utilitaire
+
+- **Statut :** `[ ]`
+- **Fichiers concernes :** 18 entites contenant `generateCuid()` en prive
+- **Probleme :** Methode `generateCuid()` dupliquee dans chaque entite. De plus, `AuditLog.php` utilise une variante differente (base_convert).
+- **Action :**
+    1. Creer `src/Util/CuidGenerator.php` avec une methode statique `generate(): string`
+    2. Uniformiser l'implementation (choisir une seule methode)
+    3. Remplacer tous les appels dans les 18 entites
+    4. Supprimer les methodes privees devenues inutiles
+- **Agent :** -
+- **Notes :** Attention a l'inconsistance entre AuditLog et les autres entites.
+
+### 2.3 Factoriser la logique de liaison dans MachineSkeletonController
+
+- **Statut :** `[ ]`
+- **Fichier :** `src/Controller/MachineSkeletonController.php` (756 LOC)
+- **Probleme :** Les methodes `applyComponentLinks()`, `applyPieceLinks()`, `applyProductLinks()` sont quasi identiques (~90 LOC chacune).
+- **Action :**
+    1. Extraire une methode generique `applyLinks(Machine $machine, array $links, string $type)`
+    2. Parametrer par le type d'entite liee (Composant, Piece, Product)
+    3. Reduire le controller a ~400 LOC max
+- **Agent :** -
+- **Notes :** -
+
+---
+
+## Phase 3 - Restructuration des controllers
+
+> **Priorite :** MOYENNE - Amelioration de la lisibilite et maintenabilite
+
+### 3.1 Decouper MachineSkeletonController
+
+- **Statut :** `[ ]`
+- **Fichier :** `src/Controller/MachineSkeletonController.php` (756 LOC)
+- **Action :**
+    1. Extraire la logique metier dans un `MachineSkeletonService`
+    2. Le controller ne doit gerer que la requete/reponse HTTP
+    3. Le service gere la logique de skeleton (get, update, applyLinks)
+    4. Extraire les helpers (`resolveIdentifier`, `indexLinksById`, `applyOverrides`, `normalizeMachineSkeletonResponse`) dans le service
+- **Agent :** -
+- **Notes :** Depend de la phase 2.3 (factorisation des liens).
+
+### 3.2 Ajouter un try-catch et du logging dans les controllers
+
+- **Statut :** `[ ]`
+- **Fichiers :** Tous les controllers dans `src/Controller/`
+- **Probleme :** Aucun try-catch autour des `flush()` et `persist()`. Pas de logging d'erreurs.
+- **Action :**
+    1. Ajouter `try-catch` autour des operations Doctrine dans chaque controller
+    2. Logger les erreurs avec le `LoggerInterface` de Symfony (Monolog)
+    3. Retourner des reponses JSON coherentes en cas d'erreur serveur (500)
+- **Agent :** -
+- **Notes :** -
+
+### 3.3 Renforcer la validation des entrees
+
+- **Statut :** `[ ]`
+- **Fichiers :**
+    - `src/Controller/CustomFieldValueController.php`
+    - `src/Controller/MachineSkeletonController.php`
+- **Probleme :** Pas de validation de longueur max, pas de regex sur les IDs, pas de controle de profondeur JSON.
+- **Action :**
+    1. Valider le format des IDs (regex CUID : `/^cl[a-f0-9]{24}$/`)
+    2. Ajouter des limites de longueur sur les champs string
+    3. Utiliser le composant Validator de Symfony pour les DTOs si pertinent
+- **Agent :** -
+- **Notes :** -
+
+---
+
+## Phase 4 - Amelioration du stockage
+
+> **Priorite :** MOYENNE - Performance et scalabilite
+
+### 4.1 Migrer le stockage PDF de base64 vers le filesystem
+
+- **Statut :** `[ ]`
+- **Fichiers :**
+    - `src/Entity/Document.php`
+    - `src/Command/CompressPdfCommand.php`
+    - `src/Service/PdfCompressorService.php`
+- **Probleme :** Les PDFs sont stockes en base64 dans la colonne `path` (TEXT) de la BDD. Risque de DoS et mauvaise perf sur des gros fichiers.
+- **Action :**
+    1. Utiliser `vich/uploader-bundle` (deja installe) pour le stockage fichier
+    2. Configurer un repertoire de stockage (`var/uploads/documents/`)
+    3. Migrer les documents existants (script de migration)
+    4. Adapter `PdfCompressorService` pour lire/ecrire sur le filesystem
+    5. Mettre a jour l'entite Document
+- **Agent :** -
+- **Notes :** Prevoir une migration de donnees pour les documents existants.
+
+### 4.2 Corriger les types de prix (string -> decimal)
+
+- **Statut :** `[ ]`
+- **Fichiers :**
+    - `src/Entity/Machine.php` (`$prix`)
+    - `src/Entity/Product.php` (`$supplierPrice`)
+- **Probleme :** Les prix sont types `?string` en PHP alors que la colonne est `DECIMAL(10,2)` en BDD.
+- **Action :**
+    1. Changer le type PHP en `?float` ou utiliser `brick/money`
+    2. Adapter les getters/setters
+    3. Verifier la serialisation API Platform
+- **Agent :** -
+- **Notes :** Impact potentiel sur le frontend (format des nombres).
+
+---
+
+## Phase 5 - Utilisation du Process Component
+
+> **Priorite :** BASSE - Bonne pratique
+
+### 5.1 Remplacer exec() par Symfony Process
+
+- **Statut :** `[ ]`
+- **Fichiers :**
+    - `src/Command/CompressPdfCommand.php` (lignes 42, 98-101)
+    - `src/Service/PdfCompressorService.php` (lignes 37-41)
+- **Probleme :** Utilisation de `exec()` directe pour appeler `qpdf`.
+- **Action :**
+    1. Remplacer par `Symfony\Component\Process\Process`
+    2. Gerer le timeout et les erreurs proprement
+    3. Tester que la compression fonctionne toujours
+- **Agent :** -
+- **Notes :** `escapeshellarg()` est deja utilise, donc pas de faille de securite immediate.
+
+---
+
+## Phase 6 - Tests
+
+> **Priorite :** HAUTE - Indispensable avant toute refacto majeure
+
+### 6.1 Mettre en place les tests unitaires
+
+- **Statut :** `[ ]`
+- **Fichiers a creer :**
+    - `tests/Unit/Util/CuidGeneratorTest.php`
+    - `tests/Unit/Entity/MachineTest.php`
+    - `tests/Unit/Entity/ProductTest.php`
+    - `tests/Unit/Service/PdfCompressorServiceTest.php`
+- **Action :**
+    1. Tester le CuidGenerator (format, unicite)
+    2. Tester les entites (validation, lifecycle callbacks)
+    3. Tester le PdfCompressorService
+- **Agent :** -
+- **Notes :** -
+
+### 6.2 Mettre en place les tests fonctionnels (API)
+
+- **Statut :** `[ ]`
+- **Fichiers a creer :**
+    - `tests/Functional/Api/MachineTest.php`
+    - `tests/Functional/Api/ProductTest.php`
+    - `tests/Functional/Api/AuthenticationTest.php`
+    - `tests/Functional/Api/MachineSkeletonTest.php`
+- **Action :**
+    1. Configurer une base de test (SQLite ou PostgreSQL de test)
+    2. Creer des fixtures de test
+    3. Tester les endpoints CRUD
+    4. Tester l'authentification JWT
+    5. Tester les endpoints custom (skeleton, custom fields)
+- **Agent :** -
+- **Notes :** Utiliser `ApiTestCase` de API Platform.
+
+### 6.3 Tests des Audit Subscribers
+
+- **Statut :** `[ ]`
+- **Fichiers a creer :**
+    - `tests/Unit/EventSubscriber/AuditSubscriberTest.php`
+- **Action :**
+    1. Tester la creation de logs sur insert/update/delete
+    2. Tester le format des diffs et snapshots
+    3. Tester la resolution de l'acteur
+- **Agent :** -
+- **Notes :** A faire APRES la phase 2.1 (refacto des subscribers).
+
+---
+
+## Phase 7 - Nett oyage et conventions
+
+> **Priorite :** BASSE - Polish final
+
+### 7.1 Supprimer les fichiers inutiles
+
+- **Statut :** `[ ]`
+- **Fichiers a verifier :**
+    - `frontend/` (dossier legacy ? vs `Inventory_frontend/`)
+    - `src/ApiResource/` (repertoire vide)
+    - Fichiers SQL a la racine (`backup_v1.0.0.sql`, `data_norm.sql`, `fullasse.sql`, `fulldata.sql`)
+- **Action :** Confirmer avec l'equipe quels fichiers sont obsoletes et les supprimer.
+- **Agent :** -
+- **Notes :** Ne pas supprimer sans validation.
+
+### 7.2 Uniformiser la gestion des null
+
+- **Statut :** `[ ]`
+- **Fichiers :** Toutes les entites dans `src/Entity/`
+- **Action :** S'assurer que les types nullable sont coherents entre PHP et la BDD (colonnes NOT NULL vs nullable).
+- **Agent :** -
+- **Notes :** -
+
+---
+
+---
+
+# FRONTEND (`Inventory_frontend/`)
+
+---
+
+## Phase F1 - Decoupage des mega-composants (CRITIQUE)
+
+> **Priorite :** MAXIMALE - Les fichiers actuels sont inmaintenables
+
+### F1.1 Decouper `machine/[id].vue` (2989 LOC → 219 LOC)
+
+- **Statut :** `[x]`
+- **Fichier :** `Inventory_frontend/app/pages/machine/[id].vue`
+- **Resultat :** Page decomposee en 2 composables + 7 composants. Orchestrateur = 219 LOC.
+- **Fichiers crees :**
+    - `composables/useMachineDetailData.ts` (1404 LOC) — state + logique metier
+    - `composables/useMachineSkeletonEditor.ts` (843 LOC) — logique skeleton
+    - `components/machine/MachineDetailHeader.vue` (76 LOC)
+    - `components/machine/MachineInfoCard.vue` (185 LOC)
+    - `components/machine/MachineDocumentsCard.vue` (116 LOC)
+    - `components/machine/MachineProductsCard.vue` (62 LOC)
+    - `components/machine/MachineComponentsCard.vue` (53 LOC)
+    - `components/machine/MachinePiecesCard.vue` (34 LOC)
+    - `components/machine/MachineSkeletonSummary.vue` (199 LOC)
+- **Pattern :** Props + Events (pas de provide/inject). Composables avec injection de dependances (interface Deps).
+- **Notes :** Typecheck 0 erreurs. Lint OK.
+
+### F1.2 Decouper `machines/new.vue` (1231 LOC → 196 LOC)
+
+- **Statut :** `[x]`
+- **Fichier :** `Inventory_frontend/app/pages/machines/new.vue`
+- **Resultat :** Page decomposee en 1 composable + 5 composants. Orchestrateur = 196 LOC.
+- **Fichiers crees :**
+    - `composables/useMachineCreatePage.ts` (460 LOC) — state, entity lookups, options, creation
+    - `components/machine/create/RequirementComponentSelector.vue` (126 LOC)
+    - `components/machine/create/RequirementPieceSelector.vue` (130 LOC)
+    - `components/machine/create/RequirementProductSelector.vue` (142 LOC)
+    - `components/machine/create/MachineCreatePreview.vue` (205 LOC)
+    - `components/machine/create/PreviewRequirementGroup.vue` (59 LOC)
+- **Pattern :** Props + Events. Composable consolide entity lookups, options, label helpers, creation.
+- **Notes :** Typecheck 0 erreurs. Lint OK. Corrige aussi un bug F1.1 (defineProps dans mauvais script block de MachineSkeletonSummary.vue).
+
+### F1.3 Decouper les pages de creation/edition (Piece, Component, Product)
+
+- **Statut :** `[x]`
+- **Fichiers :**
+    - `pages/component/create.vue` (1282 LOC)
+    - `pages/component/[id]/edit.vue` (1629 LOC)
+    - `pages/pieces/create.vue` (817 LOC)
+    - `pages/pieces/[id]/edit.vue` (1327 LOC)
+    - `pages/product/[id]/edit.vue` (936 LOC)
+- **Probleme :** Formulaires monolithiques avec sections multiples (infos generales, fournisseurs, documents, custom fields, etc.).
+- **Action :**
+    1. Identifier les sections communes entre create/edit (factoriser)
+    2. Extraire chaque section en composant reutilisable :
+        - `EntityFormGeneral.vue` (nom, reference, description)
+        - `EntityFormSuppliers.vue` (constructeurs)
+        - `EntityFormDocuments.vue` (documents)
+        - `EntityFormCustomFields.vue` (champs personnalises)
+    3. Objectif par page : <400 LOC
+- **Agent :** -
+- **Notes :** Les formulaires create et edit partagent beaucoup de code. Factoriser.
+- **Sous-taches :**
+    - [x] F1.3a Extraire `customFieldFormUtils.ts` (duplique dans 5 fichiers)
+    - [x] F1.3b Extraire `documentDisplayUtils.ts` (duplique dans 3 pages edit)
+    - [x] F1.3c Extraire `historyDisplayUtils.ts` (duplique dans 3 pages edit)
+    - [x] F1.3d Rewire les 5 pages create/edit sur les modules extraits
+    - [x] F1.3e Typecheck + commit F1.3 (erreurs F1.3 corrigees, 120 erreurs preexistantes documentees)
+
+### F1.4 Reduire PieceItem.vue (1588 LOC) et ComponentItem.vue (1336 LOC)
+
+- **Statut :** `[x]`
+- **Fichiers :**
+    - `Inventory_frontend/app/components/PieceItem.vue` (1588 → 740 LOC)
+    - `Inventory_frontend/app/components/ComponentItem.vue` (1336 → 585 LOC)
+- **Probleme :** ~700 LOC de logique dupliquee entre les deux composants (champs personnalises, documents, affichage produit).
+- **Action realisee :**
+    1. Extraction de la logique pure custom fields dans `shared/utils/entityCustomFieldLogic.ts` (~350 LOC)
+    2. Creation de `composables/useEntityCustomFields.ts` (composable reactif, ~180 LOC)
+    3. Creation de `composables/useEntityDocuments.ts` (CRUD documents + preview, ~120 LOC)
+    4. Creation de `composables/useEntityProductDisplay.ts` (affichage produit, ~100 LOC)
+    5. Import des helpers document depuis `shared/utils/documentDisplayUtils.ts` (existant)
+    6. Rewrite des deux composants pour utiliser les modules partages
+    7. Typecheck 0 erreurs, lint 0 erreurs
+- **Sous-taches :**
+    - [x] F1.4a Extraire `entityCustomFieldLogic.ts` (fonctions pures)
+    - [x] F1.4b Creer `useEntityCustomFields.ts` (composable reactif)
+    - [x] F1.4c Creer `useEntityDocuments.ts` (composable documents)
+    - [x] F1.4d Creer `useEntityProductDisplay.ts` (composable produit)
+    - [x] F1.4e Rewrite ComponentItem.vue (1336 → 585 LOC, script 900 → 150 LOC)
+    - [x] F1.4f Rewrite PieceItem.vue (1588 → 740 LOC, script 1100 → 255 LOC)
+    - [x] F1.4g Typecheck + lint (0 erreurs)
+- **Notes :** Les templates restent volumineux (~430-480 LOC) car le contenu UI est dense. Une extraction en sous-composants (DocumentList, ProductDisplay, CustomFieldForm) serait une etape future optionnelle.
+
+---
+
+## Phase F2 - Elimination de la duplication frontend
+
+> **Priorite :** HAUTE - DRY
+
+### F2.1 Extraire `extractCollection()` dans un utilitaire partage
+
+- **Statut :** `[x]`
+- **Fichiers concernes :**
+    - `composables/useSites.ts`
+    - `composables/useProducts.ts`
+    - `composables/usePieces.ts`
+    - `composables/useComposants.ts`
+    - `composables/useMachineTypesApi.js`
+    - `composables/useConstructeurs.ts`
+    - `composables/useDocuments.ts`
+    - `composables/useMachineCreateSelections.ts`
+    - `components/ComponentStructureAssignmentNode.vue`
+    - `components/model-types/ManagementView.vue`
+- **Probleme :** La fonction `extractCollection()` (parsing `hydra:member` / `member` / `items` / `data` / array) etait dupliquee dans 10 fichiers.
+- **Action :**
+    1. [x] Creer `shared/utils/apiHelpers.ts` avec `extractCollection<T>()` generique
+    2. [x] Remplacer les 10 implementations locales par un import
+- **Agent :** -
+- **Notes :** Gere aussi `items` (utilise par ManagementView.vue). `extractRelationId()` et `normalizeRelationIds()` restent dans `shared/apiRelations.ts` (deja partages).
+
+### F2.2 Fusionner les 3 composables d'historique
+
+- **Statut :** `[x]`
+- **Fichiers concernes :**
+    - `composables/useComponentHistory.ts` (67 → 13 LOC, thin wrapper)
+    - `composables/usePieceHistory.ts` (67 → 13 LOC, thin wrapper)
+    - `composables/useProductHistory.ts` (67 → 13 LOC, thin wrapper)
+    - `composables/useEntityHistory.ts` (NEW, 65 LOC, logique generique)
+- **Probleme :** 3 fichiers quasi identiques (seul le endpoint differait).
+- **Action :**
+    1. [x] Creer `composables/useEntityHistory.ts` parametrable par type d'entite
+    2. [x] Reecrire les 3 fichiers specifiques en wrappers backward-compatible
+- **Agent :** -
+- **Notes :** Les wrappers preservent l'API existante (types + fonction), aucun consommateur a modifier.
+
+### F2.3 Factoriser les composables de types (Component/Piece/Product)
+
+- **Statut :** `[x]`
+- **Fichiers concernes :**
+    - `composables/useComponentTypes.ts` (165 → 30 LOC, thin wrapper)
+    - `composables/usePieceTypes.ts` (165 → 30 LOC, thin wrapper)
+    - `composables/useProductTypes.ts` (160 → 28 LOC, thin wrapper)
+    - `composables/useEntityTypes.ts` (NEW, 172 LOC, logique generique)
+- **Probleme :** 3 composables tres similaires pour gerer les categories/types.
+- **Action :**
+    1. [x] Creer `composables/useEntityTypes.ts` generique (CRUD + singleton state par categorie)
+    2. [x] Reecrire les 3 fichiers specifiques en wrappers avec renommage des champs
+- **Agent :** -
+- **Notes :** Les wrappers renomment `types` → `componentTypes`/`pieceTypes`/`productTypes`, preservent `getXxxTypes()` et `isXxxTypeLoading()`. Etat partage via `stateByCategory` map module-level.
+
+---
+
+## Phase F3 - Migration TypeScript
+
+> **Priorite :** HAUTE - Securite du typage
+
+### F3.1 Definir les types pour les reponses API
+
+- **Statut :** `[x]` (partiellement — types definis dans chaque composable + `ApiResponse<T>` dans useApi.ts)
+- **Fichiers :**
+    - `composables/useApi.ts` — `ApiResponse<T>` generique (success/data/error/status)
+    - `composables/useMachines.ts` — `Machine` interface
+    - `composables/useMachineTypesApi.ts` — `MachineType`, `MachineTypeRequirement` interfaces
+    - `composables/useToast.ts` — `Toast`, `ToastType` types
+    - `composables/useProfiles.ts` — `Profile` interface
+    - `composables/useCustomFields.ts` — `CustomFieldValue` interface
+- **Notes :** Les types sont definis dans chaque composable (colocation). Types entite existants : `Product`, `Piece`, `Composant`, `Constructeur`, `Site`, `Document` dans leurs composables respectifs (.ts). `shared/types/inventory.ts` contient les types de structure de modele.
+
+### F3.2 Convertir les composables JS en TS
+
+- **Statut :** `[x]`
+- **Fichiers convertis (7 fichiers JS → TS) :**
+    - [x] `useToast.js` → `useToast.ts` (72 LOC, types: `Toast`, `ToastType`)
+    - [x] `useProfiles.js` → `useProfiles.ts` (68 LOC, type: `Profile`)
+    - [x] `useProfileSession.js` → `useProfileSession.ts` (85 LOC, importe `Profile`)
+    - [x] `useApi.js` → `useApi.ts` (106 LOC → 120 LOC, types: `ApiResponse<T>`, `ApiCallOptions`, ajout `put()`)
+    - [x] `useCustomFields.js` → `useCustomFields.ts` (105 LOC, type: `CustomFieldValue`)
+    - [x] `useMachineTypesApi.js` → `useMachineTypesApi.ts` (173 → 188 LOC, types: `MachineType`, `MachineTypeRequirement`)
+    - [x] `useMachines.js` → `useMachines.ts` (267 LOC, type: `Machine`, utilise `extractCollection`)
+- **Fichiers deja TS :** `useProducts.ts`, `usePieces.ts`, `useComposants.ts`, `useConstructeurs.ts`, `useSites.ts`, `useDocuments.ts`
+- **Fichiers JS restants (deprecated) :** `useComponentModels.js`, `usePieceModels.js` (stubs deprecated, a supprimer)
+- **Notes :** `ApiResponse<T = any>` par defaut `any` pour backward-compat. Les callers existants fonctionnent sans changement ; le nouveau code peut opt-in strict via `get<MyType>()`.
+
+### F3.3 Eliminer les `any` restants
+
+- **Statut :** `[x]`
+- **Fichiers concernes :**
+    - `components/ProductSelect.vue` — 1 `any` restant (slot template, incompressible)
+    - `components/model-types/ManagementView.vue` — remplace `data?: any` → `Record<string, unknown>`, `error: any` → `error: unknown`, `item: any` → `item: unknown`
+    - `components/ComponentStructureAssignmentNode.vue` — 12 casts `(definition as any).typePiece/typeProduct` elimines grace a l'extension des types
+    - `components/ComponentModelStructureEditor.vue` — `Promise<any>` → `Promise<unknown>`
+    - `components/model-types/ModelTypeForm.vue` — `(incoming as any).description` → cast `Record<string, unknown>`
+    - `shared/types/inventory.ts` — `ComponentModelPiece.typePiece?` et `ComponentModelProduct.typeProduct?` ajoutes, 3 casts `(value as any)` supprimes
+- **Probleme :** 20+ usages de `any` type identifies.
+- **Action :** Etendre les interfaces de types pour supporter les formes alternatives de l'API. Remplacer les `any` par `unknown` ou `Record<string, unknown>` la ou possible.
+- **Agent :** Claude
+- **Notes :** ~15 casts `any` elimines. Les `Record<string, any>` restants dans ComponentModelStructureEditor sont justifies (manipulation dynamique interne de custom fields). Typecheck 0 erreurs.
+
+---
+
+## Phase F4 - Qualite du code frontend
+
+> **Priorite :** MOYENNE
+
+### F4.1 Activer les regles ESLint critiques
+
+- **Statut :** `[x]` DONE
+- **Fichier :** `Inventory_frontend/eslint.config.mjs`
+- **Probleme :** Presque toutes les regles etaient desactivees (`no-console: off`, `no-unused-vars: off`, `no-explicit-any: off`).
+- **Action realisee :**
+    1. [x] Active `@typescript-eslint/no-explicit-any: warn` (526 warnings — amelioration progressive)
+    2. [x] Active `no-console: warn` avec `allow: ['error']` — 0 violations (deja nettoye en F4.2)
+    3. [x] Active `@typescript-eslint/no-unused-vars: warn` avec ignore `^_` — 0 violations (26 corrigees)
+    4. [x] Corrige les 26 violations `no-unused-vars` : imports inutilises supprimes, variables prefixees `_`, destructurations nettoyees
+- **Agent :** Claude
+- **Notes :** 16 fichiers modifies. Regles organisees par categorie (vue, console, typescript, formatting). 0 erreurs, 526 warnings `no-explicit-any` restants (warn, pas bloquant).
+
+### F4.2 Nettoyer les console.log/console.error
+
+- **Statut :** `[x]` (console.log supprime, console.error conserve)
+- **Fichiers modifies :** 8 fichiers (useMachineTypesApi.ts, useSites.ts, type/[id].vue, type/edit/[id].vue, TypeEditPieceRequirementsSection.vue, SearchSelect.vue, app.vue)
+- **Probleme :** 19 appels `console.log` de debug laisses dans le code de production.
+- **Action :**
+    1. [x] Supprimer les 19 `console.log` de debug (normalizeRequirementList, page loading, route params, etc.)
+    2. [ ] Les 72 `console.error` restants sont conserves (gestion d'erreur legitime). Migration vers un logger centralise a faire en F4.3.
+- **Agent :** Claude
+- **Notes :** 0 `console.log/warn/debug/info` restants dans le frontend.
+
+### F4.3 Centraliser la gestion d'erreurs API
+
+- **Statut :** `[ ]`
+- **Fichier :** `Inventory_frontend/app/composables/useApi.js` (105 LOC)
+- **Probleme :** Gestion d'erreur basique (juste un toast). Pas de retry, pas d'intercepteur, erreurs silencieuses dans certains composables.
+- **Action :**
+    1. Ajouter un systeme de retry configurable (1-3 tentatives)
+    2. Centraliser la gestion des erreurs HTTP (401 -> redirect login, 500 -> message explicite)
+    3. Ajouter des intercepteurs request/response
+    4. Uniformiser le pattern dans tous les composables
+- **Agent :** -
+- **Notes :** -
+
+---
+
+## Phase F5 - Reduire le fichier modelUtils.ts (1017 LOC)
+
+> **Priorite :** MOYENNE
+
+### F5.1 Decouper `shared/modelUtils.ts`
+
+- **Statut :** `[x]`
+- **Fichier :** `Inventory_frontend/app/shared/modelUtils.ts` (1017 LOC → 37 LOC barrel)
+- **Probleme :** Fichier utilitaire monolithique de 1017 lignes regroupant toute la logique de manipulation de modeles.
+- **Action :**
+    1. Identifier les groupes de fonctions (structure, custom fields, requirements, serialization)
+    2. Decouper en 3 modules thematiques :
+        - `shared/model/componentStructure.ts` (~590 LOC) — helpers, sanitize, hydrate, normalize, extract, format pour composants
+        - `shared/model/pieceProductStructure.ts` (~155 LOC) — structure piece/produit (clone, sanitize, hydrate, format)
+        - `shared/model/definitionOverrides.ts` (~50 LOC) — sanitization des overrides de definition
+    3. Re-exporter depuis `shared/modelUtils.ts` (barrel) pour ne pas casser les imports
+- **Agent :** Claude
+- **Notes :** 11 fichiers consommateurs inchanges (barrel preserve la retro-compat). Typecheck 0 erreurs.
+
+---
+
+## Phase F6 - Tests frontend
+
+> **Priorite :** HAUTE - Aucun test actuellement
+
+### F6.1 Configurer Vitest
+
+- **Statut :** `[x]` DONE
+- **Fichiers crees :**
+    - `vitest.config.ts` — config Vitest avec happy-dom, alias `~` et `#imports`
+    - `tests/__mocks__/imports.ts` — mock des auto-imports Nuxt (useRuntimeConfig, useRoute, etc.)
+    - `tests/shared/inventory-types.test.ts` — 9 tests smoke (validator, empty structures)
+- **Action realisee :**
+    1. [x] Installe `vitest`, `@vue/test-utils`, `happy-dom`
+    2. [x] Configure Vitest avec environment happy-dom et resolution d'alias
+    3. [x] Ajoute scripts `test` et `test:watch` dans `package.json`
+    4. [x] Premier test suite : `componentModelStructureValidator` (9 tests, 100% pass)
+- **Agent :** Claude
+- **Notes :** `npm test` → 9 tests, 0 failures, <1s. Alias `#imports` pointe vers un mock minimal extensible.
+
+### F6.2 Tests unitaires des composables
+
+- **Statut :** `[x]` DONE (base)
+- **Fichiers crees :**
+    - `tests/shared/apiHelpers.test.ts` — 10 tests (extractCollection, tous formats API)
+    - `tests/shared/modelUtils.test.ts` — 18 tests (isPlainObject, clone, stats, format, piece/product)
+    - `tests/shared/inventory-types.test.ts` — 9 tests (validator, empty structures)
+    - `tests/composables/useToast.test.ts` — 9 tests (add, types, max limit, clear, singleton)
+    - `tests/composables/useConfirm.test.ts` — 8 tests (open, confirm, cancel, options, singleton)
+- **Action realisee :**
+    1. [x] Teste `extractCollection()` : array, hydra:member, member, items, data, null, undefined
+    2. [x] Teste `useToast` : ajout, types, max 3 toasts, clearAll, removeToast, singleton
+    3. [x] Teste `useConfirm` : open/close, resolve true/false, custom options, singleton state
+    4. [x] Teste `modelUtils` : clone, stats, preview, isPlainObject, piece/product variants
+    5. [x] Teste `componentModelStructureValidator` : valid/invalid, custom fields, subcomponents
+- **Agent :** Claude
+- **Notes :** 54 tests, 5 fichiers, 100% pass, <2s. Tests `useApi` et CRUD composables necessitent mock fetch (phase ulterieure).
+
+### F6.3 Tests de composants
+
+- **Statut :** `[ ]`
+- **Fichiers a creer :**
+    - `tests/components/Pagination.test.ts`
+    - `tests/components/SearchSelect.test.ts`
+    - `tests/components/MachineHeader.test.ts` (apres F1.1)
+- **Action :**
+    1. Tester les composants communs (Pagination, SearchSelect)
+    2. Tester le rendu conditionnel et les events
+- **Agent :** -
+- **Notes :** -
+
+---
+
+## Phase F7 - Ameliorations UX/DX
+
+> **Priorite :** BASSE - Polish
+
+### F7.1 Reduire le props drilling
+
+- **Statut :** `[ ]`
+- **Probleme :** Props passees sur 3+ niveaux (ex: machine data dans les sous-composants).
+- **Action :**
+    1. Identifier les cas de props drilling >2 niveaux
+    2. Utiliser `provide/inject` ou des composables partages
+    3. Documenter le pattern choisi
+- **Agent :** -
+- **Notes :** A traiter apres F1 (decoupage des composants).
+
+### F7.2 Remplacer `confirm()` natif par des modales DaisyUI
+
+- **Statut :** `[x]` DONE
+- **Probleme :** Les confirmations de suppression utilisaient `window.confirm()` (UI native, non-stylee).
+- **Action realisee :**
+    1. [x] Cree `composables/useConfirm.ts` — composable promise-based avec etat reactif partage
+    2. [x] Cree `components/common/ConfirmModal.vue` — modale DaisyUI teleportee (backdrop blur, btn-error)
+    3. [x] Monte `ConfirmModal` globalement dans `app.vue`
+    4. [x] Remplace les 10 `confirm()` natifs dans 10 fichiers :
+        - `constructeurs.vue`, `profiles/manage.vue`, `ManagementView.vue`
+        - `product-catalog.vue`, `index.vue`, `machines/index.vue`
+        - `machine-skeleton/index.vue`, `pieces-catalog.vue`, `component-catalog.vue`
+        - `useSiteManagement.ts` (composable — import explicite)
+- **Agent :** Claude
+- **Notes :** API : `const { confirm } = useConfirm(); const ok = await confirm({ message: '...' })`. Auto-import Nuxt pour les SFC, import explicite pour les composables.
+
+### F7.3 Nettoyer `app.vue` (861 LOC)
+
+- **Statut :** `[x]` DONE
+- **Fichier :** `Inventory_frontend/app/app.vue` (861 → 49 LOC)
+- **Probleme :** Le fichier racine contenait le layout principal, la navbar (~676 LOC dupliquee mobile/desktop), et du state management.
+- **Action realisee :**
+    1. Cree `composables/useNavDropdown.ts` (~65 LOC) — gestion etat dropdowns navbar
+    2. Cree `components/layout/AppNavbar.vue` (~310 LOC) — navbar data-driven avec `v-for` eliminant duplication mobile/desktop
+    3. `app.vue` reecrit en orchestrateur minimal (49 LOC) + converti en TypeScript
+    4. Supprime 4 imports d'icones inutilises
+- **Agent :** Claude
+- **Notes :** Approche data-driven : liens et groupes definis comme tableaux types (`NavLink[]`, `NavGroup[]`), rendus par `v-for` pour mobile et desktop
+
+---
+
+## Ordre d'execution recommande
+
+```
+=== BACKEND ===                          === FRONTEND ===
+
+Phase 6.1 (Tests unitaires)              Phase F6.1 (Config Vitest)
+  |                                        |
+  v                                        v
+Phase 1 (Securite)                       Phase F1 (Decoupage mega-composants)
+  |                                        |
+  v                                        v
+Phase 2 (Duplication backend)            Phase F2 (Duplication frontend)
+  |                                        |
+  v                                        v
+Phase 3 (Controllers)                    Phase F3 (Migration TypeScript)
+  |                                        |
+  v                                        v
+Phase 6.2 (Tests API)                    Phase F4 (Qualite code) + Phase F5 (modelUtils)
+  |                                        |
+  v                                        v
+Phase 4 (Stockage)                       Phase F6.2-F6.3 (Tests frontend)
+  |                                        |
+  v                                        v
+Phase 5 + Phase 7 (Nettoyage)           Phase F7 (UX/DX polish)
+  |
+  v
+Phase 6.3 (Tests audit)
+```
+
+> Les colonnes backend et frontend peuvent etre executees **en parallele** par des agents differents.
+
+---
+
+## Journal des modifications
+
+| Date       | Phase | Tache                     | Agent           | Statut  | Notes                                          |
+| ---------- | ----- | ------------------------- | --------------- | ------- | ---------------------------------------------- |
+| 2026-02-03 | -     | Creation du plan backend  | Claude Opus 4.5 | Termine | Analyse initiale backend (7 phases, 17 taches) |
+| 2026-02-03 | -     | Creation du plan frontend | Claude Opus 4.5 | Termine | Analyse frontend (7 phases, 22 taches)         |
+|            |       |                           |                 |         |                                                |
+
+---
+
+## Commandes de verification
+
+> **Contexte :** Le backend tourne dans Docker (`docker compose`), le frontend est en local.
+> Les commandes ci-dessous sont executees **depuis la racine du projet** (`/home/matthieu/dev_malio/Inventory/`).
+
+### Frontend (Nuxt 3 / Vue 3 / TypeScript)
+
+| Commande             | Description                                     | Quand l'utiliser                                                                                  |
+| -------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `npx nuxi typecheck` | Verification des types TypeScript via `vue-tsc` | Apres chaque modification de fichier `.vue` ou `.ts`. C'est la commande principale de validation. |
+| `npm run lint`       | ESLint (config dans `eslint.config.mjs`)        | Apres chaque modification pour verifier le style et les erreurs statiques.                        |
+| `npm run lint:fix`   | ESLint avec auto-fix                            | Pour corriger automatiquement les erreurs de formatage.                                           |
+| `npm run build`      | Build de production Nuxt (inclut le typecheck)  | Avant un commit pour s'assurer que tout compile. Plus lent que `typecheck` seul.                  |
+| `npx nuxi prepare`   | Regenerer les types auto-generes (`.nuxt/`)     | Si les imports auto (composables, components) ne sont pas reconnus par le typecheck.              |
+
+> **Toutes les commandes frontend** sont executees depuis `Inventory_frontend/` :
+>
+> ```bash
+> cd Inventory_frontend && npx nuxi typecheck
+> ```
+
+> **Note sur les erreurs pre-existantes :** Il y a ~120 erreurs TypeScript pre-existantes documentees
+> (anterieures a la refacto). L'objectif est de ne pas en ajouter de nouvelles.
+> Pour verifier : comparer le nombre d'erreurs avant/apres modification.
+
+### Backend (Symfony 8 / PHP 8.4)
+
+| Commande                                       | Description                                           | Quand l'utiliser                                                    |
+| ---------------------------------------------- | ----------------------------------------------------- | ------------------------------------------------------------------- |
+| `vendor/bin/php-cs-fixer fix --dry-run --diff` | Verifie le style PHP (PSR-12 + Symfony) sans modifier | Apres chaque modification PHP.                                      |
+| `vendor/bin/php-cs-fixer fix`                  | Corrige automatiquement le style PHP                  | Avant chaque commit.                                                |
+| `bin/phpunit`                                  | Lance les tests PHPUnit                               | Apres chaque modification backend.                                  |
+| `php bin/console cache:clear`                  | Vide le cache Symfony                                 | Si des erreurs bizarres apparaissent apres un changement de config. |
+
+> **Les commandes backend** sont executees **dans le conteneur Docker** :
+>
+> ```bash
+> docker compose exec web vendor/bin/php-cs-fixer fix --dry-run --diff
+> docker compose exec web bin/phpunit
+> ```
+
+### Workflow de verification (checklist par tache)
+
+```
+1. Lire les fichiers concernes (AVANT toute modification)
+2. Effectuer les modifications
+3. Frontend : npx nuxi typecheck  →  verifier pas de nouvelles erreurs
+4. Frontend : npm run lint:fix    →  corriger le formatage
+5. Backend  : php-cs-fixer fix    →  corriger le style PHP
+6. Backend  : bin/phpunit         →  verifier la non-regression
+7. Commit si tout est OK
+```
+
+---
+
+## Regles pour les agents
+
+1. **Avant de commencer une tache :**
+    - Mettre le statut a `[~]` dans ce fichier
+    - Inscrire son nom/ID dans la colonne "Agent"
+    - Lire les fichiers concernes AVANT de modifier quoi que ce soit
+
+2. **Pendant le travail :**
+    - Ne modifier QUE les fichiers listes dans la tache
+    - Respecter les conventions existantes (PSR-12, strict_types)
+    - Ne pas introduire de nouvelles dependances sans justification
+    - Lancer `php-cs-fixer` apres les modifications
+
+3. **Apres avoir termine :**
+    - Mettre le statut a `[x]`
+    - Ajouter une entree dans le "Journal des modifications"
+    - Lancer les tests existants (`make test`) pour verifier la non-regression
+    - Decrire brievement les changements effectues dans "Notes"
+
+4. **En cas de blocage :**
+    - Mettre le statut a `[!]`
+    - Documenter le blocage dans "Notes"
+    - Ne PAS passer a une autre tache sans signaler le blocage
+
+5. **Regles specifiques au frontend :**
+    - Ecrire en TypeScript (pas de JS pour les nouveaux fichiers)
+    - Pas de `any` - utiliser des types concrets
+    - Pas de `console.log` - utiliser le logger ou `useToast`
+    - Composants Vue : max 400 LOC par fichier
+    - Utiliser les composants DaisyUI existants (pas de CSS custom)
+    - Tester avec Vitest quand la config est en place
+
+6. **Regles specifiques au backend :**
+    - `declare(strict_types=1)` obligatoire
+    - Respecter PSR-12 + regles Symfony (php-cs-fixer)
+    - Pas de `exec()` direct - utiliser Symfony Process
+    - Tester avec PHPUnit

RELEASE.md

@@ -0,0 +1,138 @@
+# Guide de Release
+
+## Versioning
+
+Le projet utilise le [Semantic Versioning](https://semver.org/) (SemVer) : `MAJOR.MINOR.PATCH`
+
+- **MAJOR** : Changements incompatibles avec les versions précédentes
+- **MINOR** : Nouvelles fonctionnalités rétrocompatibles
+- **PATCH** : Corrections de bugs rétrocompatibles
+
+La version est centralisée dans le fichier `VERSION` à la racine du projet.
+
+## Créer une release
+
+### Prérequis
+
+- Tous les changements doivent être commités
+- Les tests doivent passer
+- Être sur la branche à releaser (ex: `main`, `develop`)
+
+### Utilisation du script
+
+```bash
+# Afficher l'aide et la version actuelle
+./scripts/release.sh
+
+# Bump patch : 1.0.0 → 1.0.1
+./scripts/release.sh patch
+
+# Bump minor : 1.0.0 → 1.1.0
+./scripts/release.sh minor
+
+# Bump major : 1.0.0 → 2.0.0
+./scripts/release.sh major
+
+# Version spécifique
+./scripts/release.sh 2.0.0
+```
+
+Le script :
+1. Met à jour le fichier `VERSION`
+2. Met à jour `config/packages/api_platform.yaml`
+3. Crée un commit `chore(release): vX.Y.Z`
+4. Crée le tag `vX.Y.Z`
+
+### Pousser la release
+
+```bash
+git push && git push --tags
+```
+
+### Créer la release sur Gitea
+
+1. Aller sur le dépôt Gitea
+2. **Releases** > **New Release**
+3. Sélectionner le tag `vX.Y.Z`
+4. Titre : `v1.0.0` (ou avec un nom descriptif)
+5. Description : résumé des changements (voir section Notes de release)
+
+## Notes de release
+
+Template pour les notes de release :
+
+```markdown
+## Nouveautés
+- Feature A
+- Feature B
+
+## Corrections
+- Fix du bug X
+- Fix du bug Y
+
+## Changements
+- Refactoring de Z
+- Mise à jour des dépendances
+```
+
+## Fichiers impactés par le versioning
+
+| Fichier | Usage |
+|---------|-------|
+| `VERSION` | Source unique de vérité |
+| `config/packages/api_platform.yaml` | Version affichée dans l'API |
+| `Inventory_frontend/nuxt.config.ts` | Lit VERSION au build |
+| Footer de l'app | Affiche `v{{ appVersion }}` |
+
+## Déploiement en production
+
+### 1. Base de données
+
+Dump de la base locale :
+```bash
+pg_dump -h localhost -p 5433 -U root -d inventory > backup_v1.0.0.sql
+```
+
+Import en production :
+```bash
+psql -h <PROD_HOST> -U <PROD_USER> -d inventory < backup_v1.0.0.sql
+```
+
+### 2. Variables d'environnement production
+
+Créer un fichier `.env.local` en production avec :
+
+```env
+APP_ENV=prod
+APP_SECRET=<générer avec: openssl rand -hex 32>
+DATABASE_URL="postgresql://user:password@host:5432/inventory?serverVersion=16"
+CORS_ALLOW_ORIGIN='^https://votre-domaine\.com$'
+JWT_SECRET_KEY=%kernel.project_dir%/config/jwt/private.pem
+JWT_PUBLIC_KEY=%kernel.project_dir%/config/jwt/public.pem
+JWT_PASSPHRASE=<votre-passphrase>
+```
+
+### 3. Build production
+
+Backend :
+```bash
+composer install --no-dev --optimize-autoloader
+php bin/console cache:clear --env=prod
+php bin/console doctrine:migrations:migrate --no-interaction
+```
+
+Frontend :
+```bash
+cd Inventory_frontend
+NUXT_PUBLIC_API_BASE_URL=https://api.votre-domaine.com yarn build
+```
+
+### 4. Checklist avant mise en prod
+
+- [ ] Tests passent
+- [ ] Migrations DB testées
+- [ ] Variables d'environnement configurées
+- [ ] Clés JWT générées
+- [ ] CORS configuré
+- [ ] SSL/HTTPS actif
+- [ ] Backup de la DB prod existante (si upgrade)

VERSION

@@ -0,0 +1 @@
+1.6.1

config/packages/api_platform.yaml

@@ -1,7 +1,9 @@
 api_platform:
     title: Hello API Platform
-    version: 1.0.0
+    version: 1.4.0
     defaults:
         stateless: false
         cache_headers:
             vary: ['Content-Type', 'Authorization', 'Origin']
+        pagination_items_per_page: 30
+        pagination_maximum_items_per_page: 200

config/packages/doctrine.yaml

@@ -1,6 +1,9 @@
 doctrine:
     dbal:
         url: '%env(resolve:DATABASE_URL)%'
+        mapping_types:
+            modelcategory: string
+            _text: string
 
         # IMPORTANT: You MUST configure your server version,
         # either here or in the DATABASE_URL env var (see .env file)
@@ -9,7 +12,8 @@ doctrine:
         profiling_collect_backtrace: '%kernel.debug%'
     orm:
         validate_xml_mapping: true
-        naming_strategy: doctrine.orm.naming_strategy.underscore_number_aware
+        naming_strategy: doctrine.orm.naming_strategy.default
+        quote_strategy: doctrine.orm.quote_strategy.default
         identity_generation_preferences:
             Doctrine\DBAL\Platforms\PostgreSQLPlatform: identity
         auto_mapping: true

config/services.yaml

@@ -21,3 +21,15 @@ services:
 
     # add more service definitions when explicit configuration is needed
     # please note that last definitions always *replace* previous ones
+
+    App\EventSubscriber\ProductAuditSubscriber:
+        tags:
+            - { name: doctrine.event_subscriber }
+
+    App\EventSubscriber\PieceAuditSubscriber:
+        tags:
+            - { name: doctrine.event_subscriber }
+
+    App\EventSubscriber\ComposantAuditSubscriber:
+        tags:
+            - { name: doctrine.event_subscriber }

docker-compose.yml

@@ -45,34 +45,17 @@ services:
       - "${POSTGRES_PORT:-5433}:5432"
     restart: unless-stopped
 
-  pgadmin:
-    container_name: pgadmin-${DOCKER_APP_NAME}
-    image: dpage/pgadmin4:latest
-    user: root
+  adminer:
+    container_name: adminer-${DOCKER_APP_NAME}
+    image: adminer:latest
     environment:
-      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_EMAIL:-admin@admin.com}
-      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_PASSWORD:-admin}
-      PGADMIN_CONFIG_SERVER_MODE: 'False'
-      PGADMIN_CONFIG_MASTER_PASSWORD_REQUIRED: 'False'
-      PGADMIN_SERVER_JSON_FILE: '/pgadmin4/servers.json'
-    volumes:
-      - pgadmin_data:/var/lib/pgadmin
-      - ./docker/pgadmin/servers.json:/pgadmin4/servers.json:ro
-      - ./docker/pgadmin/pgpass:/pgadmin4/pgpass:ro
+      ADMINER_DEFAULT_SERVER: db
+      ADMINER_DESIGN: dracula
     ports:
-      - "${PGADMIN_PORT:-5050}:80"
+      - "${ADMINER_PORT:-5050}:8080"
     depends_on:
       - db
     restart: unless-stopped
-    entrypoint: >
-      /bin/sh -c "
-      mkdir -p /var/lib/pgadmin &&
-      cp /pgadmin4/pgpass /var/lib/pgadmin/pgpass &&
-      chmod 600 /var/lib/pgadmin/pgpass &&
-      chown 5050:5050 /var/lib/pgadmin/pgpass &&
-      /entrypoint.sh
-      "
 
 volumes:
   pg_data:
-  pgadmin_data:

docker/.env.docker

@@ -6,4 +6,4 @@ POSTGRES_DB=inventory
 POSTGRES_USER=root
 POSTGRES_PASSWORD=root
 POSTGRES_PORT=5432
-XDEBUG_CLIENT_HOST=host.docker.internal
+XDEBUG_CLIENT_HOST=host.docker.internal

docker/php/Dockerfile

@@ -33,6 +33,7 @@ RUN apt-get update && apt-get install -y \
         wget \
         git \
         unzip \
+        qpdf \
     && docker-php-ext-install -j$(nproc) \
             intl \
             zip \

fixtures/load.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Load fixtures into the database
+# Usage: ./fixtures/load.sh [--reset]
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Load environment variables
+if [ -f "$PROJECT_DIR/.env" ]; then
+    export $(grep -v '^#' "$PROJECT_DIR/.env" | xargs)
+fi
+
+DB_USER="${POSTGRES_USER:-root}"
+DB_NAME="${POSTGRES_DB:-inventory}"
+CONTAINER="${DB_CONTAINER:-inventory-db-1}"
+
+echo "Loading fixtures into $DB_NAME..."
+
+# Check if --reset flag is passed
+if [ "$1" == "--reset" ]; then
+    echo "Resetting database (truncating all tables)..."
+    docker exec -i "$CONTAINER" psql -U "$DB_USER" -d "$DB_NAME" -c "
+        DO \$\$ DECLARE
+            r RECORD;
+        BEGIN
+            FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename != 'doctrine_migration_versions') LOOP
+                EXECUTE 'TRUNCATE TABLE ' || quote_ident(r.tablename) || ' CASCADE';
+            END LOOP;
+        END \$\$;
+    "
+fi
+
+# Load fixtures with foreign key checks disabled
+docker exec -i "$CONTAINER" psql -U "$DB_USER" -d "$DB_NAME" <<EOF
+SET session_replication_role = replica;
+$(cat "$SCRIPT_DIR/data.sql")
+SET session_replication_role = DEFAULT;
+EOF
+
+echo "Fixtures loaded successfully!"

frontend/.gitignore

@@ -1,24 +0,0 @@
-# Nuxt dev/build outputs
-.output
-.data
-.nuxt
-.nitro
-.cache
-dist
-
-# Node dependencies
-node_modules
-
-# Logs
-logs
-*.log
-
-# Misc
-.DS_Store
-.fleet
-.idea
-
-# Local env files
-.env
-.env.*
-!.env.example

frontend/README.md

@@ -1,75 +0,0 @@
-# Nuxt Minimal Starter
-
-Look at the [Nuxt documentation](https://nuxt.com/docs/getting-started/introduction) to learn more.
-
-## Setup
-
-Make sure to install dependencies:
-
-```bash
-# npm
-npm install
-
-# pnpm
-pnpm install
-
-# yarn
-yarn install
-
-# bun
-bun install
-```
-
-## Development Server
-
-Start the development server on `http://localhost:3000`:
-
-```bash
-# npm
-npm run dev
-
-# pnpm
-pnpm dev
-
-# yarn
-yarn dev
-
-# bun
-bun run dev
-```
-
-## Production
-
-Build the application for production:
-
-```bash
-# npm
-npm run build
-
-# pnpm
-pnpm build
-
-# yarn
-yarn build
-
-# bun
-bun run build
-```
-
-Locally preview production build:
-
-```bash
-# npm
-npm run preview
-
-# pnpm
-pnpm preview
-
-# yarn
-yarn preview
-
-# bun
-bun run preview
-```
-
-Check out the [deployment documentation](https://nuxt.com/docs/getting-started/deployment) for more information.

frontend/app.vue

@@ -1,3 +0,0 @@
-<template>
-    <NuxtPage/>
-</template>

frontend/nuxt.config.ts

@@ -1,9 +0,0 @@
-export default defineNuxtConfig({
-  compatibilityDate: '2025-07-15',
-  devtools: { enabled: true },
-  ssr: false,
-  modules: ['@nuxtjs/tailwindcss'],
-  typescript: {
-    strict: true
-  }
-})

frontend/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "frontend",
-  "type": "module",
-  "private": true,
-  "scripts": {
-    "build": "nuxt build",
-    "dev": "nuxt dev",
-    "generate": "nuxt generate",
-    "preview": "nuxt preview",
-    "postinstall": "nuxt prepare",
-    "build:dist": "nuxt generate && rm -rf dist && cp -R .output/public dist"
-  },
-  "dependencies": {
-    "nuxt": "^4.2.2",
-    "vue": "^3.5.26",
-    "vue-router": "^4.6.4"
-  },
-  "devDependencies": {
-    "@nuxtjs/tailwindcss": "^6.14.0"
-  }
-}

frontend/pages/index.vue

@@ -1,9 +0,0 @@
-<template>
-    <div class="min-h-screen flex items-center justify-center">
-        <h1 class="text-3xl font-bold">Nuxt OK ✅</h1>
-    </div>
-</template>
-
-<script setup lang="ts">
-
-</script>

frontend/public/robots.txt

@@ -1,2 +0,0 @@
-User-Agent: *
-Disallow:

frontend/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  // https://nuxt.com/docs/guide/concepts/typescript
-  "files": [],
-  "references": [
-    {
-      "path": "./.nuxt/tsconfig.app.json"
-    },
-    {
-      "path": "./.nuxt/tsconfig.server.json"
-    },
-    {
-      "path": "./.nuxt/tsconfig.shared.json"
-    },
-    {
-      "path": "./.nuxt/tsconfig.node.json"
-    }
-  ]
-}

makefile

@@ -19,6 +19,8 @@ EXEC_PHP_ROOT				= $(DOCKER) exec -t -u root $(PHP_CONTAINER)
 EXEC_PHP_INTERACTIVE		= $(DOCKER) exec -it -u $(APP_USER) $(PHP_CONTAINER)
 EXEC_PHP_INTERACTIVE_ROOT	= $(DOCKER) exec -it -u root $(PHP_CONTAINER)
 FILES						=
+DATA_SQL					?= data.sql
+DATA_SQL_NORM				?= data_norm.sql
 
 #========================================================================================
 
@@ -58,7 +60,7 @@ build-nuxtJS:
 	$(EXEC_PHP) sh -lc "cd Inventory_frontend && npm install && npm run generate"
 
 dev-nuxt:
-	$(EXEC_PHP) sh -c "cd Inventory_frontend && npm run dev"
+	$(EXEC_PHP) sh -lc "cd Inventory_frontend && npm run dev"
 
 delete_built_dir:
 	CURRENT_UID=$(shell id -u) CURRENT_GID=$(shell id -g) $(DOCKER_COMPOSE) up -d
@@ -117,3 +119,31 @@ test:
 
 wait:
 	sleep 10
+
+# Normalize pgAdmin data-only dump and import into DB
+import-data:
+	python3 scripts/normalize-dump.py $(DATA_SQL) $(DATA_SQL_NORM) --lower
+	$(DOCKER_COMPOSE) exec -T db psql -U $(POSTGRES_USER) -d $(POSTGRES_DB) -v ON_ERROR_STOP=1 -c "SET session_replication_role = replica;"
+	$(DOCKER_COMPOSE) exec -T db psql -U $(POSTGRES_USER) -d $(POSTGRES_DB) -v ON_ERROR_STOP=1 < $(DATA_SQL_NORM)
+	$(DOCKER_COMPOSE) exec -T db psql -U $(POSTGRES_USER) -d $(POSTGRES_DB) -v ON_ERROR_STOP=1 -c "SET session_replication_role = DEFAULT;"
+
+# Fixtures management
+fixtures-dump:
+	@echo "Dumping current database to fixtures/data.sql..."
+	$(DOCKER_COMPOSE) exec -T db pg_dump -U $(POSTGRES_USER) -d $(POSTGRES_DB) \
+		--data-only --inserts --no-owner --no-privileges \
+		--exclude-table=doctrine_migration_versions \
+		| grep -v "^pg_dump:" | grep -v "^\\\\restrict" > fixtures/data.sql
+	@echo "Fixtures saved to fixtures/data.sql"
+
+fixtures-load:
+	@echo "Loading fixtures from fixtures/data.sql (FK checks disabled)..."
+	$(DOCKER_COMPOSE) exec -T db psql -U $(POSTGRES_USER) -d $(POSTGRES_DB) -c "SET session_replication_role = replica;"
+	-$(DOCKER_COMPOSE) exec -T db psql -U $(POSTGRES_USER) -d $(POSTGRES_DB) < fixtures/data.sql
+	$(DOCKER_COMPOSE) exec -T db psql -U $(POSTGRES_USER) -d $(POSTGRES_DB) -c "SET session_replication_role = DEFAULT;"
+	@echo "Fixtures loaded!"
+
+fixtures-reset:
+	@echo "Resetting database and loading fixtures..."
+	$(DOCKER_COMPOSE) exec -T db psql -U $(POSTGRES_USER) -d $(POSTGRES_DB) -c "DO \$$\$$ DECLARE r RECORD; BEGIN FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename != 'doctrine_migration_versions') LOOP EXECUTE 'TRUNCATE TABLE ' || quote_ident(r.tablename) || ' CASCADE'; END LOOP; END \$$\$$;"
+	$(MAKE) fixtures-load

migratebdd.md

@@ -0,0 +1,35 @@
+# Migration DB (manuel)
+
+Ce guide explique comment importer un dump SQL venant de pgAdmin dans la base Docker.
+
+## 1) Export pgAdmin
+
+Dans pgAdmin:
+
+- Format: Plain
+- Options: Use INSERT commands + Use column inserts
+- Fichier: `data.sql`
+
+## 2) Normaliser le dump
+
+Convertit les colonnes camelCase en lowercase compact.
+
+```bash
+python3 scripts/normalize-dump.py data.sql data_norm.sql --lower
+```
+
+## 3) Importer dans la base Docker
+
+Utilise `session_replication_role` pour eviter les erreurs de contraintes circulaires.
+
+```bash
+docker compose --env-file docker/.env.docker.local exec -T db psql -U root -d inventory -v ON_ERROR_STOP=1 -c "SET session_replication_role = replica;"
+docker compose --env-file docker/.env.docker.local exec -T db psql -U root -d inventory -v ON_ERROR_STOP=1 < data_norm.sql
+docker compose --env-file docker/.env.docker.local exec -T db psql -U root -d inventory -v ON_ERROR_STOP=1 -c "SET session_replication_role = DEFAULT;"
+```
+
+## 4) Verifier
+
+```bash
+docker compose --env-file docker/.env.docker.local exec -T db psql -U $POSTGRES_USER -d $POSTGRES_DB -c "\\dt"
+```

migrations/Version20260110202855.php

@@ -1,229 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DoctrineMigrations;
-
-use Doctrine\DBAL\Schema\Schema;
-use Doctrine\Migrations\AbstractMigration;
-
-/**
- * Auto-generated Migration: Please modify to your needs!
- */
-final class Version20260110202855 extends AbstractMigration
-{
-    public function getDescription(): string
-    {
-        return '';
-    }
-
-    public function up(Schema $schema): void
-    {
-        // this up() migration is auto-generated, please modify it to your needs
-        $this->addSql('CREATE TABLE composants (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, reference VARCHAR(255) DEFAULT NULL, prix NUMERIC(10, 2) DEFAULT NULL, structure JSON DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, typeComposantId VARCHAR(36) DEFAULT NULL, productId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_F95A31995E237E06 ON composants (name)');
-        $this->addSql('CREATE INDEX IDX_F95A3199CC8A4CEE ON composants (typeComposantId)');
-        $this->addSql('CREATE INDEX IDX_F95A319936799605 ON composants (productId)');
-        $this->addSql('CREATE TABLE _ComposantConstructeurs (A VARCHAR(36) NOT NULL, B VARCHAR(36) NOT NULL, PRIMARY KEY (A, B))');
-        $this->addSql('CREATE INDEX IDX_60760125D3D99E8B ON _ComposantConstructeurs (A)');
-        $this->addSql('CREATE INDEX IDX_607601254AD0CF31 ON _ComposantConstructeurs (B)');
-        $this->addSql('CREATE TABLE constructeurs (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, email VARCHAR(255) DEFAULT NULL, phone VARCHAR(255) DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_CC8D6F55E237E06 ON constructeurs (name)');
-        $this->addSql('CREATE TABLE custom_field_values (id VARCHAR(36) NOT NULL, value VARCHAR(255) NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, customFieldId VARCHAR(36) NOT NULL, machineId VARCHAR(36) DEFAULT NULL, composantId VARCHAR(36) DEFAULT NULL, pieceId VARCHAR(36) DEFAULT NULL, productId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_6B64D7FF5C4A705F ON custom_field_values (customFieldId)');
-        $this->addSql('CREATE INDEX IDX_6B64D7FF633EC4FD ON custom_field_values (machineId)');
-        $this->addSql('CREATE INDEX IDX_6B64D7FF345EE564 ON custom_field_values (composantId)');
-        $this->addSql('CREATE INDEX IDX_6B64D7FF3C6A9D1 ON custom_field_values (pieceId)');
-        $this->addSql('CREATE INDEX IDX_6B64D7FF36799605 ON custom_field_values (productId)');
-        $this->addSql('CREATE TABLE custom_fields (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, type VARCHAR(50) NOT NULL, required BOOLEAN DEFAULT false NOT NULL, defaultValue VARCHAR(255) DEFAULT NULL, options JSON NOT NULL, orderIndex INT DEFAULT 0 NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, typeMachineId VARCHAR(36) DEFAULT NULL, typeComposantId VARCHAR(36) DEFAULT NULL, typePieceId VARCHAR(36) DEFAULT NULL, typeProductId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_4A48378C2F024C2 ON custom_fields (typeMachineId)');
-        $this->addSql('CREATE INDEX IDX_4A48378CCC8A4CEE ON custom_fields (typeComposantId)');
-        $this->addSql('CREATE INDEX IDX_4A48378C169F1CF6 ON custom_fields (typePieceId)');
-        $this->addSql('CREATE INDEX IDX_4A48378C57B7763A ON custom_fields (typeProductId)');
-        $this->addSql('CREATE TABLE documents (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, filename VARCHAR(255) NOT NULL, path VARCHAR(500) NOT NULL, mimeType VARCHAR(100) NOT NULL, size INT NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, machineId VARCHAR(36) DEFAULT NULL, composantId VARCHAR(36) DEFAULT NULL, pieceId VARCHAR(36) DEFAULT NULL, productId VARCHAR(36) DEFAULT NULL, siteId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_A2B07288633EC4FD ON documents (machineId)');
-        $this->addSql('CREATE INDEX IDX_A2B07288345EE564 ON documents (composantId)');
-        $this->addSql('CREATE INDEX IDX_A2B072883C6A9D1 ON documents (pieceId)');
-        $this->addSql('CREATE INDEX IDX_A2B0728836799605 ON documents (productId)');
-        $this->addSql('CREATE INDEX IDX_A2B072886973A4FD ON documents (siteId)');
-        $this->addSql('CREATE TABLE machine_component_links (id VARCHAR(36) NOT NULL, nameOverride VARCHAR(255) DEFAULT NULL, referenceOverride VARCHAR(255) DEFAULT NULL, prixOverride NUMERIC(10, 2) DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, machineId VARCHAR(36) NOT NULL, composantId VARCHAR(36) NOT NULL, parentLinkId VARCHAR(36) DEFAULT NULL, typeMachineComponentRequirementId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_528EFE19633EC4FD ON machine_component_links (machineId)');
-        $this->addSql('CREATE INDEX IDX_528EFE19345EE564 ON machine_component_links (composantId)');
-        $this->addSql('CREATE INDEX IDX_528EFE19EF6CF34B ON machine_component_links (parentLinkId)');
-        $this->addSql('CREATE INDEX IDX_528EFE19C44B383C ON machine_component_links (typeMachineComponentRequirementId)');
-        $this->addSql('CREATE TABLE machine_piece_links (id VARCHAR(36) NOT NULL, nameOverride VARCHAR(255) DEFAULT NULL, referenceOverride VARCHAR(255) DEFAULT NULL, prixOverride NUMERIC(10, 2) DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, machineId VARCHAR(36) NOT NULL, pieceId VARCHAR(36) NOT NULL, parentLinkId VARCHAR(36) DEFAULT NULL, typeMachinePieceRequirementId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_62941615633EC4FD ON machine_piece_links (machineId)');
-        $this->addSql('CREATE INDEX IDX_629416153C6A9D1 ON machine_piece_links (pieceId)');
-        $this->addSql('CREATE INDEX IDX_62941615EF6CF34B ON machine_piece_links (parentLinkId)');
-        $this->addSql('CREATE INDEX IDX_62941615F957D314 ON machine_piece_links (typeMachinePieceRequirementId)');
-        $this->addSql('CREATE TABLE machine_product_links (id VARCHAR(36) NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, machineId VARCHAR(36) NOT NULL, productId VARCHAR(36) NOT NULL, typeMachineProductRequirementId VARCHAR(36) DEFAULT NULL, parentLinkId VARCHAR(36) DEFAULT NULL, parentComponentLinkId VARCHAR(36) DEFAULT NULL, parentPieceLinkId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_8CC32259633EC4FD ON machine_product_links (machineId)');
-        $this->addSql('CREATE INDEX IDX_8CC3225936799605 ON machine_product_links (productId)');
-        $this->addSql('CREATE INDEX IDX_8CC32259B590B209 ON machine_product_links (typeMachineProductRequirementId)');
-        $this->addSql('CREATE INDEX IDX_8CC32259EF6CF34B ON machine_product_links (parentLinkId)');
-        $this->addSql('CREATE INDEX IDX_8CC32259A63AC5DC ON machine_product_links (parentComponentLinkId)');
-        $this->addSql('CREATE INDEX IDX_8CC32259937A1D7C ON machine_product_links (parentPieceLinkId)');
-        $this->addSql('CREATE TABLE machines (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, reference VARCHAR(255) DEFAULT NULL, prix NUMERIC(10, 2) DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, siteId VARCHAR(36) NOT NULL, typeMachineId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_F1CE8DED5E237E06 ON machines (name)');
-        $this->addSql('CREATE INDEX IDX_F1CE8DED6973A4FD ON machines (siteId)');
-        $this->addSql('CREATE INDEX IDX_F1CE8DED2F024C2 ON machines (typeMachineId)');
-        $this->addSql('CREATE TABLE _MachineConstructeurs (A VARCHAR(36) NOT NULL, B VARCHAR(36) NOT NULL, PRIMARY KEY (A, B))');
-        $this->addSql('CREATE INDEX IDX_E6A040CCD3D99E8B ON _MachineConstructeurs (A)');
-        $this->addSql('CREATE INDEX IDX_E6A040CC4AD0CF31 ON _MachineConstructeurs (B)');
-        $this->addSql('CREATE TABLE model_types (id VARCHAR(36) NOT NULL, name VARCHAR(120) NOT NULL, code VARCHAR(60) NOT NULL, category VARCHAR(255) NOT NULL, notes TEXT DEFAULT NULL, description TEXT DEFAULT NULL, componentSkeleton JSON DEFAULT NULL, pieceSkeleton JSON DEFAULT NULL, productSkeleton JSON DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_6773A9C777153098 ON model_types (code)');
-        $this->addSql('CREATE UNIQUE INDEX unique_category_name ON model_types (category, name)');
-        $this->addSql('CREATE TABLE pieces (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, reference VARCHAR(255) DEFAULT NULL, prix NUMERIC(10, 2) DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, typePieceId VARCHAR(36) DEFAULT NULL, productId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_B92D74725E237E06 ON pieces (name)');
-        $this->addSql('CREATE INDEX IDX_B92D7472169F1CF6 ON pieces (typePieceId)');
-        $this->addSql('CREATE INDEX IDX_B92D747236799605 ON pieces (productId)');
-        $this->addSql('CREATE TABLE _PieceConstructeurs (A VARCHAR(36) NOT NULL, B VARCHAR(36) NOT NULL, PRIMARY KEY (A, B))');
-        $this->addSql('CREATE INDEX IDX_E94732E5D3D99E8B ON _PieceConstructeurs (A)');
-        $this->addSql('CREATE INDEX IDX_E94732E54AD0CF31 ON _PieceConstructeurs (B)');
-        $this->addSql('CREATE TABLE products (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, reference VARCHAR(255) DEFAULT NULL, supplierPrice NUMERIC(10, 2) DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, typeProductId VARCHAR(36) DEFAULT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_B3BA5A5A5E237E06 ON products (name)');
-        $this->addSql('CREATE INDEX IDX_B3BA5A5A57B7763A ON products (typeProductId)');
-        $this->addSql('CREATE TABLE _ProductConstructeurs (A VARCHAR(36) NOT NULL, B VARCHAR(36) NOT NULL, PRIMARY KEY (A, B))');
-        $this->addSql('CREATE INDEX IDX_CF7403FCD3D99E8B ON _ProductConstructeurs (A)');
-        $this->addSql('CREATE INDEX IDX_CF7403FC4AD0CF31 ON _ProductConstructeurs (B)');
-        $this->addSql('CREATE TABLE profiles (id VARCHAR(36) NOT NULL, email VARCHAR(180) DEFAULT NULL, firstName VARCHAR(100) NOT NULL, lastName VARCHAR(100) NOT NULL, isActive BOOLEAN DEFAULT true NOT NULL, roles JSON DEFAULT \'["ROLE_USER"]\' NOT NULL, password VARCHAR(255) DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_email ON profiles (email)');
-        $this->addSql('CREATE TABLE sites (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, contactName VARCHAR(255) DEFAULT \'\' NOT NULL, contactPhone VARCHAR(20) DEFAULT \'\' NOT NULL, contactAddress VARCHAR(500) DEFAULT \'\' NOT NULL, contactPostalCode VARCHAR(10) DEFAULT \'\' NOT NULL, contactCity VARCHAR(100) DEFAULT \'\' NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE TABLE type_machine_component_requirements (id VARCHAR(36) NOT NULL, label VARCHAR(255) DEFAULT NULL, minCount INT DEFAULT 1 NOT NULL, maxCount INT DEFAULT NULL, allowNewModels BOOLEAN DEFAULT true NOT NULL, allow_new_models BOOLEAN DEFAULT true NOT NULL, orderIndex INT DEFAULT 0 NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, typeMachineId VARCHAR(36) NOT NULL, typeComposantId VARCHAR(36) NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_969587902F024C2 ON type_machine_component_requirements (typeMachineId)');
-        $this->addSql('CREATE INDEX IDX_96958790CC8A4CEE ON type_machine_component_requirements (typeComposantId)');
-        $this->addSql('CREATE TABLE type_machine_piece_requirements (id VARCHAR(36) NOT NULL, label VARCHAR(255) DEFAULT NULL, minCount INT DEFAULT 0 NOT NULL, maxCount INT DEFAULT NULL, required BOOLEAN DEFAULT false NOT NULL, allowNewModels BOOLEAN DEFAULT true NOT NULL, orderIndex INT DEFAULT 0 NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, typeMachineId VARCHAR(36) NOT NULL, typePieceId VARCHAR(36) NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_F609E59E2F024C2 ON type_machine_piece_requirements (typeMachineId)');
-        $this->addSql('CREATE INDEX IDX_F609E59E169F1CF6 ON type_machine_piece_requirements (typePieceId)');
-        $this->addSql('CREATE TABLE type_machine_product_requirements (id VARCHAR(36) NOT NULL, label VARCHAR(255) DEFAULT NULL, minCount INT DEFAULT 0 NOT NULL, maxCount INT DEFAULT NULL, required BOOLEAN DEFAULT false NOT NULL, allowNewModels BOOLEAN DEFAULT true NOT NULL, orderIndex INT DEFAULT 0 NOT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, typeMachineId VARCHAR(36) NOT NULL, typeProductId VARCHAR(36) NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE INDEX IDX_29A51F982F024C2 ON type_machine_product_requirements (typeMachineId)');
-        $this->addSql('CREATE INDEX IDX_29A51F9857B7763A ON type_machine_product_requirements (typeProductId)');
-        $this->addSql('CREATE TABLE type_machines (id VARCHAR(36) NOT NULL, name VARCHAR(255) NOT NULL, description TEXT DEFAULT NULL, maintenanceFrequency VARCHAR(255) DEFAULT NULL, maintenance_frequency VARCHAR(255) DEFAULT NULL, criticalParts JSON DEFAULT NULL, machinePieces JSON DEFAULT NULL, machine_pieces JSON DEFAULT NULL, specifications JSON DEFAULT NULL, createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, updatedAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL, PRIMARY KEY (id))');
-        $this->addSql('CREATE UNIQUE INDEX UNIQ_3C31AA115E237E06 ON type_machines (name)');
-        $this->addSql('ALTER TABLE composants ADD CONSTRAINT FK_F95A3199CC8A4CEE FOREIGN KEY (typeComposantId) REFERENCES model_types (id) NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE composants ADD CONSTRAINT FK_F95A319936799605 FOREIGN KEY (productId) REFERENCES products (id) ON DELETE SET NULL NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _ComposantConstructeurs ADD CONSTRAINT FK_60760125D3D99E8B FOREIGN KEY (A) REFERENCES composants (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _ComposantConstructeurs ADD CONSTRAINT FK_607601254AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_field_values ADD CONSTRAINT FK_6B64D7FF5C4A705F FOREIGN KEY (customFieldId) REFERENCES custom_fields (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_field_values ADD CONSTRAINT FK_6B64D7FF633EC4FD FOREIGN KEY (machineId) REFERENCES machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_field_values ADD CONSTRAINT FK_6B64D7FF345EE564 FOREIGN KEY (composantId) REFERENCES composants (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_field_values ADD CONSTRAINT FK_6B64D7FF3C6A9D1 FOREIGN KEY (pieceId) REFERENCES pieces (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_field_values ADD CONSTRAINT FK_6B64D7FF36799605 FOREIGN KEY (productId) REFERENCES products (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_fields ADD CONSTRAINT FK_4A48378C2F024C2 FOREIGN KEY (typeMachineId) REFERENCES type_machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_fields ADD CONSTRAINT FK_4A48378CCC8A4CEE FOREIGN KEY (typeComposantId) REFERENCES model_types (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_fields ADD CONSTRAINT FK_4A48378C169F1CF6 FOREIGN KEY (typePieceId) REFERENCES model_types (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE custom_fields ADD CONSTRAINT FK_4A48378C57B7763A FOREIGN KEY (typeProductId) REFERENCES model_types (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE documents ADD CONSTRAINT FK_A2B07288633EC4FD FOREIGN KEY (machineId) REFERENCES machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE documents ADD CONSTRAINT FK_A2B07288345EE564 FOREIGN KEY (composantId) REFERENCES composants (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE documents ADD CONSTRAINT FK_A2B072883C6A9D1 FOREIGN KEY (pieceId) REFERENCES pieces (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE documents ADD CONSTRAINT FK_A2B0728836799605 FOREIGN KEY (productId) REFERENCES products (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE documents ADD CONSTRAINT FK_A2B072886973A4FD FOREIGN KEY (siteId) REFERENCES sites (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_component_links ADD CONSTRAINT FK_528EFE19633EC4FD FOREIGN KEY (machineId) REFERENCES machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_component_links ADD CONSTRAINT FK_528EFE19345EE564 FOREIGN KEY (composantId) REFERENCES composants (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_component_links ADD CONSTRAINT FK_528EFE19EF6CF34B FOREIGN KEY (parentLinkId) REFERENCES machine_component_links (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_component_links ADD CONSTRAINT FK_528EFE19C44B383C FOREIGN KEY (typeMachineComponentRequirementId) REFERENCES type_machine_component_requirements (id) ON DELETE SET NULL NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_piece_links ADD CONSTRAINT FK_62941615633EC4FD FOREIGN KEY (machineId) REFERENCES machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_piece_links ADD CONSTRAINT FK_629416153C6A9D1 FOREIGN KEY (pieceId) REFERENCES pieces (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_piece_links ADD CONSTRAINT FK_62941615EF6CF34B FOREIGN KEY (parentLinkId) REFERENCES machine_component_links (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_piece_links ADD CONSTRAINT FK_62941615F957D314 FOREIGN KEY (typeMachinePieceRequirementId) REFERENCES type_machine_piece_requirements (id) ON DELETE SET NULL NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_product_links ADD CONSTRAINT FK_8CC32259633EC4FD FOREIGN KEY (machineId) REFERENCES machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_product_links ADD CONSTRAINT FK_8CC3225936799605 FOREIGN KEY (productId) REFERENCES products (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_product_links ADD CONSTRAINT FK_8CC32259B590B209 FOREIGN KEY (typeMachineProductRequirementId) REFERENCES type_machine_product_requirements (id) ON DELETE SET NULL NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_product_links ADD CONSTRAINT FK_8CC32259EF6CF34B FOREIGN KEY (parentLinkId) REFERENCES machine_product_links (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_product_links ADD CONSTRAINT FK_8CC32259A63AC5DC FOREIGN KEY (parentComponentLinkId) REFERENCES machine_component_links (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machine_product_links ADD CONSTRAINT FK_8CC32259937A1D7C FOREIGN KEY (parentPieceLinkId) REFERENCES machine_piece_links (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machines ADD CONSTRAINT FK_F1CE8DED6973A4FD FOREIGN KEY (siteId) REFERENCES sites (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE machines ADD CONSTRAINT FK_F1CE8DED2F024C2 FOREIGN KEY (typeMachineId) REFERENCES type_machines (id) NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _MachineConstructeurs ADD CONSTRAINT FK_E6A040CCD3D99E8B FOREIGN KEY (A) REFERENCES machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _MachineConstructeurs ADD CONSTRAINT FK_E6A040CC4AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE pieces ADD CONSTRAINT FK_B92D7472169F1CF6 FOREIGN KEY (typePieceId) REFERENCES model_types (id) NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE pieces ADD CONSTRAINT FK_B92D747236799605 FOREIGN KEY (productId) REFERENCES products (id) ON DELETE SET NULL NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _PieceConstructeurs ADD CONSTRAINT FK_E94732E5D3D99E8B FOREIGN KEY (A) REFERENCES pieces (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _PieceConstructeurs ADD CONSTRAINT FK_E94732E54AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE products ADD CONSTRAINT FK_B3BA5A5A57B7763A FOREIGN KEY (typeProductId) REFERENCES model_types (id) NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _ProductConstructeurs ADD CONSTRAINT FK_CF7403FCD3D99E8B FOREIGN KEY (A) REFERENCES products (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE _ProductConstructeurs ADD CONSTRAINT FK_CF7403FC4AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE type_machine_component_requirements ADD CONSTRAINT FK_969587902F024C2 FOREIGN KEY (typeMachineId) REFERENCES type_machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE type_machine_component_requirements ADD CONSTRAINT FK_96958790CC8A4CEE FOREIGN KEY (typeComposantId) REFERENCES model_types (id) NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE type_machine_piece_requirements ADD CONSTRAINT FK_F609E59E2F024C2 FOREIGN KEY (typeMachineId) REFERENCES type_machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE type_machine_piece_requirements ADD CONSTRAINT FK_F609E59E169F1CF6 FOREIGN KEY (typePieceId) REFERENCES model_types (id) NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE type_machine_product_requirements ADD CONSTRAINT FK_29A51F982F024C2 FOREIGN KEY (typeMachineId) REFERENCES type_machines (id) ON DELETE CASCADE NOT DEFERRABLE');
-        $this->addSql('ALTER TABLE type_machine_product_requirements ADD CONSTRAINT FK_29A51F9857B7763A FOREIGN KEY (typeProductId) REFERENCES model_types (id) NOT DEFERRABLE');
-    }
-
-    public function down(Schema $schema): void
-    {
-        // this down() migration is auto-generated, please modify it to your needs
-        $this->addSql('ALTER TABLE composants DROP CONSTRAINT FK_F95A3199CC8A4CEE');
-        $this->addSql('ALTER TABLE composants DROP CONSTRAINT FK_F95A319936799605');
-        $this->addSql('ALTER TABLE _ComposantConstructeurs DROP CONSTRAINT FK_60760125D3D99E8B');
-        $this->addSql('ALTER TABLE _ComposantConstructeurs DROP CONSTRAINT FK_607601254AD0CF31');
-        $this->addSql('ALTER TABLE custom_field_values DROP CONSTRAINT FK_6B64D7FF5C4A705F');
-        $this->addSql('ALTER TABLE custom_field_values DROP CONSTRAINT FK_6B64D7FF633EC4FD');
-        $this->addSql('ALTER TABLE custom_field_values DROP CONSTRAINT FK_6B64D7FF345EE564');
-        $this->addSql('ALTER TABLE custom_field_values DROP CONSTRAINT FK_6B64D7FF3C6A9D1');
-        $this->addSql('ALTER TABLE custom_field_values DROP CONSTRAINT FK_6B64D7FF36799605');
-        $this->addSql('ALTER TABLE custom_fields DROP CONSTRAINT FK_4A48378C2F024C2');
-        $this->addSql('ALTER TABLE custom_fields DROP CONSTRAINT FK_4A48378CCC8A4CEE');
-        $this->addSql('ALTER TABLE custom_fields DROP CONSTRAINT FK_4A48378C169F1CF6');
-        $this->addSql('ALTER TABLE custom_fields DROP CONSTRAINT FK_4A48378C57B7763A');
-        $this->addSql('ALTER TABLE documents DROP CONSTRAINT FK_A2B07288633EC4FD');
-        $this->addSql('ALTER TABLE documents DROP CONSTRAINT FK_A2B07288345EE564');
-        $this->addSql('ALTER TABLE documents DROP CONSTRAINT FK_A2B072883C6A9D1');
-        $this->addSql('ALTER TABLE documents DROP CONSTRAINT FK_A2B0728836799605');
-        $this->addSql('ALTER TABLE documents DROP CONSTRAINT FK_A2B072886973A4FD');
-        $this->addSql('ALTER TABLE machine_component_links DROP CONSTRAINT FK_528EFE19633EC4FD');
-        $this->addSql('ALTER TABLE machine_component_links DROP CONSTRAINT FK_528EFE19345EE564');
-        $this->addSql('ALTER TABLE machine_component_links DROP CONSTRAINT FK_528EFE19EF6CF34B');
-        $this->addSql('ALTER TABLE machine_component_links DROP CONSTRAINT FK_528EFE19C44B383C');
-        $this->addSql('ALTER TABLE machine_piece_links DROP CONSTRAINT FK_62941615633EC4FD');
-        $this->addSql('ALTER TABLE machine_piece_links DROP CONSTRAINT FK_629416153C6A9D1');
-        $this->addSql('ALTER TABLE machine_piece_links DROP CONSTRAINT FK_62941615EF6CF34B');
-        $this->addSql('ALTER TABLE machine_piece_links DROP CONSTRAINT FK_62941615F957D314');
-        $this->addSql('ALTER TABLE machine_product_links DROP CONSTRAINT FK_8CC32259633EC4FD');
-        $this->addSql('ALTER TABLE machine_product_links DROP CONSTRAINT FK_8CC3225936799605');
-        $this->addSql('ALTER TABLE machine_product_links DROP CONSTRAINT FK_8CC32259B590B209');
-        $this->addSql('ALTER TABLE machine_product_links DROP CONSTRAINT FK_8CC32259EF6CF34B');
-        $this->addSql('ALTER TABLE machine_product_links DROP CONSTRAINT FK_8CC32259A63AC5DC');
-        $this->addSql('ALTER TABLE machine_product_links DROP CONSTRAINT FK_8CC32259937A1D7C');
-        $this->addSql('ALTER TABLE machines DROP CONSTRAINT FK_F1CE8DED6973A4FD');
-        $this->addSql('ALTER TABLE machines DROP CONSTRAINT FK_F1CE8DED2F024C2');
-        $this->addSql('ALTER TABLE _MachineConstructeurs DROP CONSTRAINT FK_E6A040CCD3D99E8B');
-        $this->addSql('ALTER TABLE _MachineConstructeurs DROP CONSTRAINT FK_E6A040CC4AD0CF31');
-        $this->addSql('ALTER TABLE pieces DROP CONSTRAINT FK_B92D7472169F1CF6');
-        $this->addSql('ALTER TABLE pieces DROP CONSTRAINT FK_B92D747236799605');
-        $this->addSql('ALTER TABLE _PieceConstructeurs DROP CONSTRAINT FK_E94732E5D3D99E8B');
-        $this->addSql('ALTER TABLE _PieceConstructeurs DROP CONSTRAINT FK_E94732E54AD0CF31');
-        $this->addSql('ALTER TABLE products DROP CONSTRAINT FK_B3BA5A5A57B7763A');
-        $this->addSql('ALTER TABLE _ProductConstructeurs DROP CONSTRAINT FK_CF7403FCD3D99E8B');
-        $this->addSql('ALTER TABLE _ProductConstructeurs DROP CONSTRAINT FK_CF7403FC4AD0CF31');
-        $this->addSql('ALTER TABLE type_machine_component_requirements DROP CONSTRAINT FK_969587902F024C2');
-        $this->addSql('ALTER TABLE type_machine_component_requirements DROP CONSTRAINT FK_96958790CC8A4CEE');
-        $this->addSql('ALTER TABLE type_machine_piece_requirements DROP CONSTRAINT FK_F609E59E2F024C2');
-        $this->addSql('ALTER TABLE type_machine_piece_requirements DROP CONSTRAINT FK_F609E59E169F1CF6');
-        $this->addSql('ALTER TABLE type_machine_product_requirements DROP CONSTRAINT FK_29A51F982F024C2');
-        $this->addSql('ALTER TABLE type_machine_product_requirements DROP CONSTRAINT FK_29A51F9857B7763A');
-        $this->addSql('DROP TABLE composants');
-        $this->addSql('DROP TABLE _ComposantConstructeurs');
-        $this->addSql('DROP TABLE constructeurs');
-        $this->addSql('DROP TABLE custom_field_values');
-        $this->addSql('DROP TABLE custom_fields');
-        $this->addSql('DROP TABLE documents');
-        $this->addSql('DROP TABLE machine_component_links');
-        $this->addSql('DROP TABLE machine_piece_links');
-        $this->addSql('DROP TABLE machine_product_links');
-        $this->addSql('DROP TABLE machines');
-        $this->addSql('DROP TABLE _MachineConstructeurs');
-        $this->addSql('DROP TABLE model_types');
-        $this->addSql('DROP TABLE pieces');
-        $this->addSql('DROP TABLE _PieceConstructeurs');
-        $this->addSql('DROP TABLE products');
-        $this->addSql('DROP TABLE _ProductConstructeurs');
-        $this->addSql('DROP TABLE profiles');
-        $this->addSql('DROP TABLE sites');
-        $this->addSql('DROP TABLE type_machine_component_requirements');
-        $this->addSql('DROP TABLE type_machine_piece_requirements');
-        $this->addSql('DROP TABLE type_machine_product_requirements');
-        $this->addSql('DROP TABLE type_machines');
-    }
-}

migrations/Version20260125143939.php

@@ -0,0 +1,891 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Auto-generated Migration: Please modify to your needs!
+ */
+final class Version20260125143939 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return '';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // this up() migration is auto-generated, please modify it to your needs
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f95a3199df92e79b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f95a3199df92e79b RENAME TO IDX_F95A3199CC8A4CEE';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f95a3199a3fdb2a7') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f95a3199a3fdb2a7 RENAME TO IDX_F95A319936799605';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE _composantconstructeurs DROP CONSTRAINT IF EXISTS "_ComposantConstructeurs_A_fkey"');
+        $this->addSql('ALTER TABLE _composantconstructeurs DROP CONSTRAINT IF EXISTS "_ComposantConstructeurs_B_fkey"');
+        $this->addSql('ALTER TABLE _composantconstructeurs ALTER A TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE _composantconstructeurs ALTER B TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE _composantconstructeurs ADD CONSTRAINT FK_60760125D3D99E8B FOREIGN KEY (A) REFERENCES composants (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _composantconstructeurs ADD CONSTRAINT FK_607601254AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _composantconstructeurs ADD PRIMARY KEY (A, B)');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_5b97d813e8b7be43') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_5b97d813e8b7be43 RENAME TO IDX_60760125D3D99E8B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('_composantconstructeurs_b_index') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX _composantconstructeurs_b_index RENAME TO IDX_607601254AD0CF31';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ff6736d61') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ff6736d61 RENAME TO IDX_6B64D7FF5C4A705F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7fff6bae05f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7fff6bae05f RENAME TO IDX_6B64D7FF633EC4FD';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ffa1dac1c6') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ffa1dac1c6 RENAME TO IDX_6B64D7FF345EE564';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ff96428d73') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ff96428d73 RENAME TO IDX_6B64D7FF3C6A9D1';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ffa3fdb2a7') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ffa3fdb2a7 RENAME TO IDX_6B64D7FF36799605';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378c158582c3') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378c158582c3 RENAME TO IDX_4A48378C2F024C2';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378cdf92e79b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378cdf92e79b RENAME TO IDX_4A48378CCC8A4CEE';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378c4ca601c8') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378c4ca601c8 RENAME TO IDX_4A48378C169F1CF6';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378c40c2d03b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378c40c2d03b RENAME TO IDX_4A48378C57B7763A';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b07288f6bae05f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b07288f6bae05f RENAME TO IDX_A2B07288633EC4FD';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b07288a1dac1c6') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b07288a1dac1c6 RENAME TO IDX_A2B07288345EE564';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b0728896428d73') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b0728896428d73 RENAME TO IDX_A2B072883C6A9D1';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b07288a3fdb2a7') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b07288a3fdb2a7 RENAME TO IDX_A2B0728836799605';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b07288fcf7805f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b07288fcf7805f RENAME TO IDX_A2B072886973A4FD';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe19f6bae05f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe19f6bae05f RENAME TO IDX_528EFE19633EC4FD';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe19a1dac1c6') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe19a1dac1c6 RENAME TO IDX_528EFE19345EE564';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe197d44d2df') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe197d44d2df RENAME TO IDX_528EFE19EF6CF34B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe19bcced9e3') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe19bcced9e3 RENAME TO IDX_528EFE19C44B383C';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_62941615f6bae05f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_62941615f6bae05f RENAME TO IDX_62941615633EC4FD';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6294161596428d73') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6294161596428d73 RENAME TO IDX_629416153C6A9D1';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_629416157d44d2df') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_629416157d44d2df RENAME TO IDX_62941615EF6CF34B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6294161532c54aaf') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6294161532c54aaf RENAME TO IDX_62941615F957D314';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('machine_product_links_machineid_idx') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX machine_product_links_machineid_idx RENAME TO IDX_8CC32259633EC4FD';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('machine_product_links_productid_idx') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX machine_product_links_productid_idx RENAME TO IDX_8CC3225936799605';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc32259357fdbff') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc32259357fdbff RENAME TO IDX_8CC32259B590B209';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc322597d44d2df') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc322597d44d2df RENAME TO IDX_8CC32259EF6CF34B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc32259bcd7dad6') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc32259bcd7dad6 RENAME TO IDX_8CC32259A63AC5DC';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc3225987ceb33f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc3225987ceb33f RENAME TO IDX_8CC32259937A1D7C';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f1ce8dedfcf7805f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f1ce8dedfcf7805f RENAME TO IDX_F1CE8DED6973A4FD';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f1ce8ded158582c3') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f1ce8ded158582c3 RENAME TO IDX_F1CE8DED2F024C2';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE _machineconstructeurs DROP CONSTRAINT IF EXISTS "_MachineConstructeurs_B_fkey"');
+        $this->addSql('ALTER TABLE _machineconstructeurs DROP CONSTRAINT IF EXISTS "_MachineConstructeurs_A_fkey"');
+        $this->addSql('ALTER TABLE _machineconstructeurs ALTER A TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE _machineconstructeurs ALTER B TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE _machineconstructeurs ADD CONSTRAINT FK_E6A040CCD3D99E8B FOREIGN KEY (A) REFERENCES machines (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _machineconstructeurs ADD CONSTRAINT FK_E6A040CC4AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _machineconstructeurs ADD PRIMARY KEY (A, B)');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4f225b32e8b7be43') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4f225b32e8b7be43 RENAME TO IDX_E6A040CCD3D99E8B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('_machineconstructeurs_b_index') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX _machineconstructeurs_b_index RENAME TO IDX_E6A040CC4AD0CF31';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE model_types DROP CONSTRAINT IF EXISTS "ModelType_category_name_key"');
+        $this->addSql('ALTER TABLE model_types DROP CONSTRAINT IF EXISTS "ModelType_code_key"');
+        $this->addSql('ALTER TABLE model_types ALTER id TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE model_types ALTER category TYPE VARCHAR(255)');
+        $this->addSql('ALTER TABLE model_types ALTER createdAt DROP DEFAULT');
+        $this->addSql('ALTER TABLE model_types ALTER componentSkeleton TYPE JSON');
+        $this->addSql('ALTER TABLE model_types ALTER pieceSkeleton TYPE JSON');
+        $this->addSql('ALTER TABLE model_types ALTER productSkeleton TYPE JSON');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_b92d74724ca601c8') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_b92d74724ca601c8 RENAME TO IDX_B92D7472169F1CF6';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_b92d7472a3fdb2a7') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_b92d7472a3fdb2a7 RENAME TO IDX_B92D747236799605';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE _piececonstructeurs DROP CONSTRAINT IF EXISTS "_PieceConstructeurs_A_fkey"');
+        $this->addSql('ALTER TABLE _piececonstructeurs DROP CONSTRAINT IF EXISTS "_PieceConstructeurs_B_fkey"');
+        $this->addSql('ALTER TABLE _piececonstructeurs ALTER A TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE _piececonstructeurs ALTER B TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE _piececonstructeurs ADD CONSTRAINT FK_E94732E5D3D99E8B FOREIGN KEY (A) REFERENCES pieces (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _piececonstructeurs ADD CONSTRAINT FK_E94732E54AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _piececonstructeurs ADD PRIMARY KEY (A, B)');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_77fc120e8b7be43') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_77fc120e8b7be43 RENAME TO IDX_E94732E5D3D99E8B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('_piececonstructeurs_b_index') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX _piececonstructeurs_b_index RENAME TO IDX_E94732E54AD0CF31';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_b3ba5a5a40c2d03b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_b3ba5a5a40c2d03b RENAME TO IDX_B3BA5A5A57B7763A';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE _productconstructeurs DROP CONSTRAINT IF EXISTS "_ProductConstructeurs_B_fkey"');
+        $this->addSql('ALTER TABLE _productconstructeurs DROP CONSTRAINT IF EXISTS "_ProductConstructeurs_A_fkey"');
+        $this->addSql('ALTER TABLE _productconstructeurs ALTER A TYPE VARCHAR(36)');
+        $this->addSql('ALTER TABLE _productconstructeurs ALTER B TYPE VARCHAR(36)');
+        // Clean orphaned relations before re-adding foreign keys.
+        $this->addSql('DELETE FROM _productconstructeurs WHERE A IS NULL OR B IS NULL');
+        $this->addSql('DELETE FROM _productconstructeurs pc WHERE NOT EXISTS (SELECT 1 FROM products p WHERE p.id = pc.A)');
+        $this->addSql('DELETE FROM _productconstructeurs pc WHERE NOT EXISTS (SELECT 1 FROM constructeurs c WHERE c.id = pc.B)');
+        $this->addSql('ALTER TABLE _productconstructeurs ADD CONSTRAINT FK_CF7403FCD3D99E8B FOREIGN KEY (A) REFERENCES products (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _productconstructeurs ADD CONSTRAINT FK_CF7403FC4AD0CF31 FOREIGN KEY (B) REFERENCES constructeurs (id) ON DELETE CASCADE NOT DEFERRABLE');
+        $this->addSql('ALTER TABLE _productconstructeurs ADD PRIMARY KEY (A, B)');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_66f61802e8b7be43') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_66f61802e8b7be43 RENAME TO IDX_CF7403FCD3D99E8B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('_productconstructeurs_b_index') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX _productconstructeurs_b_index RENAME TO IDX_CF7403FC4AD0CF31';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('DROP INDEX IF EXISTS uniq_profiles_email');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_96958790158582c3') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_96958790158582c3 RENAME TO IDX_969587902F024C2';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_96958790df92e79b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_96958790df92e79b RENAME TO IDX_96958790CC8A4CEE';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f609e59e158582c3') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f609e59e158582c3 RENAME TO IDX_F609E59E2F024C2';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f609e59e4ca601c8') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f609e59e4ca601c8 RENAME TO IDX_F609E59E169F1CF6';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_29a51f98158582c3') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_29a51f98158582c3 RENAME TO IDX_29A51F982F024C2';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_29a51f9840c2d03b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_29a51f9840c2d03b RENAME TO IDX_29A51F9857B7763A';
+  END IF;
+END $$;
+SQL
+);
+    }
+
+    public function down(Schema $schema): void
+    {
+        // this down() migration is auto-generated, please modify it to your needs
+        $this->addSql('ALTER TABLE _ComposantConstructeurs DROP CONSTRAINT IF EXISTS FK_60760125D3D99E8B');
+        $this->addSql('ALTER TABLE _ComposantConstructeurs DROP CONSTRAINT IF EXISTS FK_607601254AD0CF31');
+        $this->addSql('ALTER TABLE _ComposantConstructeurs DROP CONSTRAINT IF EXISTS _ComposantConstructeurs_pkey');
+        $this->addSql('ALTER TABLE _ComposantConstructeurs ALTER a TYPE TEXT');
+        $this->addSql('ALTER TABLE _ComposantConstructeurs ALTER b TYPE TEXT');
+        $this->addSql('ALTER TABLE _ComposantConstructeurs ADD CONSTRAINT "_ComposantConstructeurs_A_fkey" FOREIGN KEY (a) REFERENCES composants (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql('ALTER TABLE _ComposantConstructeurs ADD CONSTRAINT "_ComposantConstructeurs_B_fkey" FOREIGN KEY (b) REFERENCES constructeurs (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_607601254ad0cf31') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_607601254ad0cf31 RENAME TO "_ComposantConstructeurs_B_index"';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_60760125d3d99e8b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_60760125d3d99e8b RENAME TO IDX_5B97D813E8B7BE43';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE _MachineConstructeurs DROP CONSTRAINT IF EXISTS FK_E6A040CCD3D99E8B');
+        $this->addSql('ALTER TABLE _MachineConstructeurs DROP CONSTRAINT IF EXISTS FK_E6A040CC4AD0CF31');
+        $this->addSql('ALTER TABLE _MachineConstructeurs DROP CONSTRAINT IF EXISTS _MachineConstructeurs_pkey');
+        $this->addSql('ALTER TABLE _MachineConstructeurs ALTER a TYPE TEXT');
+        $this->addSql('ALTER TABLE _MachineConstructeurs ALTER b TYPE TEXT');
+        $this->addSql('ALTER TABLE _MachineConstructeurs ADD CONSTRAINT "_MachineConstructeurs_B_fkey" FOREIGN KEY (b) REFERENCES constructeurs (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql('ALTER TABLE _MachineConstructeurs ADD CONSTRAINT "_MachineConstructeurs_A_fkey" FOREIGN KEY (a) REFERENCES machines (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_e6a040cc4ad0cf31') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_e6a040cc4ad0cf31 RENAME TO "_MachineConstructeurs_B_index"';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_e6a040ccd3d99e8b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_e6a040ccd3d99e8b RENAME TO IDX_4F225B32E8B7BE43';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE _PieceConstructeurs DROP CONSTRAINT IF EXISTS FK_E94732E5D3D99E8B');
+        $this->addSql('ALTER TABLE _PieceConstructeurs DROP CONSTRAINT IF EXISTS FK_E94732E54AD0CF31');
+        $this->addSql('ALTER TABLE _PieceConstructeurs DROP CONSTRAINT IF EXISTS _PieceConstructeurs_pkey');
+        $this->addSql('ALTER TABLE _PieceConstructeurs ALTER a TYPE TEXT');
+        $this->addSql('ALTER TABLE _PieceConstructeurs ALTER b TYPE TEXT');
+        $this->addSql('ALTER TABLE _PieceConstructeurs ADD CONSTRAINT "_PieceConstructeurs_A_fkey" FOREIGN KEY (a) REFERENCES pieces (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql('ALTER TABLE _PieceConstructeurs ADD CONSTRAINT "_PieceConstructeurs_B_fkey" FOREIGN KEY (b) REFERENCES constructeurs (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_e94732e54ad0cf31') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_e94732e54ad0cf31 RENAME TO "_PieceConstructeurs_B_index"';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_e94732e5d3d99e8b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_e94732e5d3d99e8b RENAME TO IDX_77FC120E8B7BE43';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE _ProductConstructeurs DROP CONSTRAINT IF EXISTS FK_CF7403FCD3D99E8B');
+        $this->addSql('ALTER TABLE _ProductConstructeurs DROP CONSTRAINT IF EXISTS FK_CF7403FC4AD0CF31');
+        $this->addSql('ALTER TABLE _ProductConstructeurs DROP CONSTRAINT IF EXISTS _ProductConstructeurs_pkey');
+        $this->addSql('ALTER TABLE _ProductConstructeurs ALTER a TYPE TEXT');
+        $this->addSql('ALTER TABLE _ProductConstructeurs ALTER b TYPE TEXT');
+        $this->addSql('ALTER TABLE _ProductConstructeurs ADD CONSTRAINT "_ProductConstructeurs_B_fkey" FOREIGN KEY (b) REFERENCES products (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql('ALTER TABLE _ProductConstructeurs ADD CONSTRAINT "_ProductConstructeurs_A_fkey" FOREIGN KEY (a) REFERENCES constructeurs (id) ON UPDATE CASCADE ON DELETE CASCADE NOT DEFERRABLE INITIALLY IMMEDIATE');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_cf7403fc4ad0cf31') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_cf7403fc4ad0cf31 RENAME TO "_ProductConstructeurs_B_index"';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_cf7403fcd3d99e8b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_cf7403fcd3d99e8b RENAME TO IDX_66F61802E8B7BE43';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f95a319936799605') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f95a319936799605 RENAME TO IDX_F95A3199A3FDB2A7';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f95a3199cc8a4cee') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f95a3199cc8a4cee RENAME TO IDX_F95A3199DF92E79B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ff345ee564') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ff345ee564 RENAME TO IDX_6B64D7FFA1DAC1C6';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ff5c4a705f') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ff5c4a705f RENAME TO IDX_6B64D7FF6736D61';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ff633ec4fd') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ff633ec4fd RENAME TO IDX_6B64D7FFF6BAE05F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ff3c6a9d1') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ff3c6a9d1 RENAME TO IDX_6B64D7FF96428D73';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_6b64d7ff36799605') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_6b64d7ff36799605 RENAME TO IDX_6B64D7FFA3FDB2A7';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378c57b7763a') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378c57b7763a RENAME TO IDX_4A48378C40C2D03B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378c2f024c2') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378c2f024c2 RENAME TO IDX_4A48378C158582C3';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378c169f1cf6') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378c169f1cf6 RENAME TO IDX_4A48378C4CA601C8';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_4a48378ccc8a4cee') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_4a48378ccc8a4cee RENAME TO IDX_4A48378CDF92E79B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b07288345ee564') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b07288345ee564 RENAME TO IDX_A2B07288A1DAC1C6';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b07288633ec4fd') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b07288633ec4fd RENAME TO IDX_A2B07288F6BAE05F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b072886973a4fd') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b072886973a4fd RENAME TO IDX_A2B07288FCF7805F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b072883c6a9d1') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b072883c6a9d1 RENAME TO IDX_A2B0728896428D73';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_a2b0728836799605') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_a2b0728836799605 RENAME TO IDX_A2B07288A3FDB2A7';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe19345ee564') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe19345ee564 RENAME TO IDX_528EFE19A1DAC1C6';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe19633ec4fd') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe19633ec4fd RENAME TO IDX_528EFE19F6BAE05F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe19ef6cf34b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe19ef6cf34b RENAME TO IDX_528EFE197D44D2DF';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_528efe19c44b383c') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_528efe19c44b383c RENAME TO IDX_528EFE19BCCED9E3';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_62941615ef6cf34b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_62941615ef6cf34b RENAME TO IDX_629416157D44D2DF';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_62941615633ec4fd') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_62941615633ec4fd RENAME TO IDX_62941615F6BAE05F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_629416153c6a9d1') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_629416153c6a9d1 RENAME TO IDX_6294161596428D73';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_62941615f957d314') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_62941615f957d314 RENAME TO IDX_6294161532C54AAF';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc32259633ec4fd') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc32259633ec4fd RENAME TO "machine_product_links_machineId_idx"';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc3225936799605') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc3225936799605 RENAME TO "machine_product_links_productId_idx"';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc32259ef6cf34b') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc32259ef6cf34b RENAME TO IDX_8CC322597D44D2DF';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc32259b590b209') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc32259b590b209 RENAME TO IDX_8CC32259357FDBFF';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc32259a63ac5dc') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc32259a63ac5dc RENAME TO IDX_8CC32259BCD7DAD6';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_8cc32259937a1d7c') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_8cc32259937a1d7c RENAME TO IDX_8CC3225987CEB33F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f1ce8ded2f024c2') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f1ce8ded2f024c2 RENAME TO IDX_F1CE8DED158582C3';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f1ce8ded6973a4fd') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f1ce8ded6973a4fd RENAME TO IDX_F1CE8DEDFCF7805F';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('ALTER TABLE model_types ALTER id TYPE TEXT');
+        $this->addSql('ALTER TABLE model_types ALTER category TYPE VARCHAR');
+        $this->addSql('ALTER TABLE model_types ALTER componentskeleton TYPE JSONB');
+        $this->addSql('ALTER TABLE model_types ALTER pieceskeleton TYPE JSONB');
+        $this->addSql('ALTER TABLE model_types ALTER productskeleton TYPE JSONB');
+        $this->addSql('ALTER TABLE model_types ALTER createdat SET DEFAULT CURRENT_TIMESTAMP');
+        $this->addSql('CREATE UNIQUE INDEX "ModelType_category_name_key" ON model_types (category, name)');
+        $this->addSql('CREATE UNIQUE INDEX "ModelType_code_key" ON model_types (code)');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_b92d7472169f1cf6') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_b92d7472169f1cf6 RENAME TO IDX_B92D74724CA601C8';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_b92d747236799605') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_b92d747236799605 RENAME TO IDX_B92D7472A3FDB2A7';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_b3ba5a5a57b7763a') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_b3ba5a5a57b7763a RENAME TO IDX_B3BA5A5A40C2D03B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql('CREATE UNIQUE INDEX uniq_profiles_email ON profiles (email)');
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_969587902f024c2') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_969587902f024c2 RENAME TO IDX_96958790158582C3';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_96958790cc8a4cee') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_96958790cc8a4cee RENAME TO IDX_96958790DF92E79B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f609e59e169f1cf6') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f609e59e169f1cf6 RENAME TO IDX_F609E59E4CA601C8';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_f609e59e2f024c2') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_f609e59e2f024c2 RENAME TO IDX_F609E59E158582C3';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_29a51f9857b7763a') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_29a51f9857b7763a RENAME TO IDX_29A51F9840C2D03B';
+  END IF;
+END $$;
+SQL
+);
+        $this->addSql(<<<'SQL'
+DO $$ BEGIN
+  IF to_regclass('idx_29a51f982f024c2') IS NOT NULL THEN
+    EXECUTE 'ALTER INDEX idx_29a51f982f024c2 RENAME TO IDX_29A51F98158582C3';
+  END IF;
+END $$;
+SQL
+);
+    }
+}

migrations/Version20260125170000.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20260125170000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Add audit_logs table to store per-entity history entries.';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE audit_logs (
+                id VARCHAR(36) NOT NULL,
+                entityType VARCHAR(50) NOT NULL,
+                entityId VARCHAR(36) NOT NULL,
+                action VARCHAR(20) NOT NULL,
+                diff JSON DEFAULT NULL,
+                snapshot JSON DEFAULT NULL,
+                actorProfileId VARCHAR(36) DEFAULT NULL,
+                createdAt TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                PRIMARY KEY(id)
+            )
+        SQL);
+
+        $this->addSql('CREATE INDEX idx_audit_entity ON audit_logs (entityType, entityId)');
+        $this->addSql('CREATE INDEX idx_audit_created_at ON audit_logs (createdAt)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('DROP TABLE audit_logs');
+    }
+}

scripts/insert_profiles.sql

@@ -1,5 +1,5 @@
-INSERT INTO public.profiles (id, firstname, lastname, isactive, createdat, updatedat)
+INSERT INTO public.profiles (id, firstname, lastname, email, isactive, createdat, updatedat)
 VALUES
-  ('admin-default-profile', 'Admin', 'General', true, '2025-09-23 13:09:47.804', '2025-09-23 13:09:47.804'),
-  ('cmhab2j3x003g47v77xhnm1ff', 'Elodie', 'Souriau', true, '2025-10-28 08:29:25.437', '2025-10-28 08:29:25.437')
+  ('admin-default-profile', 'Admin', 'General', 'admin@admin.fr', true, '2025-09-23 13:09:47.804', '2025-09-23 13:09:47.804'),
+  ('cmhab2j3x003g47v77xhnm1ff', 'Elodie', 'Souriau', 'elodie@gg.fr', true, '2025-10-28 08:29:25.437', '2025-10-28 08:29:25.437')
 ON CONFLICT (id) DO NOTHING;

scripts/lowercase-columns.sql

@@ -0,0 +1,32 @@
+DO $$
+DECLARE
+    r RECORD;
+BEGIN
+    FOR r IN
+        SELECT table_schema, table_name, column_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND column_name <> lower(column_name)
+        ORDER BY table_name, column_name
+    LOOP
+        -- Skip if a lowercase version already exists to avoid collisions.
+        IF EXISTS (
+            SELECT 1
+            FROM information_schema.columns c
+            WHERE c.table_schema = r.table_schema
+              AND c.table_name = r.table_name
+              AND c.column_name = lower(r.column_name)
+        ) THEN
+            RAISE NOTICE 'Skip %.%: % -> % (target exists)', r.table_name, r.column_name, r.column_name, lower(r.column_name);
+        ELSE
+            EXECUTE format(
+                'ALTER TABLE %I.%I RENAME COLUMN %I TO %I',
+                r.table_schema,
+                r.table_name,
+                r.column_name,
+                lower(r.column_name)
+            );
+            RAISE NOTICE 'Renamed %.%: % -> %', r.table_name, r.column_name, r.column_name, lower(r.column_name);
+        END IF;
+    END LOOP;
+END $$;

scripts/normalize-dump.py

@@ -1,74 +1,171 @@
 #!/usr/bin/env python3
+import re
 import sys
 
 
+INSERT_RE = re.compile(
+    r"(?P<prefix>INSERT\s+INTO\s+[^;]*?\()(?P<cols>[^)]*)(?P<suffix>\)\s+VALUES)",
+    re.IGNORECASE | re.DOTALL,
+)
+TABLE_RE = re.compile(
+    r"(?P<before>INSERT\s+INTO\s+)(?P<table>(?:\"[^\"]+\"\.|[A-Za-z_][\w$]*\.)?\"[^\"]+\"|(?:\"[^\"]+\"\.|[A-Za-z_][\w$]*\.)?[A-Za-z_][\w$]*)",
+    re.IGNORECASE,
+)
+CREATE_DB_RE = re.compile(r"^CREATE\s+DATABASE\s+.+?;$", re.IGNORECASE | re.MULTILINE)
+CONNECT_RE = re.compile(r"^\\connect\\s+.+?$", re.IGNORECASE | re.MULTILINE)
+
+
 TABLE_NAME_MAP = {
     "ModelType": "model_types",
+    "TypeMachine": "type_machines",
+    "TypeMachineComponentRequirement": "type_machine_component_requirements",
+    "TypeMachinePieceRequirement": "type_machine_piece_requirements",
+    "TypeMachineProductRequirement": "type_machine_product_requirements",
+    "MachinePieceLink": "machine_piece_links",
+    "MachineComponentLink": "machine_component_links",
+    "MachineProductLink": "machine_product_links",
+    "Machine": "machines",
+    "Product": "products",
+    "Piece": "pieces",
+    "Composant": "composants",
+    "Profile": "profiles",
+    "CustomField": "custom_fields",
+    "CustomFieldValue": "custom_field_values",
+    "Document": "documents",
+    "Constructeur": "constructeurs",
+    "Site": "sites",
 }
 
 
-def normalize_identifiers(sql: str) -> str:
+SKIP_TABLES = {
+    "_prisma_migrations",
+}
+
+
+def to_snake(name: str) -> str:
     out = []
-    i = 0
-    in_single = False
-    length = len(sql)
-
-    while i < length:
-        ch = sql[i]
-
-        if in_single:
-            if ch == "'":
-                if i + 1 < length and sql[i + 1] == "'":
-                    out.append("''")
-                    i += 2
-                    continue
-                in_single = False
+    length = len(name)
+    for i, ch in enumerate(name):
+        if ch.isupper():
+            prev = name[i - 1] if i > 0 else ""
+            nxt = name[i + 1] if i + 1 < length else ""
+            if i > 0 and (prev.islower() or prev.isdigit() or (prev.isupper() and nxt.islower())):
+                out.append("_")
+            out.append(ch.lower())
+        else:
             out.append(ch)
-            i += 1
-            continue
+    return "".join(out)
 
-        if ch == "'":
-            in_single = True
-            out.append(ch)
-            i += 1
-            continue
 
-        if ch == '"':
-            i += 1
-            ident = []
-            while i < length:
-                if sql[i] == '"':
-                    break
-                ident.append(sql[i])
-                i += 1
-            ident_str = ''.join(ident)
-            mapped = TABLE_NAME_MAP.get(ident_str)
-            if mapped is not None:
-                out.append(mapped)
-            else:
-                out.append(ident_str.lower())
-            if i < length and sql[i] == '"':
-                i += 1
-            continue
+def to_lower_compact(name: str) -> str:
+    return name.replace("_", "").lower()
 
-        out.append(ch)
-        i += 1
 
-    return ''.join(out)
+def remap_table(ident: str, mode: str) -> str:
+    mapped = TABLE_NAME_MAP.get(ident)
+    if mapped is not None:
+        return mapped
+    if mode == "snake":
+        return to_snake(ident)
+    if mode == "lower":
+        return to_lower_compact(ident)
+    raise ValueError(f"Unsupported mode: {mode}")
+
+
+def extract_table_ident(prefix: str) -> str | None:
+    match = TABLE_RE.search(prefix)
+    if not match:
+        return None
+    table = match.group("table")
+    # Handle quoted schema like "public"."TableName"
+    if '"."' in table:
+        parts = table.split('"."', 1)
+        ident = parts[1].strip('"')
+    elif "." in table:
+        _, ident = table.split(".", 1)
+        ident = ident.strip('"')
+    else:
+        ident = table.strip('"')
+    return ident
+
+
+def normalize_table_name(prefix: str, mode: str) -> str:
+    def repl(match: re.Match[str]) -> str:
+        table = match.group("table")
+        schema = ""
+        ident = table
+        # Handle quoted schema like "public"."TableName"
+        if '"."' in table:
+            parts = table.split('"."', 1)
+            schema_name = parts[0].strip('"')
+            ident = parts[1].strip('"')
+            schema = f'"{schema_name}".'
+        elif "." in table:
+            schema_part, ident = table.split(".", 1)
+            schema_name = schema_part.strip('"')
+            schema = f'"{schema_name}".'
+            ident = ident.strip('"')
+        else:
+            ident = table.strip('"')
+        mapped = remap_table(ident, mode)
+        return f'{match.group("before")}{schema}"{mapped}"'
+
+    return TABLE_RE.sub(repl, prefix)
+
+
+def remap_columns(cols: str, mode: str) -> str:
+    def repl(match: re.Match[str]) -> str:
+        name = match.group(1)
+        if mode == "snake":
+            if any(ch.isupper() for ch in name):
+                return f"\"{to_snake(name)}\""
+            return match.group(0)
+        if mode == "lower":
+            return f"\"{to_lower_compact(name)}\""
+        raise ValueError(f"Unsupported mode: {mode}")
+
+    return re.sub(r"\"([^\"]+)\"", repl, cols)
+
+
+def normalize_dump(sql: str, mode: str) -> str:
+    sql = CREATE_DB_RE.sub("", sql)
+    sql = CONNECT_RE.sub("", sql)
+
+    def repl(match: re.Match[str]) -> str:
+        raw_prefix = match.group("prefix")
+        ident = extract_table_ident(raw_prefix)
+        if ident is not None:
+            mapped = remap_table(ident, mode)
+            if ident in SKIP_TABLES or mapped in SKIP_TABLES:
+                return ""
+        prefix = normalize_table_name(raw_prefix, mode)
+        cols = remap_columns(match.group("cols"), mode)
+        return f"{prefix}{cols}{match.group('suffix')}"
+
+    return INSERT_RE.sub(repl, sql)
 
 
 def main() -> int:
-    if len(sys.argv) != 3:
-        print("Usage: scripts/normalize-dump.py <input.sql> <output.sql>", file=sys.stderr)
+    if len(sys.argv) not in (3, 4):
+        print("Usage: scripts/normalize-dump.py <input.sql> <output.sql> [--snake|--lower]", file=sys.stderr)
         return 1
 
     src = sys.argv[1]
     dst = sys.argv[2]
+    mode = "lower"
+    if len(sys.argv) == 4:
+        if sys.argv[3] == "--snake":
+            mode = "snake"
+        elif sys.argv[3] == "--lower":
+            mode = "lower"
+        else:
+            print("Invalid mode. Use --snake or --lower.", file=sys.stderr)
+            return 1
 
     with open(src, "r", encoding="utf-8") as f:
         data = f.read()
 
-    normalized = normalize_identifiers(data)
+    normalized = normalize_dump(data, mode)
 
     with open(dst, "w", encoding="utf-8") as f:
         f.write(normalized)

scripts/release.sh

@@ -0,0 +1,195 @@
+#!/bin/bash
+set -e
+
+# Couleurs pour l'affichage
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Répertoire racine du projet
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+VERSION_FILE="$PROJECT_ROOT/VERSION"
+API_PLATFORM_FILE="$PROJECT_ROOT/config/packages/api_platform.yaml"
+FRONTEND_DIR="$PROJECT_ROOT/Inventory_frontend"
+
+# Lire la version actuelle
+current_version=$(cat "$VERSION_FILE" | tr -d '\n')
+
+# Fonction pour afficher l'aide
+show_help() {
+    echo -e "${BLUE}Usage:${NC} $0 [version|bump_type]"
+    echo ""
+    echo "Arguments:"
+    echo "  version     Version spécifique (ex: 1.2.3)"
+    echo "  bump_type   Type de bump: major, minor, patch"
+    echo ""
+    echo "Exemples:"
+    echo "  $0 1.0.0      # Définit la version à 1.0.0"
+    echo "  $0 patch      # 1.0.0 -> 1.0.1"
+    echo "  $0 minor      # 1.0.0 -> 1.1.0"
+    echo "  $0 major      # 1.0.0 -> 2.0.0"
+    echo ""
+    echo -e "Version actuelle: ${GREEN}$current_version${NC}"
+}
+
+# Fonction pour bumper la version
+bump_version() {
+    local version=$1
+    local bump_type=$2
+
+    IFS='.' read -r major minor patch <<< "$version"
+
+    case $bump_type in
+        major)
+            major=$((major + 1))
+            minor=0
+            patch=0
+            ;;
+        minor)
+            minor=$((minor + 1))
+            patch=0
+            ;;
+        patch)
+            patch=$((patch + 1))
+            ;;
+    esac
+
+    echo "$major.$minor.$patch"
+}
+
+# Vérifier les arguments
+if [ $# -eq 0 ]; then
+    show_help
+    exit 0
+fi
+
+arg=$1
+
+# Déterminer la nouvelle version
+case $arg in
+    major|minor|patch)
+        new_version=$(bump_version "$current_version" "$arg")
+        ;;
+    -h|--help|help)
+        show_help
+        exit 0
+        ;;
+    *)
+        # Vérifier le format de version (semver basique)
+        if [[ $arg =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            new_version=$arg
+        else
+            echo -e "${RED}Erreur:${NC} Format de version invalide: $arg"
+            echo "Utilisez le format X.Y.Z (ex: 1.2.3) ou major/minor/patch"
+            exit 1
+        fi
+        ;;
+esac
+
+echo -e "${BLUE}Release v$new_version${NC}"
+echo "================================"
+echo -e "Version actuelle: ${YELLOW}$current_version${NC}"
+echo -e "Nouvelle version: ${GREEN}$new_version${NC}"
+echo ""
+
+# Vérifier qu'on n'est pas sur une version identique
+if [ "$current_version" = "$new_version" ]; then
+    echo -e "${YELLOW}La version est déjà $new_version${NC}"
+    exit 0
+fi
+
+# Demander confirmation
+read -p "Continuer ? (y/N) " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Annulé."
+    exit 0
+fi
+
+cd "$PROJECT_ROOT"
+
+# ===========================================
+# ÉTAPE 1 : Gérer le submodule frontend
+# ===========================================
+echo ""
+echo -e "${BLUE}[1/6]${NC} Vérification du submodule frontend..."
+
+cd "$FRONTEND_DIR"
+
+# Vérifier s'il y a des changements non commités dans le submodule
+if ! git diff --quiet --exit-code || ! git diff --cached --quiet --exit-code; then
+    echo -e "${YELLOW}Changements détectés dans le submodule frontend${NC}"
+    git status --short
+    echo ""
+    read -p "Commiter ces changements dans le submodule ? (y/N) " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        git add -A
+        git commit -m "chore(release) : prepare v$new_version"
+    else
+        echo -e "${RED}Erreur:${NC} Veuillez d'abord commiter les changements du submodule."
+        exit 1
+    fi
+fi
+
+# ===========================================
+# ÉTAPE 2 : Tag le submodule
+# ===========================================
+echo -e "${BLUE}[2/6]${NC} Création du tag v$new_version dans le submodule..."
+
+# Vérifier si le tag existe déjà
+if git rev-parse "v$new_version" >/dev/null 2>&1; then
+    echo -e "${YELLOW}Le tag v$new_version existe déjà dans le submodule${NC}"
+else
+    git tag -a "v$new_version" -m "Release v$new_version"
+    echo -e "${GREEN}Tag v$new_version créé dans le submodule${NC}"
+fi
+
+# Retourner au projet principal
+cd "$PROJECT_ROOT"
+
+# ===========================================
+# ÉTAPE 3 : Mettre à jour VERSION
+# ===========================================
+echo -e "${BLUE}[3/6]${NC} Mise à jour du fichier VERSION..."
+echo "$new_version" > "$VERSION_FILE"
+
+# ===========================================
+# ÉTAPE 4 : Mettre à jour api_platform.yaml
+# ===========================================
+echo -e "${BLUE}[4/6]${NC} Mise à jour de api_platform.yaml..."
+sed -i "s/version: .*/version: $new_version/" "$API_PLATFORM_FILE"
+
+# ===========================================
+# ÉTAPE 5 : Commit principal (avec mise à jour du submodule)
+# ===========================================
+echo -e "${BLUE}[5/6]${NC} Création du commit principal..."
+git add "$VERSION_FILE" "$API_PLATFORM_FILE" "$FRONTEND_DIR"
+git commit -m "chore(release) : v$new_version"
+
+# ===========================================
+# ÉTAPE 6 : Tag principal
+# ===========================================
+echo -e "${BLUE}[6/6]${NC} Création du tag v$new_version..."
+git tag -a "v$new_version" -m "Release v$new_version"
+
+echo ""
+echo -e "${GREEN}✓ Release v$new_version préparée avec succès !${NC}"
+echo ""
+echo "================================"
+echo -e "${YELLOW}Prochaines étapes :${NC}"
+echo ""
+echo "1. Pousser le submodule frontend :"
+echo -e "   ${BLUE}cd Inventory_frontend && git push && git push --tags && cd ..${NC}"
+echo ""
+echo "2. Pousser le projet principal :"
+echo -e "   ${BLUE}git push && git push --tags${NC}"
+echo ""
+echo "3. Créer les releases sur Gitea :"
+echo "   - Inventory_frontend : tag v$new_version"
+echo "   - Inventory (backend) : tag v$new_version"
+echo ""
+echo "================================"

src/Command/CompressPdfCommand.php

@@ -0,0 +1,175 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Command;
+
+use App\Repository\DocumentRepository;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+#[AsCommand(
+    name: 'app:compress-pdf',
+    description: 'Compress all PDF documents stored in database without quality loss',
+)]
+class CompressPdfCommand extends Command
+{
+    public function __construct(
+        private readonly DocumentRepository $documentRepository,
+        private readonly EntityManagerInterface $em,
+    ) {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this
+            ->addOption('dry-run', null, InputOption::VALUE_NONE, 'Show what would be compressed without actually doing it')
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io     = new SymfonyStyle($input, $output);
+        $dryRun = $input->getOption('dry-run');
+
+        // Check if qpdf is installed
+        exec('which qpdf', $qpdfPath, $returnCode);
+        if (0 !== $returnCode) {
+            $io->error('qpdf is not installed. Run: sudo apt install qpdf');
+
+            return Command::FAILURE;
+        }
+
+        $documents = $this->documentRepository->findBy(['mimeType' => 'application/pdf']);
+
+        if (empty($documents)) {
+            $io->info('No PDF documents found.');
+
+            return Command::SUCCESS;
+        }
+
+        $io->title('PDF Compression');
+        $io->text(sprintf('Found %d PDF documents', count($documents)));
+
+        $totalSaved = 0;
+        $compressed = 0;
+
+        foreach ($documents as $document) {
+            $base64Data = $document->getPath();
+
+            // Remove data URI prefix if present
+            if (str_contains($base64Data, ',')) {
+                $base64Data = explode(',', $base64Data, 2)[1];
+            }
+
+            $pdfContent = base64_decode($base64Data, true);
+            if (false === $pdfContent) {
+                $io->warning(sprintf('Failed to decode document: %s', $document->getName()));
+
+                continue;
+            }
+
+            $originalSize = strlen($pdfContent);
+
+            if ($dryRun) {
+                $io->text(sprintf(
+                    '  [DRY-RUN] Would compress: %s (%s)',
+                    $document->getName(),
+                    $this->formatBytes($originalSize)
+                ));
+
+                continue;
+            }
+
+            // Create temp files
+            $tempInput  = tempnam(sys_get_temp_dir(), 'pdf_in_');
+            $tempOutput = tempnam(sys_get_temp_dir(), 'pdf_out_');
+
+            file_put_contents($tempInput, $pdfContent);
+
+            // Compress with qpdf (lossless)
+            $command = sprintf(
+                'qpdf --linearize --object-streams=generate %s %s 2>&1',
+                escapeshellarg($tempInput),
+                escapeshellarg($tempOutput)
+            );
+
+            exec($command, $cmdOutput, $returnCode);
+
+            if (0 !== $returnCode || !file_exists($tempOutput)) {
+                $io->warning(sprintf('Failed to compress: %s', $document->getName()));
+                @unlink($tempInput);
+                @unlink($tempOutput);
+
+                continue;
+            }
+
+            $compressedContent = file_get_contents($tempOutput);
+            $compressedSize    = strlen($compressedContent);
+
+            // Only update if we actually saved space
+            if ($compressedSize < $originalSize) {
+                $saved = $originalSize - $compressedSize;
+                $totalSaved += $saved;
+                ++$compressed;
+
+                // Rebuild base64 with data URI prefix
+                $newBase64 = 'data:application/pdf;base64,'.base64_encode($compressedContent);
+                $document->setPath($newBase64);
+                $document->setSize($compressedSize);
+
+                $io->text(sprintf(
+                    '  ✓ %s: %s → %s (-%s, -%.1f%%)',
+                    $document->getName(),
+                    $this->formatBytes($originalSize),
+                    $this->formatBytes($compressedSize),
+                    $this->formatBytes($saved),
+                    ($saved / $originalSize) * 100
+                ));
+            } else {
+                $io->text(sprintf(
+                    '  - %s: Already optimal (%s)',
+                    $document->getName(),
+                    $this->formatBytes($originalSize)
+                ));
+            }
+
+            @unlink($tempInput);
+            @unlink($tempOutput);
+        }
+
+        if (!$dryRun && $compressed > 0) {
+            $this->em->flush();
+            $io->success(sprintf(
+                'Compressed %d/%d PDFs. Total space saved: %s',
+                $compressed,
+                count($documents),
+                $this->formatBytes($totalSaved)
+            ));
+        } elseif ($dryRun) {
+            $io->info('Dry run completed. No changes made.');
+        } else {
+            $io->info('No PDFs needed compression.');
+        }
+
+        return Command::SUCCESS;
+    }
+
+    private function formatBytes(int $bytes): string
+    {
+        $units = ['B', 'KB', 'MB', 'GB'];
+        $i     = 0;
+        while ($bytes >= 1024 && $i < count($units) - 1) {
+            $bytes /= 1024;
+            ++$i;
+        }
+
+        return round($bytes, 2).' '.$units[$i];
+    }
+}

src/Controller/ActivityLogController.php

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller;
+
+use App\Repository\AuditLogRepository;
+use App\Repository\ProfileRepository;
+use DateTimeInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\Routing\Attribute\Route;
+
+final class ActivityLogController
+{
+    public function __construct(
+        private readonly AuditLogRepository $auditLogs,
+        private readonly ProfileRepository $profiles,
+    ) {}
+
+    #[Route('/api/activity-logs', name: 'api_activity_logs', methods: ['GET'])]
+    public function __invoke(Request $request): JsonResponse
+    {
+        $page         = max(1, $request->query->getInt('page', 1));
+        $itemsPerPage = min(100, max(1, $request->query->getInt('itemsPerPage', 30)));
+
+        $filters = [];
+        if ($entityType = $request->query->get('entityType')) {
+            $filters['entityType'] = $entityType;
+        }
+        if ($action = $request->query->get('action')) {
+            $filters['action'] = $action;
+        }
+
+        $result = $this->auditLogs->findAllPaginated($page, $itemsPerPage, $filters);
+
+        $actorIds = array_values(array_unique(array_filter(array_map(
+            static fn ($log) => $log->getActorProfileId(),
+            $result['items'],
+        ))));
+
+        $actorMap = [];
+        if ([] !== $actorIds) {
+            $profiles = $this->profiles->findBy(['id' => $actorIds]);
+            foreach ($profiles as $profile) {
+                $label = trim(sprintf('%s %s', $profile->getFirstName(), $profile->getLastName()));
+                if ('' === $label) {
+                    $label = $profile->getEmail() ?? $profile->getId();
+                }
+                $actorMap[$profile->getId()] = $label;
+            }
+        }
+
+        $items = array_map(
+            static function ($log) use ($actorMap) {
+                $actorId  = $log->getActorProfileId();
+                $snapshot = $log->getSnapshot();
+
+                return [
+                    'id'         => $log->getId(),
+                    'entityType' => $log->getEntityType(),
+                    'entityId'   => $log->getEntityId(),
+                    'entityName' => $snapshot['name'] ?? null,
+                    'entityRef'  => $snapshot['reference'] ?? null,
+                    'action'     => $log->getAction(),
+                    'createdAt'  => $log->getCreatedAt()->format(DateTimeInterface::ATOM),
+                    'actor'      => $actorId
+                        ? [
+                            'id'    => $actorId,
+                            'label' => $actorMap[$actorId] ?? $actorId,
+                        ]
+                        : null,
+                    'diff'     => $log->getDiff(),
+                    'snapshot' => $snapshot,
+                ];
+            },
+            $result['items'],
+        );
+
+        return new JsonResponse([
+            'items'        => array_values($items),
+            'total'        => $result['total'],
+            'page'         => $page,
+            'itemsPerPage' => $itemsPerPage,
+        ]);
+    }
+}

src/Controller/ComposantHistoryController.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller;
+
+use App\Repository\AuditLogRepository;
+use App\Repository\ComposantRepository;
+use App\Repository\ProfileRepository;
+use DateTimeInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+final class ComposantHistoryController
+{
+    public function __construct(
+        private readonly ComposantRepository $components,
+        private readonly AuditLogRepository $auditLogs,
+        private readonly ProfileRepository $profiles,
+    ) {}
+
+    #[Route('/api/composants/{id}/history', name: 'api_composant_history', methods: ['GET'])]
+    public function __invoke(string $id): JsonResponse
+    {
+        $component = $this->components->find($id);
+        if (!$component) {
+            return new JsonResponse(
+                ['message' => 'Composant introuvable.'],
+                Response::HTTP_NOT_FOUND,
+            );
+        }
+
+        $logs = $this->auditLogs->findEntityHistory('composant', $id, 200);
+
+        $actorIds = array_values(array_unique(array_filter(array_map(
+            static fn ($log) => $log->getActorProfileId(),
+            $logs,
+        ))));
+
+        $actorMap = [];
+        if ([] !== $actorIds) {
+            $profiles = $this->profiles->findBy(['id' => $actorIds]);
+            foreach ($profiles as $profile) {
+                $label = trim(sprintf('%s %s', $profile->getFirstName(), $profile->getLastName()));
+                if ('' === $label) {
+                    $label = $profile->getEmail() ?? $profile->getId();
+                }
+                $actorMap[$profile->getId()] = $label;
+            }
+        }
+
+        $items = array_map(
+            static function ($log) use ($actorMap) {
+                $actorId = $log->getActorProfileId();
+
+                return [
+                    'id'        => $log->getId(),
+                    'action'    => $log->getAction(),
+                    'createdAt' => $log->getCreatedAt()->format(DateTimeInterface::ATOM),
+                    'actor'     => $actorId
+                        ? [
+                            'id'    => $actorId,
+                            'label' => $actorMap[$actorId] ?? $actorId,
+                        ]
+                        : null,
+                    'diff'     => $log->getDiff(),
+                    'snapshot' => $log->getSnapshot(),
+                ];
+            },
+            $logs,
+        );
+
+        return new JsonResponse([
+            'items' => array_values($items),
+            'total' => count($items),
+        ]);
+    }
+}

src/Controller/CustomFieldValueController.php

@@ -29,8 +29,7 @@ class CustomFieldValueController extends AbstractController
         private readonly ComposantRepository $composantRepository,
         private readonly PieceRepository $pieceRepository,
         private readonly ProductRepository $productRepository,
-    ) {
-    }
+    ) {}
 
     #[Route('', name: 'custom_field_values_create', methods: ['POST'])]
     public function create(Request $request): JsonResponse
@@ -80,7 +79,7 @@ class CustomFieldValueController extends AbstractController
         }
 
         $existing = $this->customFieldValueRepository->findOneBy([
-            'customField' => $customField,
+            'customField'   => $customField,
             $target['type'] => $target['entity'],
         ]);
 
@@ -107,7 +106,7 @@ class CustomFieldValueController extends AbstractController
     {
         $target = $this->resolveTarget([
             'entityType' => $entityType,
-            'entityId' => $entityId,
+            'entityId'   => $entityId,
         ]);
 
         if ($target instanceof JsonResponse) {
@@ -173,7 +172,7 @@ class CustomFieldValueController extends AbstractController
     private function resolveCustomField(array $payload): CustomField|JsonResponse
     {
         $customFieldId = isset($payload['customFieldId']) ? trim((string) $payload['customFieldId']) : '';
-        if ($customFieldId !== '') {
+        if ('' !== $customFieldId) {
             $customField = $this->customFieldRepository->find($customFieldId);
             if ($customField instanceof CustomField) {
                 return $customField;
@@ -183,7 +182,7 @@ class CustomFieldValueController extends AbstractController
         }
 
         $customFieldName = isset($payload['customFieldName']) ? trim((string) $payload['customFieldName']) : '';
-        if ($customFieldName === '') {
+        if ('' === $customFieldName) {
             return $this->json(['success' => false, 'error' => 'customFieldId or customFieldName is required.'], 400);
         }
 
@@ -205,30 +204,31 @@ class CustomFieldValueController extends AbstractController
     private function resolveTarget(array $payload): array|JsonResponse
     {
         $entityType = isset($payload['entityType']) ? strtolower((string) $payload['entityType']) : '';
-        $entityId = isset($payload['entityId']) ? trim((string) $payload['entityId']) : '';
+        $entityId   = isset($payload['entityId']) ? trim((string) $payload['entityId']) : '';
 
-        if ($entityType === '' || $entityId === '') {
+        if ('' === $entityType || '' === $entityId) {
             foreach (['machine', 'composant', 'piece', 'product'] as $candidate) {
-                $key = $candidate . 'Id';
+                $key = $candidate.'Id';
                 if (!isset($payload[$key])) {
                     continue;
                 }
                 $entityType = $candidate;
-                $entityId = trim((string) $payload[$key]);
+                $entityId   = trim((string) $payload[$key]);
+
                 break;
             }
         }
 
-        if ($entityType === '' || $entityId === '') {
+        if ('' === $entityType || '' === $entityId) {
             return $this->json(['success' => false, 'error' => 'Entity target is missing.'], 400);
         }
 
         return match ($entityType) {
-            'machine' => $this->resolveEntity('machine', $entityId, $this->machineRepository),
+            'machine'   => $this->resolveEntity('machine', $entityId, $this->machineRepository),
             'composant' => $this->resolveEntity('composant', $entityId, $this->composantRepository),
-            'piece' => $this->resolveEntity('piece', $entityId, $this->pieceRepository),
-            'product' => $this->resolveEntity('product', $entityId, $this->productRepository),
-            default => $this->json(['success' => false, 'error' => 'Unsupported entity type.'], 400),
+            'piece'     => $this->resolveEntity('piece', $entityId, $this->pieceRepository),
+            'product'   => $this->resolveEntity('product', $entityId, $this->productRepository),
+            default     => $this->json(['success' => false, 'error' => 'Unsupported entity type.'], 400),
         };
     }
 
@@ -247,15 +247,22 @@ class CustomFieldValueController extends AbstractController
         switch ($type) {
             case 'machine':
                 $value->setMachine($entity);
+
                 break;
+
             case 'composant':
                 $value->setComposant($entity);
+
                 break;
+
             case 'piece':
                 $value->setPiece($entity);
+
                 break;
+
             case 'product':
                 $value->setProduct($entity);
+
                 break;
         }
     }
@@ -265,23 +272,23 @@ class CustomFieldValueController extends AbstractController
         $customField = $value->getCustomField();
 
         return [
-            'id' => $value->getId(),
-            'value' => $value->getValue(),
+            'id'            => $value->getId(),
+            'value'         => $value->getValue(),
             'customFieldId' => $customField->getId(),
-            'customField' => [
-                'id' => $customField->getId(),
-                'name' => $customField->getName(),
-                'type' => $customField->getType(),
-                'required' => $customField->isRequired(),
-                'options' => $customField->getOptions(),
+            'customField'   => [
+                'id'         => $customField->getId(),
+                'name'       => $customField->getName(),
+                'type'       => $customField->getType(),
+                'required'   => $customField->isRequired(),
+                'options'    => $customField->getOptions(),
                 'orderIndex' => $customField->getOrderIndex(),
             ],
-            'machineId' => $value->getMachine()?->getId(),
+            'machineId'   => $value->getMachine()?->getId(),
             'composantId' => $value->getComposant()?->getId(),
-            'pieceId' => $value->getPiece()?->getId(),
-            'productId' => $value->getProduct()?->getId(),
-            'createdAt' => $value->getCreatedAt()->format(DATE_ATOM),
-            'updatedAt' => $value->getUpdatedAt()->format(DATE_ATOM),
+            'pieceId'     => $value->getPiece()?->getId(),
+            'productId'   => $value->getProduct()?->getId(),
+            'createdAt'   => $value->getCreatedAt()->format(DATE_ATOM),
+            'updatedAt'   => $value->getUpdatedAt()->format(DATE_ATOM),
         ];
     }
 }

src/Controller/DocumentQueryController.php

@@ -25,8 +25,7 @@ class DocumentQueryController extends AbstractController
         private readonly ComposantRepository $composantRepository,
         private readonly PieceRepository $pieceRepository,
         private readonly ProductRepository $productRepository,
-    ) {
-    }
+    ) {}
 
     #[Route('/site/{id}', name: 'documents_by_site', methods: ['GET'])]
     public function listBySite(string $id): JsonResponse
@@ -100,19 +99,19 @@ class DocumentQueryController extends AbstractController
     {
         return array_map(static function (Document $document): array {
             return [
-                'id' => $document->getId(),
-                'name' => $document->getName(),
-                'filename' => $document->getFilename(),
-                'path' => $document->getPath(),
-                'mimeType' => $document->getMimeType(),
-                'size' => $document->getSize(),
-                'siteId' => $document->getSite()?->getId(),
-                'machineId' => $document->getMachine()?->getId(),
+                'id'          => $document->getId(),
+                'name'        => $document->getName(),
+                'filename'    => $document->getFilename(),
+                'path'        => $document->getPath(),
+                'mimeType'    => $document->getMimeType(),
+                'size'        => $document->getSize(),
+                'siteId'      => $document->getSite()?->getId(),
+                'machineId'   => $document->getMachine()?->getId(),
                 'composantId' => $document->getComposant()?->getId(),
-                'pieceId' => $document->getPiece()?->getId(),
-                'productId' => $document->getProduct()?->getId(),
-                'createdAt' => $document->getCreatedAt()->format(DATE_ATOM),
-                'updatedAt' => $document->getUpdatedAt()->format(DATE_ATOM),
+                'pieceId'     => $document->getPiece()?->getId(),
+                'productId'   => $document->getProduct()?->getId(),
+                'createdAt'   => $document->getCreatedAt()->format(DATE_ATOM),
+                'updatedAt'   => $document->getUpdatedAt()->format(DATE_ATOM),
             ];
         }, $documents);
     }

src/Controller/MachineCustomFieldsController.php

@@ -21,8 +21,7 @@ class MachineCustomFieldsController extends AbstractController
         private readonly EntityManagerInterface $entityManager,
         private readonly MachineRepository $machineRepository,
         private readonly CustomFieldValueRepository $customFieldValueRepository,
-    ) {
-    }
+    ) {}
 
     #[Route('/{id}/add-custom-fields', name: 'machine_add_custom_fields', methods: ['POST'])]
     public function addMissingCustomFields(string $id): JsonResponse
@@ -42,7 +41,7 @@ class MachineCustomFieldsController extends AbstractController
                 continue;
             }
             $existing = $this->customFieldValueRepository->findOneBy([
-                'machine' => $machine,
+                'machine'     => $machine,
                 'customField' => $customField,
             ]);
             if ($existing instanceof CustomFieldValue) {
@@ -61,12 +60,12 @@ class MachineCustomFieldsController extends AbstractController
         $values = $this->customFieldValueRepository->findBy(['machine' => $machine]);
 
         return $this->json([
-            'success' => true,
-            'machineId' => $machine->getId(),
+            'success'           => true,
+            'machineId'         => $machine->getId(),
             'customFieldValues' => array_map(
                 static fn (CustomFieldValue $value) => [
-                    'id' => $value->getId(),
-                    'value' => $value->getValue(),
+                    'id'            => $value->getId(),
+                    'value'         => $value->getValue(),
                     'customFieldId' => $value->getCustomField()->getId(),
                 ],
                 $values

src/Controller/MachineHistoryController.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller;
+
+use App\Repository\AuditLogRepository;
+use App\Repository\MachineRepository;
+use App\Repository\ProfileRepository;
+use DateTimeInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+final class MachineHistoryController
+{
+    public function __construct(
+        private readonly MachineRepository $machines,
+        private readonly AuditLogRepository $auditLogs,
+        private readonly ProfileRepository $profiles,
+    ) {}
+
+    #[Route('/api/machines/{id}/history', name: 'api_machine_history', methods: ['GET'])]
+    public function __invoke(string $id): JsonResponse
+    {
+        $machine = $this->machines->find($id);
+        if (!$machine) {
+            return new JsonResponse(
+                ['message' => 'Machine introuvable.'],
+                Response::HTTP_NOT_FOUND,
+            );
+        }
+
+        $logs = $this->auditLogs->findEntityHistory('machine', $id, 200);
+
+        $actorIds = array_values(array_unique(array_filter(array_map(
+            static fn ($log) => $log->getActorProfileId(),
+            $logs,
+        ))));
+
+        $actorMap = [];
+        if ([] !== $actorIds) {
+            $profiles = $this->profiles->findBy(['id' => $actorIds]);
+            foreach ($profiles as $profile) {
+                $label = trim(sprintf('%s %s', $profile->getFirstName(), $profile->getLastName()));
+                if ('' === $label) {
+                    $label = $profile->getEmail() ?? $profile->getId();
+                }
+                $actorMap[$profile->getId()] = $label;
+            }
+        }
+
+        $items = array_map(
+            static function ($log) use ($actorMap) {
+                $actorId = $log->getActorProfileId();
+
+                return [
+                    'id'        => $log->getId(),
+                    'action'    => $log->getAction(),
+                    'createdAt' => $log->getCreatedAt()->format(DateTimeInterface::ATOM),
+                    'actor'     => $actorId
+                        ? [
+                            'id'    => $actorId,
+                            'label' => $actorMap[$actorId] ?? $actorId,
+                        ]
+                        : null,
+                    'diff'     => $log->getDiff(),
+                    'snapshot' => $log->getSnapshot(),
+                ];
+            },
+            $logs,
+        );
+
+        return new JsonResponse([
+            'items' => array_values($items),
+            'total' => count($items),
+        ]);
+    }
+}

src/Controller/MachineSkeletonController.php

@@ -47,8 +47,7 @@ class MachineSkeletonController extends AbstractController
         private readonly TypeMachineComponentRequirementRepository $componentRequirementRepository,
         private readonly TypeMachinePieceRequirementRepository $pieceRequirementRepository,
         private readonly TypeMachineProductRequirementRepository $productRequirementRepository,
-    ) {
-    }
+    ) {}
 
     #[Route('/{id}/skeleton', name: 'machine_skeleton_get', methods: ['GET'])]
     public function getSkeleton(string $id): JsonResponse
@@ -59,8 +58,8 @@ class MachineSkeletonController extends AbstractController
         }
 
         $componentLinks = $this->machineComponentLinkRepository->findBy(['machine' => $machine]);
-        $pieceLinks = $this->machinePieceLinkRepository->findBy(['machine' => $machine]);
-        $productLinks = $this->machineProductLinkRepository->findBy(['machine' => $machine]);
+        $pieceLinks     = $this->machinePieceLinkRepository->findBy(['machine' => $machine]);
+        $productLinks   = $this->machineProductLinkRepository->findBy(['machine' => $machine]);
 
         return $this->json($this->normalizeMachineSkeletonResponse(
             $machine,
@@ -84,8 +83,8 @@ class MachineSkeletonController extends AbstractController
         }
 
         $componentLinksPayload = $this->normalizePayloadList($payload['componentLinks'] ?? []);
-        $pieceLinksPayload = $this->normalizePayloadList($payload['pieceLinks'] ?? []);
-        $productLinksPayload = $this->normalizePayloadList($payload['productLinks'] ?? []);
+        $pieceLinksPayload     = $this->normalizePayloadList($payload['pieceLinks'] ?? []);
+        $productLinksPayload   = $this->normalizePayloadList($payload['productLinks'] ?? []);
 
         $componentLinks = $this->applyComponentLinks($machine, $componentLinksPayload);
         if ($componentLinks instanceof JsonResponse) {
@@ -117,19 +116,20 @@ class MachineSkeletonController extends AbstractController
         if (!is_array($value)) {
             return [];
         }
+
         return array_values(array_filter($value, static fn ($item) => is_array($item)));
     }
 
     private function applyComponentLinks(Machine $machine, array $payload): array|JsonResponse
     {
-        $existing = $this->indexLinksById($this->machineComponentLinkRepository->findBy(['machine' => $machine]));
-        $keepIds = [];
+        $existing       = $this->indexLinksById($this->machineComponentLinkRepository->findBy(['machine' => $machine]));
+        $keepIds        = [];
         $pendingParents = [];
-        $links = [];
+        $links          = [];
 
         foreach ($payload as $entry) {
             $linkId = $this->resolveIdentifier($entry, ['id', 'linkId']);
-            $link = $linkId && isset($existing[$linkId]) ? $existing[$linkId] : new MachineComponentLink();
+            $link   = $linkId && isset($existing[$linkId]) ? $existing[$linkId] : new MachineComponentLink();
             if (!$linkId) {
                 $linkId = $this->generateCuid();
             }
@@ -167,7 +167,7 @@ class MachineSkeletonController extends AbstractController
 
             $this->entityManager->persist($link);
             $links[$linkId] = $link;
-            $keepIds[] = $linkId;
+            $keepIds[]      = $linkId;
         }
 
         foreach ($pendingParents as $linkId => $parentId) {
@@ -190,15 +190,15 @@ class MachineSkeletonController extends AbstractController
 
     private function applyPieceLinks(Machine $machine, array $payload, array $componentLinks): array|JsonResponse
     {
-        $existing = $this->indexLinksById($this->machinePieceLinkRepository->findBy(['machine' => $machine]));
+        $existing       = $this->indexLinksById($this->machinePieceLinkRepository->findBy(['machine' => $machine]));
         $componentIndex = $this->indexLinksById($componentLinks);
-        $keepIds = [];
+        $keepIds        = [];
         $pendingParents = [];
-        $links = [];
+        $links          = [];
 
         foreach ($payload as $entry) {
             $linkId = $this->resolveIdentifier($entry, ['id', 'linkId']);
-            $link = $linkId && isset($existing[$linkId]) ? $existing[$linkId] : new MachinePieceLink();
+            $link   = $linkId && isset($existing[$linkId]) ? $existing[$linkId] : new MachinePieceLink();
             if (!$linkId) {
                 $linkId = $this->generateCuid();
             }
@@ -236,7 +236,7 @@ class MachineSkeletonController extends AbstractController
 
             $this->entityManager->persist($link);
             $links[$linkId] = $link;
-            $keepIds[] = $linkId;
+            $keepIds[]      = $linkId;
         }
 
         foreach ($pendingParents as $linkId => $parentId) {
@@ -263,16 +263,16 @@ class MachineSkeletonController extends AbstractController
         array $componentLinks,
         array $pieceLinks,
     ): array|JsonResponse {
-        $existing = $this->indexLinksById($this->machineProductLinkRepository->findBy(['machine' => $machine]));
+        $existing       = $this->indexLinksById($this->machineProductLinkRepository->findBy(['machine' => $machine]));
         $componentIndex = $this->indexLinksById($componentLinks);
-        $pieceIndex = $this->indexLinksById($pieceLinks);
-        $keepIds = [];
+        $pieceIndex     = $this->indexLinksById($pieceLinks);
+        $keepIds        = [];
         $pendingParents = [];
-        $links = [];
+        $links          = [];
 
         foreach ($payload as $entry) {
             $linkId = $this->resolveIdentifier($entry, ['id', 'linkId']);
-            $link = $linkId && isset($existing[$linkId]) ? $existing[$linkId] : new MachineProductLink();
+            $link   = $linkId && isset($existing[$linkId]) ? $existing[$linkId] : new MachineProductLink();
             if (!$linkId) {
                 $linkId = $this->generateCuid();
             }
@@ -302,13 +302,13 @@ class MachineSkeletonController extends AbstractController
 
             $pendingParents[$linkId] = [
                 'parentComponentLinkId' => $this->resolveIdentifier($entry, ['parentComponentLinkId']),
-                'parentPieceLinkId' => $this->resolveIdentifier($entry, ['parentPieceLinkId']),
-                'parentLinkId' => $this->resolveIdentifier($entry, ['parentLinkId']),
+                'parentPieceLinkId'     => $this->resolveIdentifier($entry, ['parentPieceLinkId']),
+                'parentLinkId'          => $this->resolveIdentifier($entry, ['parentLinkId']),
             ];
 
             $this->entityManager->persist($link);
             $links[$linkId] = $link;
-            $keepIds[] = $linkId;
+            $keepIds[]      = $linkId;
         }
 
         foreach ($pendingParents as $linkId => $parentIds) {
@@ -338,8 +338,8 @@ class MachineSkeletonController extends AbstractController
         array $productLinks,
     ): array {
         $normalizedComponentLinks = $this->normalizeComponentLinks($componentLinks);
-        $componentIndex = $this->indexNormalizedLinks($normalizedComponentLinks);
-        $normalizedPieceLinks = $this->normalizePieceLinks($pieceLinks);
+        $componentIndex           = $this->indexNormalizedLinks($normalizedComponentLinks);
+        $normalizedPieceLinks     = $this->normalizePieceLinks($pieceLinks);
 
         // Build component hierarchy
         foreach ($normalizedComponentLinks as &$link) {
@@ -354,10 +354,10 @@ class MachineSkeletonController extends AbstractController
         $this->attachPiecesToComponents($componentIndex, $normalizedPieceLinks);
 
         return [
-            'machine' => $this->normalizeMachine($machine),
+            'machine'        => $this->normalizeMachine($machine),
             'componentLinks' => array_values($componentIndex),
-            'pieceLinks' => $normalizedPieceLinks,
-            'productLinks' => $this->normalizeProductLinks($productLinks),
+            'pieceLinks'     => $normalizedPieceLinks,
+            'productLinks'   => $this->normalizeProductLinks($productLinks),
         ];
     }
 
@@ -400,41 +400,86 @@ class MachineSkeletonController extends AbstractController
 
     private function normalizeMachine(Machine $machine): array
     {
+        $site        = $machine->getSite();
+        $typeMachine = $machine->getTypeMachine();
+
         return [
-            'id' => $machine->getId(),
-            'name' => $machine->getName(),
+            'id'        => $machine->getId(),
+            'name'      => $machine->getName(),
             'reference' => $machine->getReference(),
-            'prix' => $machine->getPrix(),
-            'siteId' => $machine->getSite()->getId(),
-            'typeMachineId' => $machine->getTypeMachine()?->getId(),
-            'documents' => null,
+            'prix'      => $machine->getPrix(),
+            'siteId'    => $site->getId(),
+            'site'      => [
+                'id'   => $site->getId(),
+                'name' => $site->getName(),
+            ],
+            'typeMachineId' => $typeMachine?->getId(),
+            'typeMachine'   => $typeMachine ? [
+                'id'                    => $typeMachine->getId(),
+                'name'                  => $typeMachine->getName(),
+                'category'              => $typeMachine->getCategory(),
+                'description'           => $typeMachine->getDescription(),
+                'customFields'          => $this->normalizeCustomFields($typeMachine->getCustomFields()),
+                'componentRequirements' => $typeMachine->getComponentRequirements()
+                    ->map(fn (TypeMachineComponentRequirement $req) => $this->normalizeComponentRequirement($req))
+                    ->toArray(),
+                'pieceRequirements' => $typeMachine->getPieceRequirements()
+                    ->map(fn (TypeMachinePieceRequirement $req) => $this->normalizePieceRequirement($req))
+                    ->toArray(),
+                'productRequirements' => $typeMachine->getProductRequirements()
+                    ->map(fn (TypeMachineProductRequirement $req) => $this->normalizeProductRequirement($req))
+                    ->toArray(),
+            ] : null,
+            'constructeurs'     => $this->normalizeConstructeurs($machine->getConstructeurs()),
+            'documents'         => null,
             'customFieldValues' => null,
         ];
     }
 
+    private function normalizeCustomFields(Collection $customFields): array
+    {
+        $items = [];
+        foreach ($customFields as $customField) {
+            if (!$customField instanceof CustomField) {
+                continue;
+            }
+            $items[] = [
+                'id'           => $customField->getId(),
+                'name'         => $customField->getName(),
+                'type'         => $customField->getType(),
+                'required'     => $customField->isRequired(),
+                'options'      => $customField->getOptions(),
+                'defaultValue' => $customField->getDefaultValue(),
+                'orderIndex'   => $customField->getOrderIndex(),
+            ];
+        }
+
+        return $items;
+    }
+
     private function normalizeComponentLinks(array $links): array
     {
         return array_map(function (MachineComponentLink $link): array {
-            $composant = $link->getComposant();
-            $requirement = $link->getTypeMachineComponentRequirement();
-            $parentLink = $link->getParentLink();
+            $composant           = $link->getComposant();
+            $requirement         = $link->getTypeMachineComponentRequirement();
+            $parentLink          = $link->getParentLink();
             $parentRequirementId = $parentLink?->getTypeMachineComponentRequirement()?->getId();
 
             return [
-                'id' => $link->getId(),
-                'linkId' => $link->getId(),
-                'machineId' => $link->getMachine()->getId(),
-                'composantId' => $composant->getId(),
-                'composant' => $this->normalizeComposant($composant),
-                'typeMachineComponentRequirementId' => $requirement?->getId(),
-                'typeMachineComponentRequirement' => $requirement ? $this->normalizeComponentRequirement($requirement) : null,
-                'parentLinkId' => $parentLink?->getId(),
-                'parentComponentLinkId' => $parentLink?->getId(),
-                'parentComponentId' => $parentLink?->getComposant()->getId(),
+                'id'                                  => $link->getId(),
+                'linkId'                              => $link->getId(),
+                'machineId'                           => $link->getMachine()->getId(),
+                'composantId'                         => $composant->getId(),
+                'composant'                           => $this->normalizeComposant($composant),
+                'typeMachineComponentRequirementId'   => $requirement?->getId(),
+                'typeMachineComponentRequirement'     => $requirement ? $this->normalizeComponentRequirement($requirement) : null,
+                'parentLinkId'                        => $parentLink?->getId(),
+                'parentComponentLinkId'               => $parentLink?->getId(),
+                'parentComponentId'                   => $parentLink?->getComposant()->getId(),
                 'parentMachineComponentRequirementId' => $parentRequirementId,
-                'overrides' => $this->normalizeOverrides($link),
-                'childLinks' => [],
-                'pieceLinks' => [],
+                'overrides'                           => $this->normalizeOverrides($link),
+                'childLinks'                          => [],
+                'pieceLinks'                          => [],
             ];
         }, $links);
     }
@@ -442,24 +487,24 @@ class MachineSkeletonController extends AbstractController
     private function normalizePieceLinks(array $links): array
     {
         return array_map(function (MachinePieceLink $link): array {
-            $piece = $link->getPiece();
-            $requirement = $link->getTypeMachinePieceRequirement();
-            $parentLink = $link->getParentLink();
+            $piece               = $link->getPiece();
+            $requirement         = $link->getTypeMachinePieceRequirement();
+            $parentLink          = $link->getParentLink();
             $parentRequirementId = $parentLink?->getTypeMachineComponentRequirement()?->getId();
 
             return [
-                'id' => $link->getId(),
-                'linkId' => $link->getId(),
-                'machineId' => $link->getMachine()->getId(),
-                'pieceId' => $piece->getId(),
-                'piece' => $this->normalizePiece($piece),
-                'typeMachinePieceRequirementId' => $requirement?->getId(),
-                'typeMachinePieceRequirement' => $requirement ? $this->normalizePieceRequirement($requirement) : null,
-                'parentLinkId' => $parentLink?->getId(),
-                'parentComponentLinkId' => $parentLink?->getId(),
-                'parentComponentId' => $parentLink?->getComposant()->getId(),
+                'id'                                  => $link->getId(),
+                'linkId'                              => $link->getId(),
+                'machineId'                           => $link->getMachine()->getId(),
+                'pieceId'                             => $piece->getId(),
+                'piece'                               => $this->normalizePiece($piece),
+                'typeMachinePieceRequirementId'       => $requirement?->getId(),
+                'typeMachinePieceRequirement'         => $requirement ? $this->normalizePieceRequirement($requirement) : null,
+                'parentLinkId'                        => $parentLink?->getId(),
+                'parentComponentLinkId'               => $parentLink?->getId(),
+                'parentComponentId'                   => $parentLink?->getComposant()->getId(),
                 'parentMachineComponentRequirementId' => $parentRequirementId,
-                'overrides' => $this->normalizeOverrides($link),
+                'overrides'                           => $this->normalizeOverrides($link),
             ];
         }, $links);
     }
@@ -467,20 +512,20 @@ class MachineSkeletonController extends AbstractController
     private function normalizeProductLinks(array $links): array
     {
         return array_map(function (MachineProductLink $link): array {
-            $product = $link->getProduct();
+            $product     = $link->getProduct();
             $requirement = $link->getTypeMachineProductRequirement();
 
             return [
-                'id' => $link->getId(),
-                'linkId' => $link->getId(),
-                'machineId' => $link->getMachine()->getId(),
-                'productId' => $product->getId(),
-                'product' => $this->normalizeProduct($product),
+                'id'                              => $link->getId(),
+                'linkId'                          => $link->getId(),
+                'machineId'                       => $link->getMachine()->getId(),
+                'productId'                       => $product->getId(),
+                'product'                         => $this->normalizeProduct($product),
                 'typeMachineProductRequirementId' => $requirement?->getId(),
-                'typeMachineProductRequirement' => $requirement ? $this->normalizeProductRequirement($requirement) : null,
-                'parentLinkId' => $link->getParentLink()?->getId(),
-                'parentComponentLinkId' => $link->getParentComponentLink()?->getId(),
-                'parentPieceLinkId' => $link->getParentPieceLink()?->getId(),
+                'typeMachineProductRequirement'   => $requirement ? $this->normalizeProductRequirement($requirement) : null,
+                'parentLinkId'                    => $link->getParentLink()?->getId(),
+                'parentComponentLinkId'           => $link->getParentComponentLink()?->getId(),
+                'parentPieceLinkId'               => $link->getParentPieceLink()?->getId(),
             ];
         }, $links);
     }
@@ -488,49 +533,49 @@ class MachineSkeletonController extends AbstractController
     private function normalizeComposant(Composant $composant): array
     {
         return [
-            'id' => $composant->getId(),
-            'name' => $composant->getName(),
-            'reference' => $composant->getReference(),
-            'prix' => $composant->getPrix(),
+            'id'              => $composant->getId(),
+            'name'            => $composant->getName(),
+            'reference'       => $composant->getReference(),
+            'prix'            => $composant->getPrix(),
             'typeComposantId' => $composant->getTypeComposant()?->getId(),
-            'typeComposant' => $this->normalizeModelType($composant->getTypeComposant()),
-            'productId' => $composant->getProduct()?->getId(),
-            'product' => $composant->getProduct() ? $this->normalizeProduct($composant->getProduct()) : null,
-            'constructeurs' => $this->normalizeConstructeurs($composant->getConstructeurs()),
-            'documents' => [],
-            'customFields' => [],
+            'typeComposant'   => $this->normalizeModelType($composant->getTypeComposant()),
+            'productId'       => $composant->getProduct()?->getId(),
+            'product'         => $composant->getProduct() ? $this->normalizeProduct($composant->getProduct()) : null,
+            'constructeurs'   => $this->normalizeConstructeurs($composant->getConstructeurs()),
+            'documents'       => [],
+            'customFields'    => [],
         ];
     }
 
     private function normalizePiece(Piece $piece): array
     {
         return [
-            'id' => $piece->getId(),
-            'name' => $piece->getName(),
-            'reference' => $piece->getReference(),
-            'prix' => $piece->getPrix(),
-            'typePieceId' => $piece->getTypePiece()?->getId(),
-            'typePiece' => $this->normalizeModelType($piece->getTypePiece()),
-            'productId' => $piece->getProduct()?->getId(),
-            'product' => $piece->getProduct() ? $this->normalizeProduct($piece->getProduct()) : null,
+            'id'            => $piece->getId(),
+            'name'          => $piece->getName(),
+            'reference'     => $piece->getReference(),
+            'prix'          => $piece->getPrix(),
+            'typePieceId'   => $piece->getTypePiece()?->getId(),
+            'typePiece'     => $this->normalizeModelType($piece->getTypePiece()),
+            'productId'     => $piece->getProduct()?->getId(),
+            'product'       => $piece->getProduct() ? $this->normalizeProduct($piece->getProduct()) : null,
             'constructeurs' => $this->normalizeConstructeurs($piece->getConstructeurs()),
-            'documents' => [],
-            'customFields' => [],
+            'documents'     => [],
+            'customFields'  => [],
         ];
     }
 
     private function normalizeProduct(Product $product): array
     {
         return [
-            'id' => $product->getId(),
-            'name' => $product->getName(),
-            'reference' => $product->getReference(),
+            'id'            => $product->getId(),
+            'name'          => $product->getName(),
+            'reference'     => $product->getReference(),
             'supplierPrice' => $product->getSupplierPrice(),
             'typeProductId' => $product->getTypeProduct()?->getId(),
-            'typeProduct' => $this->normalizeModelType($product->getTypeProduct()),
+            'typeProduct'   => $this->normalizeModelType($product->getTypeProduct()),
             'constructeurs' => $this->normalizeConstructeurs($product->getConstructeurs()),
-            'documents' => [],
-            'customFields' => [],
+            'documents'     => [],
+            'customFields'  => [],
         ];
     }
 
@@ -541,9 +586,9 @@ class MachineSkeletonController extends AbstractController
         }
 
         return [
-            'id' => $type->getId(),
-            'name' => $type->getName(),
-            'code' => $type->getCode(),
+            'id'       => $type->getId(),
+            'name'     => $type->getName(),
+            'code'     => $type->getCode(),
             'category' => $type->getCategory()->value,
         ];
     }
@@ -551,39 +596,39 @@ class MachineSkeletonController extends AbstractController
     private function normalizeComponentRequirement(TypeMachineComponentRequirement $requirement): array
     {
         return [
-            'id' => $requirement->getId(),
-            'label' => $requirement->getLabel(),
-            'minCount' => $requirement->getMinCount(),
-            'maxCount' => $requirement->getMaxCount(),
-            'required' => $requirement->isRequired(),
+            'id'              => $requirement->getId(),
+            'label'           => $requirement->getLabel(),
+            'minCount'        => $requirement->getMinCount(),
+            'maxCount'        => $requirement->getMaxCount(),
+            'required'        => $requirement->isRequired(),
             'typeComposantId' => $requirement->getTypeComposant()->getId(),
-            'typeComposant' => $this->normalizeModelType($requirement->getTypeComposant()),
+            'typeComposant'   => $this->normalizeModelType($requirement->getTypeComposant()),
         ];
     }
 
     private function normalizePieceRequirement(TypeMachinePieceRequirement $requirement): array
     {
         return [
-            'id' => $requirement->getId(),
-            'label' => $requirement->getLabel(),
-            'minCount' => $requirement->getMinCount(),
-            'maxCount' => $requirement->getMaxCount(),
-            'required' => $requirement->isRequired(),
+            'id'          => $requirement->getId(),
+            'label'       => $requirement->getLabel(),
+            'minCount'    => $requirement->getMinCount(),
+            'maxCount'    => $requirement->getMaxCount(),
+            'required'    => $requirement->isRequired(),
             'typePieceId' => $requirement->getTypePiece()->getId(),
-            'typePiece' => $this->normalizeModelType($requirement->getTypePiece()),
+            'typePiece'   => $this->normalizeModelType($requirement->getTypePiece()),
         ];
     }
 
     private function normalizeProductRequirement(TypeMachineProductRequirement $requirement): array
     {
         return [
-            'id' => $requirement->getId(),
-            'label' => $requirement->getLabel(),
-            'minCount' => $requirement->getMinCount(),
-            'maxCount' => $requirement->getMaxCount(),
-            'required' => $requirement->isRequired(),
+            'id'            => $requirement->getId(),
+            'label'         => $requirement->getLabel(),
+            'minCount'      => $requirement->getMinCount(),
+            'maxCount'      => $requirement->getMaxCount(),
+            'required'      => $requirement->isRequired(),
             'typeProductId' => $requirement->getTypeProduct()->getId(),
-            'typeProduct' => $this->normalizeModelType($requirement->getTypeProduct()),
+            'typeProduct'   => $this->normalizeModelType($requirement->getTypeProduct()),
         ];
     }
 
@@ -592,8 +637,8 @@ class MachineSkeletonController extends AbstractController
         $items = [];
         foreach ($constructeurs as $constructeur) {
             $items[] = [
-                'id' => $constructeur->getId(),
-                'name' => $constructeur->getName(),
+                'id'    => $constructeur->getId(),
+                'name'  => $constructeur->getName(),
                 'email' => $constructeur->getEmail(),
                 'phone' => $constructeur->getPhone(),
             ];
@@ -604,18 +649,18 @@ class MachineSkeletonController extends AbstractController
 
     private function normalizeOverrides(object $link): ?array
     {
-        $name = method_exists($link, 'getNameOverride') ? $link->getNameOverride() : null;
+        $name      = method_exists($link, 'getNameOverride') ? $link->getNameOverride() : null;
         $reference = method_exists($link, 'getReferenceOverride') ? $link->getReferenceOverride() : null;
-        $prix = method_exists($link, 'getPrixOverride') ? $link->getPrixOverride() : null;
+        $prix      = method_exists($link, 'getPrixOverride') ? $link->getPrixOverride() : null;
 
-        if ($name === null && $reference === null && $prix === null) {
+        if (null === $name && null === $reference && null === $prix) {
             return null;
         }
 
         return [
-            'name' => $name,
+            'name'      => $name,
             'reference' => $reference,
-            'prix' => $prix,
+            'prix'      => $prix,
         ];
     }
 
@@ -638,12 +683,12 @@ class MachineSkeletonController extends AbstractController
 
     private function stringOrNull(mixed $value): ?string
     {
-        if ($value === null) {
+        if (null === $value) {
             return null;
         }
         $string = trim((string) $value);
 
-        return $string === '' ? null : $string;
+        return '' === $string ? null : $string;
     }
 
     private function resolveIdentifier(array $entry, array $keys): ?string
@@ -653,9 +698,10 @@ class MachineSkeletonController extends AbstractController
                 continue;
             }
             $value = $entry[$key];
-            if ($value === null || $value === '') {
+            if (null === $value || '' === $value) {
                 continue;
             }
+
             return (string) $value;
         }
 
@@ -664,6 +710,7 @@ class MachineSkeletonController extends AbstractController
 
     /**
      * @param array<array-key, object> $links
+     *
      * @return array<string, object>
      */
     private function indexLinksById(array $links): array
@@ -706,6 +753,6 @@ class MachineSkeletonController extends AbstractController
 
     private function generateCuid(): string
     {
-        return 'cl' . bin2hex(random_bytes(12));
+        return 'cl'.bin2hex(random_bytes(12));
     }
 }

src/Controller/ModelTypeConversionController.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller;
+
+use App\Repository\ModelTypeRepository;
+use App\Service\ModelTypeCategoryConversionService;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+final class ModelTypeConversionController
+{
+    public function __construct(
+        private readonly ModelTypeRepository $modelTypes,
+        private readonly ModelTypeCategoryConversionService $conversionService,
+    ) {}
+
+    #[Route('/api/model_types/{id}/conversion-check', name: 'api_model_type_conversion_check', methods: ['GET'])]
+    public function check(string $id): JsonResponse
+    {
+        $modelType = $this->modelTypes->find($id);
+
+        if (!$modelType) {
+            return new JsonResponse(
+                ['message' => 'Catégorie introuvable.'],
+                Response::HTTP_NOT_FOUND,
+            );
+        }
+
+        return new JsonResponse($this->conversionService->checkConversion($id));
+    }
+
+    #[Route('/api/model_types/{id}/convert', name: 'api_model_type_convert', methods: ['POST'])]
+    public function convert(string $id): JsonResponse
+    {
+        $modelType = $this->modelTypes->find($id);
+
+        if (!$modelType) {
+            return new JsonResponse(
+                ['message' => 'Catégorie introuvable.'],
+                Response::HTTP_NOT_FOUND,
+            );
+        }
+
+        $result = $this->conversionService->convert($id);
+
+        if (!$result['success']) {
+            return new JsonResponse($result, Response::HTTP_CONFLICT);
+        }
+
+        return new JsonResponse($result);
+    }
+}

src/Controller/PieceHistoryController.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller;
+
+use App\Repository\AuditLogRepository;
+use App\Repository\PieceRepository;
+use App\Repository\ProfileRepository;
+use DateTimeInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+final class PieceHistoryController
+{
+    public function __construct(
+        private readonly PieceRepository $pieces,
+        private readonly AuditLogRepository $auditLogs,
+        private readonly ProfileRepository $profiles,
+    ) {}
+
+    #[Route('/api/pieces/{id}/history', name: 'api_piece_history', methods: ['GET'])]
+    public function __invoke(string $id): JsonResponse
+    {
+        $piece = $this->pieces->find($id);
+        if (!$piece) {
+            return new JsonResponse(
+                ['message' => 'Pièce introuvable.'],
+                Response::HTTP_NOT_FOUND,
+            );
+        }
+
+        $logs = $this->auditLogs->findEntityHistory('piece', $id, 200);
+
+        $actorIds = array_values(array_unique(array_filter(array_map(
+            static fn ($log) => $log->getActorProfileId(),
+            $logs,
+        ))));
+
+        $actorMap = [];
+        if ([] !== $actorIds) {
+            $profiles = $this->profiles->findBy(['id' => $actorIds]);
+            foreach ($profiles as $profile) {
+                $label = trim(sprintf('%s %s', $profile->getFirstName(), $profile->getLastName()));
+                if ('' === $label) {
+                    $label = $profile->getEmail() ?? $profile->getId();
+                }
+                $actorMap[$profile->getId()] = $label;
+            }
+        }
+
+        $items = array_map(
+            static function ($log) use ($actorMap) {
+                $actorId = $log->getActorProfileId();
+
+                return [
+                    'id'        => $log->getId(),
+                    'action'    => $log->getAction(),
+                    'createdAt' => $log->getCreatedAt()->format(DateTimeInterface::ATOM),
+                    'actor'     => $actorId
+                        ? [
+                            'id'    => $actorId,
+                            'label' => $actorMap[$actorId] ?? $actorId,
+                        ]
+                        : null,
+                    'diff'     => $log->getDiff(),
+                    'snapshot' => $log->getSnapshot(),
+                ];
+            },
+            $logs,
+        );
+
+        return new JsonResponse([
+            'items' => array_values($items),
+            'total' => count($items),
+        ]);
+    }
+}

src/Controller/ProductHistoryController.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller;
+
+use App\Repository\AuditLogRepository;
+use App\Repository\ProductRepository;
+use App\Repository\ProfileRepository;
+use DateTimeInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+final class ProductHistoryController
+{
+    public function __construct(
+        private readonly ProductRepository $products,
+        private readonly AuditLogRepository $auditLogs,
+        private readonly ProfileRepository $profiles,
+    ) {}
+
+    #[Route('/api/products/{id}/history', name: 'api_product_history', methods: ['GET'])]
+    public function __invoke(string $id): JsonResponse
+    {
+        $product = $this->products->find($id);
+        if (!$product) {
+            return new JsonResponse(
+                ['message' => 'Produit introuvable.'],
+                Response::HTTP_NOT_FOUND,
+            );
+        }
+
+        $logs = $this->auditLogs->findEntityHistory('product', $id, 200);
+
+        $actorIds = array_values(array_unique(array_filter(array_map(
+            static fn ($log) => $log->getActorProfileId(),
+            $logs,
+        ))));
+
+        $actorMap = [];
+        if ([] !== $actorIds) {
+            $profiles = $this->profiles->findBy(['id' => $actorIds]);
+            foreach ($profiles as $profile) {
+                $label = trim(sprintf('%s %s', $profile->getFirstName(), $profile->getLastName()));
+                if ('' === $label) {
+                    $label = $profile->getEmail() ?? $profile->getId();
+                }
+                $actorMap[$profile->getId()] = $label;
+            }
+        }
+
+        $items = array_map(
+            static function ($log) use ($actorMap) {
+                $actorId = $log->getActorProfileId();
+
+                return [
+                    'id'        => $log->getId(),
+                    'action'    => $log->getAction(),
+                    'createdAt' => $log->getCreatedAt()->format(DateTimeInterface::ATOM),
+                    'actor'     => $actorId
+                        ? [
+                            'id'    => $actorId,
+                            'label' => $actorMap[$actorId] ?? $actorId,
+                        ]
+                        : null,
+                    'diff'     => $log->getDiff(),
+                    'snapshot' => $log->getSnapshot(),
+                ];
+            },
+            $logs,
+        );
+
+        return new JsonResponse([
+            'items' => array_values($items),
+            'total' => count($items),
+        ]);
+    }
+}

src/Controller/SessionProfileController.php

@@ -12,9 +12,7 @@ use Symfony\Component\Routing\Attribute\Route;
 
 final class SessionProfileController
 {
-    public function __construct(private readonly ProfileRepository $profiles)
-    {
-    }
+    public function __construct(private readonly ProfileRepository $profiles) {}
 
     #[Route('/api/session/profile', name: 'api_session_profile_get', methods: ['GET'])]
     public function getActiveProfile(Request $request): JsonResponse
@@ -32,16 +30,17 @@ final class SessionProfileController
         $profile = $this->profiles->find($profileId);
         if (!$profile || !$profile->isActive()) {
             $session->remove('profileId');
+
             return new JsonResponse(['message' => 'Profil introuvable ou inactif.'], JsonResponse::HTTP_UNAUTHORIZED);
         }
 
         return new JsonResponse([
-            'id' => $profile->getId(),
+            'id'        => $profile->getId(),
             'firstName' => $profile->getFirstName(),
-            'lastName' => $profile->getLastName(),
-            'email' => $profile->getEmail(),
-            'isActive' => $profile->isActive(),
-            'roles' => $profile->getRoles(),
+            'lastName'  => $profile->getLastName(),
+            'email'     => $profile->getEmail(),
+            'isActive'  => $profile->isActive(),
+            'roles'     => $profile->getRoles(),
         ]);
     }
 
@@ -53,7 +52,7 @@ final class SessionProfileController
             return new JsonResponse(['message' => 'Session indisponible.'], JsonResponse::HTTP_INTERNAL_SERVER_ERROR);
         }
 
-        $payload = $request->toArray();
+        $payload   = $request->toArray();
         $profileId = $payload['profileId'] ?? null;
 
         if (!$profileId) {
@@ -68,12 +67,12 @@ final class SessionProfileController
         $session->set('profileId', $profile->getId());
 
         return new JsonResponse([
-            'id' => $profile->getId(),
+            'id'        => $profile->getId(),
             'firstName' => $profile->getFirstName(),
-            'lastName' => $profile->getLastName(),
-            'email' => $profile->getEmail(),
-            'isActive' => $profile->isActive(),
-            'roles' => $profile->getRoles(),
+            'lastName'  => $profile->getLastName(),
+            'email'     => $profile->getEmail(),
+            'isActive'  => $profile->isActive(),
+            'roles'     => $profile->getRoles(),
         ]);
     }
 

src/Controller/SessionProfilesController.php

@@ -16,8 +16,7 @@ final class SessionProfilesController
     public function __construct(
         private readonly ProfileRepository $profiles,
         private readonly EntityManagerInterface $entityManager
-    ) {
-    }
+    ) {}
 
     #[Route('/api/session/profiles', name: 'api_session_profiles_list', methods: ['GET'])]
     public function list(): JsonResponse
@@ -27,7 +26,8 @@ final class SessionProfilesController
             ->setParameter('active', true)
             ->orderBy('p.firstName', 'ASC')
             ->getQuery()
-            ->getResult();
+            ->getResult()
+        ;
 
         return new JsonResponse(array_map([$this, 'serializeProfile'], $items));
     }
@@ -35,11 +35,11 @@ final class SessionProfilesController
     #[Route('/api/session/profiles', name: 'api_session_profiles_create', methods: ['POST'])]
     public function create(Request $request): JsonResponse
     {
-        $payload = $request->toArray();
+        $payload   = $request->toArray();
         $firstName = trim((string) ($payload['firstName'] ?? ''));
-        $lastName = trim((string) ($payload['lastName'] ?? ''));
+        $lastName  = trim((string) ($payload['lastName'] ?? ''));
 
-        if ($firstName === '' || $lastName === '') {
+        if ('' === $firstName || '' === $lastName) {
             return new JsonResponse(['message' => 'firstName et lastName sont requis.'], JsonResponse::HTTP_BAD_REQUEST);
         }
 
@@ -71,10 +71,10 @@ final class SessionProfilesController
     private function serializeProfile(Profile $profile): array
     {
         return [
-            'id' => $profile->getId(),
+            'id'        => $profile->getId(),
             'firstName' => $profile->getFirstName(),
-            'lastName' => $profile->getLastName(),
-            'isActive' => $profile->isActive(),
+            'lastName'  => $profile->getLastName(),
+            'isActive'  => $profile->isActive(),
         ];
     }
 }

src/Doctrine/QuoteStrategy/AlwaysQuoteStrategy.php

@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Doctrine\QuoteStrategy;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\ORM\Internal\SQLResultCasing;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Mapping\JoinColumnMapping;
+use Doctrine\ORM\Mapping\ManyToManyOwningSideMapping;
+use Doctrine\ORM\Mapping\QuoteStrategy;
+
+use function array_map;
+use function array_merge;
+use function assert;
+use function explode;
+use function implode;
+
+/**
+ * Quote all identifiers to preserve camelCase column names in Postgres.
+ */
+final class AlwaysQuoteStrategy implements QuoteStrategy
+{
+    use SQLResultCasing;
+
+    public function getColumnName(string $fieldName, ClassMetadata $class, AbstractPlatform $platform): string
+    {
+        return $platform->quoteSingleIdentifier($class->fieldMappings[$fieldName]->columnName);
+    }
+
+    public function getTableName(ClassMetadata $class, AbstractPlatform $platform): string
+    {
+        $tableName = $platform->quoteSingleIdentifier($class->table['name']);
+
+        if (!empty($class->table['schema'])) {
+            return $platform->quoteSingleIdentifier($class->table['schema']).'.'.$tableName;
+        }
+
+        return $tableName;
+    }
+
+    public function getSequenceName(array $definition, ClassMetadata $class, AbstractPlatform $platform): string
+    {
+        return implode('.', array_map(
+            static fn (string $part) => $platform->quoteSingleIdentifier($part),
+            explode('.', $definition['sequenceName']),
+        ));
+    }
+
+    public function getJoinTableName(
+        ManyToManyOwningSideMapping $association,
+        ClassMetadata $class,
+        AbstractPlatform $platform,
+    ): string {
+        $schema = '';
+
+        if (isset($association->joinTable->schema)) {
+            $schema = $platform->quoteSingleIdentifier($association->joinTable->schema).'.';
+        }
+
+        return $schema.$platform->quoteSingleIdentifier($association->joinTable->name);
+    }
+
+    public function getJoinColumnName(JoinColumnMapping $joinColumn, ClassMetadata $class, AbstractPlatform $platform): string
+    {
+        return $platform->quoteSingleIdentifier($joinColumn->name);
+    }
+
+    public function getReferencedJoinColumnName(
+        JoinColumnMapping $joinColumn,
+        ClassMetadata $class,
+        AbstractPlatform $platform,
+    ): string {
+        return $platform->quoteSingleIdentifier($joinColumn->referencedColumnName);
+    }
+
+    public function getIdentifierColumnNames(ClassMetadata $class, AbstractPlatform $platform): array
+    {
+        $quotedColumnNames = [];
+
+        foreach ($class->identifier as $fieldName) {
+            if (isset($class->fieldMappings[$fieldName])) {
+                $quotedColumnNames[] = $this->getColumnName($fieldName, $class, $platform);
+
+                continue;
+            }
+
+            $assoc = $class->associationMappings[$fieldName];
+            assert($assoc->isToOneOwningSide());
+            $joinColumns            = $assoc->joinColumns;
+            $assocQuotedColumnNames = array_map(
+                static fn (JoinColumnMapping $joinColumn) => $platform->quoteSingleIdentifier($joinColumn->name),
+                $joinColumns,
+            );
+
+            $quotedColumnNames = array_merge($quotedColumnNames, $assocQuotedColumnNames);
+        }
+
+        return $quotedColumnNames;
+    }
+
+    public function getColumnAlias(
+        string $columnName,
+        int $counter,
+        AbstractPlatform $platform,
+        ?ClassMetadata $class = null,
+    ): string {
+        return $this->getSQLResultCasing($platform, $columnName.'_'.$counter);
+    }
+}

src/Entity/AuditLog.php

@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use App\Repository\AuditLogRepository;
+use DateTimeImmutable;
+use Doctrine\DBAL\Types\Types;
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity(repositoryClass: AuditLogRepository::class)]
+#[ORM\Table(name: 'audit_logs')]
+#[ORM\Index(name: 'idx_audit_entity', columns: ['entityType', 'entityId'])]
+#[ORM\Index(name: 'idx_audit_created_at', columns: ['createdAt'])]
+#[ORM\HasLifecycleCallbacks]
+class AuditLog
+{
+    #[ORM\Id]
+    #[ORM\Column(type: Types::STRING, length: 36)]
+    private ?string $id = null;
+
+    #[ORM\Column(type: Types::STRING, length: 50)]
+    private string $entityType;
+
+    #[ORM\Column(type: Types::STRING, length: 36)]
+    private string $entityId;
+
+    #[ORM\Column(type: Types::STRING, length: 20)]
+    private string $action;
+
+    #[ORM\Column(type: Types::JSON, nullable: true)]
+    private ?array $diff = null;
+
+    #[ORM\Column(type: Types::JSON, nullable: true)]
+    private ?array $snapshot = null;
+
+    #[ORM\Column(type: Types::STRING, length: 36, nullable: true)]
+    private ?string $actorProfileId = null;
+
+    #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
+    private DateTimeImmutable $createdAt;
+
+    public function __construct(
+        string $entityType,
+        string $entityId,
+        string $action,
+        ?array $diff = null,
+        ?array $snapshot = null,
+        ?string $actorProfileId = null,
+    ) {
+        $this->entityType     = $entityType;
+        $this->entityId       = $entityId;
+        $this->action         = $action;
+        $this->diff           = $diff;
+        $this->snapshot       = $snapshot;
+        $this->actorProfileId = $actorProfileId;
+    }
+
+    #[ORM\PrePersist]
+    public function initializeAuditLog(): void
+    {
+        if (!isset($this->createdAt)) {
+            $this->createdAt = new DateTimeImmutable();
+        }
+
+        if (null === $this->id) {
+            $this->id = $this->generateCuid();
+        }
+    }
+
+    public function getId(): ?string
+    {
+        return $this->id;
+    }
+
+    public function getEntityType(): string
+    {
+        return $this->entityType;
+    }
+
+    public function getEntityId(): string
+    {
+        return $this->entityId;
+    }
+
+    public function getAction(): string
+    {
+        return $this->action;
+    }
+
+    public function getDiff(): ?array
+    {
+        return $this->diff;
+    }
+
+    public function getSnapshot(): ?array
+    {
+        return $this->snapshot;
+    }
+
+    public function getActorProfileId(): ?string
+    {
+        return $this->actorProfileId;
+    }
+
+    public function getCreatedAt(): DateTimeImmutable
+    {
+        return $this->createdAt;
+    }
+
+    private function generateCuid(): string
+    {
+        // Keep the same lightweight CUID-like strategy used across the project.
+        return 'cl'.substr(strtolower(base_convert(bin2hex(random_bytes(12)), 16, 36)), 0, 24);
+    }
+}

src/Entity/Composant.php

@@ -4,41 +4,59 @@ declare(strict_types=1);
 
 namespace App\Entity;
 
+use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
+use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
+use ApiPlatform\Metadata\ApiFilter;
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\ComposantRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 
 #[ORM\Entity(repositoryClass: ComposantRepository::class)]
 #[ORM\Table(name: 'composants')]
 #[ORM\HasLifecycleCallbacks]
-#[ApiResource]
+#[ApiFilter(SearchFilter::class, properties: ['name' => 'ipartial', 'reference' => 'ipartial', 'typeComposant' => 'exact'])]
+#[ApiFilter(OrderFilter::class, properties: ['name', 'createdAt'])]
+#[ApiResource(
+    normalizationContext: ['groups' => ['composant:read']],
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
+)]
 class Composant
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['composant:read', 'document:list'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255, unique: true)]
+    #[Groups(['composant:read', 'document:list'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
+    #[Groups(['composant:read'])]
     private ?string $reference = null;
 
     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2, nullable: true)]
+    #[Groups(['composant:read'])]
     private ?string $prix = null;
 
     #[ORM\Column(type: Types::JSON, nullable: true)]
+    #[Groups(['composant:read'])]
     private ?array $structure = null;
 
     #[ORM\ManyToOne(targetEntity: ModelType::class, inversedBy: 'composants')]
     #[ORM\JoinColumn(name: 'typeComposantId', referencedColumnName: 'id', nullable: true)]
+    #[Groups(['composant:read'])]
     private ?ModelType $typeComposant = null;
 
     #[ORM\ManyToOne(targetEntity: Product::class, inversedBy: 'composants')]
     #[ORM\JoinColumn(name: 'productId', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
+    #[Groups(['composant:read'])]
     private ?Product $product = null;
 
     /**
@@ -50,18 +68,21 @@ class Composant
         joinColumns: [new ORM\JoinColumn(name: 'A', referencedColumnName: 'id', onDelete: 'CASCADE')],
         inverseJoinColumns: [new ORM\InverseJoinColumn(name: 'B', referencedColumnName: 'id', onDelete: 'CASCADE')]
     )]
+    #[Groups(['composant:read'])]
     private Collection $constructeurs;
 
     /**
      * @var Collection<int, Document>
      */
     #[ORM\OneToMany(mappedBy: 'composant', targetEntity: Document::class)]
+    #[Groups(['composant:read'])]
     private Collection $documents;
 
     /**
      * @var Collection<int, CustomFieldValue>
      */
     #[ORM\OneToMany(mappedBy: 'composant', targetEntity: CustomFieldValue::class)]
+    #[Groups(['composant:read'])]
     private Collection $customFieldValues;
 
     /**
@@ -71,27 +92,29 @@ class Composant
     private Collection $machineLinks;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    #[Groups(['composant:read'])]
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    #[Groups(['composant:read'])]
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
-        $this->constructeurs = new ArrayCollection();
-        $this->documents = new ArrayCollection();
+        $this->constructeurs     = new ArrayCollection();
+        $this->documents         = new ArrayCollection();
         $this->customFieldValues = new ArrayCollection();
-        $this->machineLinks = new ArrayCollection();
+        $this->machineLinks      = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -99,12 +122,7 @@ class Composant
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -126,7 +144,7 @@ class Composant
 
     public function setName(string $name): static
     {
-        $this->name = $name;
+        $this->name = mb_strtoupper(mb_substr($name, 0, 1)).mb_substr($name, 1);
 
         return $this;
     }
@@ -199,6 +217,38 @@ class Composant
         return $this->constructeurs;
     }
 
+    /**
+     * @param iterable<Constructeur> $constructeurs
+     */
+    public function setConstructeurs(iterable $constructeurs): static
+    {
+        $this->constructeurs = new ArrayCollection();
+
+        foreach ($constructeurs as $constructeur) {
+            if ($constructeur instanceof Constructeur && !$this->constructeurs->contains($constructeur)) {
+                $this->constructeurs->add($constructeur);
+            }
+        }
+
+        return $this;
+    }
+
+    public function addConstructeur(Constructeur $constructeur): static
+    {
+        if (!$this->constructeurs->contains($constructeur)) {
+            $this->constructeurs->add($constructeur);
+        }
+
+        return $this;
+    }
+
+    public function removeConstructeur(Constructeur $constructeur): static
+    {
+        $this->constructeurs->removeElement($constructeur);
+
+        return $this;
+    }
+
     /**
      * @return Collection<int, Document>
      */
@@ -215,13 +265,18 @@ class Composant
         return $this->customFieldValues;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/Constructeur.php

@@ -6,6 +6,7 @@ namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\ConstructeurRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -14,7 +15,10 @@ use Doctrine\ORM\Mapping as ORM;
 #[ORM\Entity(repositoryClass: ConstructeurRepository::class)]
 #[ORM\Table(name: 'constructeurs')]
 #[ORM\HasLifecycleCallbacks]
-#[ApiResource]
+#[ApiResource(
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
+)]
 class Constructeur
 {
     #[ORM\Id]
@@ -31,10 +35,10 @@ class Constructeur
     private ?string $phone = null;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     /**
      * @var Collection<int, Machine>
@@ -62,20 +66,20 @@ class Constructeur
 
     public function __construct()
     {
-        $this->machines = new ArrayCollection();
+        $this->machines   = new ArrayCollection();
         $this->composants = new ArrayCollection();
-        $this->pieces = new ArrayCollection();
-        $this->products = new ArrayCollection();
+        $this->pieces     = new ArrayCollection();
+        $this->products   = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -83,12 +87,7 @@ class Constructeur
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -139,13 +138,18 @@ class Constructeur
         return $this;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/CustomField.php

@@ -6,10 +6,12 @@ namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\CustomFieldRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 
 #[ORM\Entity(repositoryClass: CustomFieldRepository::class)]
 #[ORM\Table(name: 'custom_fields')]
@@ -19,24 +21,30 @@ class CustomField
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255)]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 50)]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private string $type;
 
     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private bool $required = false;
 
     #[ORM\Column(type: Types::STRING, length: 255, nullable: true, name: 'defaultValue')]
     private ?string $defaultValue = null;
 
     #[ORM\Column(type: Types::JSON, nullable: true)]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private ?array $options = null;
 
     #[ORM\Column(type: Types::INTEGER, options: ['default' => 0], name: 'orderIndex')]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private int $orderIndex = 0;
 
     #[ORM\ManyToOne(targetEntity: TypeMachine::class, inversedBy: 'customFields')]
@@ -62,10 +70,10 @@ class CustomField
     private Collection $customFieldValues;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
@@ -75,11 +83,11 @@ class CustomField
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -87,12 +95,7 @@ class CustomField
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -179,13 +182,30 @@ class CustomField
         return $this;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getTypeMachine(): ?TypeMachine
+    {
+        return $this->typeMachine;
+    }
+
+    public function setTypeMachine(?TypeMachine $typeMachine): static
+    {
+        $this->typeMachine = $typeMachine;
+
+        return $this;
+    }
+
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/CustomFieldValue.php

@@ -6,8 +6,10 @@ namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\CustomFieldValueRepository;
+use DateTimeImmutable;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 
 #[ORM\Entity(repositoryClass: CustomFieldValueRepository::class)]
 #[ORM\Table(name: 'custom_field_values')]
@@ -17,13 +19,16 @@ class CustomFieldValue
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255)]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private string $value;
 
     #[ORM\ManyToOne(targetEntity: CustomField::class, inversedBy: 'customFieldValues')]
     #[ORM\JoinColumn(name: 'customFieldId', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
     private CustomField $customField;
 
     #[ORM\ManyToOne(targetEntity: Machine::class, inversedBy: 'customFieldValues')]
@@ -43,19 +48,21 @@ class CustomFieldValue
     private ?Product $product = null;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    #[Groups(['composant:read', 'piece:read', 'product:read', 'machine:read'])]
+    private DateTimeImmutable $updatedAt;
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -63,12 +70,7 @@ class CustomFieldValue
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -155,13 +157,18 @@ class CustomFieldValue
         return $this;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/Document.php

@@ -5,69 +5,98 @@ declare(strict_types=1);
 namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Delete;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\GetCollection;
+use ApiPlatform\Metadata\Post;
+use ApiPlatform\Metadata\Put;
 use App\Repository\DocumentRepository;
+use DateTimeImmutable;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 
 #[ORM\Entity(repositoryClass: DocumentRepository::class)]
 #[ORM\Table(name: 'documents')]
 #[ORM\HasLifecycleCallbacks]
-#[ApiResource]
+#[ApiResource(
+    operations: [
+        new GetCollection(normalizationContext: ['groups' => ['document:list']]),
+        new Get(normalizationContext: ['groups' => ['document:list', 'document:detail']]),
+        new Post(),
+        new Put(),
+        new Delete(),
+    ],
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
+)]
 class Document
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['document:list', 'document:read', 'composant:read', 'piece:read', 'product:read'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255)]
+    #[Groups(['document:list', 'document:read', 'composant:read', 'piece:read', 'product:read'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 255)]
+    #[Groups(['document:list', 'document:read', 'composant:read', 'piece:read', 'product:read'])]
     private string $filename;
 
     #[ORM\Column(type: Types::TEXT)]
+    #[Groups(['document:detail', 'document:read', 'composant:read', 'piece:read', 'product:read'])]
     private string $path;
 
     #[ORM\Column(type: Types::STRING, length: 100, name: 'mimeType')]
+    #[Groups(['document:list', 'document:read', 'composant:read', 'piece:read', 'product:read'])]
     private string $mimeType;
 
     #[ORM\Column(type: Types::INTEGER)]
+    #[Groups(['document:list', 'document:read', 'composant:read', 'piece:read', 'product:read'])]
     private int $size;
 
     #[ORM\ManyToOne(targetEntity: Machine::class, inversedBy: 'documents')]
     #[ORM\JoinColumn(name: 'machineId', referencedColumnName: 'id', nullable: true, onDelete: 'CASCADE')]
+    #[Groups(['document:list'])]
     private ?Machine $machine = null;
 
     #[ORM\ManyToOne(targetEntity: Composant::class, inversedBy: 'documents')]
     #[ORM\JoinColumn(name: 'composantId', referencedColumnName: 'id', nullable: true, onDelete: 'CASCADE')]
+    #[Groups(['document:list'])]
     private ?Composant $composant = null;
 
     #[ORM\ManyToOne(targetEntity: Piece::class, inversedBy: 'documents')]
     #[ORM\JoinColumn(name: 'pieceId', referencedColumnName: 'id', nullable: true, onDelete: 'CASCADE')]
+    #[Groups(['document:list'])]
     private ?Piece $piece = null;
 
     #[ORM\ManyToOne(targetEntity: Product::class, inversedBy: 'documents')]
     #[ORM\JoinColumn(name: 'productId', referencedColumnName: 'id', nullable: true, onDelete: 'CASCADE')]
+    #[Groups(['document:list'])]
     private ?Product $product = null;
 
     #[ORM\ManyToOne(targetEntity: Site::class, inversedBy: 'documents')]
     #[ORM\JoinColumn(name: 'siteId', referencedColumnName: 'id', nullable: true, onDelete: 'CASCADE')]
+    #[Groups(['document:list'])]
     private ?Site $site = null;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    #[Groups(['document:list'])]
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -75,12 +104,7 @@ class Document
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -215,13 +239,18 @@ class Document
         return $this;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/Machine.php

@@ -6,10 +6,12 @@ namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\MachineRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 
 #[ORM\Entity(repositoryClass: MachineRepository::class)]
 #[ORM\Table(name: 'machines')]
@@ -19,9 +21,11 @@ class Machine
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['document:list'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255, unique: true)]
+    #[Groups(['document:list'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
@@ -80,29 +84,29 @@ class Machine
     private Collection $customFieldValues;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
-        $this->constructeurs = new ArrayCollection();
-        $this->componentLinks = new ArrayCollection();
-        $this->pieceLinks = new ArrayCollection();
-        $this->productLinks = new ArrayCollection();
-        $this->documents = new ArrayCollection();
+        $this->constructeurs     = new ArrayCollection();
+        $this->componentLinks    = new ArrayCollection();
+        $this->pieceLinks        = new ArrayCollection();
+        $this->productLinks      = new ArrayCollection();
+        $this->documents         = new ArrayCollection();
         $this->customFieldValues = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -110,12 +114,7 @@ class Machine
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -238,13 +237,18 @@ class Machine
         return $this->customFieldValues;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/MachineComponentLink.php

@@ -6,6 +6,7 @@ namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\MachineComponentLinkRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -65,26 +66,26 @@ class MachineComponentLink
     private ?string $prixOverride = null;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
-        $this->childLinks = new ArrayCollection();
-        $this->pieceLinks = new ArrayCollection();
+        $this->childLinks   = new ArrayCollection();
+        $this->pieceLinks   = new ArrayCollection();
         $this->productLinks = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -92,12 +93,7 @@ class MachineComponentLink
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -195,4 +191,9 @@ class MachineComponentLink
 
         return $this;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/MachinePieceLink.php

@@ -6,6 +6,7 @@ namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\MachinePieceLinkRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -53,10 +54,10 @@ class MachinePieceLink
     private ?string $prixOverride = null;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
@@ -66,11 +67,11 @@ class MachinePieceLink
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -78,12 +79,7 @@ class MachinePieceLink
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -181,4 +177,9 @@ class MachinePieceLink
 
         return $this;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/MachineProductLink.php

@@ -6,6 +6,7 @@ namespace App\Entity;
 
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\MachineProductLinkRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -52,10 +53,10 @@ class MachineProductLink
     private ?MachinePieceLink $parentPieceLink = null;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
@@ -65,11 +66,11 @@ class MachineProductLink
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -77,12 +78,7 @@ class MachineProductLink
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -168,4 +164,9 @@ class MachineProductLink
 
         return $this;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/ModelType.php

@@ -4,9 +4,13 @@ declare(strict_types=1);
 
 namespace App\Entity;
 
+use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
+use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
+use ApiPlatform\Metadata\ApiFilter;
 use ApiPlatform\Metadata\ApiResource;
 use App\Enum\ModelCategory;
 use App\Repository\ModelTypeRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -17,48 +21,60 @@ use Symfony\Component\Serializer\Annotation\Groups;
 #[ORM\Table(name: 'model_types')]
 #[ORM\UniqueConstraint(name: 'unique_category_name', columns: ['category', 'name'])]
 #[ORM\HasLifecycleCallbacks]
-#[ApiResource]
+#[ApiFilter(SearchFilter::class, properties: ['category' => 'exact', 'name' => 'ipartial'])]
+#[ApiFilter(OrderFilter::class, properties: ['name', 'createdAt'])]
+#[ApiResource(
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
+)]
 class ModelType
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
-    #[Groups(['type_machine:read'])]
+    #[Groups(['type_machine:read', 'model_type:read'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 120)]
-    #[Groups(['type_machine:read'])]
+    #[Groups(['type_machine:read', 'model_type:read', 'model_type:write'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 60, unique: true)]
-    #[Groups(['type_machine:read'])]
+    #[Groups(['type_machine:read', 'model_type:read', 'model_type:write'])]
     private string $code;
 
     #[ORM\Column(enumType: ModelCategory::class)]
-    #[Groups(['type_machine:read'])]
+    #[Groups(['type_machine:read', 'model_type:read', 'model_type:write'])]
     private ModelCategory $category;
 
     #[ORM\Column(type: Types::TEXT, nullable: true)]
-    #[Groups(['type_machine:read'])]
+    #[Groups(['type_machine:read', 'model_type:read', 'model_type:write'])]
     private ?string $notes = null;
 
     #[ORM\Column(type: Types::TEXT, nullable: true)]
-    #[Groups(['type_machine:read'])]
+    #[Groups(['type_machine:read', 'model_type:read', 'model_type:write'])]
     private ?string $description = null;
 
     #[ORM\Column(type: Types::JSON, nullable: true, name: 'componentSkeleton')]
+    #[Groups(['model_type:read'])]
     private ?array $componentSkeleton = null;
 
     #[ORM\Column(type: Types::JSON, nullable: true, name: 'pieceSkeleton')]
+    #[Groups(['model_type:read'])]
     private ?array $pieceSkeleton = null;
 
     #[ORM\Column(type: Types::JSON, nullable: true, name: 'productSkeleton')]
+    #[Groups(['model_type:read'])]
     private ?array $productSkeleton = null;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    #[Groups(['model_type:read'])]
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    #[Groups(['model_type:read'])]
+    private DateTimeImmutable $updatedAt;
+
+    private ?array $pendingStructure = null;
 
     /**
      * @var Collection<int, Composant>
@@ -116,25 +132,25 @@ class ModelType
 
     public function __construct()
     {
-        $this->composants = new ArrayCollection();
-        $this->pieces = new ArrayCollection();
-        $this->products = new ArrayCollection();
+        $this->composants            = new ArrayCollection();
+        $this->pieces                = new ArrayCollection();
+        $this->products              = new ArrayCollection();
         $this->componentRequirements = new ArrayCollection();
-        $this->pieceRequirements = new ArrayCollection();
-        $this->productRequirements = new ArrayCollection();
-        $this->customFields = new ArrayCollection();
-        $this->pieceCustomFields = new ArrayCollection();
-        $this->productCustomFields = new ArrayCollection();
+        $this->pieceRequirements     = new ArrayCollection();
+        $this->productRequirements   = new ArrayCollection();
+        $this->customFields          = new ArrayCollection();
+        $this->pieceCustomFields     = new ArrayCollection();
+        $this->productCustomFields   = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -142,12 +158,7 @@ class ModelType
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -169,7 +180,7 @@ class ModelType
 
     public function setName(string $name): static
     {
-        $this->name = $name;
+        $this->name = mb_strtoupper(mb_substr($name, 0, 1)).mb_substr($name, 1);
 
         return $this;
     }
@@ -195,6 +206,11 @@ class ModelType
     {
         $this->category = $category;
 
+        if (null !== $this->pendingStructure) {
+            $this->applyStructureForCategory($this->pendingStructure, $category);
+            $this->pendingStructure = null;
+        }
+
         return $this;
     }
 
@@ -258,13 +274,65 @@ class ModelType
         return $this;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    #[Groups(['model_type:read'])]
+    public function getStructure(): ?array
+    {
+        return match ($this->category) {
+            ModelCategory::COMPONENT => $this->componentSkeleton,
+            ModelCategory::PIECE     => $this->pieceSkeleton,
+            ModelCategory::PRODUCT   => $this->productSkeleton,
+        };
+    }
+
+    #[Groups(['model_type:write'])]
+    public function setStructure(?array $structure): static
+    {
+        if (!isset($this->category)) {
+            $this->pendingStructure = $structure;
+
+            return $this;
+        }
+
+        $this->applyStructureForCategory($structure, $this->category);
+
+        return $this;
+    }
+
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
+
+    private function applyStructureForCategory(?array $structure, ModelCategory $category): void
+    {
+        if (ModelCategory::COMPONENT === $category) {
+            $this->componentSkeleton = $structure;
+            $this->pieceSkeleton     = null;
+            $this->productSkeleton   = null;
+
+            return;
+        }
+
+        if (ModelCategory::PIECE === $category) {
+            $this->pieceSkeleton     = $structure;
+            $this->componentSkeleton = null;
+            $this->productSkeleton   = null;
+
+            return;
+        }
+
+        $this->productSkeleton   = $structure;
+        $this->componentSkeleton = null;
+        $this->pieceSkeleton     = null;
+    }
 }

src/Entity/Piece.php

@@ -4,40 +4,61 @@ declare(strict_types=1);
 
 namespace App\Entity;
 
+use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
+use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
+use ApiPlatform\Metadata\ApiFilter;
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\PieceRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 
 #[ORM\Entity(repositoryClass: PieceRepository::class)]
 #[ORM\Table(name: 'pieces')]
 #[ORM\HasLifecycleCallbacks]
-#[ApiResource]
+#[ApiFilter(SearchFilter::class, properties: ['name' => 'ipartial', 'reference' => 'ipartial', 'typePiece' => 'exact'])]
+#[ApiFilter(OrderFilter::class, properties: ['name', 'createdAt'])]
+#[ApiResource(
+    normalizationContext: ['groups' => ['piece:read']],
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
+)]
 class Piece
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['piece:read', 'document:list'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255, unique: true)]
+    #[Groups(['piece:read', 'document:list'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
+    #[Groups(['piece:read'])]
     private ?string $reference = null;
 
     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2, nullable: true)]
+    #[Groups(['piece:read'])]
     private ?string $prix = null;
 
     #[ORM\ManyToOne(targetEntity: ModelType::class, inversedBy: 'pieces')]
     #[ORM\JoinColumn(name: 'typePieceId', referencedColumnName: 'id', nullable: true)]
+    #[Groups(['piece:read'])]
     private ?ModelType $typePiece = null;
 
     #[ORM\ManyToOne(targetEntity: Product::class, inversedBy: 'pieces')]
     #[ORM\JoinColumn(name: 'productId', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
+    #[Groups(['piece:read'])]
     private ?Product $product = null;
 
+    #[ORM\Column(type: Types::JSON, nullable: true, name: 'productIds')]
+    #[Groups(['piece:read'])]
+    private ?array $productIds = null;
+
     /**
      * @var Collection<int, Constructeur>
      */
@@ -47,18 +68,21 @@ class Piece
         joinColumns: [new ORM\JoinColumn(name: 'A', referencedColumnName: 'id', onDelete: 'CASCADE')],
         inverseJoinColumns: [new ORM\InverseJoinColumn(name: 'B', referencedColumnName: 'id', onDelete: 'CASCADE')]
     )]
+    #[Groups(['piece:read'])]
     private Collection $constructeurs;
 
     /**
      * @var Collection<int, Document>
      */
     #[ORM\OneToMany(mappedBy: 'piece', targetEntity: Document::class)]
+    #[Groups(['piece:read'])]
     private Collection $documents;
 
     /**
      * @var Collection<int, CustomFieldValue>
      */
     #[ORM\OneToMany(mappedBy: 'piece', targetEntity: CustomFieldValue::class)]
+    #[Groups(['piece:read'])]
     private Collection $customFieldValues;
 
     /**
@@ -68,27 +92,29 @@ class Piece
     private Collection $machineLinks;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    #[Groups(['piece:read'])]
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    #[Groups(['piece:read'])]
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
-        $this->constructeurs = new ArrayCollection();
-        $this->documents = new ArrayCollection();
+        $this->constructeurs     = new ArrayCollection();
+        $this->documents         = new ArrayCollection();
         $this->customFieldValues = new ArrayCollection();
-        $this->machineLinks = new ArrayCollection();
+        $this->machineLinks      = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -96,12 +122,7 @@ class Piece
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -173,6 +194,60 @@ class Piece
     {
         $this->product = $product;
 
+        if ($product && empty($this->productIds)) {
+            $productId        = $product->getId();
+            $this->productIds = $productId ? [$productId] : null;
+        }
+
+        if (!$product && empty($this->productIds)) {
+            $this->productIds = null;
+        }
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getProductIds(): array
+    {
+        if (!is_array($this->productIds)) {
+            return [];
+        }
+
+        return array_values(
+            array_filter(
+                array_map(
+                    static fn ($value) => is_string($value) ? trim($value) : '',
+                    $this->productIds,
+                ),
+                static fn (string $value) => '' !== $value,
+            ),
+        );
+    }
+
+    public function setProductIds(?array $productIds): static
+    {
+        if (!is_array($productIds)) {
+            $this->productIds = null;
+
+            return $this;
+        }
+
+        $normalized = array_values(
+            array_unique(
+                array_filter(
+                    array_map(
+                        static fn ($value) => is_string($value) ? trim($value) : '',
+                        $productIds,
+                    ),
+                    static fn (string $value) => '' !== $value,
+                ),
+            ),
+        );
+
+        $this->productIds = [] === $normalized ? null : $normalized;
+
         return $this;
     }
 
@@ -184,6 +259,22 @@ class Piece
         return $this->constructeurs;
     }
 
+    public function addConstructeur(Constructeur $constructeur): static
+    {
+        if (!$this->constructeurs->contains($constructeur)) {
+            $this->constructeurs->add($constructeur);
+        }
+
+        return $this;
+    }
+
+    public function removeConstructeur(Constructeur $constructeur): static
+    {
+        $this->constructeurs->removeElement($constructeur);
+
+        return $this;
+    }
+
     /**
      * @return Collection<int, Document>
      */
@@ -200,13 +291,18 @@ class Piece
         return $this->customFieldValues;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/Product.php

@@ -4,34 +4,50 @@ declare(strict_types=1);
 
 namespace App\Entity;
 
+use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
+use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
+use ApiPlatform\Metadata\ApiFilter;
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\ProductRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 
 #[ORM\Entity(repositoryClass: ProductRepository::class)]
 #[ORM\Table(name: 'products')]
 #[ORM\HasLifecycleCallbacks]
-#[ApiResource]
+#[ApiFilter(SearchFilter::class, properties: ['name' => 'ipartial', 'reference' => 'ipartial', 'typeProduct' => 'exact'])]
+#[ApiFilter(OrderFilter::class, properties: ['name', 'createdAt'])]
+#[ApiResource(
+    normalizationContext: ['groups' => ['product:read']],
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
+)]
 class Product
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['product:read', 'document:list'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255, unique: true)]
+    #[Groups(['product:read', 'document:list'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
+    #[Groups(['product:read'])]
     private ?string $reference = null;
 
     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2, nullable: true, name: 'supplierPrice')]
+    #[Groups(['product:read'])]
     private ?string $supplierPrice = null;
 
     #[ORM\ManyToOne(targetEntity: ModelType::class, inversedBy: 'products')]
     #[ORM\JoinColumn(name: 'typeProductId', referencedColumnName: 'id', nullable: true)]
+    #[Groups(['product:read'])]
     private ?ModelType $typeProduct = null;
 
     /**
@@ -43,18 +59,21 @@ class Product
         joinColumns: [new ORM\JoinColumn(name: 'A', referencedColumnName: 'id', onDelete: 'CASCADE')],
         inverseJoinColumns: [new ORM\InverseJoinColumn(name: 'B', referencedColumnName: 'id', onDelete: 'CASCADE')]
     )]
+    #[Groups(['product:read'])]
     private Collection $constructeurs;
 
     /**
      * @var Collection<int, Document>
      */
     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Document::class)]
+    #[Groups(['product:read'])]
     private Collection $documents;
 
     /**
      * @var Collection<int, CustomFieldValue>
      */
     #[ORM\OneToMany(mappedBy: 'product', targetEntity: CustomFieldValue::class)]
+    #[Groups(['product:read'])]
     private Collection $customFieldValues;
 
     /**
@@ -76,29 +95,31 @@ class Product
     private Collection $machineLinks;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    #[Groups(['product:read'])]
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    #[Groups(['product:read'])]
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
-        $this->constructeurs = new ArrayCollection();
-        $this->documents = new ArrayCollection();
+        $this->constructeurs     = new ArrayCollection();
+        $this->documents         = new ArrayCollection();
         $this->customFieldValues = new ArrayCollection();
-        $this->pieces = new ArrayCollection();
-        $this->composants = new ArrayCollection();
-        $this->machineLinks = new ArrayCollection();
+        $this->pieces            = new ArrayCollection();
+        $this->composants        = new ArrayCollection();
+        $this->machineLinks      = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -106,12 +127,7 @@ class Product
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -182,6 +198,22 @@ class Product
         return $this->constructeurs;
     }
 
+    public function addConstructeur(Constructeur $constructeur): static
+    {
+        if (!$this->constructeurs->contains($constructeur)) {
+            $this->constructeurs->add($constructeur);
+        }
+
+        return $this;
+    }
+
+    public function removeConstructeur(Constructeur $constructeur): static
+    {
+        $this->constructeurs->removeElement($constructeur);
+
+        return $this;
+    }
+
     /**
      * @return Collection<int, Document>
      */
@@ -198,13 +230,18 @@ class Product
         return $this->customFieldValues;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/Profile.php

@@ -45,17 +45,17 @@ class Profile implements UserInterface, PasswordAuthenticatedUserInterface
     #[Groups(['profile:read', 'profile:write'])]
     private ?string $email = null;
 
-    #[ORM\Column(type: 'string', length: 100, name: 'firstName')]
+    #[ORM\Column(type: 'string', length: 100, name: 'firstname')]
     #[Assert\NotBlank]
     #[Groups(['profile:read', 'profile:write'])]
     private string $firstName;
 
-    #[ORM\Column(type: 'string', length: 100, name: 'lastName')]
+    #[ORM\Column(type: 'string', length: 100, name: 'lastname')]
     #[Assert\NotBlank]
     #[Groups(['profile:read', 'profile:write'])]
     private string $lastName;
 
-    #[ORM\Column(type: 'boolean', options: ['default' => true], name: 'isActive')]
+    #[ORM\Column(type: 'boolean', options: ['default' => true], name: 'isactive')]
     #[Groups(['profile:read', 'profile:write'])]
     private bool $isActive = true;
 
@@ -73,11 +73,11 @@ class Profile implements UserInterface, PasswordAuthenticatedUserInterface
     #[Groups(['profile:write'])]
     private ?string $password = null;
 
-    #[ORM\Column(type: 'datetime_immutable', name: 'createdAt')]
+    #[ORM\Column(type: 'datetime_immutable', name: 'createdat')]
     #[Groups(['profile:read'])]
     private DateTimeImmutable $createdAt;
 
-    #[ORM\Column(type: 'datetime_immutable', name: 'updatedAt')]
+    #[ORM\Column(type: 'datetime_immutable', name: 'updatedat')]
     #[Groups(['profile:read'])]
     private DateTimeImmutable $updatedAt;
 

src/Entity/Site.php

@@ -11,10 +11,12 @@ use ApiPlatform\Metadata\GetCollection;
 use ApiPlatform\Metadata\Post;
 use ApiPlatform\Metadata\Put;
 use App\Repository\SiteRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
 use Symfony\Component\Validator\Constraints as Assert;
 
 #[ORM\Entity(repositoryClass: SiteRepository::class)]
@@ -27,16 +29,20 @@ use Symfony\Component\Validator\Constraints as Assert;
         new Post(),
         new Put(),
         new Delete(),
-    ]
+    ],
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
 )]
 class Site
 {
     #[ORM\Id]
     #[ORM\Column(type: Types::STRING, length: 36)]
+    #[Groups(['document:list'])]
     private ?string $id = null;
 
     #[ORM\Column(type: Types::STRING, length: 255)]
     #[Assert\NotBlank]
+    #[Groups(['document:list'])]
     private string $name;
 
     #[ORM\Column(type: Types::STRING, length: 255, options: ['default' => ''], name: 'contactName')]
@@ -55,10 +61,10 @@ class Site
     private string $contactCity = '';
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     /**
      * @var Collection<int, Machine>
@@ -74,18 +80,18 @@ class Site
 
     public function __construct()
     {
-        $this->machines = new ArrayCollection();
+        $this->machines  = new ArrayCollection();
         $this->documents = new ArrayCollection();
     }
 
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $this->createdAt = new \DateTimeImmutable();
-        $this->updatedAt = new \DateTimeImmutable();
+        $this->createdAt = new DateTimeImmutable();
+        $this->updatedAt = new DateTimeImmutable();
 
         // Générer un ID CUID-compatible si nécessaire
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -93,13 +99,7 @@ class Site
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        // Génération d'un ID compatible CUID (format: cl + 24 caractères)
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     // Getters et Setters
@@ -188,12 +188,12 @@ class Site
         return $this;
     }
 
-    public function getCreatedAt(): \DateTimeImmutable
+    public function getCreatedAt(): DateTimeImmutable
     {
         return $this->createdAt;
     }
 
-    public function getUpdatedAt(): \DateTimeImmutable
+    public function getUpdatedAt(): DateTimeImmutable
     {
         return $this->updatedAt;
     }
@@ -257,4 +257,10 @@ class Site
 
         return $this;
     }
+
+    private function generateCuid(): string
+    {
+        // Génération d'un ID compatible CUID (format: cl + 24 caractères)
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/TypeMachine.php

@@ -32,7 +32,9 @@ use Symfony\Component\Validator\Constraints as Assert;
         new Post(),
         new Put(),
         new Delete(),
-    ]
+    ],
+    paginationClientItemsPerPage: true,
+    paginationMaximumItemsPerPage: 200
 )]
 class TypeMachine
 {
@@ -50,7 +52,7 @@ class TypeMachine
     #[Groups(['type_machine:read', 'type_machine:write'])]
     private ?string $description = null;
 
-    #[ORM\Column(type: Types::STRING, length: 255, nullable: true, name: 'maintenanceFrequency')]
+    #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
     #[Groups(['type_machine:read', 'type_machine:write'])]
     private ?string $category = null;
 
@@ -58,11 +60,11 @@ class TypeMachine
     #[Groups(['type_machine:read', 'type_machine:write'])]
     private ?string $maintenanceFrequency = null;
 
-    #[ORM\Column(type: Types::JSON, nullable: true, name: 'criticalParts')]
+    #[ORM\Column(type: Types::JSON, nullable: true)]
     #[Groups(['type_machine:read', 'type_machine:write'])]
     private ?array $components = null;
 
-    #[ORM\Column(type: Types::JSON, nullable: true, name: 'machinePieces')]
+    #[ORM\Column(type: Types::JSON, nullable: true)]
     #[Groups(['type_machine:read', 'type_machine:write'])]
     private ?array $criticalParts = null;
 
@@ -91,40 +93,41 @@ class TypeMachine
     /**
      * @var Collection<int, CustomField>
      */
-    #[ORM\OneToMany(targetEntity: CustomField::class, mappedBy: 'typeMachine')]
+    #[ORM\OneToMany(targetEntity: CustomField::class, mappedBy: 'typeMachine', cascade: ['persist', 'remove'])]
+    #[ApiProperty(readableLink: true, writableLink: true)]
     private Collection $customFields;
 
     /**
      * @var Collection<int, TypeMachineComponentRequirement>
      */
     #[ORM\OneToMany(targetEntity: TypeMachineComponentRequirement::class, mappedBy: 'typeMachine', cascade: ['persist', 'remove'])]
-    #[ApiProperty(readableLink: true)]
+    #[ApiProperty(readableLink: true, writableLink: true)]
     private Collection $componentRequirements;
 
     /**
      * @var Collection<int, TypeMachinePieceRequirement>
      */
     #[ORM\OneToMany(targetEntity: TypeMachinePieceRequirement::class, mappedBy: 'typeMachine', cascade: ['persist', 'remove'])]
-    #[ApiProperty(readableLink: true)]
+    #[ApiProperty(readableLink: true, writableLink: true)]
     private Collection $pieceRequirements;
 
     /**
      * @var Collection<int, TypeMachineProductRequirement>
      */
     #[ORM\OneToMany(targetEntity: TypeMachineProductRequirement::class, mappedBy: 'typeMachine', cascade: ['persist', 'remove'])]
-    #[ApiProperty(readableLink: true)]
+    #[ApiProperty(readableLink: true, writableLink: true)]
     private Collection $productRequirements;
 
     public function __construct()
     {
-        $this->id = 'cl' . bin2hex(random_bytes(12));
-        $this->createdAt = new DateTimeImmutable();
-        $this->updatedAt = new DateTimeImmutable();
-        $this->machines = new ArrayCollection();
-        $this->customFields = new ArrayCollection();
+        $this->id                    = 'cl'.bin2hex(random_bytes(12));
+        $this->createdAt             = new DateTimeImmutable();
+        $this->updatedAt             = new DateTimeImmutable();
+        $this->machines              = new ArrayCollection();
+        $this->customFields          = new ArrayCollection();
         $this->componentRequirements = new ArrayCollection();
-        $this->pieceRequirements = new ArrayCollection();
-        $this->productRequirements = new ArrayCollection();
+        $this->pieceRequirements     = new ArrayCollection();
+        $this->productRequirements   = new ArrayCollection();
     }
 
     public function getId(): ?string

src/Entity/TypeMachineComponentRequirement.php

@@ -7,6 +7,7 @@ namespace App\Entity;
 use ApiPlatform\Metadata\ApiProperty;
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\TypeMachineComponentRequirementRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -55,6 +56,7 @@ class TypeMachineComponentRequirement
     #[ORM\ManyToOne(targetEntity: ModelType::class, inversedBy: 'componentRequirements')]
     #[ORM\JoinColumn(name: 'typeComposantId', referencedColumnName: 'id', nullable: false)]
     #[ApiProperty(readableLink: true)]
+    #[Groups(['type_machine:read'])]
     private ModelType $typeComposant;
 
     /**
@@ -64,10 +66,10 @@ class TypeMachineComponentRequirement
     private Collection $machineComponentLinks;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
@@ -77,11 +79,11 @@ class TypeMachineComponentRequirement
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -89,12 +91,7 @@ class TypeMachineComponentRequirement
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -204,4 +201,9 @@ class TypeMachineComponentRequirement
 
         return $this;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/TypeMachinePieceRequirement.php

@@ -7,6 +7,7 @@ namespace App\Entity;
 use ApiPlatform\Metadata\ApiProperty;
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\TypeMachinePieceRequirementRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -55,6 +56,7 @@ class TypeMachinePieceRequirement
     #[ORM\ManyToOne(targetEntity: ModelType::class, inversedBy: 'pieceRequirements')]
     #[ORM\JoinColumn(name: 'typePieceId', referencedColumnName: 'id', nullable: false)]
     #[ApiProperty(readableLink: true)]
+    #[Groups(['type_machine:read'])]
     private ModelType $typePiece;
 
     /**
@@ -64,10 +66,10 @@ class TypeMachinePieceRequirement
     private Collection $machinePieceLinks;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
@@ -77,11 +79,11 @@ class TypeMachinePieceRequirement
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -89,12 +91,7 @@ class TypeMachinePieceRequirement
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -204,4 +201,9 @@ class TypeMachinePieceRequirement
 
         return $this;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Entity/TypeMachineProductRequirement.php

@@ -7,6 +7,7 @@ namespace App\Entity;
 use ApiPlatform\Metadata\ApiProperty;
 use ApiPlatform\Metadata\ApiResource;
 use App\Repository\TypeMachineProductRequirementRepository;
+use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\DBAL\Types\Types;
@@ -55,6 +56,7 @@ class TypeMachineProductRequirement
     #[ORM\ManyToOne(targetEntity: ModelType::class, inversedBy: 'productRequirements')]
     #[ORM\JoinColumn(name: 'typeProductId', referencedColumnName: 'id', nullable: false)]
     #[ApiProperty(readableLink: true)]
+    #[Groups(['type_machine:read'])]
     private ModelType $typeProduct;
 
     /**
@@ -64,10 +66,10 @@ class TypeMachineProductRequirement
     private Collection $machineProductLinks;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'createdAt')]
-    private \DateTimeImmutable $createdAt;
+    private DateTimeImmutable $createdAt;
 
     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, name: 'updatedAt')]
-    private \DateTimeImmutable $updatedAt;
+    private DateTimeImmutable $updatedAt;
 
     public function __construct()
     {
@@ -77,11 +79,11 @@ class TypeMachineProductRequirement
     #[ORM\PrePersist]
     public function setCreatedAtValue(): void
     {
-        $now = new \DateTimeImmutable();
+        $now             = new DateTimeImmutable();
         $this->createdAt = $now;
         $this->updatedAt = $now;
 
-        if ($this->id === null) {
+        if (null === $this->id) {
             $this->id = $this->generateCuid();
         }
     }
@@ -89,12 +91,7 @@ class TypeMachineProductRequirement
     #[ORM\PreUpdate]
     public function setUpdatedAtValue(): void
     {
-        $this->updatedAt = new \DateTimeImmutable();
-    }
-
-    private function generateCuid(): string
-    {
-        return 'cl' . bin2hex(random_bytes(12));
+        $this->updatedAt = new DateTimeImmutable();
     }
 
     public function getId(): ?string
@@ -204,4 +201,9 @@ class TypeMachineProductRequirement
 
         return $this;
     }
+
+    private function generateCuid(): string
+    {
+        return 'cl'.bin2hex(random_bytes(12));
+    }
 }

src/Enum/ModelCategory.php

@@ -7,6 +7,6 @@ namespace App\Enum;
 enum ModelCategory: string
 {
     case COMPONENT = 'COMPONENT';
-    case PIECE = 'PIECE';
-    case PRODUCT = 'PRODUCT';
+    case PIECE     = 'PIECE';
+    case PRODUCT   = 'PRODUCT';
 }

src/EventListener/DocumentPdfCompressorListener.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventListener;
+
+use App\Entity\Document;
+use App\Service\PdfCompressorService;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsEntityListener;
+use Doctrine\ORM\Events;
+use Psr\Log\LoggerInterface;
+
+#[AsEntityListener(event: Events::prePersist, method: 'prePersist', entity: Document::class)]
+#[AsEntityListener(event: Events::preUpdate, method: 'preUpdate', entity: Document::class)]
+class DocumentPdfCompressorListener
+{
+    public function __construct(
+        private readonly PdfCompressorService $pdfCompressor,
+        private readonly ?LoggerInterface $logger = null,
+    ) {}
+
+    public function prePersist(Document $document): void
+    {
+        $this->compressIfPdf($document);
+    }
+
+    public function preUpdate(Document $document): void
+    {
+        $this->compressIfPdf($document);
+    }
+
+    private function compressIfPdf(Document $document): void
+    {
+        if ('application/pdf' !== $document->getMimeType()) {
+            return;
+        }
+
+        $result = $this->pdfCompressor->compressBase64Pdf($document->getPath());
+
+        if (null === $result) {
+            return;
+        }
+
+        $document->setPath($result['path']);
+        $document->setSize($result['size']);
+
+        $this->logger?->info('PDF compressed', [
+            'document'       => $document->getName(),
+            'originalSize'   => $result['originalSize'],
+            'compressedSize' => $result['size'],
+            'saved'          => $result['saved'],
+        ]);
+    }
+}

src/EventSubscriber/ComposantAuditSubscriber.php

@@ -0,0 +1,397 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\AuditLog;
+use App\Entity\Composant;
+use App\Entity\CustomFieldValue;
+use App\Entity\ModelType;
+use App\Entity\Product;
+use App\Entity\Profile;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\UnitOfWork;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+use function is_array;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+
+#[AsDoctrineListener(event: Events::onFlush)]
+final class ComposantAuditSubscriber implements EventSubscriber
+{
+    public function __construct(
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::onFlush,
+        ];
+    }
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        $em = $args->getObjectManager();
+        if (!$em instanceof EntityManagerInterface) {
+            return;
+        }
+
+        $uow               = $em->getUnitOfWork();
+        $actorProfileId    = $this->resolveActorProfileId();
+        $pendingUpdates    = [];
+        $pendingSnapshots  = [];
+        $pendingComponents = [];
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if (!$entity instanceof Composant) {
+                continue;
+            }
+
+            $diff     = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            $snapshot = $this->snapshotComposant($entity);
+            $this->persistAuditLog($em, new AuditLog('composant', (string) $entity->getId(), 'create', $diff, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof Composant) {
+                continue;
+            }
+
+            $componentId = (string) $entity->getId();
+            if ('' === $componentId) {
+                continue;
+            }
+
+            $diff = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            if ([] !== $diff) {
+                $pendingUpdates[$componentId]    = $this->mergeDiffs($pendingUpdates[$componentId] ?? [], $diff);
+                $pendingSnapshots[$componentId]  = $this->snapshotComposant($entity);
+                $pendingComponents[$componentId] = $entity;
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if (!$entity instanceof Composant) {
+                continue;
+            }
+
+            $snapshot = $this->snapshotComposant($entity);
+            $this->persistAuditLog($em, new AuditLog('composant', (string) $entity->getId(), 'delete', null, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledCollectionUpdates() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingComponents);
+        }
+        foreach ($uow->getScheduledCollectionDeletions() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingComponents);
+        }
+
+        $this->collectCustomFieldValueChanges($uow, $pendingUpdates, $pendingSnapshots, $pendingComponents);
+
+        foreach ($pendingUpdates as $componentId => $diff) {
+            if ([] === $diff) {
+                continue;
+            }
+
+            $component = $pendingComponents[$componentId] ?? null;
+            if (!$component instanceof Composant) {
+                continue;
+            }
+
+            $snapshot = $pendingSnapshots[$componentId] ?? $this->snapshotComposant($component);
+            $this->persistAuditLog($em, new AuditLog('composant', $componentId, 'update', $diff, $snapshot, $actorProfileId));
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Composant>                                  $pendingComponents
+     */
+    private function collectCollectionUpdate(
+        object $collection,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingComponents,
+    ): void {
+        if (!$collection instanceof PersistentCollection) {
+            return;
+        }
+
+        $owner = $collection->getOwner();
+        if (!$owner instanceof Composant) {
+            return;
+        }
+
+        $componentId = (string) $owner->getId();
+        if ('' === $componentId) {
+            return;
+        }
+
+        $mapping   = $collection->getMapping();
+        $fieldName = $mapping['fieldName'] ?? null;
+        if ('constructeurs' !== $fieldName) {
+            return;
+        }
+
+        $before = $this->normalizeCollection($collection->getSnapshot());
+        $after  = $this->normalizeCollection($collection->toArray());
+
+        if ($before === $after) {
+            return;
+        }
+
+        $diff = [
+            'constructeurIds' => [
+                'from' => $before,
+                'to'   => $after,
+            ],
+        ];
+
+        $pendingUpdates[$componentId]    = $this->mergeDiffs($pendingUpdates[$componentId] ?? [], $diff);
+        $pendingSnapshots[$componentId]  = $this->snapshotComposant($owner);
+        $pendingComponents[$componentId] = $owner;
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Composant>                                  $pendingComponents
+     */
+    private function collectCustomFieldValueChanges(
+        UnitOfWork $uow,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingComponents,
+    ): void {
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, null, $entity->getValue(), $pendingUpdates, $pendingSnapshots, $pendingComponents);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof CustomFieldValue) {
+                continue;
+            }
+            $changeSet = $uow->getEntityChangeSet($entity);
+            if (!isset($changeSet['value'])) {
+                continue;
+            }
+            [$oldVal, $newVal] = $changeSet['value'];
+            if ($oldVal !== $newVal) {
+                $this->trackCustomFieldValueChange($entity, $oldVal, $newVal, $pendingUpdates, $pendingSnapshots, $pendingComponents);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, $entity->getValue(), null, $pendingUpdates, $pendingSnapshots, $pendingComponents);
+            }
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Composant>                                  $pendingComponents
+     */
+    private function trackCustomFieldValueChange(
+        CustomFieldValue $cfv,
+        mixed $from,
+        mixed $to,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingComponents,
+    ): void {
+        $owner = $cfv->getComposant();
+        if (!$owner instanceof Composant) {
+            return;
+        }
+
+        $ownerId = (string) $owner->getId();
+        if ('' === $ownerId) {
+            return;
+        }
+
+        $fieldName = 'customField:'.$cfv->getCustomField()->getName();
+        $diff      = [$fieldName => ['from' => $from, 'to' => $to]];
+
+        $pendingUpdates[$ownerId]    = $this->mergeDiffs($pendingUpdates[$ownerId] ?? [], $diff);
+        $pendingSnapshots[$ownerId]  = $this->snapshotComposant($owner);
+        $pendingComponents[$ownerId] = $owner;
+    }
+
+    private function persistAuditLog(EntityManagerInterface $em, AuditLog $log): void
+    {
+        $uow = $em->getUnitOfWork();
+        $log->initializeAuditLog();
+        $em->persist($log);
+
+        $meta = $em->getClassMetadata(AuditLog::class);
+        $uow->computeChangeSet($meta, $log);
+    }
+
+    /**
+     * @param array<string, array{0:mixed, 1:mixed}> $changeSet
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function buildDiffFromChangeSet(array $changeSet): array
+    {
+        $diff = [];
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            if ('updatedAt' === $field || 'createdAt' === $field) {
+                continue;
+            }
+
+            $normalizedOld = $this->normalizeValue($oldValue);
+            $normalizedNew = $this->normalizeValue($newValue);
+
+            if ($normalizedOld === $normalizedNew) {
+                continue;
+            }
+
+            $diff[$field] = [
+                'from' => $normalizedOld,
+                'to'   => $normalizedNew,
+            ];
+        }
+
+        return $diff;
+    }
+
+    private function snapshotComposant(Composant $component): array
+    {
+        return [
+            'id'              => $component->getId(),
+            'name'            => $component->getName(),
+            'reference'       => $component->getReference(),
+            'prix'            => $component->getPrix(),
+            'structure'       => $component->getStructure(),
+            'typeComposant'   => $this->normalizeValue($component->getTypeComposant()),
+            'product'         => $this->normalizeValue($component->getProduct()),
+            'constructeurIds' => $this->normalizeCollection($component->getConstructeurs()),
+        ];
+    }
+
+    /**
+     * @param iterable<mixed> $items
+     *
+     * @return list<array{id: string, name: string}|string>
+     */
+    private function normalizeCollection(iterable $items): array
+    {
+        $entries = [];
+        $seen    = [];
+        foreach ($items as $item) {
+            if (is_object($item) && method_exists($item, 'getId')) {
+                $id = $item->getId();
+                if (null === $id || '' === $id || isset($seen[(string) $id])) {
+                    continue;
+                }
+                $seen[(string) $id] = true;
+                if (method_exists($item, 'getName')) {
+                    $entries[] = ['id' => (string) $id, 'name' => (string) $item->getName()];
+                } else {
+                    $entries[] = (string) $id;
+                }
+            }
+        }
+
+        return $entries;
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        if (null === $value || is_scalar($value)) {
+            return $value;
+        }
+
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        if ($value instanceof ModelType) {
+            return [
+                'id'   => $value->getId(),
+                'name' => $value->getName(),
+                'code' => $value->getCode(),
+            ];
+        }
+
+        if ($value instanceof Product) {
+            return [
+                'id'        => $value->getId(),
+                'name'      => $value->getName(),
+                'reference' => $value->getReference(),
+            ];
+        }
+
+        if ($value instanceof Collection) {
+            return $this->normalizeCollection($value);
+        }
+
+        if (is_object($value) && method_exists($value, 'getId')) {
+            return (string) $value->getId();
+        }
+
+        if (is_array($value)) {
+            return $value;
+        }
+
+        return (string) $value;
+    }
+
+    /**
+     * @param array<string, array{from:mixed, to:mixed}> $base
+     * @param array<string, array{from:mixed, to:mixed}> $extra
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function mergeDiffs(array $base, array $extra): array
+    {
+        foreach ($extra as $field => $change) {
+            $base[$field] = $change;
+        }
+
+        return $base;
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+            // No session available (CLI context, etc.)
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/EventSubscriber/ConstructeurAuditSubscriber.php

@@ -0,0 +1,168 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\AuditLog;
+use App\Entity\Constructeur;
+use App\Entity\Profile;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Events;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+use function is_scalar;
+
+#[AsDoctrineListener(event: Events::onFlush)]
+final class ConstructeurAuditSubscriber implements EventSubscriber
+{
+    public function __construct(
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::onFlush,
+        ];
+    }
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        $em = $args->getObjectManager();
+        if (!$em instanceof EntityManagerInterface) {
+            return;
+        }
+
+        $uow            = $em->getUnitOfWork();
+        $actorProfileId = $this->resolveActorProfileId();
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if (!$entity instanceof Constructeur) {
+                continue;
+            }
+
+            $diff     = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            $snapshot = $this->snapshotConstructeur($entity);
+            $this->persistAuditLog($em, new AuditLog('constructeur', (string) $entity->getId(), 'create', $diff, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof Constructeur) {
+                continue;
+            }
+
+            $id = (string) $entity->getId();
+            if ('' === $id) {
+                continue;
+            }
+
+            $diff = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            if ([] !== $diff) {
+                $snapshot = $this->snapshotConstructeur($entity);
+                $this->persistAuditLog($em, new AuditLog('constructeur', $id, 'update', $diff, $snapshot, $actorProfileId));
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if (!$entity instanceof Constructeur) {
+                continue;
+            }
+
+            $snapshot = $this->snapshotConstructeur($entity);
+            $this->persistAuditLog($em, new AuditLog('constructeur', (string) $entity->getId(), 'delete', null, $snapshot, $actorProfileId));
+        }
+    }
+
+    private function persistAuditLog(EntityManagerInterface $em, AuditLog $log): void
+    {
+        $uow = $em->getUnitOfWork();
+        $log->initializeAuditLog();
+        $em->persist($log);
+
+        $meta = $em->getClassMetadata(AuditLog::class);
+        $uow->computeChangeSet($meta, $log);
+    }
+
+    /**
+     * @param array<string, array{0:mixed, 1:mixed}> $changeSet
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function buildDiffFromChangeSet(array $changeSet): array
+    {
+        $diff = [];
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            if ('updatedAt' === $field || 'createdAt' === $field) {
+                continue;
+            }
+
+            $normalizedOld = $this->normalizeValue($oldValue);
+            $normalizedNew = $this->normalizeValue($newValue);
+
+            if ($normalizedOld === $normalizedNew) {
+                continue;
+            }
+
+            $diff[$field] = [
+                'from' => $normalizedOld,
+                'to'   => $normalizedNew,
+            ];
+        }
+
+        return $diff;
+    }
+
+    private function snapshotConstructeur(Constructeur $constructeur): array
+    {
+        return [
+            'id'    => $constructeur->getId(),
+            'name'  => $constructeur->getName(),
+            'email' => $constructeur->getEmail(),
+            'phone' => $constructeur->getPhone(),
+        ];
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        if (null === $value || is_scalar($value)) {
+            return $value;
+        }
+
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        return (string) $value;
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+            // No session available (CLI context, etc.)
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/EventSubscriber/DocumentAuditSubscriber.php

@@ -0,0 +1,192 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\AuditLog;
+use App\Entity\Composant;
+use App\Entity\Document;
+use App\Entity\Machine;
+use App\Entity\Piece;
+use App\Entity\Product;
+use App\Entity\Profile;
+use App\Entity\Site;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Events;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+use function is_object;
+use function is_scalar;
+use function method_exists;
+
+#[AsDoctrineListener(event: Events::onFlush)]
+final class DocumentAuditSubscriber implements EventSubscriber
+{
+    public function __construct(
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::onFlush,
+        ];
+    }
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        $em = $args->getObjectManager();
+        if (!$em instanceof EntityManagerInterface) {
+            return;
+        }
+
+        $uow            = $em->getUnitOfWork();
+        $actorProfileId = $this->resolveActorProfileId();
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if (!$entity instanceof Document) {
+                continue;
+            }
+
+            $diff     = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            $snapshot = $this->snapshotDocument($entity);
+            $this->persistAuditLog($em, new AuditLog('document', (string) $entity->getId(), 'create', $diff, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof Document) {
+                continue;
+            }
+
+            $id = (string) $entity->getId();
+            if ('' === $id) {
+                continue;
+            }
+
+            $diff = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            if ([] !== $diff) {
+                $snapshot = $this->snapshotDocument($entity);
+                $this->persistAuditLog($em, new AuditLog('document', $id, 'update', $diff, $snapshot, $actorProfileId));
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if (!$entity instanceof Document) {
+                continue;
+            }
+
+            $snapshot = $this->snapshotDocument($entity);
+            $this->persistAuditLog($em, new AuditLog('document', (string) $entity->getId(), 'delete', null, $snapshot, $actorProfileId));
+        }
+    }
+
+    private function persistAuditLog(EntityManagerInterface $em, AuditLog $log): void
+    {
+        $uow = $em->getUnitOfWork();
+        $log->initializeAuditLog();
+        $em->persist($log);
+
+        $meta = $em->getClassMetadata(AuditLog::class);
+        $uow->computeChangeSet($meta, $log);
+    }
+
+    /**
+     * @param array<string, array{0:mixed, 1:mixed}> $changeSet
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function buildDiffFromChangeSet(array $changeSet): array
+    {
+        $diff = [];
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            if ('updatedAt' === $field || 'createdAt' === $field) {
+                continue;
+            }
+
+            $normalizedOld = $this->normalizeValue($oldValue);
+            $normalizedNew = $this->normalizeValue($newValue);
+
+            if ($normalizedOld === $normalizedNew) {
+                continue;
+            }
+
+            $diff[$field] = [
+                'from' => $normalizedOld,
+                'to'   => $normalizedNew,
+            ];
+        }
+
+        return $diff;
+    }
+
+    private function snapshotDocument(Document $document): array
+    {
+        return [
+            'id'        => $document->getId(),
+            'name'      => $document->getName(),
+            'filename'  => $document->getFilename(),
+            'mimeType'  => $document->getMimeType(),
+            'size'      => $document->getSize(),
+            'machine'   => $this->normalizeValue($document->getMachine()),
+            'composant' => $this->normalizeValue($document->getComposant()),
+            'piece'     => $this->normalizeValue($document->getPiece()),
+            'product'   => $this->normalizeValue($document->getProduct()),
+            'site'      => $this->normalizeValue($document->getSite()),
+        ];
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        if (null === $value || is_scalar($value)) {
+            return $value;
+        }
+
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        if ($value instanceof Machine || $value instanceof Composant || $value instanceof Piece || $value instanceof Product || $value instanceof Site) {
+            return [
+                'id'   => $value->getId(),
+                'name' => $value->getName(),
+            ];
+        }
+
+        if (is_object($value) && method_exists($value, 'getId')) {
+            return (string) $value->getId();
+        }
+
+        return (string) $value;
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+            // No session available (CLI context, etc.)
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/EventSubscriber/MachineAuditSubscriber.php

@@ -0,0 +1,412 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\AuditLog;
+use App\Entity\CustomFieldValue;
+use App\Entity\Machine;
+use App\Entity\ModelType;
+use App\Entity\Product;
+use App\Entity\Profile;
+use App\Entity\Site;
+use App\Entity\TypeMachine;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\UnitOfWork;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+use function is_array;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+
+#[AsDoctrineListener(event: Events::onFlush)]
+final class MachineAuditSubscriber implements EventSubscriber
+{
+    public function __construct(
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::onFlush,
+        ];
+    }
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        $em = $args->getObjectManager();
+        if (!$em instanceof EntityManagerInterface) {
+            return;
+        }
+
+        $uow              = $em->getUnitOfWork();
+        $actorProfileId   = $this->resolveActorProfileId();
+        $pendingUpdates   = [];
+        $pendingSnapshots = [];
+        $pendingMachines  = [];
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if (!$entity instanceof Machine) {
+                continue;
+            }
+
+            $diff     = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            $snapshot = $this->snapshotMachine($entity);
+            $this->persistAuditLog($em, new AuditLog('machine', (string) $entity->getId(), 'create', $diff, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof Machine) {
+                continue;
+            }
+
+            $machineId = (string) $entity->getId();
+            if ('' === $machineId) {
+                continue;
+            }
+
+            $diff = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            if ([] !== $diff) {
+                $pendingUpdates[$machineId]   = $this->mergeDiffs($pendingUpdates[$machineId] ?? [], $diff);
+                $pendingSnapshots[$machineId] = $this->snapshotMachine($entity);
+                $pendingMachines[$machineId]  = $entity;
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if (!$entity instanceof Machine) {
+                continue;
+            }
+
+            $snapshot = $this->snapshotMachine($entity);
+            $this->persistAuditLog($em, new AuditLog('machine', (string) $entity->getId(), 'delete', null, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledCollectionUpdates() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingMachines);
+        }
+        foreach ($uow->getScheduledCollectionDeletions() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingMachines);
+        }
+
+        $this->collectCustomFieldValueChanges($uow, $pendingUpdates, $pendingSnapshots, $pendingMachines);
+
+        foreach ($pendingUpdates as $machineId => $diff) {
+            if ([] === $diff) {
+                continue;
+            }
+
+            $machine = $pendingMachines[$machineId] ?? null;
+            if (!$machine instanceof Machine) {
+                continue;
+            }
+
+            $snapshot = $pendingSnapshots[$machineId] ?? $this->snapshotMachine($machine);
+            $this->persistAuditLog($em, new AuditLog('machine', $machineId, 'update', $diff, $snapshot, $actorProfileId));
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Machine>                                    $pendingMachines
+     */
+    private function collectCollectionUpdate(
+        object $collection,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingMachines,
+    ): void {
+        if (!$collection instanceof PersistentCollection) {
+            return;
+        }
+
+        $owner = $collection->getOwner();
+        if (!$owner instanceof Machine) {
+            return;
+        }
+
+        $machineId = (string) $owner->getId();
+        if ('' === $machineId) {
+            return;
+        }
+
+        $mapping   = $collection->getMapping();
+        $fieldName = $mapping['fieldName'] ?? null;
+        if ('constructeurs' !== $fieldName) {
+            return;
+        }
+
+        $before = $this->normalizeCollection($collection->getSnapshot());
+        $after  = $this->normalizeCollection($collection->toArray());
+
+        if ($before === $after) {
+            return;
+        }
+
+        $diff = [
+            'constructeurIds' => [
+                'from' => $before,
+                'to'   => $after,
+            ],
+        ];
+
+        $pendingUpdates[$machineId]   = $this->mergeDiffs($pendingUpdates[$machineId] ?? [], $diff);
+        $pendingSnapshots[$machineId] = $this->snapshotMachine($owner);
+        $pendingMachines[$machineId]  = $owner;
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Machine>                                    $pendingMachines
+     */
+    private function collectCustomFieldValueChanges(
+        UnitOfWork $uow,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingMachines,
+    ): void {
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, null, $entity->getValue(), $pendingUpdates, $pendingSnapshots, $pendingMachines);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof CustomFieldValue) {
+                continue;
+            }
+            $changeSet = $uow->getEntityChangeSet($entity);
+            if (!isset($changeSet['value'])) {
+                continue;
+            }
+            [$oldVal, $newVal] = $changeSet['value'];
+            if ($oldVal !== $newVal) {
+                $this->trackCustomFieldValueChange($entity, $oldVal, $newVal, $pendingUpdates, $pendingSnapshots, $pendingMachines);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, $entity->getValue(), null, $pendingUpdates, $pendingSnapshots, $pendingMachines);
+            }
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Machine>                                    $pendingMachines
+     */
+    private function trackCustomFieldValueChange(
+        CustomFieldValue $cfv,
+        mixed $from,
+        mixed $to,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingMachines,
+    ): void {
+        $owner = $cfv->getMachine();
+        if (!$owner instanceof Machine) {
+            return;
+        }
+
+        $ownerId = (string) $owner->getId();
+        if ('' === $ownerId) {
+            return;
+        }
+
+        $fieldName = 'customField:'.$cfv->getCustomField()->getName();
+        $diff      = [$fieldName => ['from' => $from, 'to' => $to]];
+
+        $pendingUpdates[$ownerId]   = $this->mergeDiffs($pendingUpdates[$ownerId] ?? [], $diff);
+        $pendingSnapshots[$ownerId] = $this->snapshotMachine($owner);
+        $pendingMachines[$ownerId]  = $owner;
+    }
+
+    private function persistAuditLog(EntityManagerInterface $em, AuditLog $log): void
+    {
+        $uow = $em->getUnitOfWork();
+        $log->initializeAuditLog();
+        $em->persist($log);
+
+        $meta = $em->getClassMetadata(AuditLog::class);
+        $uow->computeChangeSet($meta, $log);
+    }
+
+    /**
+     * @param array<string, array{0:mixed, 1:mixed}> $changeSet
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function buildDiffFromChangeSet(array $changeSet): array
+    {
+        $diff = [];
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            if ('updatedAt' === $field || 'createdAt' === $field) {
+                continue;
+            }
+
+            $normalizedOld = $this->normalizeValue($oldValue);
+            $normalizedNew = $this->normalizeValue($newValue);
+
+            if ($normalizedOld === $normalizedNew) {
+                continue;
+            }
+
+            $diff[$field] = [
+                'from' => $normalizedOld,
+                'to'   => $normalizedNew,
+            ];
+        }
+
+        return $diff;
+    }
+
+    private function snapshotMachine(Machine $machine): array
+    {
+        return [
+            'id'              => $machine->getId(),
+            'name'            => $machine->getName(),
+            'reference'       => $machine->getReference(),
+            'prix'            => $machine->getPrix(),
+            'site'            => $this->normalizeValue($machine->getSite()),
+            'typeMachine'     => $this->normalizeValue($machine->getTypeMachine()),
+            'constructeurIds' => $this->normalizeCollection($machine->getConstructeurs()),
+        ];
+    }
+
+    /**
+     * @param iterable<mixed> $items
+     *
+     * @return list<array{id: string, name: string}|string>
+     */
+    private function normalizeCollection(iterable $items): array
+    {
+        $entries = [];
+        $seen    = [];
+        foreach ($items as $item) {
+            if (is_object($item) && method_exists($item, 'getId')) {
+                $id = $item->getId();
+                if (null === $id || '' === $id || isset($seen[(string) $id])) {
+                    continue;
+                }
+                $seen[(string) $id] = true;
+                if (method_exists($item, 'getName')) {
+                    $entries[] = ['id' => (string) $id, 'name' => (string) $item->getName()];
+                } else {
+                    $entries[] = (string) $id;
+                }
+            }
+        }
+
+        return $entries;
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        if (null === $value || is_scalar($value)) {
+            return $value;
+        }
+
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        if ($value instanceof Site) {
+            return [
+                'id'   => $value->getId(),
+                'name' => $value->getName(),
+            ];
+        }
+
+        if ($value instanceof TypeMachine) {
+            return [
+                'id'   => $value->getId(),
+                'name' => $value->getName(),
+            ];
+        }
+
+        if ($value instanceof ModelType) {
+            return [
+                'id'   => $value->getId(),
+                'name' => $value->getName(),
+                'code' => $value->getCode(),
+            ];
+        }
+
+        if ($value instanceof Product) {
+            return [
+                'id'        => $value->getId(),
+                'name'      => $value->getName(),
+                'reference' => $value->getReference(),
+            ];
+        }
+
+        if ($value instanceof Collection) {
+            return $this->normalizeCollection($value);
+        }
+
+        if (is_object($value) && method_exists($value, 'getId')) {
+            return (string) $value->getId();
+        }
+
+        if (is_array($value)) {
+            return $value;
+        }
+
+        return (string) $value;
+    }
+
+    /**
+     * @param array<string, array{from:mixed, to:mixed}> $base
+     * @param array<string, array{from:mixed, to:mixed}> $extra
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function mergeDiffs(array $base, array $extra): array
+    {
+        foreach ($extra as $field => $change) {
+            $base[$field] = $change;
+        }
+
+        return $base;
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+            // No session available (CLI context, etc.)
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/EventSubscriber/ModelTypeAuditSubscriber.php

@@ -0,0 +1,180 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\AuditLog;
+use App\Entity\ModelType;
+use App\Entity\Profile;
+use App\Enum\ModelCategory;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Events;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+use function is_array;
+use function is_scalar;
+
+#[AsDoctrineListener(event: Events::onFlush)]
+final class ModelTypeAuditSubscriber implements EventSubscriber
+{
+    public function __construct(
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::onFlush,
+        ];
+    }
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        $em = $args->getObjectManager();
+        if (!$em instanceof EntityManagerInterface) {
+            return;
+        }
+
+        $uow            = $em->getUnitOfWork();
+        $actorProfileId = $this->resolveActorProfileId();
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if (!$entity instanceof ModelType) {
+                continue;
+            }
+
+            $diff     = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            $snapshot = $this->snapshotModelType($entity);
+            $this->persistAuditLog($em, new AuditLog('model_type', (string) $entity->getId(), 'create', $diff, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof ModelType) {
+                continue;
+            }
+
+            $id = (string) $entity->getId();
+            if ('' === $id) {
+                continue;
+            }
+
+            $diff = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            if ([] !== $diff) {
+                $snapshot = $this->snapshotModelType($entity);
+                $this->persistAuditLog($em, new AuditLog('model_type', $id, 'update', $diff, $snapshot, $actorProfileId));
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if (!$entity instanceof ModelType) {
+                continue;
+            }
+
+            $snapshot = $this->snapshotModelType($entity);
+            $this->persistAuditLog($em, new AuditLog('model_type', (string) $entity->getId(), 'delete', null, $snapshot, $actorProfileId));
+        }
+    }
+
+    private function persistAuditLog(EntityManagerInterface $em, AuditLog $log): void
+    {
+        $uow = $em->getUnitOfWork();
+        $log->initializeAuditLog();
+        $em->persist($log);
+
+        $meta = $em->getClassMetadata(AuditLog::class);
+        $uow->computeChangeSet($meta, $log);
+    }
+
+    /**
+     * @param array<string, array{0:mixed, 1:mixed}> $changeSet
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function buildDiffFromChangeSet(array $changeSet): array
+    {
+        $diff = [];
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            if ('updatedAt' === $field || 'createdAt' === $field) {
+                continue;
+            }
+
+            $normalizedOld = $this->normalizeValue($oldValue);
+            $normalizedNew = $this->normalizeValue($newValue);
+
+            if ($normalizedOld === $normalizedNew) {
+                continue;
+            }
+
+            $diff[$field] = [
+                'from' => $normalizedOld,
+                'to'   => $normalizedNew,
+            ];
+        }
+
+        return $diff;
+    }
+
+    private function snapshotModelType(ModelType $modelType): array
+    {
+        return [
+            'id'          => $modelType->getId(),
+            'name'        => $modelType->getName(),
+            'code'        => $modelType->getCode(),
+            'category'    => $modelType->getCategory()->value,
+            'notes'       => $modelType->getNotes(),
+            'description' => $modelType->getDescription(),
+        ];
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        if (null === $value || is_scalar($value)) {
+            return $value;
+        }
+
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        if ($value instanceof ModelCategory) {
+            return $value->value;
+        }
+
+        if (is_array($value)) {
+            return $value;
+        }
+
+        return (string) $value;
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+            // No session available (CLI context, etc.)
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/EventSubscriber/PieceAuditSubscriber.php

@@ -0,0 +1,397 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\AuditLog;
+use App\Entity\CustomFieldValue;
+use App\Entity\ModelType;
+use App\Entity\Piece;
+use App\Entity\Product;
+use App\Entity\Profile;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\UnitOfWork;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+use function is_array;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+
+#[AsDoctrineListener(event: Events::onFlush)]
+final class PieceAuditSubscriber implements EventSubscriber
+{
+    public function __construct(
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::onFlush,
+        ];
+    }
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        $em = $args->getObjectManager();
+        if (!$em instanceof EntityManagerInterface) {
+            return;
+        }
+
+        $uow              = $em->getUnitOfWork();
+        $actorProfileId   = $this->resolveActorProfileId();
+        $pendingUpdates   = [];
+        $pendingSnapshots = [];
+        $pendingPieces    = [];
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if (!$entity instanceof Piece) {
+                continue;
+            }
+
+            $diff     = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            $snapshot = $this->snapshotPiece($entity);
+            $this->persistAuditLog($em, new AuditLog('piece', (string) $entity->getId(), 'create', $diff, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof Piece) {
+                continue;
+            }
+
+            $pieceId = (string) $entity->getId();
+            if ('' === $pieceId) {
+                continue;
+            }
+
+            $diff = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            if ([] !== $diff) {
+                $pendingUpdates[$pieceId]   = $this->mergeDiffs($pendingUpdates[$pieceId] ?? [], $diff);
+                $pendingSnapshots[$pieceId] = $this->snapshotPiece($entity);
+                $pendingPieces[$pieceId]    = $entity;
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if (!$entity instanceof Piece) {
+                continue;
+            }
+
+            $snapshot = $this->snapshotPiece($entity);
+            $this->persistAuditLog($em, new AuditLog('piece', (string) $entity->getId(), 'delete', null, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledCollectionUpdates() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingPieces);
+        }
+        foreach ($uow->getScheduledCollectionDeletions() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingPieces);
+        }
+
+        $this->collectCustomFieldValueChanges($uow, $pendingUpdates, $pendingSnapshots, $pendingPieces);
+
+        foreach ($pendingUpdates as $pieceId => $diff) {
+            if ([] === $diff) {
+                continue;
+            }
+
+            $piece = $pendingPieces[$pieceId] ?? null;
+            if (!$piece instanceof Piece) {
+                continue;
+            }
+
+            $snapshot = $pendingSnapshots[$pieceId] ?? $this->snapshotPiece($piece);
+            $this->persistAuditLog($em, new AuditLog('piece', $pieceId, 'update', $diff, $snapshot, $actorProfileId));
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Piece>                                      $pendingPieces
+     */
+    private function collectCollectionUpdate(
+        object $collection,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingPieces,
+    ): void {
+        if (!$collection instanceof PersistentCollection) {
+            return;
+        }
+
+        $owner = $collection->getOwner();
+        if (!$owner instanceof Piece) {
+            return;
+        }
+
+        $pieceId = (string) $owner->getId();
+        if ('' === $pieceId) {
+            return;
+        }
+
+        $mapping   = $collection->getMapping();
+        $fieldName = $mapping['fieldName'] ?? null;
+        if ('constructeurs' !== $fieldName) {
+            return;
+        }
+
+        $before = $this->normalizeCollection($collection->getSnapshot());
+        $after  = $this->normalizeCollection($collection->toArray());
+
+        if ($before === $after) {
+            return;
+        }
+
+        $diff = [
+            'constructeurIds' => [
+                'from' => $before,
+                'to'   => $after,
+            ],
+        ];
+
+        $pendingUpdates[$pieceId]   = $this->mergeDiffs($pendingUpdates[$pieceId] ?? [], $diff);
+        $pendingSnapshots[$pieceId] = $this->snapshotPiece($owner);
+        $pendingPieces[$pieceId]    = $owner;
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Piece>                                      $pendingPieces
+     */
+    private function collectCustomFieldValueChanges(
+        UnitOfWork $uow,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingPieces,
+    ): void {
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, null, $entity->getValue(), $pendingUpdates, $pendingSnapshots, $pendingPieces);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof CustomFieldValue) {
+                continue;
+            }
+            $changeSet = $uow->getEntityChangeSet($entity);
+            if (!isset($changeSet['value'])) {
+                continue;
+            }
+            [$oldVal, $newVal] = $changeSet['value'];
+            if ($oldVal !== $newVal) {
+                $this->trackCustomFieldValueChange($entity, $oldVal, $newVal, $pendingUpdates, $pendingSnapshots, $pendingPieces);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, $entity->getValue(), null, $pendingUpdates, $pendingSnapshots, $pendingPieces);
+            }
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Piece>                                      $pendingPieces
+     */
+    private function trackCustomFieldValueChange(
+        CustomFieldValue $cfv,
+        mixed $from,
+        mixed $to,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingPieces,
+    ): void {
+        $owner = $cfv->getPiece();
+        if (!$owner instanceof Piece) {
+            return;
+        }
+
+        $ownerId = (string) $owner->getId();
+        if ('' === $ownerId) {
+            return;
+        }
+
+        $fieldName = 'customField:'.$cfv->getCustomField()->getName();
+        $diff      = [$fieldName => ['from' => $from, 'to' => $to]];
+
+        $pendingUpdates[$ownerId]   = $this->mergeDiffs($pendingUpdates[$ownerId] ?? [], $diff);
+        $pendingSnapshots[$ownerId] = $this->snapshotPiece($owner);
+        $pendingPieces[$ownerId]    = $owner;
+    }
+
+    private function persistAuditLog(EntityManagerInterface $em, AuditLog $log): void
+    {
+        $uow = $em->getUnitOfWork();
+        $log->initializeAuditLog();
+        $em->persist($log);
+
+        $meta = $em->getClassMetadata(AuditLog::class);
+        $uow->computeChangeSet($meta, $log);
+    }
+
+    /**
+     * @param array<string, array{0:mixed, 1:mixed}> $changeSet
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function buildDiffFromChangeSet(array $changeSet): array
+    {
+        $diff = [];
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            if ('updatedAt' === $field || 'createdAt' === $field) {
+                continue;
+            }
+
+            $normalizedOld = $this->normalizeValue($oldValue);
+            $normalizedNew = $this->normalizeValue($newValue);
+
+            if ($normalizedOld === $normalizedNew) {
+                continue;
+            }
+
+            $diff[$field] = [
+                'from' => $normalizedOld,
+                'to'   => $normalizedNew,
+            ];
+        }
+
+        return $diff;
+    }
+
+    private function snapshotPiece(Piece $piece): array
+    {
+        return [
+            'id'              => $piece->getId(),
+            'name'            => $piece->getName(),
+            'reference'       => $piece->getReference(),
+            'prix'            => $piece->getPrix(),
+            'typePiece'       => $this->normalizeValue($piece->getTypePiece()),
+            'product'         => $this->normalizeValue($piece->getProduct()),
+            'productIds'      => $piece->getProductIds(),
+            'constructeurIds' => $this->normalizeCollection($piece->getConstructeurs()),
+        ];
+    }
+
+    /**
+     * @param iterable<mixed> $items
+     *
+     * @return list<array{id: string, name: string}|string>
+     */
+    private function normalizeCollection(iterable $items): array
+    {
+        $entries = [];
+        $seen    = [];
+        foreach ($items as $item) {
+            if (is_object($item) && method_exists($item, 'getId')) {
+                $id = $item->getId();
+                if (null === $id || '' === $id || isset($seen[(string) $id])) {
+                    continue;
+                }
+                $seen[(string) $id] = true;
+                if (method_exists($item, 'getName')) {
+                    $entries[] = ['id' => (string) $id, 'name' => (string) $item->getName()];
+                } else {
+                    $entries[] = (string) $id;
+                }
+            }
+        }
+
+        return $entries;
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        if (null === $value || is_scalar($value)) {
+            return $value;
+        }
+
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        if ($value instanceof ModelType) {
+            return [
+                'id'   => $value->getId(),
+                'name' => $value->getName(),
+                'code' => $value->getCode(),
+            ];
+        }
+
+        if ($value instanceof Product) {
+            return [
+                'id'        => $value->getId(),
+                'name'      => $value->getName(),
+                'reference' => $value->getReference(),
+            ];
+        }
+
+        if ($value instanceof Collection) {
+            return $this->normalizeCollection($value);
+        }
+
+        if (is_object($value) && method_exists($value, 'getId')) {
+            return (string) $value->getId();
+        }
+
+        if (is_array($value)) {
+            return $value;
+        }
+
+        return (string) $value;
+    }
+
+    /**
+     * @param array<string, array{from:mixed, to:mixed}> $base
+     * @param array<string, array{from:mixed, to:mixed}> $extra
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function mergeDiffs(array $base, array $extra): array
+    {
+        foreach ($extra as $field => $change) {
+            $base[$field] = $change;
+        }
+
+        return $base;
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+            // No session available (CLI context, etc.)
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/EventSubscriber/PieceProductSyncSubscriber.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\Piece;
+use App\Repository\ProductRepository;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\Event\LifecycleEventArgs;
+use Doctrine\ORM\Event\PreUpdateEventArgs;
+use Doctrine\ORM\Events;
+
+/**
+ * Keep the legacy single product relation in sync with the new productIds array.
+ */
+final class PieceProductSyncSubscriber implements EventSubscriber
+{
+    public function __construct(private readonly ProductRepository $productRepository) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::prePersist,
+            Events::preUpdate,
+        ];
+    }
+
+    public function prePersist(LifecycleEventArgs $args): void
+    {
+        $entity = $args->getObject();
+        if (!$entity instanceof Piece) {
+            return;
+        }
+
+        $this->syncPrimaryProduct($entity);
+    }
+
+    public function preUpdate(PreUpdateEventArgs $args): void
+    {
+        $entity = $args->getObject();
+        if (!$entity instanceof Piece) {
+            return;
+        }
+
+        $this->syncPrimaryProduct($entity);
+
+        $em   = $args->getObjectManager();
+        $meta = $em->getClassMetadata(Piece::class);
+        $em->getUnitOfWork()->recomputeSingleEntityChangeSet($meta, $entity);
+    }
+
+    private function syncPrimaryProduct(Piece $piece): void
+    {
+        $productIds = $piece->getProductIds();
+
+        if ([] === $productIds) {
+            // If no explicit list is provided, keep the legacy relation as-is.
+            return;
+        }
+
+        $primaryId = $productIds[0] ?? null;
+        if (!$primaryId) {
+            $piece->setProduct(null);
+
+            return;
+        }
+
+        $currentProductId = $piece->getProduct()?->getId();
+        if ($currentProductId === $primaryId) {
+            return;
+        }
+
+        $primaryProduct = $this->productRepository->find($primaryId);
+        $piece->setProduct($primaryProduct);
+    }
+}

src/EventSubscriber/ProductAuditSubscriber.php

@@ -0,0 +1,396 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use App\Entity\AuditLog;
+use App\Entity\CustomFieldValue;
+use App\Entity\ModelType;
+use App\Entity\Product;
+use App\Entity\Profile;
+use DateTimeInterface;
+use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\EventSubscriber;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Event\OnFlushEventArgs;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\UnitOfWork;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+use function is_array;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+
+/**
+ * Record a lightweight, per-product audit trail.
+ *
+ * This MVP focuses on Product updates and captures:
+ * - scalar field changes (from Doctrine change sets)
+ * - constructeur collection changes (from collection updates)
+ */
+#[AsDoctrineListener(event: Events::onFlush)]
+final class ProductAuditSubscriber implements EventSubscriber
+{
+    public function __construct(
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    public function getSubscribedEvents(): array
+    {
+        return [
+            Events::onFlush,
+        ];
+    }
+
+    public function onFlush(OnFlushEventArgs $args): void
+    {
+        $em = $args->getObjectManager();
+        if (!$em instanceof EntityManagerInterface) {
+            return;
+        }
+
+        $uow              = $em->getUnitOfWork();
+        $actorProfileId   = $this->resolveActorProfileId();
+        $pendingUpdates   = [];
+        $pendingSnapshots = [];
+        $pendingProducts  = [];
+
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if (!$entity instanceof Product) {
+                continue;
+            }
+
+            $diff     = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            $snapshot = $this->snapshotProduct($entity);
+            $this->persistAuditLog($em, new AuditLog('product', (string) $entity->getId(), 'create', $diff, $snapshot, $actorProfileId));
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof Product) {
+                continue;
+            }
+
+            $productId = (string) $entity->getId();
+            if ('' === $productId) {
+                continue;
+            }
+
+            $diff = $this->buildDiffFromChangeSet($uow->getEntityChangeSet($entity));
+            if ([] !== $diff) {
+                $pendingUpdates[$productId]   = $this->mergeDiffs($pendingUpdates[$productId] ?? [], $diff);
+                $pendingSnapshots[$productId] = $this->snapshotProduct($entity);
+                $pendingProducts[$productId]  = $entity;
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if (!$entity instanceof Product) {
+                continue;
+            }
+
+            $snapshot = $this->snapshotProduct($entity);
+            $this->persistAuditLog($em, new AuditLog('product', (string) $entity->getId(), 'delete', null, $snapshot, $actorProfileId));
+        }
+
+        // Capture constructeur collection updates, which are not included in the change set.
+        foreach ($uow->getScheduledCollectionUpdates() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingProducts);
+        }
+        foreach ($uow->getScheduledCollectionDeletions() as $collection) {
+            $this->collectCollectionUpdate($collection, $pendingUpdates, $pendingSnapshots, $pendingProducts);
+        }
+
+        $this->collectCustomFieldValueChanges($uow, $pendingUpdates, $pendingSnapshots, $pendingProducts);
+
+        foreach ($pendingUpdates as $productId => $diff) {
+            if ([] === $diff) {
+                continue;
+            }
+
+            $product = $pendingProducts[$productId] ?? null;
+            if (!$product instanceof Product) {
+                continue;
+            }
+
+            $snapshot = $pendingSnapshots[$productId] ?? $this->snapshotProduct($product);
+            $this->persistAuditLog($em, new AuditLog('product', $productId, 'update', $diff, $snapshot, $actorProfileId));
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Product>                                    $pendingProducts
+     */
+    private function collectCollectionUpdate(
+        object $collection,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingProducts,
+    ): void {
+        if (!$collection instanceof PersistentCollection) {
+            return;
+        }
+
+        $owner = $collection->getOwner();
+        if (!$owner instanceof Product) {
+            return;
+        }
+
+        $productId = (string) $owner->getId();
+        if ('' === $productId) {
+            return;
+        }
+
+        $mapping   = $collection->getMapping();
+        $fieldName = $mapping['fieldName'] ?? null;
+        if ('constructeurs' !== $fieldName) {
+            return;
+        }
+
+        $before = $this->normalizeCollection($collection->getSnapshot());
+        $after  = $this->normalizeCollection($collection->toArray());
+
+        if ($before === $after) {
+            return;
+        }
+
+        $diff = [
+            'constructeurIds' => [
+                'from' => $before,
+                'to'   => $after,
+            ],
+        ];
+
+        $pendingUpdates[$productId]   = $this->mergeDiffs($pendingUpdates[$productId] ?? [], $diff);
+        $pendingSnapshots[$productId] = $this->snapshotProduct($owner);
+        $pendingProducts[$productId]  = $owner;
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Product>                                    $pendingProducts
+     */
+    private function collectCustomFieldValueChanges(
+        UnitOfWork $uow,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingProducts,
+    ): void {
+        foreach ($uow->getScheduledEntityInsertions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, null, $entity->getValue(), $pendingUpdates, $pendingSnapshots, $pendingProducts);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityUpdates() as $entity) {
+            if (!$entity instanceof CustomFieldValue) {
+                continue;
+            }
+            $changeSet = $uow->getEntityChangeSet($entity);
+            if (!isset($changeSet['value'])) {
+                continue;
+            }
+            [$oldVal, $newVal] = $changeSet['value'];
+            if ($oldVal !== $newVal) {
+                $this->trackCustomFieldValueChange($entity, $oldVal, $newVal, $pendingUpdates, $pendingSnapshots, $pendingProducts);
+            }
+        }
+
+        foreach ($uow->getScheduledEntityDeletions() as $entity) {
+            if ($entity instanceof CustomFieldValue) {
+                $this->trackCustomFieldValueChange($entity, $entity->getValue(), null, $pendingUpdates, $pendingSnapshots, $pendingProducts);
+            }
+        }
+    }
+
+    /**
+     * @param array<string, array<string, array{from:mixed, to:mixed}>> $pendingUpdates
+     * @param array<string, array<string, mixed>>                       $pendingSnapshots
+     * @param array<string, Product>                                    $pendingProducts
+     */
+    private function trackCustomFieldValueChange(
+        CustomFieldValue $cfv,
+        mixed $from,
+        mixed $to,
+        array &$pendingUpdates,
+        array &$pendingSnapshots,
+        array &$pendingProducts,
+    ): void {
+        $owner = $cfv->getProduct();
+        if (!$owner instanceof Product) {
+            return;
+        }
+
+        $ownerId = (string) $owner->getId();
+        if ('' === $ownerId) {
+            return;
+        }
+
+        $fieldName = 'customField:'.$cfv->getCustomField()->getName();
+        $diff      = [$fieldName => ['from' => $from, 'to' => $to]];
+
+        $pendingUpdates[$ownerId]   = $this->mergeDiffs($pendingUpdates[$ownerId] ?? [], $diff);
+        $pendingSnapshots[$ownerId] = $this->snapshotProduct($owner);
+        $pendingProducts[$ownerId]  = $owner;
+    }
+
+    private function persistAuditLog(EntityManagerInterface $em, AuditLog $log): void
+    {
+        $uow = $em->getUnitOfWork();
+        // Ensure identifiers and timestamps are set even when persisting during onFlush.
+        $log->initializeAuditLog();
+        $em->persist($log);
+
+        $meta = $em->getClassMetadata(AuditLog::class);
+        $uow->computeChangeSet($meta, $log);
+    }
+
+    /**
+     * @param array<string, array{0:mixed, 1:mixed}> $changeSet
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function buildDiffFromChangeSet(array $changeSet): array
+    {
+        $diff = [];
+        foreach ($changeSet as $field => [$oldValue, $newValue]) {
+            // Skip noisy timestamps managed automatically.
+            if ('updatedAt' === $field || 'createdAt' === $field) {
+                continue;
+            }
+
+            $normalizedOld = $this->normalizeValue($oldValue);
+            $normalizedNew = $this->normalizeValue($newValue);
+
+            if ($normalizedOld === $normalizedNew) {
+                continue;
+            }
+
+            $diff[$field] = [
+                'from' => $normalizedOld,
+                'to'   => $normalizedNew,
+            ];
+        }
+
+        return $diff;
+    }
+
+    private function snapshotProduct(Product $product): array
+    {
+        return [
+            'id'              => $product->getId(),
+            'name'            => $product->getName(),
+            'reference'       => $product->getReference(),
+            'supplierPrice'   => $product->getSupplierPrice(),
+            'typeProduct'     => $this->normalizeValue($product->getTypeProduct()),
+            'constructeurIds' => $this->normalizeCollection($product->getConstructeurs()),
+        ];
+    }
+
+    /**
+     * @param array<string, array{from:mixed, to:mixed}> $base
+     * @param array<string, array{from:mixed, to:mixed}> $extra
+     *
+     * @return array<string, array{from:mixed, to:mixed}>
+     */
+    private function mergeDiffs(array $base, array $extra): array
+    {
+        foreach ($extra as $field => $change) {
+            $base[$field] = $change;
+        }
+
+        return $base;
+    }
+
+    /**
+     * @param iterable<mixed> $items
+     *
+     * @return list<array{id: string, name: string}|string>
+     */
+    private function normalizeCollection(iterable $items): array
+    {
+        $entries = [];
+        $seen    = [];
+        foreach ($items as $item) {
+            if (is_object($item) && method_exists($item, 'getId')) {
+                $id = $item->getId();
+                if (null === $id || '' === $id || isset($seen[(string) $id])) {
+                    continue;
+                }
+                $seen[(string) $id] = true;
+                if (method_exists($item, 'getName')) {
+                    $entries[] = ['id' => (string) $id, 'name' => (string) $item->getName()];
+                } else {
+                    $entries[] = (string) $id;
+                }
+            }
+        }
+
+        return $entries;
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        if (null === $value || is_scalar($value)) {
+            return $value;
+        }
+
+        if ($value instanceof DateTimeInterface) {
+            return $value->format(DateTimeInterface::ATOM);
+        }
+
+        if ($value instanceof ModelType) {
+            return [
+                'id'   => $value->getId(),
+                'name' => $value->getName(),
+                'code' => $value->getCode(),
+            ];
+        }
+
+        if ($value instanceof Collection) {
+            return $this->normalizeCollection($value);
+        }
+
+        if (is_object($value) && method_exists($value, 'getId')) {
+            return (string) $value->getId();
+        }
+
+        if (is_array($value)) {
+            return $value;
+        }
+
+        return (string) $value;
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+            // No session available (CLI context, etc.)
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/EventSubscriber/UniqueConstraintSubscriber.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\EventSubscriber;
+
+use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpKernel\Event\ExceptionEvent;
+use Symfony\Component\HttpKernel\KernelEvents;
+use Throwable;
+
+final class UniqueConstraintSubscriber implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents(): array
+    {
+        return [
+            KernelEvents::EXCEPTION => 'onKernelException',
+        ];
+    }
+
+    public function onKernelException(ExceptionEvent $event): void
+    {
+        $exception = $this->findUniqueConstraintViolation($event->getThrowable());
+
+        if (!$exception) {
+            return;
+        }
+
+        $event->setResponse(new JsonResponse(
+            [
+                'success' => false,
+                'error'   => 'nom duplique',
+            ],
+            JsonResponse::HTTP_CONFLICT
+        ));
+    }
+
+    private function findUniqueConstraintViolation(Throwable $throwable): ?UniqueConstraintViolationException
+    {
+        for ($current = $throwable; null !== $current; $current = $current->getPrevious()) {
+            if ($current instanceof UniqueConstraintViolationException) {
+                return $current;
+            }
+        }
+
+        return null;
+    }
+}

src/Repository/AuditLogRepository.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\AuditLog;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<AuditLog>
+ */
+final class AuditLogRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, AuditLog::class);
+    }
+
+    /**
+     * @return list<AuditLog>
+     */
+    public function findEntityHistory(string $entityType, string $entityId, int $limit = 100): array
+    {
+        return $this->createQueryBuilder('a')
+            ->andWhere('a.entityType = :entityType')
+            ->andWhere('a.entityId = :entityId')
+            ->setParameter('entityType', $entityType)
+            ->setParameter('entityId', $entityId)
+            ->orderBy('a.createdAt', 'DESC')
+            ->setMaxResults($limit)
+            ->getQuery()
+            ->getResult()
+        ;
+    }
+
+    /**
+     * @param array{entityType?: string, action?: string} $filters
+     *
+     * @return array{items: list<AuditLog>, total: int}
+     */
+    public function findAllPaginated(int $page = 1, int $itemsPerPage = 30, array $filters = []): array
+    {
+        $qb = $this->createQueryBuilder('a')
+            ->orderBy('a.createdAt', 'DESC')
+        ;
+
+        if (!empty($filters['entityType'])) {
+            $qb->andWhere('a.entityType = :entityType')
+                ->setParameter('entityType', $filters['entityType'])
+            ;
+        }
+
+        if (!empty($filters['action'])) {
+            $qb->andWhere('a.action = :action')
+                ->setParameter('action', $filters['action'])
+            ;
+        }
+
+        $countQb = clone $qb;
+        $countQb->select('COUNT(a.id)')
+            ->resetDQLPart('orderBy')
+        ;
+        $total = (int) $countQb->getQuery()->getSingleScalarResult();
+
+        $qb->setFirstResult(($page - 1) * $itemsPerPage)
+            ->setMaxResults($itemsPerPage)
+        ;
+
+        return [
+            'items' => $qb->getQuery()->getResult(),
+            'total' => $total,
+        ];
+    }
+}

src/Service/ModelTypeCategoryConversionService.php

@@ -0,0 +1,494 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use App\Entity\Profile;
+use App\Enum\ModelCategory;
+use App\Repository\ModelTypeRepository;
+use DateTimeImmutable;
+use Doctrine\DBAL\Connection;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Throwable;
+
+final class ModelTypeCategoryConversionService
+{
+    public function __construct(
+        private readonly Connection $connection,
+        private readonly ModelTypeRepository $modelTypes,
+        private readonly RequestStack $requestStack,
+        private readonly Security $security,
+    ) {}
+
+    /**
+     * @return array{canConvert: bool, direction: null|string, itemCount: int, names: list<string>, blockers: list<string>}
+     */
+    public function checkConversion(string $modelTypeId): array
+    {
+        $modelType = $this->modelTypes->find($modelTypeId);
+
+        if (!$modelType) {
+            return [
+                'canConvert' => false,
+                'direction'  => null,
+                'itemCount'  => 0,
+                'names'      => [],
+                'blockers'   => ['Catégorie introuvable.'],
+            ];
+        }
+
+        $category = $modelType->getCategory();
+
+        if (ModelCategory::PRODUCT === $category) {
+            return [
+                'canConvert' => false,
+                'direction'  => null,
+                'itemCount'  => 0,
+                'names'      => [],
+                'blockers'   => ['La conversion n\'est pas disponible pour les catégories de produit.'],
+            ];
+        }
+
+        if (ModelCategory::PIECE === $category) {
+            return $this->checkPieceToComponent($modelTypeId, $modelType->getName());
+        }
+
+        return $this->checkComponentToPiece($modelTypeId, $modelType->getName());
+    }
+
+    /**
+     * @return array{success: bool, convertedCount: int, error: null|string}
+     */
+    public function convert(string $modelTypeId): array
+    {
+        $check = $this->checkConversion($modelTypeId);
+
+        if (!$check['canConvert']) {
+            return [
+                'success'        => false,
+                'convertedCount' => 0,
+                'error'          => implode(' ', $check['blockers']),
+            ];
+        }
+
+        $modelType = $this->modelTypes->find($modelTypeId);
+
+        if (!$modelType) {
+            return ['success' => false, 'convertedCount' => 0, 'error' => 'Catégorie introuvable.'];
+        }
+
+        $category = $modelType->getCategory();
+
+        $direction = ModelCategory::PIECE === $category ? 'piece_to_component' : 'component_to_piece';
+        $names     = $check['names'];
+        $modelName = $modelType->getName();
+        $modelCode = $modelType->getCode();
+
+        $this->connection->beginTransaction();
+
+        try {
+            if (ModelCategory::PIECE === $category) {
+                $count = $this->convertPieceToComponent($modelTypeId);
+            } else {
+                $count = $this->convertComponentToPiece($modelTypeId);
+            }
+
+            $this->logConversionAudit($modelTypeId, $modelName, $modelCode, $direction, $count, $names);
+
+            $this->connection->commit();
+
+            return ['success' => true, 'convertedCount' => $count, 'error' => null];
+        } catch (Throwable $e) {
+            $this->connection->rollBack();
+
+            return ['success' => false, 'convertedCount' => 0, 'error' => $e->getMessage()];
+        }
+    }
+
+    /**
+     * @return array{canConvert: bool, direction: string, itemCount: int, names: list<string>, blockers: list<string>}
+     */
+    private function checkPieceToComponent(string $modelTypeId, string $modelTypeName): array
+    {
+        $blockers = [];
+
+        $pieceCount = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM pieces WHERE typepieceid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        $names = $this->connection->fetchFirstColumn(
+            'SELECT name FROM pieces WHERE typepieceid = :id ORDER BY name',
+            ['id' => $modelTypeId],
+        );
+
+        // Check machine links
+        $machineLinked = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM machine_piece_links mpl
+             JOIN pieces p ON mpl.pieceid = p.id
+             WHERE p.typepieceid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        if ($machineLinked > 0) {
+            $blockers[] = sprintf('%d pièce(s) liée(s) à des machines.', $machineLinked);
+        }
+
+        // Check type machine requirements
+        $requirementCount = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM type_machine_piece_requirements WHERE typepieceid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        if ($requirementCount > 0) {
+            $blockers[] = sprintf('Utilisé dans %d modèle(s) de type de machine.', $requirementCount);
+        }
+
+        // Check name collision with existing composants
+        $collisions = $this->connection->fetchFirstColumn(
+            'SELECT p.name FROM pieces p
+             WHERE p.typepieceid = :id
+             AND p.name IN (SELECT c.name FROM composants c)',
+            ['id' => $modelTypeId],
+        );
+
+        if ([] !== $collisions) {
+            $blockers[] = sprintf(
+                'Collision de nom avec des composants existants : %s.',
+                implode(', ', $collisions),
+            );
+        }
+
+        // Check ModelType name collision
+        $nameCollision = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM model_types WHERE category = :cat AND name = :name AND id != :id',
+            ['cat' => ModelCategory::COMPONENT->value, 'name' => $modelTypeName, 'id' => $modelTypeId],
+        );
+
+        if ($nameCollision > 0) {
+            $blockers[] = sprintf('Une catégorie de composant « %s » existe déjà.', $modelTypeName);
+        }
+
+        return [
+            'canConvert' => [] === $blockers,
+            'direction'  => 'piece_to_component',
+            'itemCount'  => $pieceCount,
+            'names'      => $names,
+            'blockers'   => $blockers,
+        ];
+    }
+
+    /**
+     * @return array{canConvert: bool, direction: string, itemCount: int, names: list<string>, blockers: list<string>}
+     */
+    private function checkComponentToPiece(string $modelTypeId, string $modelTypeName): array
+    {
+        $blockers = [];
+
+        $composantCount = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM composants WHERE typecomposantid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        $names = $this->connection->fetchFirstColumn(
+            'SELECT name FROM composants WHERE typecomposantid = :id ORDER BY name',
+            ['id' => $modelTypeId],
+        );
+
+        // Check machine links
+        $machineLinked = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM machine_component_links mcl
+             JOIN composants c ON mcl.composantid = c.id
+             WHERE c.typecomposantid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        if ($machineLinked > 0) {
+            $blockers[] = sprintf('%d composant(s) lié(s) à des machines.', $machineLinked);
+        }
+
+        // Check type machine requirements
+        $requirementCount = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM type_machine_component_requirements WHERE typecomposantid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        if ($requirementCount > 0) {
+            $blockers[] = sprintf('Utilisé dans %d modèle(s) de type de machine.', $requirementCount);
+        }
+
+        // Check if any composant has pieces or sub-components in structure
+        $withStructure = $this->connection->fetchAllAssociative(
+            'SELECT name, structure FROM composants WHERE typecomposantid = :id AND structure IS NOT NULL',
+            ['id' => $modelTypeId],
+        );
+
+        foreach ($withStructure as $row) {
+            $structure = json_decode($row['structure'], true);
+
+            if (!is_array($structure)) {
+                continue;
+            }
+
+            $hasPieces        = !empty($structure['pieces']);
+            $hasSubcomponents = !empty($structure['subcomponents']);
+
+            if ($hasPieces || $hasSubcomponents) {
+                $parts = [];
+
+                if ($hasPieces) {
+                    $parts[] = 'pièces';
+                }
+
+                if ($hasSubcomponents) {
+                    $parts[] = 'sous-composants';
+                }
+
+                $blockers[] = sprintf(
+                    'Le composant « %s » contient des %s dans sa structure.',
+                    $row['name'],
+                    implode(' et ', $parts),
+                );
+            }
+        }
+
+        // Check name collision with existing pieces
+        $collisions = $this->connection->fetchFirstColumn(
+            'SELECT c.name FROM composants c
+             WHERE c.typecomposantid = :id
+             AND c.name IN (SELECT p.name FROM pieces p)',
+            ['id' => $modelTypeId],
+        );
+
+        if ([] !== $collisions) {
+            $blockers[] = sprintf(
+                'Collision de nom avec des pièces existantes : %s.',
+                implode(', ', $collisions),
+            );
+        }
+
+        // Check ModelType name collision
+        $nameCollision = (int) $this->connection->fetchOne(
+            'SELECT COUNT(*) FROM model_types WHERE category = :cat AND name = :name AND id != :id',
+            ['cat' => ModelCategory::PIECE->value, 'name' => $modelTypeName, 'id' => $modelTypeId],
+        );
+
+        if ($nameCollision > 0) {
+            $blockers[] = sprintf('Une catégorie de pièce « %s » existe déjà.', $modelTypeName);
+        }
+
+        return [
+            'canConvert' => [] === $blockers,
+            'direction'  => 'component_to_piece',
+            'itemCount'  => $composantCount,
+            'names'      => $names,
+            'blockers'   => $blockers,
+        ];
+    }
+
+    private function convertPieceToComponent(string $modelTypeId): int
+    {
+        // 1. Insert into composants from pieces
+        $count = $this->connection->executeStatement(
+            'INSERT INTO composants (id, name, reference, prix, structure, typecomposantid, productid, createdat, updatedat)
+             SELECT id, name, reference, prix, NULL, typepieceid, productid, createdat, updatedat
+             FROM pieces
+             WHERE typepieceid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        // 2. Transfer constructeur associations
+        $this->connection->executeStatement(
+            'INSERT INTO _composantconstructeurs (a, b)
+             SELECT pc.a, pc.b FROM _piececonstructeurs pc
+             WHERE pc.a IN (SELECT id FROM composants WHERE typecomposantid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        $this->connection->executeStatement(
+            'DELETE FROM _piececonstructeurs
+             WHERE a IN (SELECT id FROM pieces WHERE typepieceid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        // 3. Transfer document references
+        $this->connection->executeStatement(
+            'UPDATE documents SET composantid = pieceid, pieceid = NULL
+             WHERE pieceid IN (SELECT id FROM pieces WHERE typepieceid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        // 4. Transfer custom_field_values references
+        $this->connection->executeStatement(
+            'UPDATE custom_field_values SET composantid = pieceid, pieceid = NULL
+             WHERE pieceid IN (SELECT id FROM pieces WHERE typepieceid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        // 5. Transfer custom_fields from typePiece to typeComposant
+        $this->connection->executeStatement(
+            'UPDATE custom_fields SET typecomposantid = typepieceid, typepieceid = NULL
+             WHERE typepieceid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        // 6. Delete original pieces
+        $this->connection->executeStatement(
+            'DELETE FROM pieces WHERE typepieceid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        // 7. Update ModelType
+        $this->connection->executeStatement(
+            'UPDATE model_types
+             SET category = :cat,
+                 componentskeleton = pieceskeleton,
+                 pieceskeleton = NULL,
+                 updatedat = :now
+             WHERE id = :id',
+            [
+                'cat' => ModelCategory::COMPONENT->value,
+                'now' => new DateTimeImmutable()->format('Y-m-d H:i:s'),
+                'id'  => $modelTypeId,
+            ],
+        );
+
+        return $count;
+    }
+
+    private function convertComponentToPiece(string $modelTypeId): int
+    {
+        // 1. Insert into pieces from composants
+        $count = $this->connection->executeStatement(
+            'INSERT INTO pieces (id, name, reference, prix, productids, typepieceid, productid, createdat, updatedat)
+             SELECT id, name, reference, prix, NULL, typecomposantid, productid, createdat, updatedat
+             FROM composants
+             WHERE typecomposantid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        // 2. Transfer constructeur associations
+        $this->connection->executeStatement(
+            'INSERT INTO _piececonstructeurs (a, b)
+             SELECT cc.a, cc.b FROM _composantconstructeurs cc
+             WHERE cc.a IN (SELECT id FROM pieces WHERE typepieceid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        $this->connection->executeStatement(
+            'DELETE FROM _composantconstructeurs
+             WHERE a IN (SELECT id FROM composants WHERE typecomposantid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        // 3. Transfer document references
+        $this->connection->executeStatement(
+            'UPDATE documents SET pieceid = composantid, composantid = NULL
+             WHERE composantid IN (SELECT id FROM composants WHERE typecomposantid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        // 4. Transfer custom_field_values references
+        $this->connection->executeStatement(
+            'UPDATE custom_field_values SET pieceid = composantid, composantid = NULL
+             WHERE composantid IN (SELECT id FROM composants WHERE typecomposantid = :id)',
+            ['id' => $modelTypeId],
+        );
+
+        // 5. Transfer custom_fields from typeComposant to typePiece
+        $this->connection->executeStatement(
+            'UPDATE custom_fields SET typepieceid = typecomposantid, typecomposantid = NULL
+             WHERE typecomposantid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        // 6. Delete original composants
+        $this->connection->executeStatement(
+            'DELETE FROM composants WHERE typecomposantid = :id',
+            ['id' => $modelTypeId],
+        );
+
+        // 7. Update ModelType
+        $this->connection->executeStatement(
+            'UPDATE model_types
+             SET category = :cat,
+                 pieceskeleton = componentskeleton,
+                 componentskeleton = NULL,
+                 updatedat = :now
+             WHERE id = :id',
+            [
+                'cat' => ModelCategory::PIECE->value,
+                'now' => new DateTimeImmutable()->format('Y-m-d H:i:s'),
+                'id'  => $modelTypeId,
+            ],
+        );
+
+        return $count;
+    }
+
+    /**
+     * @param list<string> $names
+     */
+    private function logConversionAudit(
+        string $modelTypeId,
+        string $modelName,
+        string $modelCode,
+        string $direction,
+        int $convertedCount,
+        array $names,
+    ): void {
+        $now = new DateTimeImmutable()->format('Y-m-d H:i:s');
+        $id  = 'cl'.bin2hex(random_bytes(12));
+
+        $snapshot = [
+            'id'   => $modelTypeId,
+            'name' => $modelName,
+            'code' => $modelCode,
+        ];
+
+        $diff = [
+            'direction'      => ['from' => null, 'to' => $direction],
+            'convertedCount' => ['from' => null, 'to' => $convertedCount],
+            'convertedNames' => ['from' => null, 'to' => $names],
+        ];
+
+        $this->connection->executeStatement(
+            'INSERT INTO audit_logs (id, entitytype, entityid, action, diff, snapshot, actorprofileid, createdat)
+             VALUES (:id, :entityType, :entityId, :action, :diff, :snapshot, :actor, :now)',
+            [
+                'id'         => $id,
+                'entityType' => 'model_type',
+                'entityId'   => $modelTypeId,
+                'action'     => 'convert',
+                'diff'       => json_encode($diff),
+                'snapshot'   => json_encode($snapshot),
+                'actor'      => $this->resolveActorProfileId(),
+                'now'        => $now,
+            ],
+        );
+    }
+
+    private function resolveActorProfileId(): ?string
+    {
+        try {
+            $session = $this->requestStack->getSession();
+            if ($session instanceof SessionInterface) {
+                $profileId = $session->get('profileId');
+                if ($profileId) {
+                    return (string) $profileId;
+                }
+            }
+        } catch (Throwable) {
+        }
+
+        $user = $this->security->getUser();
+        if ($user instanceof Profile) {
+            return $user->getId();
+        }
+
+        return null;
+    }
+}

src/Service/PdfCompressorService.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+class PdfCompressorService
+{
+    public function compressBase64Pdf(string $base64Data): ?array
+    {
+        // Check if qpdf is available
+        exec('which qpdf', $qpdfPath, $returnCode);
+        if (0 !== $returnCode) {
+            return null;
+        }
+
+        // Remove data URI prefix if present
+        $originalBase64 = $base64Data;
+        if (str_contains($base64Data, ',')) {
+            $base64Data = explode(',', $base64Data, 2)[1];
+        }
+
+        $pdfContent = base64_decode($base64Data, true);
+        if (false === $pdfContent) {
+            return null;
+        }
+
+        $originalSize = strlen($pdfContent);
+
+        // Create temp files
+        $tempInput  = tempnam(sys_get_temp_dir(), 'pdf_in_');
+        $tempOutput = tempnam(sys_get_temp_dir(), 'pdf_out_');
+
+        file_put_contents($tempInput, $pdfContent);
+
+        // Compress with qpdf (lossless)
+        $command = sprintf(
+            'qpdf --linearize --object-streams=generate %s %s 2>&1',
+            escapeshellarg($tempInput),
+            escapeshellarg($tempOutput)
+        );
+
+        exec($command, $cmdOutput, $returnCode);
+
+        if (0 !== $returnCode || !file_exists($tempOutput)) {
+            @unlink($tempInput);
+            @unlink($tempOutput);
+
+            return null;
+        }
+
+        $compressedContent = file_get_contents($tempOutput);
+        $compressedSize    = strlen($compressedContent);
+
+        @unlink($tempInput);
+        @unlink($tempOutput);
+
+        // Only return compressed version if it's smaller
+        if ($compressedSize >= $originalSize) {
+            return null;
+        }
+
+        // Rebuild with data URI prefix
+        $newBase64 = 'data:application/pdf;base64,'.base64_encode($compressedContent);
+
+        return [
+            'path'         => $newBase64,
+            'size'         => $compressedSize,
+            'originalSize' => $originalSize,
+            'saved'        => $originalSize - $compressedSize,
+        ];
+    }
+}