1420 lines
44 KiB
Markdown
1420 lines
44 KiB
Markdown
# Plan de Migration : NestJS/Prisma → Symfony/API Platform
|
||
|
||
**Date de création**: 2026-01-10
|
||
**Dernière mise à jour**: 2026-01-11
|
||
**Objectif**: Migrer le backend Inventory (NestJS + Prisma) vers Symfony 8 + API Platform avec JWT auth, tout en conservant les données existantes et en minimisant les disruptions.
|
||
|
||
---
|
||
|
||
## 📊 État des Lieux - 2026-01-11
|
||
|
||
### ✅ Phase 1 : Préparation (TERMINÉE, ajustée)
|
||
- ✅ Bundles Symfony installés (JWT, VichUploader, Uid)
|
||
- ✅ Entité Profile créée (UserInterface + session ready)
|
||
- ✅ pgAdmin configuré et connecté à PostgreSQL
|
||
- ✅ Docker fonctionnel (web:8081, db:5433, pgadmin:5050)
|
||
- ✅ API Platform configurée avec préfixe `/api`
|
||
- ⚠️ JWT désactivé temporairement (session cookie pour compatibilité front)
|
||
|
||
### ✅ Phase 2 : Tests & Validation (TERMINÉE, version session)
|
||
- ✅ API Platform retourne JSON-LD correctement
|
||
- ✅ Routes session `/api/session/profile` + `/api/session/profiles` opérationnelles
|
||
- ✅ CORS prévu via Nelmio (mais variable d'env à injecter dans container)
|
||
|
||
### 📦 Données à Migrer (Base: `inventory-data`)
|
||
|
||
**Total: 673 lignes réparties sur 22 tables (migrées)**
|
||
|
||
| Table | Lignes | Priorité | Commentaire |
|
||
|-------|--------|----------|-------------|
|
||
| `sites` | 3 | ⚠️ Critique | Point d'entrée, relations cascades |
|
||
| `machines` | 3 | ⚠️ Critique | Entité centrale |
|
||
| `type_machines` | 3 | ⚠️ Critique | Configuration machines |
|
||
| `ModelType` | 71 | 🔴 Haute | Templates composants/pièces/produits |
|
||
| `composants` | 23 | 🔴 Haute | - |
|
||
| `pieces` | 82 | 🔴 Haute | Plus grande table métier |
|
||
| `products` | 2 | 🟡 Moyenne | - |
|
||
| `constructeurs` | 20 | 🟡 Moyenne | - |
|
||
| `custom_fields` | 95 | 🔴 Haute | Configuration champs custom |
|
||
| `custom_field_values` | 203 | 🔴 Haute | Plus grande table (valeurs) |
|
||
| `documents` | 14 | 🟡 Moyenne | Fichiers uploadés |
|
||
| `machine_component_links` | 25 | 🔴 Haute | Relations machines ↔ composants |
|
||
| `machine_piece_links` | 99 | 🔴 Haute | Relations machines ↔ pièces |
|
||
| `machine_product_links` | 0 | 🟢 Basse | Table vide |
|
||
| `type_machine_*_requirements` (×3) | 22 | 🟡 Moyenne | Config requirements types |
|
||
| `_*Constructeurs` (×4) | 14 | 🟡 Moyenne | Tables de liaison ManyToMany |
|
||
| `profiles` | 2 | 🟢 Basse | Utilisateurs session (migrés) |
|
||
|
||
**Complexités identifiées (résolues ou contournées)** :
|
||
- ✅ IDs CUID Prisma → conservés en `string(36)` côté Doctrine (compatibles)
|
||
- ✅ Champs JSON complexes importés (components, criticalParts, machinePieces, specifications)
|
||
- ✅ Relations polymorphiques Document + CustomFieldValue migrées
|
||
- ✅ Tables de liaison ManyToMany (`_*Constructeurs`) migrées
|
||
- ✅ Custom fields dynamiques migrés (95 définitions, 203 valeurs)
|
||
|
||
### 🏗️ Structure Actuelle des Projets
|
||
|
||
```
|
||
/home/r-dev/Inventory/
|
||
├── Inventory_backend/ # NestJS + Prisma (11k lignes)
|
||
│ ├── src/ # 18 modules NestJS
|
||
│ ├── prisma/schema.prisma # Schéma DB source
|
||
│ └── package.json
|
||
├── Inventory_frontend/ # Nuxt 3 (front principal)
|
||
│ ├── app/
|
||
│ │ ├── composables/
|
||
│ │ └── pages/
|
||
│ └── package.json
|
||
├── src/ # ⚡ Symfony backend
|
||
│ ├── Entity/ # Toutes entités créées
|
||
│ ├── Controller/ # Session + custom fields + documents + skeleton
|
||
│ └── Repository/
|
||
├── config/ # Configuration Symfony
|
||
├── migrations/ # Migrations Doctrine
|
||
└── docker-compose.yml # Web + DB + pgAdmin
|
||
```
|
||
|
||
### 🎯 Prochaines Étapes (Phase 3 - Mise en production fonctionnelle)
|
||
|
||
#### Étape 3.1 : Réorganisation du Projet (optionnel)
|
||
- [ ] Déplacer `Inventory_frontend/` vers `frontend/` (si besoin)
|
||
- [ ] Archiver `Inventory_backend/` vers `_archives/backend_nestjs/`
|
||
- [ ] Mettre à jour .gitignore
|
||
|
||
#### Étape 3.2 : Entités & API Platform (TERMINÉE)
|
||
- [x] Site, TypeMachine, Machine
|
||
- [x] ModelType, Composant, Piece, Product
|
||
- [x] Constructeur, Document
|
||
- [x] CustomField, CustomFieldValue
|
||
- [x] MachineComponentLink, MachinePieceLink, MachineProductLink
|
||
- [x] TypeMachine*Requirement (×3)
|
||
|
||
#### Étape 3.3 : Migration des Données (TERMINÉE)
|
||
- [x] Backup `inventory-data`
|
||
- [x] Schéma Doctrine aligné
|
||
- [x] Import `inventory-data` → `inventory`
|
||
- [x] Validation des comptes (script `scripts/validate-migration.php`)
|
||
|
||
#### Étape 3.4 : Front Nuxt (EN COURS)
|
||
- [x] Base URL API -> `http://localhost:8081/api`
|
||
- [x] Parsing JSON-LD dans composables
|
||
- [x] Normalisation des relations vers IRI
|
||
- [x] Endpoints session profile compatibles
|
||
- [ ] Corriger CORS (injecter `CORS_ALLOW_ORIGIN` dans container + clear cache)
|
||
- [ ] Valider le squelette machine (endpoint `/api/machines/{id}/skeleton`)
|
||
- [ ] Valider documents catalogue (composant/piece/produit)
|
||
|
||
#### Étape 3.5 : Sécurité (À FAIRE)
|
||
- [ ] Réactiver JWT (après stabilisation)
|
||
- [ ] Ajouter refresh token si nécessaire
|
||
|
||
---
|
||
|
||
## Table des Matières
|
||
1. [Vue d'ensemble](#vue-densemble)
|
||
2. [Architecture Cible](#architecture-cible)
|
||
3. [Mapping Prisma → Doctrine](#mapping-prisma--doctrine)
|
||
4. [Stratégie de Migration des Données](#stratégie-de-migration-des-données)
|
||
5. [Configuration Docker](#configuration-docker)
|
||
6. [Plan d'Exécution Phase par Phase](#plan-dexécution-phase-par-phase)
|
||
7. [Gestion des Risques](#gestion-des-risques)
|
||
8. [Checklist de Migration](#checklist-de-migration)
|
||
|
||
---
|
||
|
||
## 1. Vue d'ensemble
|
||
|
||
### Situation Actuelle
|
||
- **Backend NestJS**: Port 3000, Prisma ORM, PostgreSQL, Sessions cookie-based
|
||
- **Frontend Nuxt 3**: Port 3001, API calls vers localhost:3000
|
||
- **Base de données**: PostgreSQL 16 sur port 5433, 28 modèles Prisma, données en production
|
||
- **Docker**: Container unique avec PHP 8.4 + Node 24.12, Apache, XDebug
|
||
|
||
### Objectif Final
|
||
- **Backend Symfony 8**: Port 8081, Doctrine ORM, API Platform 4.2, JWT auth
|
||
- **Frontend Nuxt 3**: Port 3001, API calls vers localhost:8081
|
||
- **Base de données**: Même PostgreSQL, migration Prisma → Doctrine
|
||
- **Docker**: 2 backends en parallèle pendant la transition (NestJS:3000 + Symfony:8081)
|
||
|
||
### Pourquoi cette migration ?
|
||
- Code généré par IA (ChatGPT) à nettoyer et reprendre en main
|
||
- Symfony + API Platform = stack PHP standard, mature, bien documentée
|
||
- JWT auth plus adapté pour API REST moderne
|
||
- Meilleure intégration avec l'écosystème PHP existant
|
||
|
||
---
|
||
|
||
## 2. Architecture Cible
|
||
|
||
### Stack Technique
|
||
|
||
#### Backend Symfony
|
||
```
|
||
Symfony 8.0
|
||
├── API Platform 4.2 # REST API auto-documentée (OpenAPI)
|
||
├── Doctrine ORM 3.6 # ORM pour PostgreSQL
|
||
├── Lexik JWT Bundle # JWT authentication
|
||
├── Nelmio CORS Bundle # CORS pour frontend
|
||
├── VichUploader Bundle # Upload de documents
|
||
├── Symfony Validator # Validation des DTOs
|
||
└── Doctrine Migrations # Gestion des migrations DB
|
||
```
|
||
|
||
#### Structure de Projet
|
||
```
|
||
src/
|
||
├── Entity/ # 16 entités Doctrine
|
||
│ ├── Site.php
|
||
│ ├── Machine.php
|
||
│ ├── Composant.php
|
||
│ ├── Piece.php
|
||
│ ├── Product.php
|
||
│ ├── TypeMachine.php
|
||
│ ├── ModelType.php
|
||
│ ├── Constructeur.php
|
||
│ ├── Profile.php
|
||
│ ├── Document.php
|
||
│ ├── CustomField.php
|
||
│ ├── CustomFieldValue.php
|
||
│ ├── MachineComponentLink.php
|
||
│ ├── MachinePieceLink.php
|
||
│ ├── MachineProductLink.php
|
||
│ └── TypeMachine*Requirement.php (×3)
|
||
├── Repository/ # Repositories Doctrine
|
||
├── Controller/ # Controllers custom si besoin
|
||
├── State/ # State providers/processors API Platform
|
||
├── Validator/ # Contraintes de validation custom
|
||
└── Service/ # Services métier (équivalents NestJS services)
|
||
```
|
||
|
||
#### Configuration JWT
|
||
|
||
**Flow d'authentification**:
|
||
```
|
||
1. POST /api/login_check
|
||
Body: {"username": "...", "password": "..."}
|
||
Response: {"token": "eyJ0eXAiOiJKV1QiLCJhbGc..."}
|
||
|
||
2. Requêtes authentifiées
|
||
Header: Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGc...
|
||
|
||
3. Token refresh (optionnel)
|
||
POST /api/token/refresh
|
||
Body: {"refresh_token": "..."}
|
||
```
|
||
|
||
**Configuration sécurité** (`config/packages/security.yaml`):
|
||
```yaml
|
||
security:
|
||
password_hashers:
|
||
App\Entity\Profile:
|
||
algorithm: auto
|
||
|
||
providers:
|
||
app_user_provider:
|
||
entity:
|
||
class: App\Entity\Profile
|
||
property: email # À ajouter à Profile
|
||
|
||
firewalls:
|
||
login:
|
||
pattern: ^/api/login
|
||
stateless: true
|
||
json_login:
|
||
check_path: /api/login_check
|
||
success_handler: lexik_jwt_authentication.handler.authentication_success
|
||
failure_handler: lexik_jwt_authentication.handler.authentication_failure
|
||
|
||
api:
|
||
pattern: ^/api
|
||
stateless: true
|
||
jwt: ~
|
||
|
||
access_control:
|
||
- { path: ^/api/login, roles: PUBLIC_ACCESS }
|
||
- { path: ^/api/docs, roles: PUBLIC_ACCESS }
|
||
- { path: ^/api, roles: IS_AUTHENTICATED_FULLY }
|
||
```
|
||
|
||
---
|
||
|
||
## 3. Mapping Prisma → Doctrine
|
||
|
||
### 3.1 Types de Données
|
||
|
||
| Prisma | Doctrine | Notes |
|
||
|--------|----------|-------|
|
||
| `String` | `string` | `@ORM\Column(type="string")` |
|
||
| `String @id @default(cuid())` | `Ulid` | `@ORM\Id` + `@ORM\GeneratedValue(strategy="CUSTOM")` |
|
||
| `Int` | `integer` | `@ORM\Column(type="integer")` |
|
||
| `Decimal @db.Decimal(10,2)` | `string` | `@ORM\Column(type="decimal", precision=10, scale=2)` |
|
||
| `Boolean` | `bool` | `@ORM\Column(type="boolean")` |
|
||
| `DateTime` | `\DateTimeImmutable` | `@ORM\Column(type="datetime_immutable")` |
|
||
| `Json` | `array` | `@ORM\Column(type="json")` |
|
||
| `String[]` | `array` | `@ORM\Column(type="json")` |
|
||
| `String?` | `?string` | `@ORM\Column(nullable=true)` |
|
||
|
||
### 3.2 Relations
|
||
|
||
| Prisma | Doctrine | Exemple |
|
||
|--------|----------|---------|
|
||
| `@relation(onDelete: Cascade)` | `@ORM\JoinColumn(onDelete="CASCADE")` | Machine → Site |
|
||
| `@relation(onDelete: SetNull)` | `@ORM\JoinColumn(nullable=true, onDelete="SET NULL")` | Composant → Product |
|
||
| `Model[]` | `@ORM\OneToMany` + `Collection` | Site → machines |
|
||
| `Model` | `@ORM\ManyToOne` | Machine → site |
|
||
| Pas de `@relation` | `@ORM\ManyToMany` | Machine ↔ Constructeurs |
|
||
|
||
### 3.3 Contraintes et Index
|
||
|
||
| Prisma | Doctrine |
|
||
|--------|----------|
|
||
| `@unique` | `@ORM\Column(unique=true)` |
|
||
| `@@unique([field1, field2])` | `@ORM\UniqueConstraint(columns=["field1", "field2"])` |
|
||
| `@@map("table_name")` | `@ORM\Table(name="table_name")` |
|
||
| `@db.VarChar(120)` | `@ORM\Column(type="string", length=120)` |
|
||
| `@default("")` | `#[ORM\Column(options: ['default' => ''])]` |
|
||
|
||
### 3.4 Mapping Détaillé des 16 Entités
|
||
|
||
#### 1. Site
|
||
```php
|
||
#[ORM\Entity(repositoryClass: SiteRepository::class)]
|
||
#[ORM\Table(name: 'sites')]
|
||
#[ApiResource(
|
||
operations: [
|
||
new Get(),
|
||
new GetCollection(),
|
||
new Post(),
|
||
new Put(),
|
||
new Delete()
|
||
]
|
||
)]
|
||
class Site
|
||
{
|
||
#[ORM\Id]
|
||
#[ORM\Column(type: 'ulid', unique: true)]
|
||
#[ORM\GeneratedValue(strategy: 'CUSTOM')]
|
||
#[ORM\CustomIdGenerator(class: UlidGenerator::class)]
|
||
private ?Ulid $id = null;
|
||
|
||
#[ORM\Column(type: 'string', length: 255)]
|
||
#[Assert\NotBlank]
|
||
private string $name;
|
||
|
||
#[ORM\Column(type: 'string', length: 255, options: ['default' => ''])]
|
||
private string $contactName = '';
|
||
|
||
#[ORM\Column(type: 'string', length: 20, options: ['default' => ''])]
|
||
private string $contactPhone = '';
|
||
|
||
#[ORM\Column(type: 'string', length: 500, options: ['default' => ''])]
|
||
private string $contactAddress = '';
|
||
|
||
#[ORM\Column(type: 'string', length: 10, options: ['default' => ''])]
|
||
private string $contactPostalCode = '';
|
||
|
||
#[ORM\Column(type: 'string', length: 100, options: ['default' => ''])]
|
||
private string $contactCity = '';
|
||
|
||
#[ORM\Column(type: 'datetime_immutable')]
|
||
private \DateTimeImmutable $createdAt;
|
||
|
||
#[ORM\Column(type: 'datetime_immutable')]
|
||
private \DateTimeImmutable $updatedAt;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'site', targetEntity: Machine::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
|
||
private Collection $machines;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'site', targetEntity: Document::class, cascade: ['remove'], orphanRemoval: true)]
|
||
private Collection $documents;
|
||
|
||
#[ORM\PrePersist]
|
||
public function setCreatedAtValue(): void
|
||
{
|
||
$this->createdAt = new \DateTimeImmutable();
|
||
$this->updatedAt = new \DateTimeImmutable();
|
||
}
|
||
|
||
#[ORM\PreUpdate]
|
||
public function setUpdatedAtValue(): void
|
||
{
|
||
$this->updatedAt = new \DateTimeImmutable();
|
||
}
|
||
}
|
||
```
|
||
|
||
#### 2. Machine
|
||
```php
|
||
#[ORM\Entity]
|
||
#[ORM\Table(name: 'machines')]
|
||
#[ApiResource]
|
||
class Machine
|
||
{
|
||
#[ORM\Id]
|
||
#[ORM\Column(type: 'ulid')]
|
||
private ?Ulid $id = null;
|
||
|
||
#[ORM\Column(type: 'string', length: 255, unique: true)]
|
||
private string $name;
|
||
|
||
#[ORM\Column(type: 'string', length: 255, nullable: true)]
|
||
private ?string $reference = null;
|
||
|
||
#[ORM\Column(type: 'decimal', precision: 10, scale: 2, nullable: true)]
|
||
private ?string $prix = null;
|
||
|
||
#[ORM\ManyToOne(targetEntity: Site::class, inversedBy: 'machines')]
|
||
#[ORM\JoinColumn(nullable: false, onDelete: 'CASCADE')]
|
||
private Site $site;
|
||
|
||
#[ORM\ManyToOne(targetEntity: TypeMachine::class, inversedBy: 'machines')]
|
||
#[ORM\JoinColumn(nullable: true)]
|
||
private ?TypeMachine $typeMachine = null;
|
||
|
||
#[ORM\ManyToMany(targetEntity: Constructeur::class, inversedBy: 'machines')]
|
||
#[ORM\JoinTable(name: 'machine_constructeurs')]
|
||
private Collection $constructeurs;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'machine', targetEntity: MachineComponentLink::class, cascade: ['persist', 'remove'])]
|
||
private Collection $componentLinks;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'machine', targetEntity: MachinePieceLink::class, cascade: ['persist', 'remove'])]
|
||
private Collection $pieceLinks;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'machine', targetEntity: MachineProductLink::class, cascade: ['persist', 'remove'])]
|
||
private Collection $productLinks;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'machine', targetEntity: Document::class, cascade: ['remove'])]
|
||
private Collection $documents;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'machine', targetEntity: CustomFieldValue::class, cascade: ['persist', 'remove'])]
|
||
private Collection $customFieldValues;
|
||
|
||
#[ORM\Column(type: 'datetime_immutable')]
|
||
private \DateTimeImmutable $createdAt;
|
||
|
||
#[ORM\Column(type: 'datetime_immutable')]
|
||
private \DateTimeImmutable $updatedAt;
|
||
}
|
||
```
|
||
|
||
#### 3. TypeMachine (avec champs JSON)
|
||
```php
|
||
#[ORM\Entity]
|
||
#[ORM\Table(name: 'type_machines')]
|
||
#[ApiResource]
|
||
class TypeMachine
|
||
{
|
||
#[ORM\Id]
|
||
#[ORM\Column(type: 'ulid')]
|
||
private ?Ulid $id = null;
|
||
|
||
#[ORM\Column(type: 'string', length: 255, unique: true)]
|
||
private string $name;
|
||
|
||
#[ORM\Column(type: 'text', nullable: true)]
|
||
private ?string $description = null;
|
||
|
||
#[ORM\Column(type: 'string', length: 100, nullable: true)]
|
||
private ?string $category = null;
|
||
|
||
#[ORM\Column(type: 'string', length: 100, nullable: true)]
|
||
private ?string $maintenanceFrequency = null;
|
||
|
||
// Champs JSON (structure hiérarchique, specs techniques)
|
||
#[ORM\Column(type: 'json', nullable: true)]
|
||
private ?array $components = null;
|
||
|
||
#[ORM\Column(type: 'json', nullable: true)]
|
||
private ?array $criticalParts = null;
|
||
|
||
#[ORM\Column(type: 'json', nullable: true)]
|
||
private ?array $machinePieces = null;
|
||
|
||
#[ORM\Column(type: 'json', nullable: true)]
|
||
private ?array $specifications = null;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typeMachine', targetEntity: Machine::class)]
|
||
private Collection $machines;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typeMachine', targetEntity: CustomField::class, cascade: ['remove'])]
|
||
private Collection $customFields;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typeMachine', targetEntity: TypeMachineComponentRequirement::class, cascade: ['persist', 'remove'])]
|
||
private Collection $componentRequirements;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typeMachine', targetEntity: TypeMachinePieceRequirement::class, cascade: ['persist', 'remove'])]
|
||
private Collection $pieceRequirements;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typeMachine', targetEntity: TypeMachineProductRequirement::class, cascade: ['persist', 'remove'])]
|
||
private Collection $productRequirements;
|
||
}
|
||
```
|
||
|
||
#### 4. ModelType (avec Enum)
|
||
```php
|
||
enum ModelCategory: string
|
||
{
|
||
case COMPONENT = 'COMPONENT';
|
||
case PIECE = 'PIECE';
|
||
case PRODUCT = 'PRODUCT';
|
||
}
|
||
|
||
#[ORM\Entity]
|
||
#[ORM\Table(name: 'model_types')]
|
||
#[ORM\UniqueConstraint(name: 'unique_category_name', columns: ['category', 'name'])]
|
||
#[ApiResource]
|
||
class ModelType
|
||
{
|
||
#[ORM\Id]
|
||
#[ORM\Column(type: 'ulid')]
|
||
private ?Ulid $id = null;
|
||
|
||
#[ORM\Column(type: 'string', length: 120)]
|
||
private string $name;
|
||
|
||
#[ORM\Column(type: 'string', length: 60, unique: true)]
|
||
private string $code;
|
||
|
||
#[ORM\Column(type: 'string', enumType: ModelCategory::class)]
|
||
private ModelCategory $category;
|
||
|
||
#[ORM\Column(type: 'text', nullable: true)]
|
||
private ?string $notes = null;
|
||
|
||
#[ORM\Column(type: 'text', nullable: true)]
|
||
private ?string $description = null;
|
||
|
||
#[ORM\Column(type: 'json', nullable: true)]
|
||
private ?array $componentSkeleton = null;
|
||
|
||
#[ORM\Column(type: 'json', nullable: true)]
|
||
private ?array $pieceSkeleton = null;
|
||
|
||
#[ORM\Column(type: 'json', nullable: true)]
|
||
private ?array $productSkeleton = null;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typeComposant', targetEntity: Composant::class)]
|
||
private Collection $composants;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typePiece', targetEntity: Piece::class)]
|
||
private Collection $pieces;
|
||
|
||
#[ORM\OneToMany(mappedBy: 'typeProduct', targetEntity: Product::class)]
|
||
private Collection $products;
|
||
|
||
// Relations avec les requirements (×3)
|
||
// Relations avec les custom fields (×3)
|
||
}
|
||
```
|
||
|
||
#### 5. Document (Relations Polymorphiques)
|
||
```php
|
||
#[ORM\Entity]
|
||
#[ORM\Table(name: 'documents')]
|
||
#[ApiResource(
|
||
normalizationContext: ['groups' => ['document:read']],
|
||
denormalizationContext: ['groups' => ['document:write']]
|
||
)]
|
||
class Document
|
||
{
|
||
#[ORM\Id]
|
||
#[ORM\Column(type: 'ulid')]
|
||
private ?Ulid $id = null;
|
||
|
||
#[ORM\Column(type: 'string', length: 255)]
|
||
private string $name;
|
||
|
||
#[ORM\Column(type: 'string', length: 255)]
|
||
private string $filename;
|
||
|
||
#[ORM\Column(type: 'string', length: 500)]
|
||
private string $path;
|
||
|
||
#[ORM\Column(type: 'string', length: 100)]
|
||
private string $mimeType;
|
||
|
||
#[ORM\Column(type: 'integer')]
|
||
private int $size;
|
||
|
||
// Relations polymorphiques (nullable)
|
||
#[ORM\ManyToOne(targetEntity: Machine::class, inversedBy: 'documents')]
|
||
#[ORM\JoinColumn(nullable: true, onDelete: 'CASCADE')]
|
||
private ?Machine $machine = null;
|
||
|
||
#[ORM\ManyToOne(targetEntity: Composant::class, inversedBy: 'documents')]
|
||
#[ORM\JoinColumn(nullable: true, onDelete: 'CASCADE')]
|
||
private ?Composant $composant = null;
|
||
|
||
#[ORM\ManyToOne(targetEntity: Piece::class, inversedBy: 'documents')]
|
||
#[ORM\JoinColumn(nullable: true, onDelete: 'CASCADE')]
|
||
private ?Piece $piece = null;
|
||
|
||
#[ORM\ManyToOne(targetEntity: Product::class, inversedBy: 'documents')]
|
||
#[ORM\JoinColumn(nullable: true, onDelete: 'CASCADE')]
|
||
private ?Product $product = null;
|
||
|
||
#[ORM\ManyToOne(targetEntity: Site::class, inversedBy: 'documents')]
|
||
#[ORM\JoinColumn(nullable: true, onDelete: 'CASCADE')]
|
||
private ?Site $site = null;
|
||
}
|
||
```
|
||
|
||
#### 6-16. Autres Entités
|
||
Les autres entités suivent le même pattern :
|
||
- **Composant, Piece, Product** : Similaires à Machine avec relations vers ModelType
|
||
- **Constructeur** : ManyToMany avec Machine/Composant/Piece/Product
|
||
- **Profile** : Entité utilisateur (à enrichir avec email/password pour JWT)
|
||
- **CustomField, CustomFieldValue** : Système de champs dynamiques
|
||
- **MachineComponentLink, MachinePieceLink, MachineProductLink** : Tables de liaison avec overrides
|
||
- **TypeMachine*Requirement (×3)** : Définition des requirements (minCount, maxCount, label, etc.)
|
||
|
||
---
|
||
|
||
## 4. Stratégie de Migration des Données
|
||
|
||
### 4.1 Problème : CUID vs ULID
|
||
|
||
**Prisma utilise CUID** (`@default(cuid())`) :
|
||
- Format: `clabcd123xyz...` (25 caractères)
|
||
- Exemple: `cldu8kzj30000vh8q9k0y8h7i`
|
||
|
||
**Doctrine recommande ULID** :
|
||
- Format: `01ARZ3NDEKTSV4RRFFQ69G5FAV` (26 caractères)
|
||
- Type Symfony : `Symfony\Component\Uid\Ulid`
|
||
|
||
**Solutions possibles** :
|
||
|
||
#### Option A : Garder les CUID comme chaînes (RECOMMANDÉE)
|
||
```php
|
||
#[ORM\Id]
|
||
#[ORM\Column(type: 'string', length: 30)]
|
||
private string $id;
|
||
```
|
||
|
||
**Avantages** :
|
||
- ✅ Aucune modification des IDs existants
|
||
- ✅ Migration transparente, pas de mapping d'IDs
|
||
- ✅ Relations FK préservées
|
||
- ✅ Frontend continue à utiliser les mêmes IDs
|
||
|
||
**Inconvénients** :
|
||
- ❌ Pas de type Ulid natif Symfony
|
||
- ❌ Moins "moderne"
|
||
|
||
#### Option B : Migrer CUID → ULID avec mapping
|
||
```php
|
||
#[ORM\Id]
|
||
#[ORM\Column(type: 'ulid')]
|
||
private Ulid $id;
|
||
```
|
||
|
||
**Nécessite** :
|
||
1. Créer une table de mapping `cuid_to_ulid`
|
||
2. Générer de nouveaux ULIDs pour chaque ligne
|
||
3. Mettre à jour toutes les FK
|
||
4. Adapter le frontend
|
||
|
||
**Risque** : Complexité élevée, risque de perte de données.
|
||
|
||
### 4.2 Approche Recommandée : Migration en 3 Étapes
|
||
|
||
#### Étape 1 : Créer le schéma Doctrine en parallèle (SAFE)
|
||
|
||
1. Générer les migrations Doctrine sans exécution :
|
||
```bash
|
||
php bin/console doctrine:migrations:diff
|
||
```
|
||
|
||
2. **NE PAS exécuter** la migration immédiatement
|
||
|
||
3. Analyser le SQL généré pour détecter les différences :
|
||
- Noms de colonnes (camelCase → snake_case)
|
||
- Types de données (Decimal en Prisma → string en Doctrine)
|
||
- Contraintes (vérifier les FK, indexes)
|
||
|
||
#### Étape 2 : Script de Validation (Dry-run)
|
||
|
||
Créer un script PHP qui :
|
||
1. Lit toutes les tables Prisma actuelles
|
||
2. Compare avec le schéma Doctrine généré
|
||
3. Génère un rapport de différences
|
||
4. Valide que toutes les données peuvent être mappées
|
||
|
||
```php
|
||
// scripts/validate-migration.php
|
||
use Doctrine\ORM\EntityManagerInterface;
|
||
|
||
class MigrationValidator
|
||
{
|
||
public function validate(): array
|
||
{
|
||
$issues = [];
|
||
|
||
// Vérifier chaque table
|
||
foreach ($this->getTables() as $table) {
|
||
// Comparer schéma Prisma vs Doctrine
|
||
$schemaIssues = $this->compareSchemas($table);
|
||
|
||
// Vérifier les données peuvent être migrées
|
||
$dataIssues = $this->validateData($table);
|
||
|
||
$issues = array_merge($issues, $schemaIssues, $dataIssues);
|
||
}
|
||
|
||
return $issues;
|
||
}
|
||
}
|
||
```
|
||
|
||
#### Étape 3 : Migration réelle (avec Backup)
|
||
|
||
```bash
|
||
# 1. BACKUP de la DB
|
||
pg_dump -U postgres -h localhost -p 5433 inventory_db > backup_$(date +%Y%m%d_%H%M%S).sql
|
||
|
||
# 2. Exécuter les migrations Doctrine
|
||
php bin/console doctrine:migrations:migrate --no-interaction
|
||
|
||
# 3. Vérifier l'intégrité
|
||
php bin/console doctrine:schema:validate
|
||
|
||
# 4. Si erreur : ROLLBACK
|
||
psql -U postgres -h localhost -p 5433 inventory_db < backup_YYYYMMDD_HHMMSS.sql
|
||
```
|
||
|
||
### 4.3 Mapping des Noms de Colonnes
|
||
|
||
Prisma → Doctrine naming strategy :
|
||
|
||
| Prisma | Doctrine | Action |
|
||
|--------|----------|--------|
|
||
| `siteId` | `site_id` | Annotation `#[ORM\JoinColumn(name="siteId")]` ou laisser Doctrine snake_case |
|
||
| `createdAt` | `created_at` | Idem |
|
||
| `contactName` | `contact_name` | Idem |
|
||
|
||
**Recommandation** : Utiliser `#[ORM\Column(name="xxx")]` pour garder les noms Prisma existants et éviter les ALTER TABLE.
|
||
|
||
### 4.4 Checklist de Migration DB
|
||
|
||
- [ ] Créer backup complet de la DB
|
||
- [ ] Générer migration Doctrine (`doctrine:migrations:diff`)
|
||
- [ ] Analyser SQL généré manuellement
|
||
- [ ] Tester migration sur copie locale de la DB
|
||
- [ ] Valider que les données sont intactes après migration
|
||
- [ ] Créer script de rollback
|
||
- [ ] Documenter les différences schéma Prisma vs Doctrine
|
||
- [ ] Tester toutes les requêtes via Doctrine
|
||
- [ ] Vérifier les performances (indexes, FK)
|
||
|
||
---
|
||
|
||
## 5. Configuration Docker
|
||
|
||
### 5.1 Setup : 2 Backends en Parallèle
|
||
|
||
**Objectif** : Faire tourner NestJS (port 3000) ET Symfony (port 8081) simultanément pendant la transition.
|
||
|
||
#### Modification `docker-compose.yml`
|
||
|
||
```yaml
|
||
services:
|
||
web:
|
||
container_name: php-${DOCKER_APP_NAME}-apache
|
||
build:
|
||
context: ./docker/php
|
||
dockerfile: Dockerfile
|
||
args:
|
||
DOCKER_PHP_VERSION: ${DOCKER_PHP_VERSION}
|
||
DOCKER_NODE_VERSION: ${DOCKER_NODE_VERSION}
|
||
CURRENT_UID: ${CURRENT_UID}
|
||
CURRENT_GID: ${CURRENT_GID}
|
||
environment:
|
||
PHP_IDE_CONFIG: serverName=${DOCKER_APP_NAME}-docker
|
||
XDEBUG_CLIENT_HOST: ${XDEBUG_CLIENT_HOST:-host.docker.internal}
|
||
XDEBUG_CONFIG: client_host=${XDEBUG_CLIENT_HOST:-host.docker.internal} client_port=9003
|
||
DATABASE_URL: "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}?serverVersion=16&charset=utf8"
|
||
# Variables pour NestJS
|
||
NESTJS_DATABASE_URL: "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}?schema=public"
|
||
NESTJS_PORT: 3000
|
||
NESTJS_CORS_ORIGIN: "http://localhost:3001"
|
||
# Variables pour Symfony
|
||
APP_ENV: dev
|
||
APP_SECRET: ${APP_SECRET}
|
||
JWT_SECRET_KEY: ${JWT_SECRET_KEY}
|
||
JWT_PUBLIC_KEY: ${JWT_PUBLIC_KEY}
|
||
JWT_PASSPHRASE: ${JWT_PASSPHRASE}
|
||
volumes:
|
||
- ./:/var/www/html
|
||
- ~/.cache:/var/www/.cache
|
||
- ~/.config:/var/www/.config
|
||
- ~/.composer:/var/www/.composer
|
||
- ./docker/php/config/php.ini:/usr/local/etc/php/php.ini
|
||
- ./docker/php/config/vhost.conf:/etc/apache2/sites-available/000-default.conf
|
||
- ./docker/php/config/docker-php-ext-xdebug.ini:/usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
|
||
- ./LOG:/var/www/html/LOG
|
||
- ./LOG/logs_apache:/var/log/apache2/
|
||
extra_hosts:
|
||
- "host.docker.internal:host-gateway"
|
||
depends_on:
|
||
- db
|
||
ports:
|
||
- "8081:80" # Apache/Symfony
|
||
- "3000:3000" # NestJS backend (nouveau mapping)
|
||
- "3001:3001" # Nuxt frontend
|
||
restart: unless-stopped
|
||
|
||
db:
|
||
image: postgres:16-alpine
|
||
environment:
|
||
POSTGRES_DB: ${POSTGRES_DB}
|
||
POSTGRES_USER: ${POSTGRES_USER}
|
||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
|
||
volumes:
|
||
- pg_data:/var/lib/postgresql/data
|
||
ports:
|
||
- "${POSTGRES_PORT:-5433}:5432"
|
||
restart: unless-stopped
|
||
|
||
volumes:
|
||
pg_data:
|
||
```
|
||
|
||
#### Configuration Apache VirtualHost
|
||
|
||
```apache
|
||
# /docker/php/config/vhost.conf
|
||
|
||
<VirtualHost *:80>
|
||
ServerName localhost
|
||
DocumentRoot /var/www/html/public
|
||
|
||
<Directory /var/www/html/public>
|
||
AllowOverride All
|
||
Require all granted
|
||
FallbackResource /index.php
|
||
</Directory>
|
||
|
||
# Logs
|
||
ErrorLog /var/log/apache2/error.log
|
||
CustomLog /var/log/apache2/access.log combined
|
||
</VirtualHost>
|
||
```
|
||
|
||
#### Script de Démarrage des 2 Backends
|
||
|
||
Créer `/docker/start-services.sh` :
|
||
|
||
```bash
|
||
#!/bin/bash
|
||
|
||
# Démarrer Apache (Symfony)
|
||
apache2-foreground &
|
||
|
||
# Installer dépendances NestJS si besoin
|
||
cd /var/www/html/Inventory_backend
|
||
if [ ! -d "node_modules" ]; then
|
||
npm install
|
||
fi
|
||
|
||
# Démarrer NestJS
|
||
npm run start:dev &
|
||
|
||
# Installer dépendances Nuxt si besoin
|
||
cd /var/www/html/Inventory_frontend
|
||
if [ ! -d "node_modules" ]; then
|
||
npm install
|
||
fi
|
||
|
||
# Démarrer Nuxt
|
||
npm run dev &
|
||
|
||
# Garder le container actif
|
||
wait -n
|
||
```
|
||
|
||
Modifier `Dockerfile` pour utiliser ce script :
|
||
|
||
```dockerfile
|
||
# À la fin du Dockerfile
|
||
COPY start-services.sh /usr/local/bin/
|
||
RUN chmod +x /usr/local/bin/start-services.sh
|
||
|
||
CMD ["start-services.sh"]
|
||
```
|
||
|
||
### 5.2 Variables d'Environnement
|
||
|
||
Créer `/docker/.env.docker.local` (déjà existant, à compléter) :
|
||
|
||
```env
|
||
# Existant
|
||
DOCKER_APP_NAME=inventory
|
||
DOCKER_PHP_VERSION=8.4.6
|
||
DOCKER_NODE_VERSION=24.12.0
|
||
CURRENT_UID=1000
|
||
CURRENT_GID=1000
|
||
POSTGRES_DB=inventory_db
|
||
POSTGRES_USER=postgres
|
||
POSTGRES_PASSWORD=postgres
|
||
POSTGRES_PORT=5433
|
||
|
||
# Nouveau : Symfony
|
||
APP_ENV=dev
|
||
APP_SECRET=changeme_super_secret_key_123456789
|
||
JWT_SECRET_KEY=%kernel.project_dir%/config/jwt/private.pem
|
||
JWT_PUBLIC_KEY=%kernel.project_dir%/config/jwt/public.pem
|
||
JWT_PASSPHRASE=your_jwt_passphrase
|
||
|
||
# Nouveau : NestJS
|
||
NESTJS_PORT=3000
|
||
SESSION_SECRET=changeme_session_secret
|
||
CORS_ORIGIN=http://localhost:3001
|
||
```
|
||
|
||
### 5.3 Génération des Clés JWT
|
||
|
||
Ajouter au script de démarrage :
|
||
|
||
```bash
|
||
# Générer clés JWT si inexistantes
|
||
mkdir -p /var/www/html/config/jwt
|
||
if [ ! -f /var/www/html/config/jwt/private.pem ]; then
|
||
openssl genpkey -out /var/www/html/config/jwt/private.pem -aes256 -algorithm rsa -pkeyopt rsa_keybits:4096 -pass pass:${JWT_PASSPHRASE}
|
||
openssl pkey -in /var/www/html/config/jwt/private.pem -passin pass:${JWT_PASSPHRASE} -out /var/www/html/config/jwt/public.pem -pubout
|
||
chmod 600 /var/www/html/config/jwt/*.pem
|
||
fi
|
||
```
|
||
|
||
---
|
||
|
||
## 6. Plan d'Exécution Phase par Phase
|
||
|
||
### Phase 1 : Préparation (Semaine 1)
|
||
|
||
#### Tâches
|
||
1. **Installer bundles Symfony** :
|
||
```bash
|
||
composer require lexik/jwt-authentication-bundle
|
||
composer require vich/uploader-bundle
|
||
composer require symfony/uid
|
||
```
|
||
|
||
2. **Configurer JWT** :
|
||
- Générer clés RSA
|
||
- Configurer `lexik_jwt_authentication.yaml`
|
||
- Configurer `security.yaml`
|
||
|
||
3. **Créer entité Profile enrichie** :
|
||
```php
|
||
class Profile implements UserInterface
|
||
{
|
||
// Ajouter email, password, roles
|
||
}
|
||
```
|
||
|
||
4. **Analyser schéma Prisma** :
|
||
- Documenter toutes les relations
|
||
- Identifier les champs JSON complexes
|
||
- Lister les contraintes de validation
|
||
|
||
5. **Setup Docker** :
|
||
- Modifier `docker-compose.yml`
|
||
- Créer script de démarrage multi-services
|
||
- Tester les 2 backends en parallèle
|
||
|
||
#### Livrables
|
||
- [ ] Symfony configuré avec tous les bundles
|
||
- [ ] JWT fonctionnel avec endpoint `/api/login_check`
|
||
- [ ] Docker lance NestJS (3000) + Symfony (8081) + Nuxt (3001)
|
||
- [ ] Documentation schéma Prisma complète
|
||
|
||
---
|
||
|
||
### Phase 2 : Création des Entités (Semaine 2-3)
|
||
|
||
#### Tâches
|
||
1. **Créer toutes les entités Doctrine** (16 entités) :
|
||
- Utiliser les attributs PHP 8 (`#[ORM\Entity]`)
|
||
- Mapper exactement le schéma Prisma
|
||
- Ajouter annotations API Platform
|
||
- Implémenter les lifecycle callbacks (`#[ORM\PrePersist]`, etc.)
|
||
|
||
2. **Générer repositories** :
|
||
```bash
|
||
php bin/console make:entity --regenerate
|
||
```
|
||
|
||
3. **Créer migration Doctrine** :
|
||
```bash
|
||
php bin/console doctrine:migrations:diff
|
||
```
|
||
|
||
4. **Analyser SQL généré** :
|
||
- Comparer avec schéma Prisma actuel
|
||
- Identifier les différences
|
||
- Préparer script d'ajustement si besoin
|
||
|
||
5. **Tester sur DB vide** :
|
||
```bash
|
||
# Créer DB test
|
||
createdb inventory_test
|
||
# Appliquer migrations
|
||
php bin/console doctrine:migrations:migrate --env=test
|
||
# Valider schéma
|
||
php bin/console doctrine:schema:validate
|
||
```
|
||
|
||
#### Livrables
|
||
- [ ] 16 entités Doctrine complètes avec relations
|
||
- [ ] Migration Doctrine générée et validée
|
||
- [ ] Tests sur DB vide réussis
|
||
- [ ] Documentation des différences Prisma/Doctrine
|
||
|
||
---
|
||
|
||
### Phase 3 : Migration de la Base de Données (Semaine 4)
|
||
|
||
#### Tâches
|
||
1. **Backup complet** :
|
||
```bash
|
||
pg_dump -U postgres -h localhost -p 5433 inventory_db > backup_avant_migration.sql
|
||
```
|
||
|
||
2. **Créer script de validation** :
|
||
```php
|
||
// scripts/validate-schema.php
|
||
// Comparer schéma Prisma vs Doctrine
|
||
```
|
||
|
||
3. **Exécuter migration Doctrine** :
|
||
```bash
|
||
php bin/console doctrine:migrations:migrate --no-interaction
|
||
```
|
||
|
||
4. **Valider données migrées** :
|
||
- Compter les lignes par table (Prisma count vs Doctrine count)
|
||
- Vérifier intégrité référentielle
|
||
- Tester quelques requêtes
|
||
|
||
5. **Tests de régression** :
|
||
- Lire toutes les entités via Doctrine
|
||
- Vérifier les relations
|
||
- Tester les champs JSON
|
||
|
||
#### Livrables
|
||
- [ ] Base de données migrée avec succès
|
||
- [ ] Backup de sécurité créé
|
||
- [ ] Script de validation OK (0 différences)
|
||
- [ ] Tests de lecture/écriture via Doctrine OK
|
||
|
||
---
|
||
|
||
### Phase 4 : Logique Métier (Semaine 5-6)
|
||
|
||
#### Tâches
|
||
1. **Migrer services NestJS → Symfony** :
|
||
|
||
**Mapping des services** :
|
||
|
||
| NestJS Service | Symfony Service | Responsabilités |
|
||
|----------------|-----------------|-----------------|
|
||
| `SitesService` | `SiteManager` | CRUD sites |
|
||
| `MachinesService` | `MachineManager` | CRUD machines, reconfiguration |
|
||
| `ComposantsService` | `ComposantManager` | CRUD composants |
|
||
| `PiecesService` | `PieceManager` | CRUD pieces |
|
||
| `ProductsService` | `ProductManager` | CRUD products |
|
||
| `TypesService` | `TypeMachineManager` | Gestion types machines |
|
||
| `ModelTypeService` | `ModelTypeManager` | Gestion model types |
|
||
| `DocumentsService` | `DocumentManager` | Upload/download documents |
|
||
| `CustomFieldsService` | `CustomFieldManager` | Gestion custom fields |
|
||
| `ConstructeursService` | `ConstructeurManager` | Gestion constructeurs |
|
||
| `ProfilesService` | `ProfileManager` | Gestion profiles |
|
||
| `SessionService` | Supprimé (JWT) | - |
|
||
|
||
2. **Implémenter upload de documents** :
|
||
- Configurer VichUploaderBundle
|
||
- Créer endpoint `POST /api/documents`
|
||
- Créer endpoint `GET /api/documents/{id}/download`
|
||
|
||
3. **Implémenter custom fields** :
|
||
- Service de gestion des définitions
|
||
- Service de gestion des valeurs
|
||
- Validation dynamique
|
||
|
||
4. **Créer State Processors API Platform** :
|
||
- Pour logique custom (ex: reconfiguration machine)
|
||
- Pour validation complexe
|
||
|
||
5. **Tests unitaires** :
|
||
- Tester chaque service
|
||
- Mocker les repositories
|
||
- Vérifier logique métier
|
||
|
||
#### Livrables
|
||
- [ ] Tous les services métier migrés
|
||
- [ ] Upload/download documents fonctionnel
|
||
- [ ] Custom fields opérationnels
|
||
- [ ] Tests unitaires couvrant 80%+ du code
|
||
|
||
---
|
||
|
||
### Phase 5 : API Platform (Semaine 7)
|
||
|
||
#### Tâches
|
||
1. **Configurer les endpoints API Platform** :
|
||
- Vérifier routes auto-générées
|
||
- Customiser opérations si besoin
|
||
- Ajouter filtres de recherche
|
||
- Configurer pagination
|
||
|
||
2. **Sérialisation** :
|
||
- Créer groupes de normalisation
|
||
- Gérer relations circulaires
|
||
- Optimiser avec `@Groups`
|
||
|
||
3. **Validation** :
|
||
- Ajouter contraintes de validation
|
||
- Créer validators custom
|
||
- Gérer messages d'erreur
|
||
|
||
4. **Documentation API** :
|
||
- Générer OpenAPI spec
|
||
- Tester via Swagger UI
|
||
- Documenter endpoints custom
|
||
|
||
5. **Tests d'intégration** :
|
||
- Tester tous les endpoints CRUD
|
||
- Vérifier codes de réponse HTTP
|
||
- Valider structure JSON
|
||
|
||
#### Livrables
|
||
- [ ] Tous les endpoints API fonctionnels
|
||
- [ ] Documentation OpenAPI complète
|
||
- [ ] Tests d'intégration OK
|
||
- [ ] Swagger UI accessible sur `/api/docs`
|
||
|
||
---
|
||
|
||
### Phase 6 : Adaptation Frontend (Semaine 8)
|
||
|
||
#### Tâches
|
||
1. **Modifier `useApi.js`** :
|
||
```js
|
||
// Ancien
|
||
const baseURL = 'http://localhost:3000';
|
||
|
||
// Nouveau
|
||
const baseURL = import.meta.env.VITE_API_URL || 'http://localhost:8081/api';
|
||
```
|
||
|
||
2. **Implémenter gestion JWT** :
|
||
```js
|
||
// composables/useAuth.js
|
||
export const useAuth = () => {
|
||
const token = ref(localStorage.getItem('jwt_token'));
|
||
|
||
const login = async (username, password) => {
|
||
const response = await fetch('/api/login_check', {
|
||
method: 'POST',
|
||
body: JSON.stringify({ username, password })
|
||
});
|
||
const { token } = await response.json();
|
||
localStorage.setItem('jwt_token', token);
|
||
token.value = token;
|
||
};
|
||
|
||
const logout = () => {
|
||
localStorage.removeItem('jwt_token');
|
||
token.value = null;
|
||
};
|
||
|
||
return { token, login, logout };
|
||
};
|
||
```
|
||
|
||
3. **Adapter les composables** :
|
||
- `useSites.js` → vérifier format réponse
|
||
- `useMachines.js` → idem
|
||
- Tous les autres composables
|
||
|
||
4. **Gestion des changements d'API** :
|
||
- Ajuster parsing des réponses JSON:API vs JSON simple
|
||
- Gérer les nouveaux formats d'erreur
|
||
- Adapter les IDs si changement
|
||
|
||
5. **Tests fonctionnels** :
|
||
- Tester chaque page du frontend
|
||
- Vérifier tous les flows utilisateur
|
||
- Tester upload/download documents
|
||
|
||
#### Livrables
|
||
- [ ] Frontend connecté au backend Symfony
|
||
- [ ] Authentification JWT fonctionnelle
|
||
- [ ] Tous les composables adaptés
|
||
- [ ] Tests fonctionnels réussis
|
||
|
||
---
|
||
|
||
### Phase 7 : Tests & Décommissionnement NestJS (Semaine 9)
|
||
|
||
#### Tâches
|
||
1. **Tests de charge** :
|
||
- Comparer performances NestJS vs Symfony
|
||
- Vérifier temps de réponse
|
||
- Tester avec données réelles
|
||
|
||
2. **Tests de régression complète** :
|
||
- Rejouer tous les scénarios utilisateur
|
||
- Comparer résultats NestJS vs Symfony
|
||
- Fixer les bugs
|
||
|
||
3. **Documentation** :
|
||
- Documenter nouvelle architecture
|
||
- Créer guide migration pour équipe
|
||
- Documenter différences API
|
||
|
||
4. **Décommissionner NestJS** :
|
||
- Arrêter le service NestJS
|
||
- Supprimer du docker-compose
|
||
- Archiver le code (ne pas supprimer)
|
||
|
||
5. **Cleanup** :
|
||
- Supprimer dépendances NestJS inutilisées
|
||
- Nettoyer fichiers de config
|
||
- Optimiser Docker
|
||
|
||
#### Livrables
|
||
- [ ] Tests de charge validés
|
||
- [ ] 0 bugs de régression
|
||
- [ ] Documentation complète
|
||
- [ ] NestJS arrêté, Symfony en production
|
||
- [ ] Code NestJS archivé
|
||
|
||
---
|
||
|
||
## 7. Gestion des Risques
|
||
|
||
### 7.1 Risques Techniques
|
||
|
||
| Risque | Probabilité | Impact | Mitigation |
|
||
|--------|-------------|--------|------------|
|
||
| **Perte de données pendant migration DB** | Faible | Critique | Backup complet avant migration, script de rollback, validation post-migration |
|
||
| **Incompatibilité schéma Prisma/Doctrine** | Moyenne | Élevé | Validation schema dry-run, tests sur DB copie, garder noms de colonnes Prisma |
|
||
| **Performances Symfony < NestJS** | Faible | Moyen | Benchmarks, optimisation requêtes Doctrine, cache API Platform |
|
||
| **Bugs lors migration logique métier** | Moyenne | Élevé | Tests unitaires + intégration, comparison NestJS/Symfony side-by-side |
|
||
| **JWT incompatible avec frontend** | Faible | Moyen | Tests d'auth dès Phase 1, documentation claire |
|
||
| **Upload documents ne fonctionne pas** | Faible | Moyen | Tester VichUploader tôt, fallback manuel si besoin |
|
||
| **Relations Doctrine mal configurées** | Moyenne | Élevé | Tests avec données réelles, validation via `doctrine:schema:validate` |
|
||
|
||
### 7.2 Risques Projet
|
||
|
||
| Risque | Probabilité | Impact | Mitigation |
|
||
|--------|-------------|--------|------------|
|
||
| **Timeline trop optimiste** | Élevée | Moyen | Buffer de 2 semaines, découpage en phases indépendantes |
|
||
| **Manque de tests** | Moyenne | Élevé | Écrire tests dès Phase 2, coverage > 80% |
|
||
| **Documentation insuffisante** | Moyenne | Moyen | Documenter au fur et à mesure, pas à la fin |
|
||
| **Réversion nécessaire** | Faible | Critique | Garder NestJS actif en parallèle, backup DB, script de rollback |
|
||
|
||
### 7.3 Plan de Rollback
|
||
|
||
Si problème critique :
|
||
|
||
1. **Arrêter Symfony** :
|
||
```bash
|
||
docker-compose stop web
|
||
```
|
||
|
||
2. **Restaurer DB depuis backup** :
|
||
```bash
|
||
psql -U postgres -h localhost -p 5433 inventory_db < backup_avant_migration.sql
|
||
```
|
||
|
||
3. **Redémarrer NestJS** :
|
||
```bash
|
||
cd Inventory_backend && npm run start:dev
|
||
```
|
||
|
||
4. **Reconfigurer frontend** :
|
||
```js
|
||
// Revert API URL
|
||
const baseURL = 'http://localhost:3000';
|
||
```
|
||
|
||
5. **Analyser l'erreur** :
|
||
- Lire logs Symfony (`var/log/dev.log`)
|
||
- Lire logs PostgreSQL
|
||
- Identifier root cause
|
||
|
||
6. **Fix et retry** :
|
||
- Corriger le problème
|
||
- Retester en local
|
||
- Relancer migration
|
||
|
||
---
|
||
|
||
## 8. Checklist de Migration
|
||
|
||
### Avant de Commencer
|
||
- [ ] Lire entièrement ce document
|
||
- [ ] Comprendre schéma Prisma actuel
|
||
- [ ] Valider que Docker fonctionne
|
||
- [ ] Créer backup DB initial
|
||
- [ ] Setup environnement de dev local
|
||
|
||
### Phase 1 : Préparation
|
||
- [ ] Installer bundles Symfony (JWT, VichUploader, Uid)
|
||
- [ ] Configurer JWT avec clés RSA
|
||
- [ ] Enrichir entité Profile (email, password, roles)
|
||
- [ ] Modifier docker-compose.yml pour 2 backends
|
||
- [ ] Tester démarrage des 2 backends en parallèle
|
||
- [ ] Documenter schéma Prisma
|
||
|
||
### Phase 2 : Entités
|
||
- [ ] Créer 16 entités Doctrine
|
||
- [ ] Ajouter annotations API Platform
|
||
- [ ] Générer migration Doctrine
|
||
- [ ] Analyser SQL généré
|
||
- [ ] Tester migration sur DB vide
|
||
- [ ] Valider schéma Doctrine
|
||
|
||
### Phase 3 : Migration DB
|
||
- [ ] Créer backup DB production
|
||
- [ ] Créer script de validation
|
||
- [ ] Exécuter migration Doctrine
|
||
- [ ] Appliquer migrations post-migration (ajouts colonnes, types JSON)
|
||
- [ ] Valider count de lignes par table
|
||
- [ ] Tester requêtes Doctrine
|
||
- [ ] Vérifier intégrité référentielle
|
||
|
||
### Phase 4 : Services
|
||
- [ ] Migrer les 11 services métier
|
||
- [ ] Implémenter upload documents
|
||
- [ ] Implémenter custom fields
|
||
- [ ] Écrire tests unitaires
|
||
- [ ] Valider logique métier
|
||
|
||
### Phase 5 : API
|
||
- [ ] Configurer endpoints API Platform
|
||
- [ ] Implémenter sérialisation
|
||
- [ ] Ajouter validation
|
||
- [ ] Générer doc OpenAPI
|
||
- [ ] Tests d'intégration
|
||
|
||
### Phase 6 : Frontend
|
||
- [ ] Modifier useApi.js (nouveau baseURL)
|
||
- [ ] Implémenter gestion JWT
|
||
- [ ] Adapter tous les composables
|
||
- [ ] Tester toutes les pages
|
||
- [ ] Valider flows utilisateur
|
||
|
||
### Phase 7 : Finalisation
|
||
- [ ] Tests de charge
|
||
- [ ] Tests de régression complète
|
||
- [ ] Documenter nouvelle architecture
|
||
- [ ] Arrêter NestJS
|
||
- [ ] Archiver code NestJS
|
||
- [ ] Cleanup Docker
|
||
|
||
---
|
||
|
||
## Annexes
|
||
|
||
### A. Commandes Utiles
|
||
|
||
```bash
|
||
# Symfony
|
||
php bin/console doctrine:schema:validate
|
||
php bin/console doctrine:migrations:diff
|
||
php bin/console doctrine:migrations:migrate
|
||
php bin/console doctrine:query:sql "SELECT COUNT(*) FROM sites"
|
||
php bin/console debug:router
|
||
php bin/console cache:clear
|
||
|
||
# Docker
|
||
docker-compose up -d --build
|
||
docker-compose logs -f web
|
||
docker-compose exec web bash
|
||
docker-compose down
|
||
|
||
# Base de données
|
||
pg_dump -U postgres -h localhost -p 5433 inventory_db > backup.sql
|
||
psql -U postgres -h localhost -p 5433 inventory_db < backup.sql
|
||
psql -U postgres -h localhost -p 5433 inventory_db -c "SELECT COUNT(*) FROM sites"
|
||
|
||
# Tests
|
||
php bin/phpunit
|
||
php vendor/bin/phpstan analyse src
|
||
```
|
||
|
||
### B. Structure Finale du Projet
|
||
|
||
```
|
||
/home/r-dev/Inventory/
|
||
├── Inventory_backend/ # À archiver après migration
|
||
├── Inventory_frontend/ # Frontend Nuxt (à garder)
|
||
│ ├── app/
|
||
│ │ ├── composables/
|
||
│ │ │ ├── useApi.js # Modifier baseURL
|
||
│ │ │ ├── useAuth.js # Nouveau : JWT
|
||
│ │ │ └── ...
|
||
│ │ └── pages/
|
||
├── src/ # Backend Symfony (nouveau)
|
||
│ ├── Entity/
|
||
│ │ ├── Site.php
|
||
│ │ ├── Machine.php
|
||
│ │ └── ... (16 entités)
|
||
│ ├── Repository/
|
||
│ ├── Service/
|
||
│ │ ├── SiteManager.php
|
||
│ │ ├── MachineManager.php
|
||
│ │ └── ... (11 services)
|
||
│ ├── Controller/ # Si besoin de custom controllers
|
||
│ └── State/ # State providers API Platform
|
||
├── config/
|
||
│ ├── packages/
|
||
│ │ ├── doctrine.yaml
|
||
│ │ ├── api_platform.yaml
|
||
│ │ ├── lexik_jwt_authentication.yaml
|
||
│ │ ├── security.yaml
|
||
│ │ └── nelmio_cors.yaml
|
||
│ └── jwt/
|
||
│ ├── private.pem
|
||
│ └── public.pem
|
||
├── migrations/ # Migrations Doctrine
|
||
├── docker/
|
||
│ ├── php/
|
||
│ │ ├── Dockerfile
|
||
│ │ └── config/
|
||
│ ├── start-services.sh # Nouveau : lance Symfony + Nuxt
|
||
│ ├── .env.docker
|
||
│ └── .env.docker.local
|
||
├── docker-compose.yml # Modifié : 2 backends
|
||
├── composer.json # Symfony dependencies
|
||
└── MIGRATION_PLAN.md # Ce document
|
||
```
|
||
|
||
### C. Ressources
|
||
|
||
- [API Platform Docs](https://api-platform.com/docs/)
|
||
- [Doctrine ORM Docs](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/)
|
||
- [Lexik JWT Bundle](https://github.com/lexik/LexikJWTAuthenticationBundle/blob/2.x/Resources/doc/index.rst)
|
||
- [Symfony Best Practices](https://symfony.com/doc/current/best_practices.html)
|
||
- [Prisma to Doctrine Migration Guide](https://symfony.com/doc/current/doctrine.html#creating-an-entity-class)
|
||
|
||
---
|
||
|
||
## Conclusion
|
||
|
||
Ce plan de migration détaille la stratégie pour passer de NestJS/Prisma à Symfony/API Platform de manière progressive et sécurisée. Les points clés :
|
||
|
||
1. **Migration incrémentale** : Garder NestJS actif en parallèle
|
||
2. **Sécurité des données** : Backups, validation, rollback
|
||
3. **Modernisation** : JWT auth, API Platform, documentation OpenAPI
|
||
4. **Minimiser les risques** : Tests à chaque phase, validation continue
|
||
|
||
**Durée estimée** : 9 semaines (avec buffer)
|
||
**Effort requis** : 1 développeur full-time
|
||
|
||
**Prêt à démarrer ?** Validation de ce plan avant de commencer la Phase 1.
|