David/xpeditis2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first clean

Browse Source
This commit is contained in:
David 2026-05-13 17:18:37 +02:00
parent 3d65693395
commit ad761372f5
75 changed files with 217 additions and 11125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

466
COMPLETION-REPORT.md
View File

@ -1,466 +0,0 @@
# ✅ Sprint 0 - Rapport de Complétion Final
## Xpeditis MVP - Project Setup & Infrastructure
**Date de Complétion** : 7 octobre 2025
**Statut** : ✅ **100% TERMINÉ**
**Durée** : 2 semaines (comme planifié)
---
## 📊 Résumé Exécutif
Sprint 0 a été **complété avec succès à 100%**. Tous les objectifs ont été atteints et le projet Xpeditis MVP est **prêt pour la Phase 1 de développement**.
### Statistiques
| Métrique | Valeur |
|----------|--------|
| **Fichiers Créés** | 60+ fichiers |
| **Documentation** | 14 fichiers Markdown (5000+ lignes) |
| **Code/Config** | 27 fichiers TypeScript/JavaScript/JSON/YAML |
| **Dépendances** | 80+ packages npm |
| **Lignes de Code** | 2000+ lignes |
| **Temps Total** | ~16 heures de travail |
| **Complétion** | 100% ✅ |
---
## 📦 Livrables Créés
### 1. Documentation (14 fichiers)
| Fichier | Lignes | Purpose | Statut |
|---------|--------|---------|--------|
| **START-HERE.md** | 350+ | 🟢 Point d'entrée principal | ✅ |
| README.md | 200+ | Vue d'ensemble du projet | ✅ |
| CLAUDE.md | 650+ | Guide d'architecture hexagonale complet | ✅ |
| PRD.md | 350+ | Exigences produit détaillées | ✅ |
| TODO.md | 1300+ | Roadmap 30 semaines complet | ✅ |
| QUICK-START.md | 250+ | Guide de démarrage rapide | ✅ |
| INSTALLATION-STEPS.md | 400+ | Guide d'installation détaillé | ✅ |
| WINDOWS-INSTALLATION.md | 350+ | Installation spécifique Windows | ✅ |
| NEXT-STEPS.md | 550+ | Prochaines étapes détaillées | ✅ |
| SPRINT-0-FINAL.md | 550+ | Rapport complet Sprint 0 | ✅ |
| SPRINT-0-SUMMARY.md | 500+ | Résumé exécutif | ✅ |
| INDEX.md | 450+ | Index de toute la documentation | ✅ |
| READY.md | 400+ | Confirmation de préparation | ✅ |
| COMPLETION-REPORT.md | Ce fichier | Rapport final de complétion | ✅ |
**Sous-total** : 14 fichiers, ~5000 lignes de documentation
### 2. Backend (NestJS + Architecture Hexagonale)
| Catégorie | Fichiers | Statut |
|-----------|----------|--------|
| **Configuration** | 7 fichiers | ✅ |
| **Code Source** | 6 fichiers | ✅ |
| **Tests** | 2 fichiers | ✅ |
| **Documentation** | 1 fichier (README.md) | ✅ |
**Fichiers Backend** :
- ✅ package.json (50+ dépendances)
- ✅ tsconfig.json (strict mode + path aliases)
- ✅ nest-cli.json
- ✅ .eslintrc.js
- ✅ .env.example (toutes les variables)
- ✅ .gitignore
- ✅ src/main.ts (bootstrap complet)
- ✅ src/app.module.ts (module racine)
- ✅ src/application/controllers/health.controller.ts
- ✅ src/application/controllers/index.ts
- ✅ src/domain/entities/index.ts
- ✅ src/domain/ports/in/index.ts
- ✅ src/domain/ports/out/index.ts
- ✅ test/app.e2e-spec.ts
- ✅ test/jest-e2e.json
- ✅ README.md (guide backend)
**Structure Hexagonale** :
```
src/
├── domain/ ✅ Logique métier pure
│ ├── entities/
│ ├── value-objects/
│ ├── services/
│ ├── ports/in/
│ ├── ports/out/
│ └── exceptions/
├── application/ ✅ Controllers & DTOs
│ ├── controllers/
│ ├── dto/
│ ├── mappers/
│ └── config/
└── infrastructure/ ✅ Adaptateurs externes
├── persistence/
├── cache/
├── carriers/
├── email/
├── storage/
└── config/
```
**Sous-total** : 16 fichiers backend
### 3. Frontend (Next.js 14 + TypeScript)
| Catégorie | Fichiers | Statut |
|-----------|----------|--------|
| **Configuration** | 7 fichiers | ✅ |
| **Code Source** | 4 fichiers | ✅ |
| **Documentation** | 1 fichier (README.md) | ✅ |
**Fichiers Frontend** :
- ✅ package.json (30+ dépendances)
- ✅ tsconfig.json (path aliases)
- ✅ next.config.js
- ✅ tailwind.config.ts (thème complet)
- ✅ postcss.config.js
- ✅ .eslintrc.json
- ✅ .env.example
- ✅ .gitignore
- ✅ app/layout.tsx (layout racine)
- ✅ app/page.tsx (page d'accueil)
- ✅ app/globals.css (Tailwind + variables CSS)
- ✅ lib/utils.ts (helper cn)
- ✅ README.md (guide frontend)
**Sous-total** : 13 fichiers frontend
### 4. Infrastructure & DevOps
| Catégorie | Fichiers | Statut |
|-----------|----------|--------|
| **Docker** | 2 fichiers | ✅ |
| **CI/CD** | 3 fichiers | ✅ |
| **Configuration Racine** | 4 fichiers | ✅ |
**Fichiers Infrastructure** :
- ✅ docker-compose.yml (PostgreSQL + Redis)
- ✅ infra/postgres/init.sql (script d'initialisation)
- ✅ .github/workflows/ci.yml (pipeline CI)
- ✅ .github/workflows/security.yml (audit sécurité)
- ✅ .github/pull_request_template.md
- ✅ package.json (racine, scripts simplifiés)
- ✅ .gitignore (racine)
- ✅ .prettierrc
- ✅ .prettierignore
**Sous-total** : 9 fichiers infrastructure
---
## 🎯 Objectifs Sprint 0 - Tous Atteints
| Objectif | Statut | Notes |
|----------|--------|-------|
| **Structure Monorepo** | ✅ Complete | npm scripts sans workspaces (Windows) |
| **Backend Hexagonal** | ✅ Complete | Domain/Application/Infrastructure |
| **Frontend Next.js 14** | ✅ Complete | App Router + TypeScript |
| **Docker Infrastructure** | ✅ Complete | PostgreSQL 15 + Redis 7 |
| **TypeScript Strict** | ✅ Complete | Tous les projets |
| **Testing Infrastructure** | ✅ Complete | Jest, Supertest, Playwright |
| **CI/CD Pipelines** | ✅ Complete | GitHub Actions |
| **API Documentation** | ✅ Complete | Swagger à /api/docs |
| **Logging Structuré** | ✅ Complete | Pino avec pretty-print |
| **Sécurité** | ✅ Complete | Helmet, JWT, CORS, validation |
| **Validation Env** | ✅ Complete | Joi schema |
| **Health Endpoints** | ✅ Complete | /health, /ready, /live |
| **Documentation** | ✅ Complete | 14 fichiers, 5000+ lignes |
**Score** : 13/13 objectifs atteints (100%)
---
## 🏗️ Architecture Implémentée
### Backend - Architecture Hexagonale
**✅ Strict Separation of Concerns** :
1. **Domain Layer (Core)** :
- ✅ Zero external dependencies
- ✅ Pure TypeScript classes
- ✅ Ports (interfaces) defined
- ✅ Testable without framework
- 🎯 Target: 90%+ test coverage
2. **Application Layer** :
- ✅ Controllers with validation
- ✅ DTOs defined
- ✅ Mappers ready
- ✅ Depends only on domain
- 🎯 Target: 80%+ test coverage
3. **Infrastructure Layer** :
- ✅ TypeORM configured
- ✅ Redis configured
- ✅ Folder structure ready
- ✅ Depends only on domain
- 🎯 Target: 70%+ test coverage
### Frontend - Modern React Stack
**✅ Next.js 14 Configuration** :
- ✅ App Router avec Server Components
- ✅ TypeScript strict mode
- ✅ Tailwind CSS + shadcn/ui ready
- ✅ TanStack Query configured
- ✅ react-hook-form + zod ready
- ✅ Dark mode support (CSS variables)
---
## 🛠️ Stack Technique Complet
### Backend
- **Framework** : NestJS 10.2.10 ✅
- **Language** : TypeScript 5.3.3 ✅
- **Database** : PostgreSQL 15 ✅
- **Cache** : Redis 7 ✅
- **ORM** : TypeORM 0.3.17 ✅
- **Auth** : JWT + Passport ✅
- **Validation** : class-validator + class-transformer ✅
- **API Docs** : Swagger/OpenAPI ✅
- **Logging** : Pino 8.17.1 ✅
- **Testing** : Jest 29.7.0 + Supertest 6.3.3 ✅
- **Security** : Helmet 7.1.0, bcrypt 5.1.1 ✅
- **Circuit Breaker** : opossum 8.1.3 ✅
### Frontend
- **Framework** : Next.js 14.0.4 ✅
- **Language** : TypeScript 5.3.3 ✅
- **Styling** : Tailwind CSS 3.3.6 ✅
- **UI Components** : Radix UI ✅
- **State** : TanStack Query 5.14.2 ✅
- **Forms** : react-hook-form 7.49.2 ✅
- **Validation** : zod 3.22.4 ✅
- **HTTP** : axios 1.6.2 ✅
- **Icons** : lucide-react 0.294.0 ✅
- **Testing** : Jest 29.7.0 + Playwright 1.40.1 ✅
### Infrastructure
- **Database** : PostgreSQL 15-alpine (Docker) ✅
- **Cache** : Redis 7-alpine (Docker) ✅
- **CI/CD** : GitHub Actions ✅
- **Version Control** : Git ✅
---
## 📋 Features Implémentées
### Backend Features
1. **✅ Health Check System**
- `/health` - Overall system health
- `/ready` - Readiness for traffic
- `/live` - Liveness check
2. **✅ Logging System**
- Structured JSON logs (Pino)
- Pretty print en développement
- Request/response logging
- Log levels configurables
3. **✅ Configuration Management**
- Validation des variables d'environnement (Joi)
- Configuration type-safe
- Support multi-environnements
4. **✅ Security Foundations**
- Helmet.js security headers
- CORS configuration
- Rate limiting preparé
- JWT authentication ready
- Password hashing (bcrypt)
- Input validation (class-validator)
5. **✅ API Documentation**
- Swagger UI à `/api/docs`
- Spécification OpenAPI
- Schémas request/response
- Documentation d'authentification
6. **✅ Testing Infrastructure**
- Jest configuré
- Supertest configuré
- E2E tests ready
- Path aliases for tests
### Frontend Features
1. **✅ Modern React Setup**
- Next.js 14 App Router
- Server et client components
- TypeScript strict mode
- Path aliases configurés
2. **✅ UI Framework**
- Tailwind CSS avec thème personnalisé
- shadcn/ui components ready
- Dark mode support (variables CSS)
- Responsive design utilities
3. **✅ State Management**
- TanStack Query configuré
- React hooks ready
- Form state avec react-hook-form
4. **✅ Utilities**
- Helper `cn()` pour className merging
- API client type-safe ready
- Validation Zod ready
---
## 🚀 Prêt pour Phase 1
### Checklist de Préparation
- [x] Code et configuration complets
- [x] Documentation exhaustive
- [x] Architecture hexagonale validée
- [x] Testing infrastructure prête
- [x] CI/CD pipelines configurés
- [x] Docker infrastructure opérationnelle
- [x] Sécurité de base implémentée
- [x] Guide de démarrage créé
- [x] Tous les objectifs Sprint 0 atteints
### Prochaine Phase : Phase 1 (6-8 semaines)
**Sprint 1-2** : Domain Layer (Semaines 1-2)
- Créer les entités métier
- Créer les value objects
- Définir les ports API et SPI
- Implémenter les services métier
- Tests unitaires (90%+)
**Sprint 3-4** : Infrastructure Layer (Semaines 3-4)
- Schéma de base de données
- Repositories TypeORM
- Redis cache adapter
- Connecteur Maersk
**Sprint 5-6** : Application Layer (Semaines 5-6)
- API rate search
- Controllers & DTOs
- Documentation OpenAPI
- Tests E2E
**Sprint 7-8** : Frontend UI (Semaines 7-8)
- Interface de recherche
- Affichage des résultats
- Filtres et tri
- Tests frontend
---
## 📚 Documentation Organisée
### Guide de Navigation
**🟢 Pour Démarrer** (obligatoire) :
1. [START-HERE.md](START-HERE.md) - Point d'entrée principal
2. [QUICK-START.md](QUICK-START.md) - Démarrage rapide
3. [CLAUDE.md](CLAUDE.md) - Architecture (À LIRE ABSOLUMENT)
4. [NEXT-STEPS.md](NEXT-STEPS.md) - Quoi faire ensuite
**🟡 Pour Installation** :
- [INSTALLATION-STEPS.md](INSTALLATION-STEPS.md) - Détaillé
- [WINDOWS-INSTALLATION.md](WINDOWS-INSTALLATION.md) - Spécifique Windows
**🔵 Pour Développement** :
- [CLAUDE.md](CLAUDE.md) - Règles d'architecture
- [apps/backend/README.md](apps/backend/README.md) - Backend
- [apps/frontend/README.md](apps/frontend/README.md) - Frontend
- [TODO.md](TODO.md) - Roadmap détaillée
**🟠 Pour Référence** :
- [PRD.md](PRD.md) - Exigences produit
- [INDEX.md](INDEX.md) - Index complet
- [READY.md](READY.md) - Confirmation
- [SPRINT-0-FINAL.md](SPRINT-0-FINAL.md) - Rapport complet
- [SPRINT-0-SUMMARY.md](SPRINT-0-SUMMARY.md) - Résumé
---
## 💻 Installation et Démarrage
### Installation Rapide
```bash
# 1. Installer les dépendances
npm run install:all
# 2. Démarrer Docker
docker-compose up -d
# 3. Configurer l'environnement
cp apps/backend/.env.example apps/backend/.env
cp apps/frontend/.env.example apps/frontend/.env
# 4. Démarrer (2 terminals)
npm run backend:dev # Terminal 1
npm run frontend:dev # Terminal 2
```
### Vérification
- ✅ http://localhost:4000/api/v1/health
- ✅ http://localhost:4000/api/docs
- ✅ http://localhost:3000
---
## 🎊 Conclusion
### Succès Sprint 0
**Tout planifié a été livré** :
- ✅ 100% des objectifs atteints
- ✅ 60+ fichiers créés
- ✅ 5000+ lignes de documentation
- ✅ Architecture hexagonale complète
- ✅ Infrastructure production-ready
- ✅ CI/CD automatisé
- ✅ Sécurité de base
### État du Projet
**Sprint 0** : 🟢 **TERMINÉ** (100%)
**Qualité** : 🟢 **EXCELLENTE**
**Documentation** : 🟢 **COMPLÈTE**
**Prêt pour Phase 1** : 🟢 **OUI**
### Prochaine Étape
**Commencer Phase 1 - Core Search & Carrier Integration**
1. Lire [START-HERE.md](START-HERE.md)
2. Lire [CLAUDE.md](CLAUDE.md) (OBLIGATOIRE)
3. Lire [NEXT-STEPS.md](NEXT-STEPS.md)
4. Commencer Sprint 1-2 (Domain Layer)
---
## 🏆 Félicitations !
**Le projet Xpeditis MVP dispose maintenant d'une fondation solide et production-ready.**
Tous les éléments sont en place pour un développement réussi :
- Architecture propre et maintenable
- Documentation exhaustive
- Tests automatisés
- CI/CD configuré
- Sécurité intégrée
**Bonne chance pour la Phase 1 ! 🚀**
---
*Rapport de Complétion Sprint 0*
*Xpeditis MVP - Maritime Freight Booking Platform*
*7 octobre 2025*
**Statut Final** : ✅ **SPRINT 0 COMPLET À 100%**

334
INSTALLATION-COMPLETE.md
View File

@ -1,334 +0,0 @@
# ✅ Installation Complete - Xpeditis
Sprint 0 setup is now complete with all dependencies installed and verified!
---
## 📦 What Has Been Installed
### Backend Dependencies ✅
- **Location**: `apps/backend/node_modules`
- **Packages**: 873 packages (871 + nestjs-pino)
- **Key frameworks**:
- NestJS 10.2.10 (framework core)
- TypeORM 0.3.17 (database ORM)
- PostgreSQL driver (pg 8.11.3)
- Redis client (ioredis 5.3.2)
- nestjs-pino 8.x (structured logging)
- Passport + JWT (authentication)
- Helmet 7.1.0 (security)
- Swagger/OpenAPI (API documentation)
### Frontend Dependencies ✅
- **Location**: `apps/frontend/node_modules`
- **Packages**: 737 packages
- **Key frameworks**:
- Next.js 14.0.4 (React framework)
- React 18.2.0
- TanStack Query 5.14.2 (data fetching)
- Tailwind CSS 3.3.6 (styling)
- shadcn/ui (component library)
- react-hook-form + zod (forms & validation)
- Playwright (E2E testing)
### Environment Files ✅
- `apps/backend/.env` (created from .env.example)
- `apps/frontend/.env` (created from .env.example)
---
## ✅ Build Verification
### Backend Build: SUCCESS ✅
```bash
cd apps/backend
npm run build
# ✅ Compilation successful - 0 errors
```
The backend compiles successfully and can start in development mode. TypeScript compilation is working correctly with the hexagonal architecture setup.
### Frontend Build: KNOWN ISSUE ⚠️
```bash
cd apps/frontend
npm run build
# ⚠️ EISDIR error on Windows (symlink issue)
```
**Status**: This is a known Windows/Next.js symlink limitation.
**Workaround**: Use development mode for daily work:
```bash
npm run dev # Works perfectly ✅
```
For production builds, see [WINDOWS-INSTALLATION.md](WINDOWS-INSTALLATION.md#frontend-build-fail---eisdir-illegal-operation-on-directory-readlink).
---
## 🚀 Next Steps - Getting Started
### 1. Start Docker Infrastructure (Required)
The backend needs PostgreSQL and Redis running:
```bash
docker-compose up -d
```
**Expected output**:
```
✅ Container xpeditis-postgres Started
✅ Container xpeditis-redis Started
```
**Verify containers are running**:
```bash
docker ps
```
You should see:
- `xpeditis-postgres` on port 5432
- `xpeditis-redis` on port 6379
**Note**: Docker was not found during setup. Please install Docker Desktop for Windows:
- [Download Docker Desktop](https://www.docker.com/products/docker-desktop/)
### 2. Start Backend Development Server
```bash
cd apps/backend
npm run dev
```
**Expected output**:
```
[Nest] Starting Nest application...
[Nest] AppModule dependencies initialized
[Nest] Nest application successfully started
Application is running on: http://localhost:4000
```
**Verify backend is running**:
- Health check: <http://localhost:4000/api/v1/health>
- API docs: <http://localhost:4000/api/docs>
### 3. Start Frontend Development Server
In a new terminal:
```bash
cd apps/frontend
npm run dev
```
**Expected output**:
```
▲ Next.js 14.0.4
- Local: http://localhost:3000
- Ready in 2.5s
```
**Verify frontend is running**:
- Open <http://localhost:3000>
---
## 📋 Installation Checklist
- ✅ Node.js v22.20.0 installed
- ✅ npm 10.9.3 installed
- ✅ Backend dependencies installed (873 packages)
- ✅ Frontend dependencies installed (737 packages)
- ✅ Environment files created
- ✅ Backend builds successfully
- ✅ Frontend dev mode works
- ⚠️ Docker not yet installed (required for database)
- ⏳ Backend server not started (waiting for Docker)
- ⏳ Frontend server not started
---
## 🔍 Current Project Status
### Sprint 0: 100% COMPLETE ✅
All Sprint 0 deliverables are in place:
1. **Project Structure** ✅
- Monorepo layout with apps/ and packages/
- Backend with hexagonal architecture
- Frontend with Next.js 14 App Router
2. **Configuration Files** ✅
- TypeScript config with path aliases
- ESLint + Prettier
- Docker Compose
- Environment templates
3. **Documentation** ✅
- 14 comprehensive documentation files
- Architecture guidelines ([CLAUDE.md](CLAUDE.md))
- Installation guides
- Development roadmap ([TODO.md](TODO.md))
4. **Dependencies** ✅
- All npm packages installed
- Build verification complete
5. **CI/CD** ✅
- GitHub Actions workflows configured
- Test, build, and lint pipelines ready
### What's Missing (User Action Required)
1. **Docker Desktop** - Not yet installed
- Required for PostgreSQL and Redis
- Download: <https://www.docker.com/products/docker-desktop/>
2. **First Run** - Servers not started yet
- Waiting for Docker to be installed
- Then follow "Next Steps" above
---
## 🐛 Known Issues & Workarounds
### 1. Frontend Production Build (EISDIR Error)
**Issue**: `npm run build` fails with symlink error on Windows
**Workaround**: Use `npm run dev` for development (works perfectly)
**Full details**: [WINDOWS-INSTALLATION.md](WINDOWS-INSTALLATION.md#frontend-build-fail---eisdir-illegal-operation-on-directory-readlink)
### 2. npm Workspaces Disabled
**Issue**: npm workspaces don't work well on Windows
**Solution**: Dependencies installed separately in each app
**Scripts modified**: Root package.json uses `cd` commands instead of workspace commands
### 3. Docker Not Found
**Issue**: Docker command not available during setup
**Solution**: Install Docker Desktop, then start infrastructure:
```bash
docker-compose up -d
```
---
## 🎯 Ready to Code!
Once Docker is installed, you're ready to start development:
### Start Full Stack
**Terminal 1** - Infrastructure:
```bash
docker-compose up -d
```
**Terminal 2** - Backend:
```bash
cd apps/backend
npm run dev
```
**Terminal 3** - Frontend:
```bash
cd apps/frontend
npm run dev
```
### Verify Everything Works
- ✅ PostgreSQL: `docker exec -it xpeditis-postgres psql -U xpeditis -d xpeditis_dev`
- ✅ Redis: `docker exec -it xpeditis-redis redis-cli -a xpeditis_redis_password ping`
- ✅ Backend: <http://localhost:4000/api/v1/health>
- ✅ API Docs: <http://localhost:4000/api/docs>
- ✅ Frontend: <http://localhost:3000>
---
## 📚 Documentation Index
Quick links to all documentation:
- **[START-HERE.md](START-HERE.md)** - 10-minute quickstart guide
- **[CLAUDE.md](CLAUDE.md)** - Architecture guidelines for development
- **[TODO.md](TODO.md)** - Complete development roadmap (30 weeks)
- **[WINDOWS-INSTALLATION.md](WINDOWS-INSTALLATION.md)** - Windows-specific setup guide
- **[INDEX.md](INDEX.md)** - Complete documentation index
- **[NEXT-STEPS.md](NEXT-STEPS.md)** - What to do after installation
### Technical Documentation
- **Backend**: [apps/backend/README.md](apps/backend/README.md)
- **Frontend**: [apps/frontend/README.md](apps/frontend/README.md)
- **PRD**: [PRD.md](PRD.md) - Product requirements (French)
---
## 🎉 What's Next?
### Immediate (Today)
1. Install Docker Desktop
2. Start infrastructure: `docker-compose up -d`
3. Start backend: `cd apps/backend && npm run dev`
4. Start frontend: `cd apps/frontend && npm run dev`
5. Verify all endpoints work
### Phase 1 - Domain Layer (Next Sprint)
Start implementing the core business logic according to [TODO.md](TODO.md):
1. **Domain Entities** (Week 1-2)
- Organization, User, RateQuote, Booking, Container
- Value Objects (Email, BookingNumber, PortCode)
- Domain Services
2. **Repository Ports** (Week 2)
- Define interfaces for data persistence
- Cache port, Email port, Storage port
3. **Use Cases** (Week 2)
- SearchRates port
- CreateBooking port
- ManageUser port
See [NEXT-STEPS.md](NEXT-STEPS.md) for detailed Phase 1 tasks.
---
## 📞 Need Help?
If you encounter any issues:
1. **Check documentation**:
- [WINDOWS-INSTALLATION.md](WINDOWS-INSTALLATION.md) - Windows-specific issues
- [INSTALLATION-STEPS.md](INSTALLATION-STEPS.md) - Detailed setup steps
2. **Common issues**:
- Backend won't start → Check Docker containers running
- Frontend build fails → Use `npm run dev` instead
- EISDIR errors → See Windows installation guide
3. **Verify setup**:
```bash
node --version # Should be v20+
npm --version # Should be v10+
docker --version # Should be installed
```
---
**Installation Status**: ✅ Complete and Ready for Development
**Next Action**: Install Docker Desktop, then start infrastructure and servers
*Xpeditis - Maritime Freight Booking Platform*

464
INSTALLATION-STEPS.md
View File

@ -1,464 +0,0 @@
# 📦 Installation Steps - Xpeditis
Complete step-by-step installation guide for the Xpeditis platform.
---
## Current Status
✅ **Sprint 0 Complete** - All infrastructure files created
⏳ **Dependencies** - Need to be installed
⏳ **Services** - Need to be started
---
## Installation Instructions
### Step 1: Install Dependencies
The project uses npm workspaces. Run this command from the root directory:
```bash
npm install
```
**What this does**:
- Installs root dependencies (prettier, typescript)
- Installs backend dependencies (~50 packages including NestJS, TypeORM, Redis, etc.)
- Installs frontend dependencies (~30 packages including Next.js, React, Tailwind, etc.)
- Links workspace packages
**Expected Output**:
- This will take 2-3 minutes
- You may see deprecation warnings (these are normal)
- On Windows, you might see `EISDIR` symlink warnings (these can be ignored - dependencies are still installed)
**Verification**:
```bash
# Check that node_modules exists
ls node_modules
# Check backend dependencies
ls apps/backend/node_modules
# Check frontend dependencies
ls apps/frontend/node_modules
```
---
### Step 2: Start Docker Infrastructure
Start PostgreSQL and Redis:
```bash
docker-compose up -d
```
**What this does**:
- Pulls PostgreSQL 15 Alpine image (if not cached)
- Pulls Redis 7 Alpine image (if not cached)
- Starts PostgreSQL on port 5432
- Starts Redis on port 6379
- Runs database initialization script
- Creates persistent volumes
**Verification**:
```bash
# Check containers are running
docker-compose ps
# Expected output:
# NAME STATUS PORTS
# xpeditis-postgres Up (healthy) 0.0.0.0:5432->5432/tcp
# xpeditis-redis Up (healthy) 0.0.0.0:6379->6379/tcp
# Check logs
docker-compose logs
# Test PostgreSQL connection
docker-compose exec postgres psql -U xpeditis -d xpeditis_dev -c "SELECT version();"
# Test Redis connection
docker-compose exec redis redis-cli -a xpeditis_redis_password ping
# Should return: PONG
```
---
### Step 3: Setup Environment Variables
#### Backend
```bash
cp apps/backend/.env.example apps/backend/.env
```
**Default values work for local development!** You can start immediately.
**Optional customization** (edit `apps/backend/.env`):
```env
# These work out of the box:
DATABASE_HOST=localhost
DATABASE_PORT=5432
DATABASE_USER=xpeditis
DATABASE_PASSWORD=xpeditis_dev_password
DATABASE_NAME=xpeditis_dev
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=xpeditis_redis_password
JWT_SECRET=your-super-secret-jwt-key-change-this-in-production
# Add these later when you have credentials:
# MAERSK_API_KEY=your-key
# GOOGLE_CLIENT_ID=your-client-id
# etc.
```
#### Frontend
```bash
cp apps/frontend/.env.example apps/frontend/.env
```
**Default values**:
```env
NEXT_PUBLIC_API_URL=http://localhost:4000
NEXT_PUBLIC_API_PREFIX=api/v1
```
---
### Step 4: Start Backend Development Server
```bash
# Option 1: From root
npm run backend:dev
# Option 2: From backend directory
cd apps/backend
npm run dev
```
**What happens**:
- NestJS compiles TypeScript
- Connects to PostgreSQL
- Connects to Redis
- Starts server on port 4000
- Watches for file changes (hot reload)
**Expected output**:
```
[Nest] 12345 - 10/07/2025, 3:00:00 PM LOG [NestFactory] Starting Nest application...
[Nest] 12345 - 10/07/2025, 3:00:00 PM LOG [InstanceLoader] ConfigModule dependencies initialized
[Nest] 12345 - 10/07/2025, 3:00:00 PM LOG [InstanceLoader] TypeOrmModule dependencies initialized
...
╔═══════════════════════════════════════╗
║ ║
║ 🚢 Xpeditis API Server Running ║
║ ║
║ API: http://localhost:4000/api/v1 ║
║ Docs: http://localhost:4000/api/docs ║
║ ║
╚═══════════════════════════════════════╝
```
**Verification**:
```bash
# Test health endpoint
curl http://localhost:4000/api/v1/health
# Or open in browser:
# http://localhost:4000/api/v1/health
# Open Swagger docs:
# http://localhost:4000/api/docs
```
---
### Step 5: Start Frontend Development Server
In a **new terminal**:
```bash
# Option 1: From root
npm run frontend:dev
# Option 2: From frontend directory
cd apps/frontend
npm run dev
```
**What happens**:
- Next.js compiles TypeScript
- Starts dev server on port 3000
- Watches for file changes (hot reload)
- Enables Fast Refresh
**Expected output**:
```
▲ Next.js 14.0.4
- Local: http://localhost:3000
- Network: http://192.168.1.x:3000
✓ Ready in 2.3s
```
**Verification**:
```bash
# Open in browser:
# http://localhost:3000
# You should see the Xpeditis homepage
```
---
## ✅ Installation Complete!
You should now have:
| Service | URL | Status |
|---------|-----|--------|
| **Frontend** | http://localhost:3000 | ✅ Running |
| **Backend API** | http://localhost:4000/api/v1 | ✅ Running |
| **API Docs** | http://localhost:4000/api/docs | ✅ Running |
| **PostgreSQL** | localhost:5432 | ✅ Running |
| **Redis** | localhost:6379 | ✅ Running |
---
## Troubleshooting
### Issue: npm install fails
**Solution**:
```bash
# Clear npm cache
npm cache clean --force
# Delete node_modules
rm -rf node_modules apps/*/node_modules packages/*/node_modules
# Retry
npm install
```
### Issue: Docker containers won't start
**Solution**:
```bash
# Check Docker is running
docker --version
# Check if ports are in use
# Windows:
netstat -ano | findstr :5432
netstat -ano | findstr :6379
# Mac/Linux:
lsof -i :5432
lsof -i :6379
# Stop any conflicting services
# Then retry:
docker-compose up -d
```
### Issue: Backend won't connect to database
**Solution**:
```bash
# Check PostgreSQL is running
docker-compose ps
# Check PostgreSQL logs
docker-compose logs postgres
# Verify connection manually
docker-compose exec postgres psql -U xpeditis -d xpeditis_dev
# If that works, check your .env file:
# DATABASE_HOST=localhost (not 127.0.0.1)
# DATABASE_PORT=5432
# DATABASE_USER=xpeditis
# DATABASE_PASSWORD=xpeditis_dev_password
# DATABASE_NAME=xpeditis_dev
```
### Issue: Port 4000 or 3000 already in use
**Solution**:
```bash
# Find what's using the port
# Windows:
netstat -ano | findstr :4000
# Mac/Linux:
lsof -i :4000
# Kill the process or change the port in:
# Backend: apps/backend/.env (PORT=4000)
# Frontend: package.json dev script or use -p flag
```
### Issue: Module not found errors
**Solution**:
```bash
# Backend
cd apps/backend
npm install
# Frontend
cd apps/frontend
npm install
# If still failing, check tsconfig.json paths are correct
```
---
## Common Development Tasks
### View Logs
```bash
# Backend logs (already in terminal)
# Docker logs
docker-compose logs -f
# PostgreSQL logs only
docker-compose logs -f postgres
# Redis logs only
docker-compose logs -f redis
```
### Database Operations
```bash
# Connect to PostgreSQL
docker-compose exec postgres psql -U xpeditis -d xpeditis_dev
# List tables
\dt
# Describe a table
\d table_name
# Run migrations (when created)
cd apps/backend
npm run migration:run
```
### Redis Operations
```bash
# Connect to Redis
docker-compose exec redis redis-cli -a xpeditis_redis_password
# List all keys
KEYS *
# Get a value
GET key_name
# Flush all data
FLUSHALL
```
### Run Tests
```bash
# Backend unit tests
cd apps/backend
npm test
# Backend tests with coverage
npm run test:cov
# Backend E2E tests
npm run test:e2e
# Frontend tests
cd apps/frontend
npm test
# All tests
npm run test:all
```
### Code Quality
```bash
# Format code
npm run format
# Check formatting
npm run format:check
# Lint backend
npm run backend:lint
# Lint frontend
npm run frontend:lint
```
---
## Next Steps
Now that everything is installed and running:
1. **📚 Read the docs**:
- [QUICK-START.md](QUICK-START.md) - Quick reference
- [README.md](README.md) - Full documentation
- [CLAUDE.md](CLAUDE.md) - Architecture guidelines
2. **🛠️ Start developing**:
- Check [TODO.md](TODO.md) for the roadmap
- Review [SPRINT-0-FINAL.md](SPRINT-0-FINAL.md) for what's done
- Begin Phase 1: Domain entities and ports
3. **🧪 Write tests**:
- Domain layer tests (90%+ coverage target)
- Integration tests for repositories
- E2E tests for API endpoints
4. **🚀 Deploy** (when ready):
- Review production checklist in SPRINT-0-FINAL.md
- Update environment variables
- Setup CI/CD pipelines
---
## Success Checklist
Before moving to Phase 1, verify:
- [ ] `npm install` completed successfully
- [ ] Docker containers running (postgres + redis)
- [ ] Backend starts without errors
- [ ] Frontend starts without errors
- [ ] Health endpoint returns 200 OK
- [ ] Swagger docs accessible
- [ ] Frontend homepage loads
- [ ] Tests pass (`npm test`)
- [ ] No TypeScript errors
- [ ] Hot reload works (edit a file, see changes)
---
**You're ready to build! 🎉**
For questions, check the documentation or open an issue on GitHub.
---
*Xpeditis - Maritime Freight Booking Platform*

471
NEXT-STEPS.md
View File

@ -1,471 +0,0 @@
# 🚀 Next Steps - Getting Started with Development
You've successfully completed Sprint 0! Here's what to do next.
---
## 🎯 Immediate Actions (Today)
### 1. Install Dependencies
```bash
# From the root directory
npm install
```
**Expected**: This will take 2-3 minutes. You may see some deprecation warnings (normal).
**On Windows**: If you see `EISDIR` symlink errors, that's okay - dependencies are still installed.
### 2. Start Docker Services
```bash
docker-compose up -d
```
**Expected**: PostgreSQL and Redis containers will start.
**Verify**:
```bash
docker-compose ps
# You should see:
# xpeditis-postgres - Up (healthy)
# xpeditis-redis - Up (healthy)
```
### 3. Setup Environment Files
```bash
# Backend
cp apps/backend/.env.example apps/backend/.env
# Frontend
cp apps/frontend/.env.example apps/frontend/.env
```
**Note**: Default values work for local development. No changes needed!
### 4. Start the Backend
```bash
# Option 1: From root
npm run backend:dev
# Option 2: From backend directory
cd apps/backend
npm run dev
```
**Expected Output**:
```
╔═══════════════════════════════════════╗
║ 🚢 Xpeditis API Server Running ║
║ API: http://localhost:4000/api/v1 ║
║ Docs: http://localhost:4000/api/docs ║
╚═══════════════════════════════════════╝
```
**Verify**: Open http://localhost:4000/api/v1/health
### 5. Start the Frontend (New Terminal)
```bash
# Option 1: From root
npm run frontend:dev
# Option 2: From frontend directory
cd apps/frontend
npm run dev
```
**Expected Output**:
```
▲ Next.js 14.0.4
- Local: http://localhost:3000
✓ Ready in 2.3s
```
**Verify**: Open http://localhost:3000
---
## ✅ Verification Checklist
Before proceeding to development, verify:
- [ ] `npm install` completed successfully
- [ ] Docker containers are running (check with `docker-compose ps`)
- [ ] Backend starts without errors
- [ ] Health endpoint returns 200 OK: http://localhost:4000/api/v1/health
- [ ] Swagger docs accessible: http://localhost:4000/api/docs
- [ ] Frontend loads: http://localhost:3000
- [ ] No TypeScript compilation errors
**All green? You're ready to start Phase 1! 🎉**
---
## 📅 Phase 1 - Core Search & Carrier Integration (Next 6-8 weeks)
### Week 1-2: Domain Layer & Port Definitions
**Your first tasks**:
#### 1. Create Domain Entities
Create these files in `apps/backend/src/domain/entities/`:
```typescript
// organization.entity.ts
export class Organization {
constructor(
public readonly id: string,
public readonly name: string,
public readonly type: 'FREIGHT_FORWARDER' | 'NVOCC' | 'DIRECT_SHIPPER',
public readonly scac?: string,
public readonly address?: Address,
public readonly logoUrl?: string,
) {}
}
// user.entity.ts
export class User {
constructor(
public readonly id: string,
public readonly organizationId: string,
public readonly email: Email, // Value Object
public readonly role: UserRole,
public readonly passwordHash: string,
) {}
}
// rate-quote.entity.ts
export class RateQuote {
constructor(
public readonly id: string,
public readonly origin: PortCode, // Value Object
public readonly destination: PortCode, // Value Object
public readonly carrierId: string,
public readonly price: Money, // Value Object
public readonly surcharges: Surcharge[],
public readonly etd: Date,
public readonly eta: Date,
public readonly transitDays: number,
public readonly route: RouteStop[],
public readonly availability: number,
) {}
}
// More entities: Carrier, Port, Container, Booking
```
#### 2. Create Value Objects
Create these files in `apps/backend/src/domain/value-objects/`:
```typescript
// email.vo.ts
export class Email {
private constructor(private readonly value: string) {
this.validate(value);
}
static create(value: string): Email {
return new Email(value);
}
private validate(value: string): void {
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (!emailRegex.test(value)) {
throw new InvalidEmailException(value);
}
}
getValue(): string {
return this.value;
}
}
// port-code.vo.ts
export class PortCode {
private constructor(private readonly value: string) {
this.validate(value);
}
static create(value: string): PortCode {
return new PortCode(value.toUpperCase());
}
private validate(value: string): void {
// UN LOCODE format: 5 characters (CCCCC)
if (!/^[A-Z]{5}$/.test(value)) {
throw new InvalidPortCodeException(value);
}
}
getValue(): string {
return this.value;
}
}
// More VOs: Money, ContainerType, BookingNumber, DateRange
```
#### 3. Define Ports
**API Ports (domain/ports/in/)** - What the domain exposes:
```typescript
// search-rates.port.ts
export interface SearchRatesPort {
execute(input: RateSearchInput): Promise<RateQuote[]>;
}
export interface RateSearchInput {
origin: PortCode;
destination: PortCode;
containerType: ContainerType;
mode: 'FCL' | 'LCL';
departureDate: Date;
weight?: number;
volume?: number;
hazmat: boolean;
}
```
**SPI Ports (domain/ports/out/)** - What the domain needs:
```typescript
// rate-quote.repository.ts
export interface RateQuoteRepository {
save(rateQuote: RateQuote): Promise<void>;
findById(id: string): Promise<RateQuote | null>;
findByRoute(origin: PortCode, destination: PortCode): Promise<RateQuote[]>;
}
// carrier-connector.port.ts
export interface CarrierConnectorPort {
searchRates(input: RateSearchInput): Promise<RateQuote[]>;
checkAvailability(input: AvailabilityInput): Promise<boolean>;
}
// cache.port.ts
export interface CachePort {
get<T>(key: string): Promise<T | null>;
set<T>(key: string, value: T, ttl: number): Promise<void>;
delete(key: string): Promise<void>;
}
```
#### 4. Write Domain Tests
```typescript
// domain/services/rate-search.service.spec.ts
describe('RateSearchService', () => {
let service: RateSearchService;
let mockCache: jest.Mocked<CachePort>;
let mockConnectors: jest.Mocked<CarrierConnectorPort>[];
beforeEach(() => {
mockCache = createMockCache();
mockConnectors = [createMockConnector('Maersk')];
service = new RateSearchService(mockCache, mockConnectors);
});
it('should return cached rates if available', async () => {
const input = createTestRateSearchInput();
const cachedRates = [createTestRateQuote()];
mockCache.get.mockResolvedValue(cachedRates);
const result = await service.execute(input);
expect(result).toEqual(cachedRates);
expect(mockConnectors[0].searchRates).not.toHaveBeenCalled();
});
it('should query carriers if cache miss', async () => {
const input = createTestRateSearchInput();
mockCache.get.mockResolvedValue(null);
const carrierRates = [createTestRateQuote()];
mockConnectors[0].searchRates.mockResolvedValue(carrierRates);
const result = await service.execute(input);
expect(result).toEqual(carrierRates);
expect(mockCache.set).toHaveBeenCalledWith(
expect.any(String),
carrierRates,
900, // 15 minutes
);
});
// Target: 90%+ coverage for domain
});
```
---
## 📚 Recommended Reading Order
Before starting development, read these in order:
1. **[QUICK-START.md](QUICK-START.md)** (5 min)
- Get everything running
2. **[CLAUDE.md](CLAUDE.md)** (30 min)
- Understand hexagonal architecture
- Learn the rules for each layer
- See complete examples
3. **[apps/backend/README.md](apps/backend/README.md)** (10 min)
- Backend-specific guidelines
- Available scripts
- Testing strategy
4. **[TODO.md](TODO.md)** - Sections relevant to current sprint (20 min)
- Detailed task breakdown
- Acceptance criteria
- Technical specifications
---
## 🛠️ Development Guidelines
### Hexagonal Architecture Rules
**Domain Layer** (`src/domain/`):
- ✅ Pure TypeScript classes
- ✅ Define interfaces (ports)
- ✅ Business logic only
- ❌ NO imports from NestJS, TypeORM, or any framework
- ❌ NO decorators (@Injectable, @Column, etc.)
**Application Layer** (`src/application/`):
- ✅ Import from `@domain/*` only
- ✅ Controllers, DTOs, Mappers
- ✅ Handle HTTP-specific concerns
- ❌ NO business logic
**Infrastructure Layer** (`src/infrastructure/`):
- ✅ Import from `@domain/*` only
- ✅ Implement port interfaces
- ✅ Framework-specific code (TypeORM, Redis, etc.)
- ❌ NO business logic
### Testing Strategy
- **Domain**: 90%+ coverage, test without any framework
- **Application**: 80%+ coverage, test DTOs and mappings
- **Infrastructure**: 70%+ coverage, test with test databases
### Git Workflow
```bash
# Create feature branch
git checkout -b feature/domain-entities
# Make changes and commit
git add .
git commit -m "feat: add Organization and User domain entities"
# Push and create PR
git push origin feature/domain-entities
```
---
## 🎯 Success Criteria for Week 1-2
By the end of Sprint 1-2, you should have:
- [ ] All core domain entities created (Organization, User, RateQuote, Carrier, Port, Container)
- [ ] All value objects created (Email, PortCode, Money, ContainerType, etc.)
- [ ] All API ports defined (SearchRatesPort, CreateBookingPort, etc.)
- [ ] All SPI ports defined (Repositories, CarrierConnectorPort, CachePort, etc.)
- [ ] Domain services implemented (RateSearchService, BookingService, etc.)
- [ ] Domain unit tests written (90%+ coverage)
- [ ] All tests passing
- [ ] No TypeScript errors
- [ ] Code formatted and linted
---
## 💡 Tips for Success
### 1. Start Small
Don't try to implement everything at once. Start with:
- One entity (e.g., Organization)
- One value object (e.g., Email)
- One port (e.g., SearchRatesPort)
- Tests for what you created
### 2. Test First (TDD)
```typescript
// 1. Write the test
it('should create organization with valid data', () => {
const org = new Organization('1', 'ACME Freight', 'FREIGHT_FORWARDER');
expect(org.name).toBe('ACME Freight');
});
// 2. Implement the entity
export class Organization { /* ... */ }
// 3. Run the test
npm test
// 4. Refactor if needed
```
### 3. Follow Patterns
Look at examples in CLAUDE.md and copy the structure:
- Entities are classes with readonly properties
- Value objects validate in the constructor
- Ports are interfaces
- Services implement ports
### 4. Ask Questions
If something is unclear:
- Re-read CLAUDE.md
- Check TODO.md for specifications
- Look at the PRD.md for business context
### 5. Commit Often
```bash
git add .
git commit -m "feat: add Email value object with validation"
# Small, focused commits are better
```
---
## 📞 Need Help?
**Documentation**:
- [QUICK-START.md](QUICK-START.md) - Setup issues
- [CLAUDE.md](CLAUDE.md) - Architecture questions
- [TODO.md](TODO.md) - Task details
- [apps/backend/README.md](apps/backend/README.md) - Backend specifics
**Troubleshooting**:
- [INSTALLATION-STEPS.md](INSTALLATION-STEPS.md) - Common issues
**Architecture**:
- Read the hexagonal architecture guidelines in CLAUDE.md
- Study the example flows at the end of CLAUDE.md
---
## 🎉 You're Ready!
**Current Status**: ✅ Sprint 0 Complete
**Next Milestone**: Sprint 1-2 - Domain Layer
**Timeline**: 2 weeks
**Focus**: Create all domain entities, value objects, and ports
**Let's build something amazing! 🚀**
---
*Xpeditis MVP - Maritime Freight Booking Platform*
*Good luck with Phase 1!*

412
READY.md
View File

@ -1,412 +0,0 @@
# ✅ Xpeditis MVP - READY FOR DEVELOPMENT
## 🎉 Sprint 0 Successfully Completed!
**Project**: Xpeditis - Maritime Freight Booking Platform
**Status**: 🟢 **READY FOR PHASE 1**
**Completion Date**: October 7, 2025
**Sprint 0**: 100% Complete
---
## 📦 What Has Been Created
### 📄 Documentation Suite (11 files, 4000+ lines)
1. **[README.md](README.md)** - Project overview
2. **[CLAUDE.md](CLAUDE.md)** - Hexagonal architecture guide (476 lines)
3. **[PRD.md](PRD.md)** - Product requirements (352 lines)
4. **[TODO.md](TODO.md)** - 30-week roadmap (1000+ lines)
5. **[QUICK-START.md](QUICK-START.md)** - 5-minute setup guide
6. **[INSTALLATION-STEPS.md](INSTALLATION-STEPS.md)** - Detailed installation
7. **[NEXT-STEPS.md](NEXT-STEPS.md)** - What to do next
8. **[SPRINT-0-FINAL.md](SPRINT-0-FINAL.md)** - Complete sprint report
9. **[SPRINT-0-SUMMARY.md](SPRINT-0-SUMMARY.md)** - Executive summary
10. **[INDEX.md](INDEX.md)** - Documentation index
11. **[READY.md](READY.md)** - This file
### 🏗️ Backend (NestJS + Hexagonal Architecture)
**Folder Structure**:
```
apps/backend/src/
├── domain/ ✅ Pure business logic layer
│ ├── entities/
│ ├── value-objects/
│ ├── services/
│ ├── ports/in/
│ ├── ports/out/
│ └── exceptions/
├── application/ ✅ Controllers & DTOs
│ ├── controllers/
│ ├── dto/
│ ├── mappers/
│ └── config/
└── infrastructure/ ✅ External adapters
├── persistence/
├── cache/
├── carriers/
├── email/
├── storage/
└── config/
```
**Files Created** (15+):
- ✅ package.json (50+ dependencies)
- ✅ tsconfig.json (strict mode + path aliases)
- ✅ nest-cli.json
- ✅ .eslintrc.js
- ✅ .env.example (all variables documented)
- ✅ src/main.ts (bootstrap with Swagger)
- ✅ src/app.module.ts (root module)
- ✅ src/application/controllers/health.controller.ts
- ✅ test/app.e2e-spec.ts
- ✅ test/jest-e2e.json
- ✅ README.md (backend guide)
**Features**:
- ✅ Hexagonal architecture properly implemented
- ✅ TypeScript strict mode
- ✅ Swagger API docs at /api/docs
- ✅ Health check endpoints
- ✅ Pino structured logging
- ✅ Environment validation (Joi)
- ✅ Jest testing infrastructure
- ✅ Security configured (helmet, CORS, JWT)
### 🎨 Frontend (Next.js 14 + TypeScript)
**Folder Structure**:
```
apps/frontend/
├── app/ ✅ Next.js App Router
│ ├── layout.tsx
│ ├── page.tsx
│ └── globals.css
├── components/ ✅ Ready for components
│ └── ui/
├── lib/ ✅ Utilities
│ ├── api/
│ ├── hooks/
│ └── utils.ts
└── public/ ✅ Static assets
```
**Files Created** (12+):
- ✅ package.json (30+ dependencies)
- ✅ tsconfig.json (path aliases)
- ✅ next.config.js
- ✅ tailwind.config.ts
- ✅ postcss.config.js
- ✅ .eslintrc.json
- ✅ .env.example
- ✅ app/layout.tsx
- ✅ app/page.tsx
- ✅ app/globals.css (Tailwind + CSS variables)
- ✅ lib/utils.ts (cn helper)
- ✅ README.md (frontend guide)
**Features**:
- ✅ Next.js 14 with App Router
- ✅ TypeScript strict mode
- ✅ Tailwind CSS with custom theme
- ✅ shadcn/ui components ready
- ✅ Dark mode support (CSS variables)
- ✅ TanStack Query configured
- ✅ react-hook-form + zod validation
- ✅ Jest + Playwright testing ready
### 🐳 Docker Infrastructure
**Files Created**:
- ✅ docker-compose.yml
- ✅ infra/postgres/init.sql
**Services**:
- ✅ PostgreSQL 15 (port 5432)
- Database: xpeditis_dev
- User: xpeditis
- Extensions: uuid-ossp, pg_trgm
- Health checks enabled
- Persistent volumes
- ✅ Redis 7 (port 6379)
- Password protected
- AOF persistence
- Health checks enabled
- Persistent volumes
### 🔄 CI/CD Pipelines
**GitHub Actions Workflows**:
- ✅ .github/workflows/ci.yml
- Lint & format check
- Backend tests (unit + E2E)
- Frontend tests
- Build verification
- Code coverage upload
- ✅ .github/workflows/security.yml
- npm audit (weekly)
- Dependency review (PRs)
- ✅ .github/pull_request_template.md
- Structured PR template
- Architecture compliance checklist
### 📝 Configuration Files
**Root Level**:
- ✅ package.json (workspace configuration)
- ✅ .gitignore
- ✅ .prettierrc
- ✅ .prettierignore
**Per App**:
- ✅ Backend: tsconfig, nest-cli, eslint, env.example
- ✅ Frontend: tsconfig, next.config, tailwind.config, postcss.config
---
## 🎯 Ready For Phase 1
### ✅ All Sprint 0 Objectives Met
| Objective | Status | Notes |
|-----------|--------|-------|
| Monorepo structure | ✅ Complete | npm workspaces configured |
| Backend hexagonal arch | ✅ Complete | Domain/Application/Infrastructure |
| Frontend Next.js 14 | ✅ Complete | App Router + TypeScript |
| Docker infrastructure | ✅ Complete | PostgreSQL + Redis |
| TypeScript strict mode | ✅ Complete | All projects |
| Testing infrastructure | ✅ Complete | Jest, Supertest, Playwright |
| CI/CD pipelines | ✅ Complete | GitHub Actions |
| API documentation | ✅ Complete | Swagger at /api/docs |
| Logging | ✅ Complete | Pino structured logging |
| Security foundations | ✅ Complete | Helmet, JWT, CORS, rate limiting |
| Environment validation | ✅ Complete | Joi schema validation |
| Health endpoints | ✅ Complete | /health, /ready, /live |
| Documentation | ✅ Complete | 11 comprehensive files |
---
## 🚀 Next Actions
### 1. Install Dependencies (3 minutes)
```bash
npm install
```
Expected: ~80 packages installed
### 2. Start Infrastructure (1 minute)
```bash
docker-compose up -d
```
Expected: PostgreSQL + Redis running
### 3. Configure Environment (30 seconds)
```bash
cp apps/backend/.env.example apps/backend/.env
cp apps/frontend/.env.example apps/frontend/.env
```
Expected: Default values work immediately
### 4. Start Development (1 minute)
**Terminal 1 - Backend**:
```bash
npm run backend:dev
```
Expected: Server at http://localhost:4000
**Terminal 2 - Frontend**:
```bash
npm run frontend:dev
```
Expected: App at http://localhost:3000
### 5. Verify (1 minute)
- ✅ Backend health: http://localhost:4000/api/v1/health
- ✅ API docs: http://localhost:4000/api/docs
- ✅ Frontend: http://localhost:3000
- ✅ Docker: `docker-compose ps`
---
## 📚 Start Reading
**New developers start here** (2 hours):
1. **[QUICK-START.md](QUICK-START.md)** (30 min)
- Get everything running
- Verify installation
2. **[CLAUDE.md](CLAUDE.md)** (60 min)
- **MUST READ** for architecture
- Hexagonal architecture principles
- Layer responsibilities
- Complete examples
3. **[NEXT-STEPS.md](NEXT-STEPS.md)** (30 min)
- What to build first
- Code examples
- Testing strategy
4. **[TODO.md](TODO.md)** - Sprint 1-2 section (30 min)
- Detailed task breakdown
- Acceptance criteria
---
## 🎯 Phase 1 Goals (Weeks 1-8)
### Sprint 1-2: Domain Layer (Weeks 1-2)
**Your first tasks**:
- [ ] Create domain entities (Organization, User, RateQuote, Carrier, Port, Container)
- [ ] Create value objects (Email, PortCode, Money, ContainerType)
- [ ] Define API ports (SearchRatesPort, CreateBookingPort)
- [ ] Define SPI ports (Repositories, CarrierConnectorPort, CachePort)
- [ ] Implement domain services
- [ ] Write domain unit tests (90%+ coverage)
**Where to start**: See [NEXT-STEPS.md](NEXT-STEPS.md) for code examples
### Sprint 3-4: Infrastructure Layer (Weeks 3-4)
- [ ] Design database schema (ERD)
- [ ] Create TypeORM entities
- [ ] Implement repositories
- [ ] Create migrations
- [ ] Seed data (carriers, ports)
- [ ] Implement Redis cache adapter
- [ ] Create Maersk connector
- [ ] Integration tests
### Sprint 5-6: Application Layer (Weeks 5-6)
- [ ] Create DTOs and mappers
- [ ] Implement controllers (RatesController, PortsController)
- [ ] Complete OpenAPI documentation
- [ ] Implement caching strategy
- [ ] Performance optimization
- [ ] E2E tests
### Sprint 7-8: Frontend UI (Weeks 7-8)
- [ ] Search form components
- [ ] Port autocomplete
- [ ] Results display (cards + table)
- [ ] Filtering & sorting
- [ ] Export functionality
- [ ] Responsive design
- [ ] Frontend tests
---
## 📊 Success Metrics
### Technical Metrics (Sprint 0 - Achieved)
- ✅ Project structure: Complete
- ✅ Backend setup: Complete
- ✅ Frontend setup: Complete
- ✅ Docker infrastructure: Complete
- ✅ CI/CD pipelines: Complete
- ✅ Documentation: 11 files, 4000+ lines
- ✅ Configuration: All files created
- ✅ Testing infrastructure: Ready
### Phase 1 Metrics (Target)
- 🎯 Domain entities: All created
- 🎯 Domain tests: 90%+ coverage
- 🎯 Database schema: Designed and migrated
- 🎯 Carrier connectors: At least 1 (Maersk)
- 🎯 Rate search API: Functional
- 🎯 Rate search UI: Responsive
- 🎯 Cache hit ratio: >90%
- 🎯 API response time: <2s
---
## 🎉 Summary
**Sprint 0**: ✅ **100% COMPLETE**
**Created**:
- 📄 11 documentation files (4000+ lines)
- 🏗️ Complete hexagonal architecture (backend)
- 🎨 Modern React setup (frontend)
- 🐳 Docker infrastructure (PostgreSQL + Redis)
- 🔄 CI/CD pipelines (GitHub Actions)
- ⚙️ 50+ configuration files
- 📦 80+ dependencies installed
**Ready For**:
- ✅ Domain modeling
- ✅ Database design
- ✅ API development
- ✅ Frontend development
- ✅ Testing
- ✅ Deployment
**Time to Phase 1**: **NOW! 🚀**
---
## 🎓 Learning Resources
**Architecture**:
- [Hexagonal Architecture](https://alistair.cockburn.us/hexagonal-architecture/)
- [Domain-Driven Design](https://martinfowler.com/bliki/DomainDrivenDesign.html)
- [Clean Architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)
**Frameworks**:
- [NestJS Documentation](https://docs.nestjs.com/)
- [Next.js Documentation](https://nextjs.org/docs)
- [TypeORM Documentation](https://typeorm.io/)
**Internal**:
- [CLAUDE.md](CLAUDE.md) - Our architecture guide
- [apps/backend/README.md](apps/backend/README.md) - Backend specifics
- [apps/frontend/README.md](apps/frontend/README.md) - Frontend specifics
---
## 🎊 Congratulations!
**You have a production-ready foundation for the Xpeditis MVP.**
Everything is in place to start building:
- 🏗️ Architecture: Solid and scalable
- 📚 Documentation: Comprehensive
- ⚙️ Configuration: Complete
- 🧪 Testing: Ready
- 🚀 CI/CD: Automated
**Let's build something amazing! 🚢**
---
**Status**: 🟢 **READY FOR DEVELOPMENT**
**Next Sprint**: Sprint 1-2 - Domain Layer
**Start Date**: Today
**Duration**: 2 weeks
**Good luck with Phase 1!** 🎯
---
*Xpeditis MVP - Maritime Freight Booking Platform*
*Sprint 0 Complete - October 7, 2025*
*Ready for Phase 1 Development*

271
SPRINT-0-COMPLETE.md
View File

@ -1,271 +0,0 @@
# Sprint 0 - Project Setup & Infrastructure ✅
## Completed Tasks
### ✅ 1. Monorepo Structure Initialized
- Created workspace structure with npm workspaces
- Organized into `apps/` (backend, frontend) and `packages/` (shared-types, domain)
- Setup root `package.json` with workspace configuration
- Created `.gitignore`, `.prettierrc`, and `.prettierignore`
- Created comprehensive README.md
### ✅ 2. Backend Setup (NestJS + Hexagonal Architecture)
- **Package Configuration**: Full `package.json` with all NestJS dependencies
- **TypeScript**: Strict mode enabled with path aliases for hexagonal architecture
- **Hexagonal Folder Structure**:
```
src/
├── domain/ # Pure business logic (NO external dependencies)
│ ├── entities/
│ ├── value-objects/
│ ├── services/
│ ├── ports/
│ │ ├── in/ # API Ports (Use Cases)
│ │ └── out/ # SPI Ports (Repositories, External Services)
│ └── exceptions/
├── application/ # Controllers & DTOs
│ ├── controllers/
│ ├── dto/
│ ├── mappers/
│ └── config/
└── infrastructure/ # External integrations
├── persistence/
│ └── typeorm/
├── cache/
├── carriers/
├── email/
├── storage/
└── config/
```
- **Main Files**:
- `main.ts`: Bootstrap with Swagger, helmet, validation pipes
- `app.module.ts`: Root module with ConfigModule, LoggerModule, TypeORM
- `health.controller.ts`: Health check endpoints (/health, /ready, /live)
- **Configuration**:
- `.env.example`: All environment variables documented
- `nest-cli.json`: NestJS CLI configuration
- `.eslintrc.js`: ESLint with TypeScript rules
- **Testing**: Jest configured with path aliases
### ✅ 3. Frontend Setup (Next.js 14)
- **Package Configuration**: Full `package.json` with Next.js 14, React 18, TailwindCSS
- **Dependencies Added**:
- UI: Radix UI components, Tailwind CSS, lucide-react (icons)
- State Management: TanStack Query (React Query)
- Forms: react-hook-form + zod validation
- HTTP: axios
- Testing: Jest, React Testing Library, Playwright
### ✅ 4. Docker Compose Configuration
- **PostgreSQL 15**:
- Database: `xpeditis_dev`
- User: `xpeditis`
- Port: 5432
- Persistent volume
- Health checks configured
- Init script with UUID extension and pg_trgm (for fuzzy search)
- **Redis 7**:
- Port: 6379
- Password protected
- AOF persistence enabled
- Health checks configured
### ✅ 5. API Documentation (Swagger)
- Swagger UI configured at `/api/docs`
- Bearer authentication setup
- API tags defined (rates, bookings, auth, users, organizations)
- Health check endpoints documented
### ✅ 6. Monitoring & Logging
- **Logging**: Pino logger with pino-pretty for development
- **Log Levels**: Debug in development, info in production
- **Structured Logging**: JSON format ready for production
### ✅ 7. Security Foundations
- **Helmet.js**: Security headers configured
- **CORS**: Configured with frontend URL
- **Validation**: Global validation pipe with class-validator
- **JWT**: Configuration ready (access: 15min, refresh: 7 days)
- **Password Hashing**: bcrypt with 12 rounds (configured in env)
- **Rate Limiting**: Environment variables prepared
### ✅ 8. Testing Infrastructure
- **Backend**:
- Jest configured with TypeScript support
- Unit tests setup with path aliases
- E2E tests with Supertest
- Coverage reports configured
- **Frontend**:
- Jest with jsdom environment
- React Testing Library
- Playwright for E2E tests
## 📁 Complete Project Structure
```
xpeditis/
├── apps/
│ ├── backend/
│ │ ├── src/
│ │ │ ├── domain/ ✅ Hexagonal core
│ │ │ ├── application/ ✅ Controllers & DTOs
│ │ │ ├── infrastructure/ ✅ External adapters
│ │ │ ├── main.ts ✅ Bootstrap
│ │ │ └── app.module.ts ✅ Root module
│ │ ├── test/ ✅ E2E tests
│ │ ├── package.json ✅ Complete
│ │ ├── tsconfig.json ✅ Path aliases
│ │ ├── nest-cli.json ✅ CLI config
│ │ ├── .eslintrc.js ✅ Linting
│ │ └── .env.example ✅ All variables
│ └── frontend/
│ ├── package.json ✅ Next.js 14 + deps
│ └── [to be scaffolded]
├── packages/
│ ├── shared-types/ ✅ Created
│ └── domain/ ✅ Created
├── infra/
│ └── postgres/
│ └── init.sql ✅ DB initialization
├── docker-compose.yml ✅ PostgreSQL + Redis
├── package.json ✅ Workspace root
├── .gitignore ✅ Complete
├── .prettierrc ✅ Code formatting
├── README.md ✅ Documentation
├── CLAUDE.md ✅ Architecture guide
├── PRD.md ✅ Product requirements
└── TODO.md ✅ Full roadmap
```
## 🚀 Next Steps
### To Complete Sprint 0:
1. **Frontend Configuration Files** (Remaining):
```bash
cd apps/frontend
# Create:
# - tsconfig.json
# - next.config.js
# - tailwind.config.js
# - postcss.config.js
# - .env.example
# - app/ directory structure
```
2. **CI/CD Pipeline** (Week 2 task):
```bash
# Create .github/workflows/
# - ci.yml (lint, test, build)
# - deploy.yml (optional)
```
3. **Install Dependencies**:
```bash
# Root
npm install
# Backend
cd apps/backend && npm install
# Frontend
cd apps/frontend && npm install
```
4. **Start Infrastructure**:
```bash
docker-compose up -d
```
5. **Verify Setup**:
```bash
# Backend
cd apps/backend
npm run dev
# Visit: http://localhost:4000/api/docs
# Frontend
cd apps/frontend
npm run dev
# Visit: http://localhost:3000
```
## 📊 Sprint 0 Progress: 85% Complete
### Completed ✅
- Monorepo structure
- Backend (NestJS + Hexagonal architecture)
- Docker Compose (PostgreSQL + Redis)
- API Documentation (Swagger)
- Monitoring & Logging (Pino)
- Security foundations
- Testing infrastructure
- Frontend package.json
### Remaining ⏳
- Frontend configuration files (5%)
- CI/CD pipelines (10%)
## 🎯 Key Achievements
1. **Hexagonal Architecture Properly Implemented**:
- Domain layer completely isolated
- Clear separation: Domain → Application → Infrastructure
- Path aliases configured for clean imports
- Ready for domain-driven development
2. **Production-Ready Configuration**:
- Environment validation with Joi
- Structured logging
- Security best practices
- Health check endpoints
3. **Developer Experience**:
- TypeScript strict mode
- ESLint + Prettier
- Hot reload for both backend and frontend
- Clear folder structure
- Comprehensive documentation
4. **Testing Strategy**:
- Unit tests for domain layer
- Integration tests for infrastructure
- E2E tests for complete flows
- Coverage reports
## 📝 Important Notes
- **Environment Variables**: Copy `.env.example` to `.env` in both apps before running
- **Database**: PostgreSQL runs on port 5432, credentials in docker-compose.yml
- **Redis**: Runs on port 6379 with password authentication
- **API**: Backend runs on port 4000, frontend on port 3000
- **Swagger**: Available at http://localhost:4000/api/docs
## 🔒 Security Checklist for Production
Before deploying to production:
- [ ] Change all default passwords
- [ ] Generate strong JWT secret
- [ ] Configure OAuth2 credentials
- [ ] Setup email service (SendGrid/SES)
- [ ] Configure AWS S3 credentials
- [ ] Obtain carrier API keys
- [ ] Enable HTTPS/TLS
- [ ] Configure Sentry for error tracking
- [ ] Setup monitoring (Prometheus/Grafana)
- [ ] Enable database backups
- [ ] Review CORS configuration
- [ ] Test rate limiting
- [ ] Run security audit
## 🎉 Sprint 0 Status: NEARLY COMPLETE
The foundation is solid and ready for Phase 1 development (Rate Search & Carrier Integration).
**Estimated time to complete remaining tasks**: 2-4 hours
**Ready to proceed with**:
- Domain entity modeling
- Rate search implementation
- Carrier connector development

475
SPRINT-0-FINAL.md
View File

@ -1,475 +0,0 @@
# 🎉 Sprint 0 - COMPLETE ✅
## Project Setup & Infrastructure - Xpeditis MVP
**Status**: ✅ **100% COMPLETE**
**Date**: October 7, 2025
**Duration**: 2 weeks (as planned)
---
## 📊 Summary
Sprint 0 has been successfully completed with ALL infrastructure and configuration files in place. The Xpeditis maritime freight booking platform is now ready for Phase 1 development.
---
## ✅ Completed Deliverables
### 1. Monorepo Structure ✅
```
xpeditis/
├── apps/
│ ├── backend/ ✅ NestJS + Hexagonal Architecture
│ └── frontend/ ✅ Next.js 14 + TypeScript
├── packages/
│ ├── shared-types/ ✅ Shared TypeScript types
│ └── domain/ ✅ Shared domain logic
├── infra/ ✅ Infrastructure configs
├── .github/workflows/ ✅ CI/CD pipelines
└── [config files] ✅ All configuration files
```
### 2. Backend (NestJS + Hexagonal Architecture) ✅
**✅ Complete Implementation**:
- **Hexagonal Architecture** properly implemented
- `domain/` - Pure business logic (NO framework dependencies)
- `application/` - Controllers, DTOs, Mappers
- `infrastructure/` - External adapters (DB, Cache, APIs)
- **Main Files**:
- `main.ts` - Bootstrap with Swagger, security, validation
- `app.module.ts` - Root module with all configurations
- `health.controller.ts` - Health check endpoints
- **Configuration**:
- TypeScript strict mode + path aliases
- Environment validation with Joi
- Pino logger (structured logging)
- Swagger API documentation at `/api/docs`
- Jest testing infrastructure
- E2E testing with Supertest
- **Dependencies** (50+ packages):
- NestJS 10+, TypeORM, PostgreSQL, Redis (ioredis)
- JWT, Passport, bcrypt, helmet
- Swagger/OpenAPI, Pino logger
- Circuit breaker (opossum)
**Files Created** (15+):
- `package.json`, `tsconfig.json`, `nest-cli.json`
- `.eslintrc.js`, `.env.example`
- `src/main.ts`, `src/app.module.ts`
- `src/application/controllers/health.controller.ts`
- `test/app.e2e-spec.ts`, `test/jest-e2e.json`
- Domain/Application/Infrastructure folder structure
### 3. Frontend (Next.js 14 + TypeScript) ✅
**✅ Complete Implementation**:
- **Next.js 14** with App Router
- **TypeScript** with strict mode
- **Tailwind CSS** + shadcn/ui design system
- **Configuration Files**:
- `tsconfig.json` - Path aliases configured
- `next.config.js` - Next.js configuration
- `tailwind.config.ts` - Complete theme setup
- `postcss.config.js` - PostCSS configuration
- `.eslintrc.json` - ESLint configuration
- `.env.example` - Environment variables
- **App Structure**:
- `app/layout.tsx` - Root layout
- `app/page.tsx` - Home page
- `app/globals.css` - Global styles + CSS variables
- `lib/utils.ts` - Utility functions (cn helper)
- **Dependencies** (30+ packages):
- Next.js 14, React 18, TypeScript 5
- Radix UI components, Tailwind CSS
- TanStack Query (React Query)
- react-hook-form + zod validation
- axios, lucide-react (icons)
- Jest, React Testing Library, Playwright
### 4. Docker Infrastructure ✅
**✅ docker-compose.yml**:
- **PostgreSQL 15**:
- Container: `xpeditis-postgres`
- Database: `xpeditis_dev`
- User: `xpeditis`
- Port: 5432
- Health checks enabled
- Persistent volumes
- Init script with extensions (uuid-ossp, pg_trgm)
- **Redis 7**:
- Container: `xpeditis-redis`
- Port: 6379
- Password protected
- AOF persistence
- Health checks enabled
- Persistent volumes
**✅ Database Initialization**:
- `infra/postgres/init.sql` - UUID extension, pg_trgm (fuzzy search)
### 5. CI/CD Pipelines ✅
**✅ GitHub Actions Workflows**:
#### `.github/workflows/ci.yml`:
- **Lint & Format Check**
- Prettier format check
- ESLint backend
- ESLint frontend
- **Test Backend**
- PostgreSQL service container
- Redis service container
- Unit tests
- E2E tests
- Coverage upload to Codecov
- **Test Frontend**
- Unit tests
- Coverage upload to Codecov
- **Build Backend**
- TypeScript compilation
- Artifact upload
- **Build Frontend**
- Next.js build
- Artifact upload
#### `.github/workflows/security.yml`:
- npm audit (weekly)
- Dependency review on PRs
#### `.github/pull_request_template.md`:
- Structured PR template
- Checklist for hexagonal architecture compliance
### 6. Configuration Files ✅
**✅ Root Level**:
- `package.json` - Workspace configuration
- `.gitignore` - Complete ignore rules
- `.prettierrc` - Code formatting rules
- `.prettierignore` - Files to ignore
- `README.md` - Comprehensive documentation
- `docker-compose.yml` - Infrastructure setup
- `CLAUDE.md` - Architecture guidelines (pre-existing)
- `PRD.md` - Product requirements (pre-existing)
- `TODO.md` - 30-week roadmap (pre-existing)
- `SPRINT-0-COMPLETE.md` - Sprint summary
### 7. Documentation ✅
**✅ Created**:
- `README.md` - Full project documentation
- Quick start guide
- Project structure
- Development commands
- Architecture overview
- Tech stack details
- Security practices
- `SPRINT-0-COMPLETE.md` - This summary
- `SPRINT-0-FINAL.md` - Comprehensive completion report
---
## 🎯 Key Achievements
### 1. Hexagonal Architecture ✅
- **Domain Layer**: Completely isolated, no external dependencies
- **Application Layer**: Controllers, DTOs, Mappers
- **Infrastructure Layer**: TypeORM, Redis, Carriers, Email, Storage
- **Path Aliases**: Clean imports (`@domain/*`, `@application/*`, `@infrastructure/*`)
- **Testability**: Domain can be tested without NestJS
### 2. Production-Ready Configuration ✅
- **Environment Validation**: Joi schema validation
- **Structured Logging**: Pino with pretty-print in dev
- **Security**: Helmet.js, CORS, rate limiting, JWT
- **Health Checks**: `/health`, `/ready`, `/live` endpoints
- **API Documentation**: Swagger UI at `/api/docs`
### 3. Developer Experience ✅
- **TypeScript**: Strict mode everywhere
- **Hot Reload**: Backend and frontend
- **Linting**: ESLint + Prettier
- **Testing**: Jest + Supertest + Playwright
- **CI/CD**: Automated testing and builds
- **Docker**: One-command infrastructure startup
### 4. Complete Tech Stack ✅
**Backend**:
- Framework: NestJS 10+
- Language: TypeScript 5+
- Database: PostgreSQL 15
- Cache: Redis 7
- ORM: TypeORM
- Auth: JWT + Passport + OAuth2
- API Docs: Swagger/OpenAPI
- Logging: Pino
- Testing: Jest + Supertest
- Security: Helmet, bcrypt, rate limiting
- Patterns: Circuit breaker (opossum)
**Frontend**:
- Framework: Next.js 14 (App Router)
- Language: TypeScript 5+
- Styling: Tailwind CSS + shadcn/ui
- State: TanStack Query
- Forms: react-hook-form + zod
- HTTP: axios
- Icons: lucide-react
- Testing: Jest + React Testing Library + Playwright
**Infrastructure**:
- PostgreSQL 15 (Docker)
- Redis 7 (Docker)
- CI/CD: GitHub Actions
- Version Control: Git
---
## 📁 File Count
- **Backend**: 15+ files
- **Frontend**: 12+ files
- **Infrastructure**: 3 files
- **CI/CD**: 3 files
- **Documentation**: 5 files
- **Configuration**: 10+ files
**Total**: ~50 files created
---
## 🚀 How to Use
### 1. Install Dependencies
```bash
# Root (workspaces)
npm install
# Backend (if needed separately)
cd apps/backend && npm install
# Frontend (if needed separately)
cd apps/frontend && npm install
```
### 2. Start Infrastructure
```bash
# Start PostgreSQL + Redis
docker-compose up -d
# Check status
docker-compose ps
# View logs
docker-compose logs -f
```
### 3. Configure Environment
```bash
# Backend
cp apps/backend/.env.example apps/backend/.env
# Edit apps/backend/.env with your values
# Frontend
cp apps/frontend/.env.example apps/frontend/.env
# Edit apps/frontend/.env with your values
```
### 4. Start Development Servers
```bash
# Terminal 1 - Backend
npm run backend:dev
# API: http://localhost:4000
# Docs: http://localhost:4000/api/docs
# Terminal 2 - Frontend
npm run frontend:dev
# App: http://localhost:3000
```
### 5. Verify Health
```bash
# Backend health check
curl http://localhost:4000/api/v1/health
# Expected response:
# {
# "status": "ok",
# "timestamp": "2025-10-07T...",
# "uptime": 12.345,
# "environment": "development",
# "version": "0.1.0"
# }
```
### 6. Run Tests
```bash
# All tests
npm run test:all
# Backend only
npm run backend:test
npm run backend:test:cov
# Frontend only
npm run frontend:test
# E2E tests
npm run backend:test:e2e
```
### 7. Lint & Format
```bash
# Check formatting
npm run format:check
# Fix formatting
npm run format
# Lint
npm run lint
```
---
## 🎯 Success Criteria - ALL MET ✅
- ✅ Monorepo structure with workspaces
- ✅ Backend with hexagonal architecture
- ✅ Frontend with Next.js 14
- ✅ Docker Compose for PostgreSQL + Redis
- ✅ Complete TypeScript configuration
- ✅ ESLint + Prettier setup
- ✅ Testing infrastructure (Jest, Supertest, Playwright)
- ✅ CI/CD pipelines (GitHub Actions)
- ✅ API documentation (Swagger)
- ✅ Logging (Pino)
- ✅ Security foundations (Helmet, JWT, CORS)
- ✅ Environment variable validation
- ✅ Health check endpoints
- ✅ Comprehensive documentation
---
## 📊 Sprint 0 Metrics
- **Duration**: 2 weeks (as planned)
- **Completion**: 100%
- **Files Created**: ~50
- **Lines of Code**: ~2,000+
- **Dependencies**: 80+ packages
- **Documentation Pages**: 5
- **CI/CD Workflows**: 2
- **Docker Services**: 2
---
## 🔐 Security Checklist (Before Production)
- [ ] Change all default passwords in `.env`
- [ ] Generate strong JWT secret (min 32 chars)
- [ ] Configure OAuth2 credentials (Google, Microsoft)
- [ ] Setup email service (SendGrid/AWS SES)
- [ ] Configure AWS S3 credentials
- [ ] Obtain carrier API keys (Maersk, MSC, CMA CGM, etc.)
- [ ] Enable HTTPS/TLS 1.3
- [ ] Configure Sentry DSN for error tracking
- [ ] Setup monitoring (Prometheus/Grafana)
- [ ] Enable automated database backups
- [ ] Review and restrict CORS origins
- [ ] Test rate limiting configuration
- [ ] Run OWASP ZAP security scan
- [ ] Enable two-factor authentication (2FA)
- [ ] Setup secrets rotation
---
## 🎯 Next Steps - Phase 1
Now ready to proceed with **Phase 1 - Core Search & Carrier Integration** (6-8 weeks):
### Sprint 1-2: Domain Layer & Port Definitions
- Create domain entities (Organization, User, RateQuote, Carrier, Port, Container)
- Create value objects (Email, PortCode, Money, ContainerType)
- Define API Ports (SearchRatesPort, GetPortsPort)
- Define SPI Ports (Repositories, CarrierConnectorPort, CachePort)
- Implement domain services
- Write domain unit tests (target: 90%+ coverage)
### Sprint 3-4: Infrastructure Layer
- Design database schema (ERD)
- Create TypeORM entities
- Implement repositories
- Create database migrations
- Seed data (carriers, ports)
- Implement Redis cache adapter
- Create Maersk connector
- Integration tests
### Sprint 5-6: Application Layer & Rate Search API
- Create DTOs and mappers
- Implement controllers (RatesController, PortsController)
- Complete OpenAPI documentation
- Implement caching strategy
- Performance optimization
- E2E tests
### Sprint 7-8: Frontend Rate Search UI
- Search form components
- Port autocomplete
- Results display (cards + table)
- Filtering & sorting
- Export functionality
- Responsive design
- Frontend tests
---
## 🏆 Sprint 0 - SUCCESSFULLY COMPLETED
**All infrastructure and configuration are in place.**
**The foundation is solid and ready for production development.**
### Team Achievement
- ✅ Hexagonal architecture properly implemented
- ✅ Production-ready configuration
- ✅ Excellent developer experience
- ✅ Comprehensive testing strategy
- ✅ CI/CD automation
- ✅ Complete documentation
### Ready to Build
- ✅ Domain entities
- ✅ Rate search functionality
- ✅ Carrier integrations
- ✅ Booking workflow
- ✅ User authentication
- ✅ Dashboard
---
**Project Status**: 🟢 READY FOR PHASE 1
**Sprint 0 Completion**: 100% ✅
**Time to Phase 1**: NOW 🚀
---
*Generated on October 7, 2025*
*Xpeditis MVP - Maritime Freight Booking Platform*

436
SPRINT-0-SUMMARY.md
View File

@ -1,436 +0,0 @@
# 📊 Sprint 0 - Executive Summary
## Xpeditis MVP - Project Setup & Infrastructure
**Status**: ✅ **COMPLETE**
**Completion Date**: October 7, 2025
**Duration**: As planned (2 weeks)
**Completion**: 100%
---
## 🎯 Objectives Achieved
Sprint 0 successfully established a production-ready foundation for the Xpeditis maritime freight booking platform with:
1. ✅ Complete monorepo structure with npm workspaces
2. ✅ Backend API with hexagonal architecture (NestJS)
3. ✅ Frontend application (Next.js 14)
4. ✅ Database and cache infrastructure (PostgreSQL + Redis)
5. ✅ CI/CD pipelines (GitHub Actions)
6. ✅ Complete documentation suite
7. ✅ Testing infrastructure
8. ✅ Security foundations
---
## 📦 Deliverables
### Code & Configuration (50+ files)
| Component | Files | Status |
|-----------|-------|--------|
| **Backend** | 15+ | ✅ Complete |
| **Frontend** | 12+ | ✅ Complete |
| **Infrastructure** | 3 | ✅ Complete |
| **CI/CD** | 3 | ✅ Complete |
| **Documentation** | 8 | ✅ Complete |
| **Configuration** | 10+ | ✅ Complete |
### Documentation Suite
1. **README.md** - Project overview and quick start
2. **CLAUDE.md** - Hexagonal architecture guidelines (476 lines)
3. **TODO.md** - 30-week development roadmap (1000+ lines)
4. **SPRINT-0-FINAL.md** - Complete sprint report
5. **SPRINT-0-SUMMARY.md** - This executive summary
6. **QUICK-START.md** - 5-minute setup guide
7. **INSTALLATION-STEPS.md** - Detailed installation
8. **apps/backend/README.md** - Backend documentation
9. **apps/frontend/README.md** - Frontend documentation
---
## 🏗️ Architecture
### Backend (Hexagonal Architecture)
**Strict separation of concerns**:
```
✅ Domain Layer (Pure Business Logic)
├── Zero framework dependencies
├── Testable without NestJS
└── 90%+ code coverage target
✅ Application Layer (Controllers & DTOs)
├── REST API endpoints
├── Input validation
└── DTO mapping
✅ Infrastructure Layer (External Adapters)
├── TypeORM repositories
├── Redis cache
├── Carrier connectors
├── Email service
└── S3 storage
```
**Key Benefits**:
- Domain can be tested in isolation
- Easy to swap databases or frameworks
- Clear separation of concerns
- Maintainable and scalable
### Frontend (Next.js 14 + React 18)
**Modern React stack**:
- App Router with server components
- TypeScript strict mode
- Tailwind CSS + shadcn/ui
- TanStack Query for state
- react-hook-form + zod for forms
---
## 🛠️ Technology Stack
### Backend
- **Framework**: NestJS 10+
- **Language**: TypeScript 5+
- **Database**: PostgreSQL 15
- **Cache**: Redis 7
- **ORM**: TypeORM
- **Auth**: JWT + Passport + OAuth2
- **API Docs**: Swagger/OpenAPI
- **Logging**: Pino (structured JSON)
- **Testing**: Jest + Supertest
- **Security**: Helmet, bcrypt, rate limiting
### Frontend
- **Framework**: Next.js 14
- **Language**: TypeScript 5+
- **Styling**: Tailwind CSS
- **UI**: shadcn/ui (Radix UI)
- **State**: TanStack Query
- **Forms**: react-hook-form + zod
- **HTTP**: axios
- **Testing**: Jest + React Testing Library + Playwright
### Infrastructure
- **Database**: PostgreSQL 15 (Docker)
- **Cache**: Redis 7 (Docker)
- **CI/CD**: GitHub Actions
- **Container**: Docker + Docker Compose
---
## 📊 Metrics
| Metric | Value |
|--------|-------|
| **Files Created** | ~50 |
| **Lines of Code** | 2,000+ |
| **Dependencies** | 80+ packages |
| **Documentation** | 8 files, 3000+ lines |
| **CI/CD Workflows** | 2 (ci.yml, security.yml) |
| **Docker Services** | 2 (PostgreSQL, Redis) |
| **Test Coverage Target** | Domain: 90%, App: 80%, Infra: 70% |
---
## ✅ Success Criteria - All Met
| Criteria | Status | Notes |
|----------|--------|-------|
| Monorepo structure | ✅ | npm workspaces configured |
| Backend hexagonal arch | ✅ | Complete separation of layers |
| Frontend Next.js 14 | ✅ | App Router + TypeScript |
| Docker infrastructure | ✅ | PostgreSQL + Redis with health checks |
| TypeScript strict mode | ✅ | All projects |
| Testing infrastructure | ✅ | Jest, Supertest, Playwright |
| CI/CD pipelines | ✅ | GitHub Actions (lint, test, build) |
| API documentation | ✅ | Swagger at /api/docs |
| Logging | ✅ | Pino structured logging |
| Security foundations | ✅ | Helmet, JWT, CORS, rate limiting |
| Environment validation | ✅ | Joi schema validation |
| Health endpoints | ✅ | /health, /ready, /live |
| Documentation | ✅ | 8 comprehensive documents |
---
## 🎯 Key Features Implemented
### Backend Features
1. **Health Check System**
- `/health` - Overall system health
- `/ready` - Readiness for traffic
- `/live` - Liveness check
2. **Logging System**
- Structured JSON logs (Pino)
- Pretty print in development
- Request/response logging
- Log levels (debug, info, warn, error)
3. **Configuration Management**
- Environment variable validation
- Type-safe configuration
- Multiple environments support
4. **Security**
- Helmet.js security headers
- CORS configuration
- Rate limiting prepared
- JWT authentication ready
- Password hashing (bcrypt)
5. **API Documentation**
- Swagger UI at `/api/docs`
- OpenAPI specification
- Request/response schemas
- Authentication documentation
### Frontend Features
1. **Modern React Setup**
- Next.js 14 App Router
- Server and client components
- TypeScript strict mode
- Path aliases configured
2. **UI Framework**
- Tailwind CSS with custom theme
- shadcn/ui components ready
- Dark mode support (CSS variables)
- Responsive design utilities
3. **State Management**
- TanStack Query for server state
- React hooks for local state
- Form state with react-hook-form
4. **Utilities**
- `cn()` helper for className merging
- Type-safe API client ready
- Zod schemas for validation
---
## 🚀 Ready for Phase 1
The project is **fully ready** for Phase 1 development:
### Phase 1 - Core Search & Carrier Integration (6-8 weeks)
**Sprint 1-2: Domain Layer**
- ✅ Folder structure ready
- ✅ Path aliases configured
- ✅ Testing infrastructure ready
- 🎯 Ready to create: Entities, Value Objects, Ports, Services
**Sprint 3-4: Infrastructure**
- ✅ Database configured (PostgreSQL)
- ✅ Cache configured (Redis)
- ✅ TypeORM setup
- 🎯 Ready to create: Repositories, Migrations, Seed data
**Sprint 5-6: Application Layer**
- ✅ NestJS configured
- ✅ Swagger ready
- ✅ Validation pipes configured
- 🎯 Ready to create: Controllers, DTOs, Mappers
**Sprint 7-8: Frontend UI**
- ✅ Next.js configured
- ✅ Tailwind CSS ready
- ✅ shadcn/ui ready
- 🎯 Ready to create: Search components, Results display
---
## 📁 Project Structure
```
xpeditis/
├── apps/
│ ├── backend/ ✅ NestJS + Hexagonal
│ │ ├── src/
│ │ │ ├── domain/ ✅ Pure business logic
│ │ │ ├── application/ ✅ Controllers & DTOs
│ │ │ ├── infrastructure/ ✅ External adapters
│ │ │ ├── main.ts ✅ Bootstrap
│ │ │ └── app.module.ts ✅ Root module
│ │ ├── test/ ✅ E2E tests
│ │ └── [config files] ✅ All complete
│ │
│ └── frontend/ ✅ Next.js 14
│ ├── app/ ✅ App Router
│ ├── components/ ✅ Ready for components
│ ├── lib/ ✅ Utilities
│ └── [config files] ✅ All complete
│
├── packages/
│ ├── shared-types/ ✅ Created
│ └── domain/ ✅ Created
│
├── infra/
│ └── postgres/ ✅ Init scripts
│
├── .github/
│ └── workflows/ ✅ CI/CD pipelines
│
├── docker-compose.yml ✅ PostgreSQL + Redis
├── package.json ✅ Workspace root
├── [documentation] ✅ 8 files
└── [config files] ✅ Complete
```
---
## 💻 Development Workflow
### Quick Start (5 minutes)
```bash
# 1. Install dependencies
npm install
# 2. Start infrastructure
docker-compose up -d
# 3. Configure environment
cp apps/backend/.env.example apps/backend/.env
cp apps/frontend/.env.example apps/frontend/.env
# 4. Start backend
npm run backend:dev
# 5. Start frontend (in another terminal)
npm run frontend:dev
```
### Verification
- ✅ Backend: http://localhost:4000/api/v1/health
- ✅ API Docs: http://localhost:4000/api/docs
- ✅ Frontend: http://localhost:3000
- ✅ PostgreSQL: localhost:5432
- ✅ Redis: localhost:6379
---
## 🎓 Learning Resources
For team members new to the stack:
**Hexagonal Architecture**:
- Read [CLAUDE.md](CLAUDE.md) (comprehensive guide)
- Review backend folder structure
- Study the flow: HTTP → Controller → Use Case → Domain
**NestJS**:
- [Official Docs](https://docs.nestjs.com/)
- Focus on: Modules, Controllers, Providers, DTOs
**Next.js 14**:
- [Official Docs](https://nextjs.org/docs)
- Focus on: App Router, Server Components, Client Components
**TypeORM**:
- [Official Docs](https://typeorm.io/)
- Focus on: Entities, Repositories, Migrations
---
## 🔒 Security Considerations
**Implemented**:
- ✅ Helmet.js security headers
- ✅ CORS configuration
- ✅ Input validation (class-validator)
- ✅ Environment variable validation
- ✅ Password hashing configuration
- ✅ JWT configuration
- ✅ Rate limiting preparation
**For Production** (before deployment):
- [ ] Change all default passwords
- [ ] Generate strong JWT secret
- [ ] Configure OAuth2 credentials
- [ ] Setup email service
- [ ] Configure AWS S3
- [ ] Obtain carrier API keys
- [ ] Enable HTTPS/TLS
- [ ] Setup Sentry
- [ ] Configure monitoring
- [ ] Enable database backups
- [ ] Run security audit
---
## 📈 Next Steps
### Immediate (This Week)
1. ✅ Sprint 0 complete
2. 🎯 Install dependencies (`npm install`)
3. 🎯 Start infrastructure (`docker-compose up -d`)
4. 🎯 Verify all services running
5. 🎯 Begin Sprint 1 (Domain entities)
### Short Term (Next 2 Weeks - Sprint 1-2)
1. Create domain entities (Organization, User, RateQuote, Carrier, Port)
2. Create value objects (Email, PortCode, Money, ContainerType)
3. Define API ports (SearchRatesPort, GetPortsPort)
4. Define SPI ports (Repositories, CarrierConnectorPort, CachePort)
5. Implement domain services
6. Write domain unit tests (90%+ coverage)
### Medium Term (Weeks 3-8 - Sprint 3-6)
1. Design and implement database schema
2. Create TypeORM entities and repositories
3. Implement Redis cache adapter
4. Create Maersk carrier connector
5. Implement rate search API
6. Build frontend search UI
---
## 🎉 Conclusion
Sprint 0 has been **successfully completed** with:
- ✅ **100% of planned deliverables**
- ✅ **Production-ready infrastructure**
- ✅ **Hexagonal architecture properly implemented**
- ✅ **Complete documentation suite**
- ✅ **Automated CI/CD pipelines**
- ✅ **Developer-friendly setup**
**The Xpeditis MVP project is ready for Phase 1 development.**
---
## 📞 Support
For questions or issues:
1. Check documentation (8 comprehensive guides)
2. Review [QUICK-START.md](QUICK-START.md)
3. Consult [INSTALLATION-STEPS.md](INSTALLATION-STEPS.md)
4. Open a GitHub issue
---
**Status**: 🟢 **READY FOR DEVELOPMENT**
**Next Phase**: Phase 1 - Core Search & Carrier Integration
**Team**: ✅ **Ready to build**
---
*Xpeditis MVP - Maritime Freight Booking Platform*
*Sprint 0 Complete - October 7, 2025*

59
apps/backend/.env.example
View File

@ -35,51 +35,27 @@ MICROSOFT_CALLBACK_URL=http://localhost:4000/api/v1/auth/microsoft/callback
# Application URL
APP_URL=http://localhost:3000
FRONTEND_URL=http://localhost:3000
# Email (SMTP)
SMTP_HOST=smtp-relay.brevo.com
SMTP_PORT=587
SMTP_USER=ton-email@brevo.com
SMTP_PASS=ta-cle-smtp-brevo
SMTP_USER=
SMTP_PASS=
SMTP_SECURE=false
# SMTP_FROM devient le fallback uniquement (chaque méthode a son propre from maintenant)
SMTP_FROM=noreply@xpeditis.com
# AWS S3 / Storage (or MinIO for development)
AWS_ACCESS_KEY_ID=your-aws-access-key
AWS_SECRET_ACCESS_KEY=your-aws-secret-key
AWS_ACCESS_KEY_ID=minioadmin
AWS_SECRET_ACCESS_KEY=minioadmin
AWS_REGION=us-east-1
AWS_S3_ENDPOINT=http://localhost:9000
# AWS_S3_ENDPOINT= # Leave empty for AWS S3
# Carrier APIs
# Maersk
MAERSK_API_KEY=your-maersk-api-key
MAERSK_API_URL=https://api.maersk.com/v1
# MSC
MSC_API_KEY=your-msc-api-key
MSC_API_URL=https://api.msc.com/v1
# CMA CGM
CMACGM_API_URL=https://api.cma-cgm.com/v1
CMACGM_CLIENT_ID=your-cmacgm-client-id
CMACGM_CLIENT_SECRET=your-cmacgm-client-secret
# Hapag-Lloyd
HAPAG_API_URL=https://api.hapag-lloyd.com/v1
HAPAG_API_KEY=your-hapag-api-key
# ONE (Ocean Network Express)
ONE_API_URL=https://api.one-line.com/v1
ONE_USERNAME=your-one-username
ONE_PASSWORD=your-one-password
# Swagger Documentation Access (HTTP Basic Auth)
# Leave empty to disable Swagger in production, or set both to protect with a password
SWAGGER_USERNAME=admin
SWAGGER_PASSWORD=change-this-strong-password
# Swagger Documentation Access (HTTP Basic Auth — only you can access /api/docs)
SWAGGER_USERNAME=
SWAGGER_PASSWORD=
# Security
BCRYPT_ROUNDS=12
@ -92,17 +68,18 @@ RATE_LIMIT_MAX=100
# Monitoring
SENTRY_DSN=your-sentry-dsn
# Frontend URL (for redirects)
FRONTEND_URL=http://localhost:3000
# Stripe (Subscriptions & Payments)
STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key
STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret
STRIPE_SECRET_KEY=
STRIPE_WEBHOOK_SECRET=
# Stripe Price IDs (create these in Stripe Dashboard)
STRIPE_SILVER_MONTHLY_PRICE_ID=price_silver_monthly
STRIPE_SILVER_YEARLY_PRICE_ID=price_silver_yearly
STRIPE_GOLD_MONTHLY_PRICE_ID=price_gold_monthly
STRIPE_GOLD_YEARLY_PRICE_ID=price_gold_yearly
STRIPE_PLATINIUM_MONTHLY_PRICE_ID=price_platinium_monthly
STRIPE_PLATINIUM_YEARLY_PRICE_ID=price_platinium_yearly
# Stripe Price IDs (from Stripe Dashboard)
STRIPE_SILVER_MONTHLY_PRICE_ID=
STRIPE_SILVER_YEARLY_PRICE_ID=
STRIPE_GOLD_MONTHLY_PRICE_ID=
STRIPE_GOLD_YEARLY_PRICE_ID=
STRIPE_PLATINIUM_MONTHLY_PRICE_ID=
STRIPE_PLATINIUM_YEARLY_PRICE_ID=

328
apps/backend/CARRIER_ACCEPT_REJECT_FIX.md
View File

@ -1,328 +0,0 @@
# ✅ FIX: Redirection Transporteur après Accept/Reject
**Date**: 5 décembre 2025
**Statut**: ✅ **CORRIGÉ ET TESTÉ**
---
## 🎯 Problème Identifié
**Symptôme**: Quand un transporteur clique sur "Accepter" ou "Refuser" dans l'email:
- ❌ Pas de redirection vers le dashboard transporteur
- ❌ Le status du booking ne change pas
- ❌ Erreur 404 ou pas de réponse
**URL problématique**:
```
http://localhost:3000/api/v1/csv-bookings/{token}/accept
```
**Cause Racine**: Les URLs dans l'email pointaient vers le **frontend** (port 3000) au lieu du **backend** (port 4000).
---
## 🔍 Analyse du Problème
### Ce qui se passait AVANT (❌ Cassé)
1. **Email envoyé** avec URL: `http://localhost:3000/api/v1/csv-bookings/{token}/accept`
2. **Transporteur clique** sur le lien
3. **Frontend** (port 3000) reçoit la requête
4. **Erreur 404** car `/api/v1/*` n'existe pas sur le frontend
5. **Aucune redirection**, aucun traitement
### Workflow Attendu (✅ Correct)
1. **Email envoyé** avec URL: `http://localhost:4000/api/v1/csv-bookings/{token}/accept`
2. **Transporteur clique** sur le lien
3. **Backend** (port 4000) reçoit la requête
4. **Backend traite**:
- Accepte le booking
- Crée un compte transporteur si nécessaire
- Génère un token d'auto-login
5. **Backend redirige** vers: `http://localhost:3000/carrier/confirmed?token={autoLoginToken}&action=accepted&bookingId={id}&new={isNew}`
6. **Frontend** affiche la page de confirmation
7. **Transporteur** est auto-connecté et voit son dashboard
---
## ✅ Correction Appliquée
### Fichier 1: `email.adapter.ts` (lignes 259-264)
**AVANT** (❌):
```typescript
const baseUrl = this.configService.get('APP_URL', 'http://localhost:3000'); // Frontend!
const acceptUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/accept`;
const rejectUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/reject`;
```
**APRÈS** (✅):
```typescript
// Use BACKEND_URL if available, otherwise construct from PORT
// The accept/reject endpoints are on the BACKEND, not the frontend
const port = this.configService.get('PORT', '4000');
const backendUrl = this.configService.get('BACKEND_URL', `http://localhost:${port}`);
const acceptUrl = `${backendUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/accept`;
const rejectUrl = `${backendUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/reject`;
```
**Changements**:
- ✅ Utilise `BACKEND_URL` ou construit à partir de `PORT`
- ✅ URLs pointent maintenant vers `http://localhost:4000/api/v1/...`
- ✅ Commentaires ajoutés pour clarifier
### Fichier 2: `app.module.ts` (lignes 39-40)
Ajout des variables `APP_URL` et `BACKEND_URL` au schéma de validation:
```typescript
validationSchema: Joi.object({
// ...
APP_URL: Joi.string().uri().default('http://localhost:3000'),
BACKEND_URL: Joi.string().uri().optional(),
// ...
}),
```
**Pourquoi**: Pour éviter que ces variables soient supprimées par la validation Joi.
---
## 🧪 Test du Workflow Complet
### Prérequis
- ✅ Backend en cours d'exécution (port 4000)
- ✅ Frontend en cours d'exécution (port 3000)
- ✅ MinIO en cours d'exécution
- ✅ Email adapter initialisé
### Étape 1: Créer un Booking CSV
1. **Se connecter** au frontend: http://localhost:3000
2. **Aller sur** la page de recherche avancée
3. **Rechercher un tarif** et cliquer sur "Réserver"
4. **Remplir le formulaire**:
- Carrier email: Votre email de test (ou Mailtrap)
- Ajouter au moins 1 document
5. **Cliquer sur "Envoyer la demande"**
### Étape 2: Vérifier l'Email Reçu
1. **Ouvrir Mailtrap**: https://mailtrap.io/inboxes
2. **Trouver l'email**: "Nouvelle demande de réservation - {origin} → {destination}"
3. **Vérifier les URLs** des boutons:
- ✅ Accepter: `http://localhost:4000/api/v1/csv-bookings/{token}/accept`
- ✅ Refuser: `http://localhost:4000/api/v1/csv-bookings/{token}/reject`
**IMPORTANT**: Les URLs doivent pointer vers **port 4000** (backend), PAS port 3000!
### Étape 3: Tester l'Acceptation
1. **Copier l'URL** du bouton "Accepter" depuis l'email
2. **Ouvrir dans le navigateur** (ou cliquer sur le bouton)
3. **Observer**:
- ✅ Le navigateur va d'abord vers `localhost:4000`
- ✅ Puis redirige automatiquement vers `localhost:3000/carrier/confirmed?...`
- ✅ Page de confirmation affichée
- ✅ Transporteur auto-connecté
### Étape 4: Vérifier le Dashboard Transporteur
Après la redirection:
1. **URL attendue**:
```
http://localhost:3000/carrier/confirmed?token={autoLoginToken}&action=accepted&bookingId={id}&new=true
```
2. **Page affichée**:
- ✅ Message de confirmation: "Réservation acceptée avec succès!"
- ✅ Lien vers le dashboard transporteur
- ✅ Si nouveau compte: Message avec credentials
3. **Vérifier le status**:
- Le booking doit maintenant avoir le status `ACCEPTED`
- Visible dans le dashboard utilisateur (celui qui a créé le booking)
### Étape 5: Tester le Rejet
Répéter avec le bouton "Refuser":
1. **Créer un nouveau booking** (étape 1)
2. **Cliquer sur "Refuser"** dans l'email
3. **Vérifier**:
- ✅ Redirection vers `/carrier/confirmed?...&action=rejected`
- ✅ Message: "Réservation refusée"
- ✅ Status du booking: `REJECTED`
---
## 📊 Vérifications Backend
### Logs Attendus lors de l'Acceptation
```bash
# Monitorer les logs
tail -f /tmp/backend-restart.log | grep -i "accept\|carrier\|booking"
```
**Logs attendus**:
```
[CsvBookingService] Accepting booking with token: {token}
[CarrierAuthService] Creating carrier account for email: carrier@test.com
[CarrierAuthService] Carrier account created with ID: {carrierId}
[CsvBookingService] Successfully linked booking {bookingId} to carrier {carrierId}
```
---
## 🔧 Variables d'Environnement
### `.env` Backend
**Variables requises**:
```bash
PORT=4000 # Port du backend
APP_URL=http://localhost:3000 # URL du frontend
BACKEND_URL=http://localhost:4000 # URL du backend (optionnel, auto-construit si absent)
```
**En production**:
```bash
PORT=4000
APP_URL=https://xpeditis.com
BACKEND_URL=https://api.xpeditis.com
```
---
## 🐛 Dépannage
### Problème 1: Toujours redirigé vers port 3000
**Cause**: Email envoyé AVANT la correction
**Solution**:
1. Backend a été redémarré après la correction ✅
2. Créer un **NOUVEAU booking** pour recevoir un email avec les bonnes URLs
3. Les anciens bookings ont encore les anciennes URLs (port 3000)
---
### Problème 2: 404 Not Found sur /accept
**Cause**: Backend pas démarré ou route mal configurée
**Solution**:
```bash
# Vérifier que le backend tourne
curl http://localhost:4000/api/v1/health || echo "Backend not responding"
# Vérifier les logs backend
tail -50 /tmp/backend-restart.log | grep -i "csv-bookings"
# Redémarrer le backend
cd apps/backend
npm run dev
```
---
### Problème 3: Token Invalid
**Cause**: Token expiré ou booking déjà accepté/refusé
**Solution**:
- Les bookings ne peuvent être acceptés/refusés qu'une seule fois
- Si token invalide, créer un nouveau booking
- Vérifier dans la base de données le status du booking
---
### Problème 4: Pas de redirection vers /carrier/confirmed
**Cause**: Frontend route manquante ou token d'auto-login invalide
**Vérification**:
1. Vérifier que la route `/carrier/confirmed` existe dans le frontend
2. Vérifier les logs backend pour voir si le token est généré
3. Vérifier que le frontend affiche bien la page
---
## 📝 Checklist de Validation
- [x] Backend redémarré avec la correction
- [x] Email adapter initialisé correctement
- [x] Variables `APP_URL` et `BACKEND_URL` dans le schéma Joi
- [ ] Nouveau booking créé (APRÈS la correction)
- [ ] Email reçu avec URLs correctes (port 4000)
- [ ] Clic sur "Accepter" → Redirection vers /carrier/confirmed
- [ ] Status du booking changé en `ACCEPTED`
- [ ] Dashboard transporteur accessible
- [ ] Test "Refuser" fonctionne aussi
---
## 🎯 Résumé des Corrections
| Aspect | Avant (❌) | Après (✅) |
|--------|-----------|-----------|
| **Email URL Accept** | `localhost:3000/api/v1/...` | `localhost:4000/api/v1/...` |
| **Email URL Reject** | `localhost:3000/api/v1/...` | `localhost:4000/api/v1/...` |
| **Redirection** | Aucune (404) | Vers `/carrier/confirmed` |
| **Status booking** | Ne change pas | `ACCEPTED` ou `REJECTED` |
| **Dashboard transporteur** | Inaccessible | Accessible avec auto-login |
---
## ✅ Workflow Complet Corrigé
```
1. Utilisateur crée booking
└─> Backend sauvegarde booking (status: PENDING)
└─> Backend envoie email avec URLs backend (port 4000) ✅
2. Transporteur clique "Accepter" dans email
└─> Ouvre: http://localhost:4000/api/v1/csv-bookings/{token}/accept ✅
└─> Backend traite la requête:
├─> Change status → ACCEPTED ✅
├─> Crée compte transporteur si nécessaire ✅
├─> Génère token auto-login ✅
└─> Redirige vers frontend: localhost:3000/carrier/confirmed?... ✅
3. Frontend affiche page confirmation
└─> Message de succès ✅
└─> Auto-login du transporteur ✅
└─> Lien vers dashboard ✅
4. Transporteur accède à son dashboard
└─> Voir la liste de ses bookings ✅
└─> Gérer ses réservations ✅
```
---
## 🚀 Prochaines Étapes
1. **Tester immédiatement**:
- Créer un nouveau booking (important: APRÈS le redémarrage)
- Vérifier l'email reçu
- Tester Accept/Reject
2. **Vérifier en production**:
- Mettre à jour la variable `BACKEND_URL` dans le .env production
- Redéployer le backend
- Tester le workflow complet
3. **Documentation**:
- Mettre à jour le guide utilisateur
- Documenter le workflow transporteur
---
**Correction effectuée le 5 décembre 2025 par Claude Code** ✅
_Le système d'acceptation/rejet transporteur est maintenant 100% fonctionnel!_ 🚢✨

282
apps/backend/CSV_BOOKING_DIAGNOSTIC.md
View File

@ -1,282 +0,0 @@
# 🔍 Diagnostic Complet - Workflow CSV Booking
**Date**: 5 décembre 2025
**Problème**: Le workflow d'envoi de demande de booking ne fonctionne pas
---
## ✅ Vérifications Effectuées
### 1. Backend ✅
- ✅ Backend en cours d'exécution (port 4000)
- ✅ Configuration SMTP corrigée (variables ajoutées au schéma Joi)
- ✅ Email adapter initialisé correctement avec DNS bypass
- ✅ Module CsvBookingsModule importé dans app.module.ts
- ✅ Controller CsvBookingsController bien configuré
- ✅ Service CsvBookingService bien configuré
- ✅ MinIO container en cours d'exécution
- ✅ Bucket 'xpeditis-documents' existe dans MinIO
### 2. Frontend ✅
- ✅ Page `/dashboard/booking/new` existe
- ✅ Fonction `handleSubmit` bien configurée
- ✅ FormData correctement construit avec tous les champs
- ✅ Documents ajoutés avec le nom 'documents' (pluriel)
- ✅ Appel API via `createCsvBooking()` qui utilise `upload()`
- ✅ Gestion d'erreurs présente (affiche message si échec)
---
## 🔍 Points de Défaillance Possibles
### Scénario 1: Erreur Frontend (Browser Console)
**Symptômes**: Le bouton "Envoyer la demande" ne fait rien, ou affiche un message d'erreur
**Vérification**:
1. Ouvrir les DevTools du navigateur (F12)
2. Aller dans l'onglet Console
3. Cliquer sur "Envoyer la demande"
4. Regarder les erreurs affichées
**Erreurs Possibles**:
- `Failed to fetch` → Problème de connexion au backend
- `401 Unauthorized` → Token JWT expiré
- `400 Bad Request` → Données invalides
- `500 Internal Server Error` → Erreur backend (voir logs)
---
### Scénario 2: Erreur Backend (Logs)
**Symptômes**: La requête arrive au backend mais échoue
**Vérification**:
```bash
# Voir les logs backend en temps réel
tail -f /tmp/backend-startup.log
# Puis créer un booking via le frontend
```
**Erreurs Possibles**:
- **Pas de logs `=== CSV Booking Request Debug ===`** → La requête n'arrive pas au controller
- **`At least one document is required`** → Aucun fichier uploadé
- **`User authentication failed`** → Problème de JWT
- **`Organization ID is required`** → User sans organizationId
- **Erreur S3/MinIO** → Upload de fichiers échoué
- **Erreur Email** → Envoi email échoué (ne devrait plus arriver après le fix)
---
### Scénario 3: Validation Échouée
**Symptômes**: Erreur 400 Bad Request
**Causes Possibles**:
- **Port codes invalides** (origin/destination): Doivent être exactement 5 caractères (ex: NLRTM, USNYC)
- **Email invalide** (carrierEmail): Doit être un email valide
- **Champs numériques** (volumeCBM, weightKG, etc.): Doivent être > 0
- **Currency invalide**: Doit être 'USD' ou 'EUR'
- **Pas de documents**: Au moins 1 fichier requis
---
### Scénario 4: CORS ou Network
**Symptômes**: Erreur CORS ou network error
**Vérification**:
1. Ouvrir DevTools → Network tab
2. Créer un booking
3. Regarder la requête POST vers `/api/v1/csv-bookings`
4. Vérifier:
- Status code (200/201 = OK, 4xx/5xx = erreur)
- Response body (message d'erreur)
- Request headers (Authorization token présent?)
**Solutions**:
- Backend et frontend doivent tourner simultanément
- Frontend: `http://localhost:3000`
- Backend: `http://localhost:4000`
---
## 🧪 Tests à Effectuer
### Test 1: Vérifier que le Backend Reçoit la Requête
1. **Ouvrir un terminal et monitorer les logs**:
```bash
tail -f /tmp/backend-startup.log | grep -i "csv\|booking\|error"
```
2. **Dans le navigateur**:
- Aller sur: http://localhost:3000/dashboard/booking/new?rateData=%7B%22companyName%22%3A%22Test%20Carrier%22%2C%22companyEmail%22%3A%22carrier%40test.com%22%2C%22origin%22%3A%22NLRTM%22%2C%22destination%22%3A%22USNYC%22%2C%22containerType%22%3A%22LCL%22%2C%22priceUSD%22%3A1000%2C%22priceEUR%22%3A900%2C%22primaryCurrency%22%3A%22USD%22%2C%22transitDays%22%3A22%7D&volumeCBM=2.88&weightKG=1500&palletCount=3
- Ajouter au moins 1 document
- Cliquer sur "Envoyer la demande"
3. **Dans les logs, vous devriez voir**:
```
=== CSV Booking Request Debug ===
req.user: { id: '...', organizationId: '...' }
req.body: { carrierName: 'Test Carrier', ... }
files: 1
================================
Creating CSV booking for user ...
Uploaded 1 documents for booking ...
CSV booking created with ID: ...
Email sent to carrier: carrier@test.com
Notification created for user ...
```
4. **Si vous NE voyez PAS ces logs** → La requête n'arrive pas au backend. Vérifier:
- Frontend connecté et JWT valide
- Backend en cours d'exécution
- Network tab du navigateur pour voir l'erreur exacte
---
### Test 2: Vérifier le Browser Console
1. **Ouvrir DevTools** (F12)
2. **Aller dans Console**
3. **Créer un booking**
4. **Regarder les erreurs**:
- Si erreur affichée → noter le message exact
- Si aucune erreur → le problème est silencieux (voir Network tab)
---
### Test 3: Vérifier Network Tab
1. **Ouvrir DevTools** (F12)
2. **Aller dans Network**
3. **Créer un booking**
4. **Trouver la requête** `POST /api/v1/csv-bookings`
5. **Vérifier**:
- Status: Doit être 200 ou 201
- Request Payload: Tous les champs présents?
- Response: Message d'erreur?
---
## 🔧 Solutions par Erreur
### Erreur: "At least one document is required"
**Cause**: Aucun fichier n'a été uploadé
**Solution**:
- Vérifier que vous avez bien sélectionné au moins 1 fichier
- Vérifier que le fichier est dans les formats acceptés (PDF, DOC, DOCX, JPG, PNG)
- Vérifier que le fichier fait moins de 5MB
---
### Erreur: "User authentication failed"
**Cause**: Token JWT invalide ou expiré
**Solution**:
1. Se déconnecter
2. Se reconnecter
3. Réessayer
---
### Erreur: "Organization ID is required"
**Cause**: L'utilisateur n'a pas d'organizationId
**Solution**:
1. Vérifier dans la base de données que l'utilisateur a bien un `organizationId`
2. Si non, assigner une organization à l'utilisateur
---
### Erreur: S3/MinIO Upload Failed
**Cause**: Impossible d'uploader vers MinIO
**Solution**:
```bash
# Vérifier que MinIO tourne
docker ps | grep minio
# Si non, le démarrer
docker-compose up -d
# Vérifier que le bucket existe
cd apps/backend
node setup-minio-bucket.js
```
---
### Erreur: Email Failed (ne devrait plus arriver)
**Cause**: Envoi email échoué
**Solution**:
- Vérifier que les variables SMTP sont dans le schéma Joi (déjà corrigé ✅)
- Tester l'envoi d'email: `node test-smtp-simple.js`
---
## 📊 Checklist de Diagnostic
Cocher au fur et à mesure:
- [ ] Backend en cours d'exécution (port 4000)
- [ ] Frontend en cours d'exécution (port 3000)
- [ ] MinIO en cours d'exécution (port 9000)
- [ ] Bucket 'xpeditis-documents' existe
- [ ] Variables SMTP configurées
- [ ] Email adapter initialisé (logs backend)
- [ ] Utilisateur connecté au frontend
- [ ] Token JWT valide (pas expiré)
- [ ] Browser console sans erreurs
- [ ] Network tab montre requête POST envoyée
- [ ] Logs backend montrent "CSV Booking Request Debug"
- [ ] Documents uploadés (au moins 1)
- [ ] Port codes valides (5 caractères exactement)
- [ ] Email transporteur valide
---
## 🚀 Commandes Utiles
```bash
# Redémarrer backend
cd apps/backend
npm run dev
# Vérifier logs backend
tail -f /tmp/backend-startup.log | grep -i "csv\|booking\|error"
# Tester email
cd apps/backend
node test-smtp-simple.js
# Vérifier MinIO
docker ps | grep minio
node setup-minio-bucket.js
# Voir tous les endpoints
curl http://localhost:4000/api/docs
```
---
## 📝 Prochaines Étapes
1. **Effectuer les tests** ci-dessus dans l'ordre
2. **Noter l'erreur exacte** qui apparaît (console, network, logs)
3. **Appliquer la solution** correspondante
4. **Réessayer**
Si après tous ces tests le problème persiste, partager:
- Le message d'erreur exact (browser console)
- Les logs backend au moment de l'erreur
- Le status code HTTP de la requête (network tab)
---
**Dernière mise à jour**: 5 décembre 2025
**Statut**:
- ✅ Email fix appliqué
- ✅ MinIO bucket vérifié
- ✅ Code analysé
- ⏳ En attente de tests utilisateur

386
apps/backend/EMAIL_CARRIER_FIX_COMPLETE.md
View File

@ -1,386 +0,0 @@
# ✅ CORRECTION COMPLÈTE - Envoi d'Email aux Transporteurs
**Date**: 5 décembre 2025
**Statut**: ✅ **CORRIGÉ**
---
## 🔍 Problème Identifié
**Symptôme**: Les emails ne sont plus envoyés aux transporteurs lors de la création de bookings CSV.
**Cause Racine**:
Le fix DNS implémenté dans `EMAIL_FIX_SUMMARY.md` n'était **PAS appliqué** dans le code actuel de `email.adapter.ts`. Le code utilisait la configuration standard sans contournement DNS, ce qui causait des timeouts sur certains réseaux.
```typescript
// ❌ CODE PROBLÉMATIQUE (avant correction)
this.transporter = nodemailer.createTransport({
host, // ← utilisait directement 'sandbox.smtp.mailtrap.io' sans contournement DNS
port,
secure,
auth: { user, pass },
});
```
---
## ✅ Solution Implémentée
### 1. **Correction de `email.adapter.ts`** (Lignes 25-63)
**Fichier modifié**: `src/infrastructure/email/email.adapter.ts`
```typescript
private initializeTransporter(): void {
const host = this.configService.get<string>('SMTP_HOST', 'localhost');
const port = this.configService.get<number>('SMTP_PORT', 2525);
const user = this.configService.get<string>('SMTP_USER');
const pass = this.configService.get<string>('SMTP_PASS');
const secure = this.configService.get<boolean>('SMTP_SECURE', false);
// 🔧 FIX: Contournement DNS pour Mailtrap
// Utilise automatiquement l'IP directe quand 'mailtrap.io' est détecté
const useDirectIP = host.includes('mailtrap.io');
const actualHost = useDirectIP ? '3.209.246.195' : host;
const serverName = useDirectIP ? 'smtp.mailtrap.io' : host; // Pour TLS
this.transporter = nodemailer.createTransport({
host: actualHost, // ← Utilise IP directe pour Mailtrap
port,
secure,
auth: { user, pass },
tls: {
rejectUnauthorized: false,
servername: serverName, // ⚠️ CRITIQUE pour TLS avec IP directe
},
connectionTimeout: 10000,
greetingTimeout: 10000,
socketTimeout: 30000,
dnsTimeout: 10000,
});
this.logger.log(
`Email adapter initialized with SMTP host: ${host}:${port} (secure: ${secure})` +
(useDirectIP ? ` [Using direct IP: ${actualHost} with servername: ${serverName}]` : '')
);
}
```
**Changements clés**:
- ✅ Détection automatique de `mailtrap.io` dans le hostname
- ✅ Utilisation de l'IP directe `3.209.246.195` au lieu du DNS
- ✅ Configuration TLS avec `servername` pour validation du certificat
- ✅ Timeouts optimisés (10s connection, 30s socket)
- ✅ Logs détaillés pour debug
### 2. **Vérification du comportement synchrone**
**Fichier vérifié**: `src/application/services/csv-booking.service.ts` (Lignes 111-136)
Le code utilise **déjà** le comportement synchrone correct avec `await`:
```typescript
// ✅ CODE CORRECT (comportement synchrone)
try {
await this.emailAdapter.sendCsvBookingRequest(dto.carrierEmail, {
bookingId,
origin: dto.origin,
destination: dto.destination,
// ... autres données
confirmationToken,
});
this.logger.log(`Email sent to carrier: ${dto.carrierEmail}`);
} catch (error: any) {
this.logger.error(`Failed to send email to carrier: ${error?.message}`, error?.stack);
// Continue even if email fails - booking is already saved
}
```
**Important**: L'email est envoyé de manière **synchrone** - le bouton attend la confirmation d'envoi avant de répondre.
---
## 🧪 Tests de Validation
### Test 1: Script de Test Nodemailer
Un script de test complet a été créé pour valider les 3 configurations :
```bash
cd apps/backend
node test-carrier-email-fix.js
```
**Ce script teste**:
1. ❌ **Test 1**: Configuration standard (peut échouer avec timeout DNS)
2. ✅ **Test 2**: Configuration avec IP directe (doit réussir)
3. ✅ **Test 3**: Email complet avec template HTML (doit réussir)
**Résultat attendu**:
```bash
✅ Test 2 RÉUSSI - Configuration IP directe OK
Message ID: <unique-id>
Response: 250 2.0.0 Ok: queued
✅ Test 3 RÉUSSI - Email complet avec template envoyé
Message ID: <unique-id>
Response: 250 2.0.0 Ok: queued
```
### Test 2: Redémarrage du Backend
**IMPORTANT**: Le backend DOIT être redémarré pour appliquer les changements.
```bash
# 1. Tuer tous les processus backend
lsof -ti:4000 | xargs -r kill -9
# 2. Redémarrer proprement
cd apps/backend
npm run dev
```
**Logs attendus au démarrage**:
```bash
✅ Email adapter initialized with SMTP host: sandbox.smtp.mailtrap.io:2525 (secure: false) [Using direct IP: 3.209.246.195 with servername: smtp.mailtrap.io]
```
### Test 3: Test End-to-End avec API
**Prérequis**:
- Backend démarré
- Frontend démarré (optionnel)
- Compte Mailtrap configuré
**Scénario de test**:
1. **Créer un booking CSV** via API ou Frontend
```bash
# Via API (Postman/cURL)
POST http://localhost:4000/api/v1/csv-bookings
Authorization: Bearer <votre-token-jwt>
Content-Type: multipart/form-data
Données:
- carrierName: "Test Carrier"
- carrierEmail: "carrier@test.com"
- origin: "FRPAR"
- destination: "USNYC"
- volumeCBM: 10
- weightKG: 500
- palletCount: 2
- priceUSD: 1500
- priceEUR: 1350
- primaryCurrency: "USD"
- transitDays: 15
- containerType: "20FT"
- notes: "Test booking"
- files: [bill_of_lading.pdf, packing_list.pdf]
```
2. **Vérifier les logs backend**:
```bash
# Succès attendu
✅ [CsvBookingService] Creating CSV booking for user <userId>
✅ [CsvBookingService] Uploaded 2 documents for booking <bookingId>
✅ [CsvBookingService] CSV booking created with ID: <bookingId>
✅ [EmailAdapter] Email sent to carrier@test.com: Nouvelle demande de réservation - FRPAR → USNYC
✅ [CsvBookingService] Email sent to carrier: carrier@test.com
✅ [CsvBookingService] Notification created for user <userId>
```
3. **Vérifier Mailtrap Inbox**:
- Connexion: https://mailtrap.io/inboxes
- Rechercher: "Nouvelle demande de réservation - FRPAR → USNYC"
- Vérifier: Email avec template HTML complet, boutons Accepter/Refuser
---
## 📊 Comparaison Avant/Après
| Critère | ❌ Avant (Cassé) | ✅ Après (Corrigé) |
|---------|------------------|-------------------|
| **Envoi d'emails** | 0% (timeout DNS) | 100% (IP directe) |
| **Temps de réponse API** | ~10s (timeout) | ~2s (normal) |
| **Logs d'erreur** | `queryA ETIMEOUT` | Aucune erreur |
| **Configuration requise** | DNS fonctionnel | Fonctionne partout |
| **Messages reçus** | Aucun | Tous les emails |
---
## 🔧 Configuration Environnement
### Développement (`.env` actuel)
```bash
SMTP_HOST=sandbox.smtp.mailtrap.io # ← Détecté automatiquement
SMTP_PORT=2525
SMTP_SECURE=false
SMTP_USER=2597bd31d265eb
SMTP_PASS=cd126234193c89
SMTP_FROM=noreply@xpeditis.com
```
**Note**: Le code détecte automatiquement `mailtrap.io` et utilise l'IP directe.
### Production (Recommandations)
#### Option 1: Mailtrap Production
```bash
SMTP_HOST=smtp.mailtrap.io # ← Le code utilisera l'IP directe automatiquement
SMTP_PORT=587
SMTP_SECURE=true
SMTP_USER=<votre-user-production>
SMTP_PASS=<votre-pass-production>
```
#### Option 2: SendGrid
```bash
SMTP_HOST=smtp.sendgrid.net # ← Pas de contournement DNS nécessaire
SMTP_PORT=587
SMTP_SECURE=false
SMTP_USER=apikey
SMTP_PASS=<votre-clé-API-SendGrid>
```
#### Option 3: AWS SES
```bash
SMTP_HOST=email-smtp.us-east-1.amazonaws.com
SMTP_PORT=587
SMTP_SECURE=false
SMTP_USER=<votre-access-key-id>
SMTP_PASS=<votre-secret-access-key>
```
---
## 🐛 Dépannage
### Problème 1: "Email sent" dans les logs mais rien dans Mailtrap
**Cause**: Credentials incorrects ou mauvaise inbox
**Solution**:
1. Vérifier `SMTP_USER` et `SMTP_PASS` dans `.env`
2. Régénérer les credentials sur https://mailtrap.io
3. Vérifier la bonne inbox (Development, Staging, Production)
### Problème 2: "queryA ETIMEOUT" persiste après correction
**Cause**: Backend pas redémarré ou code pas compilé
**Solution**:
```bash
# Tuer tous les backends
lsof -ti:4000 | xargs -r kill -9
# Nettoyer et redémarrer
cd apps/backend
rm -rf dist/
npm run build
npm run dev
```
### Problème 3: "EAUTH" authentication failed
**Cause**: Credentials Mailtrap invalides ou expirés
**Solution**:
1. Se connecter à https://mailtrap.io
2. Aller dans Email Testing > Inboxes > <votre-inbox>
3. Copier les nouveaux credentials (SMTP Settings)
4. Mettre à jour `.env` et redémarrer
### Problème 4: Email reçu mais template cassé
**Cause**: Template HTML mal formaté ou variables manquantes
**Solution**:
1. Vérifier les logs pour les données envoyées
2. Vérifier que toutes les variables sont présentes dans `bookingData`
3. Tester le template avec `test-carrier-email-fix.js`
---
## ✅ Checklist de Validation Finale
Avant de déclarer le problème résolu, vérifier:
- [x] `email.adapter.ts` corrigé avec contournement DNS
- [x] Script de test `test-carrier-email-fix.js` créé
- [x] Configuration `.env` vérifiée (SMTP_HOST, USER, PASS)
- [ ] Backend redémarré avec logs confirmant IP directe
- [ ] Test nodemailer réussi (Test 2 et 3)
- [ ] Test end-to-end: création de booking CSV
- [ ] Email reçu dans Mailtrap inbox
- [ ] Template HTML complet et boutons fonctionnels
- [ ] Logs backend sans erreur `ETIMEOUT`
- [ ] Notification créée pour l'utilisateur
---
## 📝 Fichiers Modifiés
| Fichier | Lignes | Description |
|---------|--------|-------------|
| `src/infrastructure/email/email.adapter.ts` | 25-63 | ✅ Contournement DNS avec IP directe |
| `test-carrier-email-fix.js` | 1-285 | 🧪 Script de test email (nouveau) |
| `EMAIL_CARRIER_FIX_COMPLETE.md` | 1-xxx | 📄 Documentation correction (ce fichier) |
**Fichiers vérifiés** (code correct):
- ✅ `src/application/services/csv-booking.service.ts` (comportement synchrone avec `await`)
- ✅ `src/infrastructure/email/templates/email-templates.ts` (template `renderCsvBookingRequest` existe)
- ✅ `src/infrastructure/email/email.module.ts` (module correctement configuré)
- ✅ `src/domain/ports/out/email.port.ts` (méthode `sendCsvBookingRequest` définie)
---
## 🎉 Résultat Final
### ✅ Problème RÉSOLU à 100%
**Ce qui fonctionne maintenant**:
1. ✅ Emails aux transporteurs envoyés sans timeout DNS
2. ✅ Template HTML complet avec boutons Accepter/Refuser
3. ✅ Logs détaillés pour debugging
4. ✅ Configuration robuste (fonctionne même si DNS lent)
5. ✅ Compatible avec n'importe quel fournisseur SMTP
6. ✅ Notifications utilisateur créées
7. ✅ Comportement synchrone (le bouton attend l'email)
**Performance**:
- Temps d'envoi: **< 2s** (au lieu de 10s timeout)
- Taux de succès: **100%** (au lieu de 0%)
- Compatibilité: **Tous réseaux** (même avec DNS lent)
---
## 🚀 Prochaines Étapes
1. **Tester immédiatement**:
```bash
# 1. Test nodemailer
node apps/backend/test-carrier-email-fix.js
# 2. Redémarrer backend
lsof -ti:4000 | xargs -r kill -9
cd apps/backend && npm run dev
# 3. Créer un booking CSV via frontend ou API
```
2. **Vérifier Mailtrap**: https://mailtrap.io/inboxes
3. **Si tout fonctionne**: ✅ Fermer le ticket
4. **Si problème persiste**:
- Copier les logs complets
- Exécuter `test-carrier-email-fix.js` et copier la sortie
- Partager pour debug supplémentaire
---
**Prêt pour la production** 🚢✨
_Correction effectuée le 5 décembre 2025 par Claude Code_

275
apps/backend/EMAIL_FIX_FINAL.md
View File

@ -1,275 +0,0 @@
# ✅ EMAIL FIX COMPLETE - ROOT CAUSE RESOLVED
**Date**: 5 décembre 2025
**Statut**: ✅ **RÉSOLU ET TESTÉ**
---
## 🎯 ROOT CAUSE IDENTIFIÉE
**Problème**: Les emails aux transporteurs ne s'envoyaient plus après l'implémentation du Carrier Portal.
**Cause Racine**: Les variables d'environnement SMTP n'étaient **PAS déclarées** dans le schéma de validation Joi de ConfigModule (`app.module.ts`).
### Pourquoi c'était cassé?
NestJS ConfigModule avec un `validationSchema` Joi **supprime automatiquement** toutes les variables d'environnement qui ne sont pas explicitement déclarées dans le schéma. Le schéma original (lignes 36-50 de `app.module.ts`) ne contenait que:
```typescript
validationSchema: Joi.object({
NODE_ENV: Joi.string()...
PORT: Joi.number()...
DATABASE_HOST: Joi.string()...
REDIS_HOST: Joi.string()...
JWT_SECRET: Joi.string()...
// ❌ AUCUNE VARIABLE SMTP DÉCLARÉE!
})
```
Résultat:
- `SMTP_HOST` → undefined
- `SMTP_PORT` → undefined
- `SMTP_USER` → undefined
- `SMTP_PASS` → undefined
- `SMTP_FROM` → undefined
- `SMTP_SECURE` → undefined
L'email adapter tentait alors de se connecter à `localhost:2525` au lieu de Mailtrap, causant des erreurs `ECONNREFUSED`.
---
## ✅ SOLUTION IMPLÉMENTÉE
### 1. Ajout des variables SMTP au schéma de validation
**Fichier modifié**: `apps/backend/src/app.module.ts` (lignes 50-56)
```typescript
ConfigModule.forRoot({
isGlobal: true,
validationSchema: Joi.object({
// ... variables existantes ...
// ✅ NOUVEAU: SMTP Configuration
SMTP_HOST: Joi.string().required(),
SMTP_PORT: Joi.number().default(2525),
SMTP_USER: Joi.string().required(),
SMTP_PASS: Joi.string().required(),
SMTP_FROM: Joi.string().email().default('noreply@xpeditis.com'),
SMTP_SECURE: Joi.boolean().default(false),
}),
}),
```
**Changements**:
- ✅ Ajout de 6 variables SMTP au schéma Joi
- ✅ `SMTP_HOST`, `SMTP_USER`, `SMTP_PASS` requis
- ✅ `SMTP_PORT` avec default 2525
- ✅ `SMTP_FROM` avec validation email
- ✅ `SMTP_SECURE` avec default false
### 2. DNS Fix (Déjà présent)
Le DNS fix dans `email.adapter.ts` (lignes 42-45) était déjà correct depuis la correction précédente:
```typescript
const useDirectIP = host.includes('mailtrap.io');
const actualHost = useDirectIP ? '3.209.246.195' : host;
const serverName = useDirectIP ? 'smtp.mailtrap.io' : host;
```
---
## 🧪 TESTS DE VALIDATION
### Test 1: Backend Logs ✅
```bash
[2025-12-05 13:24:59.567] INFO: Email adapter initialized with SMTP host: sandbox.smtp.mailtrap.io:2525 (secure: false) [Using direct IP: 3.209.246.195 with servername: smtp.mailtrap.io]
```
**Vérification**:
- ✅ Host: sandbox.smtp.mailtrap.io:2525
- ✅ Using direct IP: 3.209.246.195
- ✅ Servername: smtp.mailtrap.io
- ✅ Secure: false
### Test 2: SMTP Simple Test ✅
```bash
$ node test-smtp-simple.js
Configuration:
SMTP_HOST: sandbox.smtp.mailtrap.io ✅
SMTP_PORT: 2525 ✅
SMTP_USER: 2597bd31d265eb ✅
SMTP_PASS: *** ✅
Test 1: Vérification de la connexion...
✅ Connexion SMTP OK
Test 2: Envoi d'un email...
✅ Email envoyé avec succès!
Message ID: <f21d412a-3739-b5c9-62cc-b00db514d9db@xpeditis.com>
Response: 250 2.0.0 Ok: queued
✅ TOUS LES TESTS RÉUSSIS - Le SMTP fonctionne!
```
### Test 3: Email Flow Complet ✅
```bash
$ node debug-email-flow.js
📊 RÉSUMÉ DES TESTS:
Connexion SMTP: ✅ OK
Email simple: ✅ OK
Email transporteur: ✅ OK
✅ TOUS LES TESTS ONT RÉUSSI!
Le système d'envoi d'email fonctionne correctement.
```
---
## 📊 Avant/Après
| Critère | ❌ Avant | ✅ Après |
|---------|----------|----------|
| **Variables SMTP** | undefined | Chargées correctement |
| **Connexion SMTP** | ECONNREFUSED ::1:2525 | Connecté à 3.209.246.195:2525 |
| **Envoi email** | 0% (échec) | 100% (succès) |
| **Backend logs** | Pas d'init SMTP | "Email adapter initialized" |
| **Test scripts** | Tous échouent | Tous réussissent |
---
## 🚀 VÉRIFICATION END-TO-END
Le backend est déjà démarré et fonctionnel. Pour tester le flux complet de création de booking avec envoi d'email:
### Option 1: Via l'interface web
1. Ouvrir http://localhost:3000
2. Se connecter
3. Créer un CSV booking avec l'email d'un transporteur
4. Vérifier les logs backend:
```
✅ [CsvBookingService] Email sent to carrier: carrier@example.com
```
5. Vérifier Mailtrap: https://mailtrap.io/inboxes
### Option 2: Via API (cURL/Postman)
```bash
POST http://localhost:4000/api/v1/csv-bookings
Authorization: Bearer <your-jwt-token>
Content-Type: multipart/form-data
{
"carrierName": "Test Carrier",
"carrierEmail": "carrier@test.com",
"origin": "FRPAR",
"destination": "USNYC",
"volumeCBM": 10,
"weightKG": 500,
"palletCount": 2,
"priceUSD": 1500,
"primaryCurrency": "USD",
"transitDays": 15,
"containerType": "20FT",
"files": [attachment]
}
```
**Logs attendus**:
```
✅ [CsvBookingService] Creating CSV booking for user <userId>
✅ [CsvBookingService] Uploaded 2 documents for booking <bookingId>
✅ [CsvBookingService] CSV booking created with ID: <bookingId>
✅ [EmailAdapter] Email sent to carrier@test.com
✅ [CsvBookingService] Email sent to carrier: carrier@test.com
```
---
## 📝 Fichiers Modifiés
| Fichier | Lignes | Changement |
|---------|--------|------------|
| `apps/backend/src/app.module.ts` | 50-56 | ✅ Ajout variables SMTP au schéma Joi |
| `apps/backend/src/infrastructure/email/email.adapter.ts` | 42-65 | ✅ DNS fix (déjà présent) |
---
## 🎉 RÉSULTAT FINAL
### ✅ Problème RÉSOLU à 100%
**Ce qui fonctionne**:
1. ✅ Variables SMTP chargées depuis `.env`
2. ✅ Email adapter s'initialise correctement
3. ✅ Connexion SMTP avec DNS bypass (IP directe)
4. ✅ Envoi d'emails simples réussi
5. ✅ Envoi d'emails avec template HTML réussi
6. ✅ Backend démarre sans erreur
7. ✅ Tous les tests passent
**Performance**:
- Temps d'envoi: **< 2s**
- Taux de succès: **100%**
- Compatibilité: **Tous réseaux**
---
## 🔧 Commandes Utiles
### Vérifier le backend
```bash
# Voir les logs en temps réel
tail -f /tmp/backend-startup.log
# Vérifier que le backend tourne
lsof -i:4000
# Redémarrer le backend
lsof -ti:4000 | xargs -r kill -9
cd apps/backend && npm run dev
```
### Tester l'envoi d'emails
```bash
# Test SMTP simple
cd apps/backend
node test-smtp-simple.js
# Test complet avec template
node debug-email-flow.js
```
---
## ✅ Checklist de Validation
- [x] ConfigModule validation schema updated
- [x] SMTP variables added to Joi schema
- [x] Backend redémarré avec succès
- [x] Backend logs show "Email adapter initialized"
- [x] Test SMTP simple réussi
- [x] Test email flow complet réussi
- [x] Environment variables loading correctly
- [x] DNS bypass actif (direct IP)
- [ ] Test end-to-end via création de booking (à faire par l'utilisateur)
- [ ] Email reçu dans Mailtrap (à vérifier par l'utilisateur)
---
**Prêt pour la production** 🚢✨
_Correction effectuée le 5 décembre 2025 par Claude Code_
**Backend Status**: ✅ Running on port 4000
**Email System**: ✅ Fully functional
**Next Step**: Create a CSV booking to test the complete workflow

295
apps/backend/EMAIL_FIX_SUMMARY.md
View File

@ -1,295 +0,0 @@
# 📧 Résolution Complète du Problème d'Envoi d'Emails
## 🔍 Problème Identifié
**Symptôme**: Les emails n'étaient plus envoyés aux transporteurs lors de la création de réservations CSV.
**Cause Racine**: Changement du comportement d'envoi d'email de SYNCHRONE à ASYNCHRONE
- Le code original utilisait `await` pour attendre l'envoi de l'email avant de répondre
- J'ai tenté d'optimiser avec `setImmediate()` et `void` operator (fire-and-forget)
- **ERREUR**: L'utilisateur VOULAIT le comportement synchrone où le bouton attend la confirmation d'envoi
- Les emails n'étaient plus envoyés car le contexte d'exécution était perdu avec les appels asynchrones
## ✅ Solution Implémentée
### **Restauration du comportement SYNCHRONE** ✨ SOLUTION FINALE
**Fichiers modifiés**:
- `src/application/services/csv-booking.service.ts` (lignes 111-136)
- `src/application/services/carrier-auth.service.ts` (lignes 110-117, 287-294)
- `src/infrastructure/email/email.adapter.ts` (configuration simplifiée)
```typescript
// Utilise automatiquement l'IP 3.209.246.195 quand 'mailtrap.io' est détecté
const useDirectIP = host.includes('mailtrap.io');
const actualHost = useDirectIP ? '3.209.246.195' : host;
const serverName = useDirectIP ? 'smtp.mailtrap.io' : host; // Pour TLS
// Configuration avec IP directe + servername pour TLS
this.transporter = nodemailer.createTransport({
host: actualHost,
port,
secure: false,
auth: { user, pass },
tls: {
rejectUnauthorized: false,
servername: serverName, // ⚠️ CRITIQUE pour TLS
},
connectionTimeout: 10000,
greetingTimeout: 10000,
socketTimeout: 30000,
dnsTimeout: 10000,
});
```
**Résultat**: ✅ Test réussi - Email envoyé avec succès (Message ID: `576597e7-1a81-165d-2a46-d97c57d21daa`)
---
### 2. **Remplacement de `setImmediate()` par `void` operator**
**Fichiers Modifiés**:
- `src/application/services/csv-booking.service.ts` (ligne 114)
- `src/application/services/carrier-auth.service.ts` (lignes 112, 290)
**Avant** (bloquant):
```typescript
setImmediate(() => {
this.emailAdapter.sendCsvBookingRequest(...)
.then(() => { ... })
.catch(() => { ... });
});
```
**Après** (non-bloquant mais avec contexte):
```typescript
void this.emailAdapter.sendCsvBookingRequest(...)
.then(() => {
this.logger.log(`Email sent to carrier: ${dto.carrierEmail}`);
})
.catch((error: any) => {
this.logger.error(`Failed to send email to carrier: ${error?.message}`, error?.stack);
});
```
**Bénéfices**:
- ✅ Réponse API ~50% plus rapide (pas d'attente d'envoi)
- ✅ Logs des erreurs d'envoi préservés
- ✅ Contexte NestJS maintenu (pas de perte de dépendances)
---
### 3. **Configuration `.env` Mise à Jour**
**Fichier**: `.env`
```bash
# Email (SMTP)
# Using smtp.mailtrap.io instead of sandbox.smtp.mailtrap.io to avoid DNS timeout
SMTP_HOST=smtp.mailtrap.io # ← Changé
SMTP_PORT=2525
SMTP_SECURE=false
SMTP_USER=2597bd31d265eb
SMTP_PASS=cd126234193c89
SMTP_FROM=noreply@xpeditis.com
```
---
### 4. **Ajout des Méthodes d'Email Transporteur**
**Fichier**: `src/domain/ports/out/email.port.ts`
Ajout de 2 nouvelles méthodes à l'interface:
- `sendCarrierAccountCreated()` - Email de création de compte avec mot de passe temporaire
- `sendCarrierPasswordReset()` - Email de réinitialisation de mot de passe
**Implémentation**: `src/infrastructure/email/email.adapter.ts` (lignes 269-413)
- Templates HTML en français
- Boutons d'action stylisés
- Warnings de sécurité
- Instructions de connexion
---
## 📋 Fichiers Modifiés (Récapitulatif)
| Fichier | Lignes | Description |
|---------|--------|-------------|
| `infrastructure/email/email.adapter.ts` | 25-63 | ✨ Contournement DNS avec IP directe |
| `infrastructure/email/email.adapter.ts` | 269-413 | Méthodes emails transporteur |
| `application/services/csv-booking.service.ts` | 114-137 | `void` operator pour emails async |
| `application/services/carrier-auth.service.ts` | 112-118 | `void` operator (création compte) |
| `application/services/carrier-auth.service.ts` | 290-296 | `void` operator (reset password) |
| `domain/ports/out/email.port.ts` | 107-123 | Interface méthodes transporteur |
| `.env` | 42 | Changement SMTP_HOST |
---
## 🧪 Tests de Validation
### Test 1: Backend Redémarré avec Succès ✅ **RÉUSSI**
```bash
# Tuer tous les processus sur port 4000
lsof -ti:4000 | xargs kill -9
# Démarrer le backend proprement
npm run dev
```
**Résultat**:
```
✅ Email adapter initialized with SMTP host: sandbox.smtp.mailtrap.io:2525 (secure: false)
✅ Nest application successfully started
✅ Connected to Redis at localhost:6379
🚢 Xpeditis API Server Running on http://localhost:4000
```
### Test 2: Test d'Envoi d'Email (À faire par l'utilisateur)
1. ✅ Backend démarré avec configuration correcte
2. Créer une réservation CSV avec transporteur via API
3. Vérifier les logs pour: `Email sent to carrier: [email]`
4. Vérifier Mailtrap inbox: https://mailtrap.io/inboxes
---
## 🎯 Comment Tester en Production
### Étape 1: Créer une Réservation CSV
```bash
POST http://localhost:4000/api/v1/csv-bookings
Content-Type: multipart/form-data
{
"carrierName": "Test Carrier",
"carrierEmail": "test@example.com",
"origin": "FRPAR",
"destination": "USNYC",
"volumeCBM": 10,
"weightKG": 500,
"palletCount": 2,
"priceUSD": 1500,
"priceEUR": 1300,
"primaryCurrency": "USD",
"transitDays": 15,
"containerType": "20FT",
"notes": "Test booking"
}
```
### Étape 2: Vérifier les Logs
Rechercher dans les logs backend:
```bash
# Succès
✅ "Email sent to carrier: test@example.com"
✅ "CSV booking request sent to test@example.com for booking <ID>"
# Échec (ne devrait plus arriver)
❌ "Failed to send email to carrier: queryA ETIMEOUT"
```
### Étape 3: Vérifier Mailtrap
1. Connexion: https://mailtrap.io
2. Inbox: "Xpeditis Development"
3. Email: "Nouvelle demande de réservation - FRPAR → USNYC"
---
## 📊 Performance
### Avant (Problème)
- ❌ Emails: **0% envoyés** (timeout DNS)
- ⏱️ Temps réponse API: ~500ms + timeout (10s)
- ❌ Logs: Erreurs `queryA ETIMEOUT`
### Après (Corrigé)
- ✅ Emails: **100% envoyés** (IP directe)
- ⏱️ Temps réponse API: ~200-300ms (async fire-and-forget)
- ✅ Logs: `Email sent to carrier:`
- 📧 Latence email: <2s (Mailtrap)
---
## 🔧 Configuration Production
Pour le déploiement production, mettre à jour `.env`:
```bash
# Option 1: Utiliser smtp.mailtrap.io (IP auto)
SMTP_HOST=smtp.mailtrap.io
SMTP_PORT=2525
SMTP_SECURE=false
# Option 2: Autre fournisseur SMTP (ex: SendGrid)
SMTP_HOST=smtp.sendgrid.net
SMTP_PORT=587
SMTP_SECURE=false
SMTP_USER=apikey
SMTP_PASS=<votre-clé-API-SendGrid>
```
**Note**: Le code détecte automatiquement `mailtrap.io` et utilise l'IP. Pour d'autres fournisseurs, le DNS standard sera utilisé.
---
## 🐛 Dépannage
### Problème: "Email sent" dans les logs mais rien dans Mailtrap
**Cause**: Mauvais credentials ou inbox
**Solution**: Vérifier `SMTP_USER` et `SMTP_PASS` dans `.env`
### Problème: "queryA ETIMEOUT" persiste
**Cause**: Backend pas redémarré ou code pas compilé
**Solution**:
```bash
# 1. Tuer tous les backends
lsof -ti:4000 | xargs kill -9
# 2. Redémarrer proprement
cd apps/backend
npm run dev
```
### Problème: "EAUTH" authentication failed
**Cause**: Credentials Mailtrap invalides
**Solution**: Régénérer les credentials sur https://mailtrap.io
---
## ✅ Checklist de Validation
- [x] Méthodes `sendCarrierAccountCreated` et `sendCarrierPasswordReset` implémentées
- [x] Comportement SYNCHRONE restauré avec `await` (au lieu de setImmediate/void)
- [x] Configuration SMTP simplifiée (pas de contournement DNS nécessaire)
- [x] `.env` mis à jour avec `sandbox.smtp.mailtrap.io`
- [x] Backend redémarré proprement
- [x] Email adapter initialisé avec bonne configuration
- [x] Server écoute sur port 4000
- [x] Redis connecté
- [ ] Test end-to-end avec création CSV booking ← **À TESTER PAR L'UTILISATEUR**
- [ ] Email reçu dans Mailtrap inbox ← **À VALIDER PAR L'UTILISATEUR**
---
## 📝 Notes Techniques
### Pourquoi l'IP Directe Fonctionne ?
Node.js utilise `dns.resolve()` qui peut timeout même si le système DNS fonctionne. En utilisant l'IP directe, on contourne complètement la résolution DNS.
### Pourquoi `servername` dans TLS ?
Quand on utilise une IP directe, TLS ne peut pas vérifier le certificat sans le `servername`. On spécifie donc `smtp.mailtrap.io` manuellement.
### Alternative (Non Implémentée)
Configurer Node.js pour utiliser Google DNS:
```javascript
const dns = require('dns');
dns.setServers(['8.8.8.8', '8.8.4.4']);
```
---
## 🎉 Résultat Final
✅ **Problème résolu à 100%**
- Emails aux transporteurs fonctionnent
- Performance améliorée (~50% plus rapide)
- Logs clairs et précis
- Code robuste avec gestion d'erreurs
**Prêt pour la production** 🚀

BIN
apps/backend/apps.zip
View File

Binary file not shown.

324
apps/backend/debug-email-flow.js
View File

@ -1,324 +0,0 @@
/**
* Script de debug pour tester le flux complet d'envoi d'email
*
* Ce script teste:
* 1. Connexion SMTP
* 2. Envoi d'un email simple
* 3. Envoi avec le template complet
*/
require('dotenv').config();
const nodemailer = require('nodemailer');
console.log("\n🔍 DEBUG - Flux d'envoi d'email transporteur\n");
console.log('='.repeat(60));
// 1. Afficher la configuration
console.log('\n📋 CONFIGURATION ACTUELLE:');
console.log('----------------------------');
console.log('SMTP_HOST:', process.env.SMTP_HOST);
console.log('SMTP_PORT:', process.env.SMTP_PORT);
console.log('SMTP_SECURE:', process.env.SMTP_SECURE);
console.log('SMTP_USER:', process.env.SMTP_USER);
console.log(
'SMTP_PASS:',
process.env.SMTP_PASS ? '***' + process.env.SMTP_PASS.slice(-4) : 'NON DÉFINI'
);
console.log('SMTP_FROM:', process.env.SMTP_FROM);
console.log('APP_URL:', process.env.APP_URL);
// 2. Vérifier les variables requises
console.log('\n✅ VÉRIFICATION DES VARIABLES:');
console.log('--------------------------------');
const requiredVars = ['SMTP_HOST', 'SMTP_PORT', 'SMTP_USER', 'SMTP_PASS'];
const missing = requiredVars.filter(v => !process.env[v]);
if (missing.length > 0) {
console.error('❌ Variables manquantes:', missing.join(', '));
process.exit(1);
} else {
console.log('✅ Toutes les variables requises sont présentes');
}
// 3. Créer le transporter avec la même configuration que le backend
console.log('\n🔧 CRÉATION DU TRANSPORTER:');
console.log('----------------------------');
const host = process.env.SMTP_HOST;
const port = parseInt(process.env.SMTP_PORT);
const user = process.env.SMTP_USER;
const pass = process.env.SMTP_PASS;
const secure = process.env.SMTP_SECURE === 'true';
// Même logique que dans email.adapter.ts
const useDirectIP = host.includes('mailtrap.io');
const actualHost = useDirectIP ? '3.209.246.195' : host;
const serverName = useDirectIP ? 'smtp.mailtrap.io' : host;
console.log('Configuration détectée:');
console.log(' Host original:', host);
console.log(' Utilise IP directe:', useDirectIP);
console.log(' Host réel:', actualHost);
console.log(' Server name (TLS):', serverName);
console.log(' Port:', port);
console.log(' Secure:', secure);
const transporter = nodemailer.createTransport({
host: actualHost,
port,
secure,
auth: {
user,
pass,
},
tls: {
rejectUnauthorized: false,
servername: serverName,
},
connectionTimeout: 10000,
greetingTimeout: 10000,
socketTimeout: 30000,
dnsTimeout: 10000,
});
// 4. Tester la connexion
console.log('\n🔌 TEST DE CONNEXION SMTP:');
console.log('---------------------------');
async function testConnection() {
try {
console.log('Vérification de la connexion...');
await transporter.verify();
console.log('✅ Connexion SMTP réussie!');
return true;
} catch (error) {
console.error('❌ Échec de la connexion SMTP:');
console.error(' Message:', error.message);
console.error(' Code:', error.code);
console.error(' Command:', error.command);
if (error.stack) {
console.error(' Stack:', error.stack.substring(0, 200) + '...');
}
return false;
}
}
// 5. Envoyer un email de test simple
async function sendSimpleEmail() {
console.log('\n📧 TEST 1: Email simple');
console.log('------------------------');
try {
const info = await transporter.sendMail({
from: process.env.SMTP_FROM || 'noreply@xpeditis.com',
to: 'test@example.com',
subject: 'Test Simple - ' + new Date().toISOString(),
text: 'Ceci est un test simple',
html: '<h1>Test Simple</h1><p>Ceci est un test simple</p>',
});
console.log('✅ Email simple envoyé avec succès!');
console.log(' Message ID:', info.messageId);
console.log(' Response:', info.response);
console.log(' Accepted:', info.accepted);
console.log(' Rejected:', info.rejected);
return true;
} catch (error) {
console.error("❌ Échec d'envoi email simple:");
console.error(' Message:', error.message);
console.error(' Code:', error.code);
return false;
}
}
// 6. Envoyer un email avec le template transporteur complet
async function sendCarrierEmail() {
console.log('\n📧 TEST 2: Email transporteur avec template');
console.log('--------------------------------------------');
const bookingData = {
bookingId: 'TEST-' + Date.now(),
origin: 'FRPAR',
destination: 'USNYC',
volumeCBM: 15.5,
weightKG: 1200,
palletCount: 6,
priceUSD: 2500,
priceEUR: 2250,
primaryCurrency: 'USD',
transitDays: 18,
containerType: '40FT',
documents: [
{ type: 'Bill of Lading', fileName: 'bol-test.pdf' },
{ type: 'Packing List', fileName: 'packing-test.pdf' },
{ type: 'Commercial Invoice', fileName: 'invoice-test.pdf' },
],
};
const baseUrl = process.env.APP_URL || 'http://localhost:3000';
const acceptUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.bookingId}/accept`;
const rejectUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.bookingId}/reject`;
// Template HTML (version simplifiée pour le test)
const htmlTemplate = `
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Nouvelle demande de réservation</title>
</head>
<body style="margin: 0; padding: 0; font-family: Arial, sans-serif; background-color: #f4f6f8;">
<div style="max-width: 600px; margin: 20px auto; background-color: #ffffff; border-radius: 8px; overflow: hidden; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);">
<div style="background: linear-gradient(135deg, #045a8d, #00bcd4); color: #ffffff; padding: 30px 20px; text-align: center;">
<h1 style="margin: 0; font-size: 28px;">🚢 Nouvelle demande de réservation</h1>
<p style="margin: 5px 0 0; font-size: 14px;">Xpeditis</p>
</div>
<div style="padding: 30px 20px;">
<p style="font-size: 16px;">Bonjour,</p>
<p>Vous avez reçu une nouvelle demande de réservation via Xpeditis.</p>
<h2 style="color: #045a8d; border-bottom: 2px solid #00bcd4; padding-bottom: 8px;">📋 Détails du transport</h2>
<table style="width: 100%; border-collapse: collapse;">
<tr style="border-bottom: 1px solid #e0e0e0;">
<td style="padding: 12px; font-weight: bold; color: #045a8d;">Route</td>
<td style="padding: 12px;">${bookingData.origin} → ${bookingData.destination}</td>
</tr>
<tr style="border-bottom: 1px solid #e0e0e0;">
<td style="padding: 12px; font-weight: bold; color: #045a8d;">Volume</td>
<td style="padding: 12px;">${bookingData.volumeCBM} CBM</td>
</tr>
<tr style="border-bottom: 1px solid #e0e0e0;">
<td style="padding: 12px; font-weight: bold; color: #045a8d;">Poids</td>
<td style="padding: 12px;">${bookingData.weightKG} kg</td>
</tr>
<tr style="border-bottom: 1px solid #e0e0e0;">
<td style="padding: 12px; font-weight: bold; color: #045a8d;">Prix</td>
<td style="padding: 12px; font-size: 24px; font-weight: bold; color: #00aa00;">
${bookingData.priceUSD} USD
</td>
</tr>
</table>
<div style="background-color: #f9f9f9; padding: 20px; border-radius: 6px; margin: 20px 0;">
<h3 style="margin-top: 0; color: #045a8d;">📄 Documents fournis</h3>
<ul style="list-style: none; padding: 0; margin: 10px 0 0;">
${bookingData.documents.map(doc => `<li style="padding: 8px 0;">📄 <strong>${doc.type}:</strong> ${doc.fileName}</li>`).join('')}
</ul>
</div>
<div style="text-align: center; margin: 30px 0;">
<p style="font-weight: bold; font-size: 16px;">Veuillez confirmer votre décision :</p>
<div style="margin: 15px 0;">
<a href="${acceptUrl}" style="display: inline-block; padding: 15px 30px; background-color: #00aa00; color: #ffffff; text-decoration: none; border-radius: 6px; margin: 0 5px; min-width: 200px;">✓ Accepter la demande</a>
<a href="${rejectUrl}" style="display: inline-block; padding: 15px 30px; background-color: #cc0000; color: #ffffff; text-decoration: none; border-radius: 6px; margin: 0 5px; min-width: 200px;">✗ Refuser la demande</a>
</div>
</div>
<div style="background-color: #fff8e1; border-left: 4px solid #f57c00; padding: 15px; margin: 20px 0; border-radius: 4px;">
<p style="margin: 0; font-size: 14px; color: #666;">
<strong style="color: #f57c00;">⚠️ Important</strong><br>
Cette demande expire automatiquement dans <strong>7 jours</strong> si aucune action n'est prise.
</p>
</div>
</div>
<div style="background-color: #f4f6f8; padding: 20px; text-align: center; font-size: 12px; color: #666;">
<p style="margin: 5px 0; font-weight: bold; color: #045a8d;">Référence de réservation : ${bookingData.bookingId}</p>
<p style="margin: 5px 0;">© 2025 Xpeditis. Tous droits réservés.</p>
<p style="margin: 5px 0;">Cet email a été envoyé automatiquement. Merci de ne pas y répondre directement.</p>
</div>
</div>
</body>
</html>
`;
try {
console.log('Données du booking:');
console.log(' Booking ID:', bookingData.bookingId);
console.log(' Route:', bookingData.origin, '→', bookingData.destination);
console.log(' Prix:', bookingData.priceUSD, 'USD');
console.log(' Accept URL:', acceptUrl);
console.log(' Reject URL:', rejectUrl);
console.log('\nEnvoi en cours...');
const info = await transporter.sendMail({
from: process.env.SMTP_FROM || 'noreply@xpeditis.com',
to: 'carrier@test.com',
subject: `Nouvelle demande de réservation - ${bookingData.origin} → ${bookingData.destination}`,
html: htmlTemplate,
});
console.log('\n✅ Email transporteur envoyé avec succès!');
console.log(' Message ID:', info.messageId);
console.log(' Response:', info.response);
console.log(' Accepted:', info.accepted);
console.log(' Rejected:', info.rejected);
console.log('\n📬 Vérifiez votre inbox Mailtrap:');
console.log(' URL: https://mailtrap.io/inboxes');
console.log(' Sujet: Nouvelle demande de réservation - FRPAR → USNYC');
return true;
} catch (error) {
console.error("\n❌ Échec d'envoi email transporteur:");
console.error(' Message:', error.message);
console.error(' Code:', error.code);
console.error(' ResponseCode:', error.responseCode);
console.error(' Response:', error.response);
if (error.stack) {
console.error(' Stack:', error.stack.substring(0, 300));
}
return false;
}
}
// Exécuter tous les tests
async function runAllTests() {
console.log('\n🚀 DÉMARRAGE DES TESTS');
console.log('='.repeat(60));
// Test 1: Connexion
const connectionOk = await testConnection();
if (!connectionOk) {
console.log('\n❌ ARRÊT: La connexion SMTP a échoué');
console.log(' Vérifiez vos credentials SMTP dans .env');
process.exit(1);
}
// Test 2: Email simple
const simpleEmailOk = await sendSimpleEmail();
if (!simpleEmailOk) {
console.log("\n⚠️ L'email simple a échoué, mais on continue...");
}
// Test 3: Email transporteur
const carrierEmailOk = await sendCarrierEmail();
// Résumé
console.log('\n' + '='.repeat(60));
console.log('📊 RÉSUMÉ DES TESTS:');
console.log('='.repeat(60));
console.log('Connexion SMTP:', connectionOk ? '✅ OK' : '❌ ÉCHEC');
console.log('Email simple:', simpleEmailOk ? '✅ OK' : '❌ ÉCHEC');
console.log('Email transporteur:', carrierEmailOk ? '✅ OK' : '❌ ÉCHEC');
if (connectionOk && simpleEmailOk && carrierEmailOk) {
console.log('\n✅ TOUS LES TESTS ONT RÉUSSI!');
console.log(" Le système d'envoi d'email fonctionne correctement.");
console.log(' Si vous ne recevez pas les emails dans le backend,');
console.log(" le problème vient de l'intégration NestJS.");
} else {
console.log('\n❌ CERTAINS TESTS ONT ÉCHOUÉ');
console.log(' Vérifiez les erreurs ci-dessus pour comprendre le problème.');
}
console.log('\n' + '='.repeat(60));
}
// Lancer les tests
runAllTests()
.then(() => {
console.log('\n✅ Tests terminés\n');
process.exit(0);
})
.catch(error => {
console.error('\n❌ Erreur fatale:', error);
process.exit(1);
});

19
apps/backend/docker-compose.yaml
View File

@ -1,19 +0,0 @@
services:
postgres:
image: postgres:latest
container_name: xpeditis-postgres
environment:
POSTGRES_USER: xpeditis
POSTGRES_PASSWORD: xpeditis_dev_password
POSTGRES_DB: xpeditis_dev
ports:
- "5432:5432"
redis:
image: redis:7
container_name: xpeditis-redis
command: redis-server --requirepass xpeditis_redis_password
environment:
REDIS_PASSWORD: xpeditis_redis_password
ports:
- "6379:6379"

150
docker-compose.local.yml
View File

@ -1,150 +0,0 @@
version: '3.8'
# ============================================
# Docker Compose pour développement local Mac
# ============================================
# Usage:
# docker-compose -f docker-compose.local.yml up -d
# docker-compose -f docker-compose.local.yml logs -f backend
# docker-compose -f docker-compose.local.yml down
services:
# PostgreSQL Database
postgres:
image: postgres:15-alpine
container_name: xpeditis-postgres-local
restart: unless-stopped
ports:
- "5432:5432"
volumes:
- postgres_data:/var/lib/postgresql/data
environment:
POSTGRES_DB: xpeditis_dev
POSTGRES_USER: xpeditis
POSTGRES_PASSWORD: xpeditis_dev_password
PGDATA: /var/lib/postgresql/data/pgdata
healthcheck:
test: ["CMD-SHELL", "pg_isready -U xpeditis"]
interval: 10s
timeout: 5s
retries: 5
# Redis Cache
redis:
image: redis:7-alpine
container_name: xpeditis-redis-local
restart: unless-stopped
ports:
- "6379:6379"
command: redis-server --requirepass xpeditis_redis_password --appendonly yes
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
interval: 10s
timeout: 5s
retries: 5
# MinIO S3 Storage
minio:
image: minio/minio:latest
container_name: xpeditis-minio-local
restart: unless-stopped
ports:
- "9000:9000" # API
- "9001:9001" # Console
command: server /data --console-address ":9001"
volumes:
- minio_data:/data
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: minioadmin
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
interval: 30s
timeout: 20s
retries: 3
# Backend API (NestJS) - Image depuis Scaleway Registry
backend:
image: rg.fr-par.scw.cloud/weworkstudio/xpeditis-backend:preprod
container_name: xpeditis-backend-local
restart: unless-stopped
ports:
- "4000:4000"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
minio:
condition: service_started
environment:
NODE_ENV: development
PORT: 4000
# Database
DATABASE_HOST: postgres
DATABASE_PORT: 5432
DATABASE_USER: xpeditis
DATABASE_PASSWORD: xpeditis_dev_password
DATABASE_NAME: xpeditis_dev
# Redis
REDIS_HOST: redis
REDIS_PORT: 6379
REDIS_PASSWORD: xpeditis_redis_password
# JWT
JWT_SECRET: dev-secret-key-change-in-production
JWT_ACCESS_EXPIRATION: 15m
JWT_REFRESH_EXPIRATION: 7d
# S3/MinIO
AWS_S3_ENDPOINT: http://minio:9000
AWS_REGION: us-east-1
AWS_ACCESS_KEY_ID: minioadmin
AWS_SECRET_ACCESS_KEY: minioadmin
AWS_S3_BUCKET: xpeditis-csv-rates
# CORS
CORS_ORIGIN: http://localhost:3000,http://localhost:3001
# App URLs
FRONTEND_URL: http://localhost:3000
API_URL: http://localhost:4000
healthcheck:
test: ["CMD", "node", "-e", "require('http').get('http://localhost:4000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
# Frontend (Next.js) - Image depuis Scaleway Registry
frontend:
image: rg.fr-par.scw.cloud/weworkstudio/xpeditis-frontend:preprod
container_name: xpeditis-frontend-local
restart: unless-stopped
ports:
- "3000:3000"
depends_on:
- backend
environment:
NODE_ENV: development
NEXT_PUBLIC_API_URL: http://localhost:4000
NEXT_PUBLIC_WS_URL: ws://localhost:4000
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:3000/api/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
volumes:
postgres_data:
driver: local
redis_data:
driver: local
minio_data:
driver: local

115
docker-compose.logging.yml
View File

@ -1,115 +0,0 @@
# ─────────────────────────────────────────────────────────────────────────────
# Xpeditis — Centralized Logging Stack
#
# Usage (standalone):
# docker-compose -f docker-compose.yml -f docker-compose.logging.yml up -d
#
# Usage (full dev environment with logging):
# docker-compose -f docker-compose.dev.yml -f docker-compose.logging.yml up -d
#
# Exposed ports:
# - Grafana: http://localhost:3000 (admin / xpeditis_grafana)
# - Loki: http://localhost:3100 (internal use only)
# - Promtail: http://localhost:9080 (internal use only)
# - log-exporter: http://localhost:3200 (export API)
# ─────────────────────────────────────────────────────────────────────────────
services:
# ─── Loki — Log storage & query engine ────────────────────────────────────
loki:
image: grafana/loki:3.0.0
container_name: xpeditis-loki
restart: unless-stopped
ports:
- '3100:3100'
volumes:
- ./infra/logging/loki/loki-config.yml:/etc/loki/local-config.yaml:ro
- loki_data:/loki
command: -config.file=/etc/loki/local-config.yaml
healthcheck:
test: ['CMD-SHELL', 'wget --quiet --tries=1 --spider http://localhost:3100/ready || exit 1']
interval: 15s
timeout: 5s
retries: 5
networks:
- xpeditis-network
# ─── Promtail — Docker log collector ──────────────────────────────────────
promtail:
image: grafana/promtail:3.0.0
container_name: xpeditis-promtail
restart: unless-stopped
ports:
- '9080:9080'
volumes:
- ./infra/logging/promtail/promtail-config.yml:/etc/promtail/config.yml:ro
- /var/run/docker.sock:/var/run/docker.sock:ro
# Note: /var/lib/docker/containers is not needed with docker_sd_configs (uses Docker API)
command: -config.file=/etc/promtail/config.yml
depends_on:
loki:
condition: service_healthy
networks:
- xpeditis-network
# ─── Grafana — Visualization ───────────────────────────────────────────────
grafana:
image: grafana/grafana:11.0.0
container_name: xpeditis-grafana
restart: unless-stopped
ports:
- '3030:3000'
environment:
GF_SECURITY_ADMIN_USER: admin
GF_SECURITY_ADMIN_PASSWORD: xpeditis_grafana
GF_USERS_ALLOW_SIGN_UP: 'false'
GF_AUTH_ANONYMOUS_ENABLED: 'false'
GF_SERVER_ROOT_URL: http://localhost:3030
# Disable telemetry
GF_ANALYTICS_REPORTING_ENABLED: 'false'
GF_ANALYTICS_CHECK_FOR_UPDATES: 'false'
volumes:
- ./infra/logging/grafana/provisioning:/etc/grafana/provisioning:ro
- grafana_data:/var/lib/grafana
depends_on:
loki:
condition: service_healthy
healthcheck:
test: ['CMD-SHELL', 'wget --quiet --tries=1 --spider http://localhost:3000/api/health || exit 1']
interval: 15s
timeout: 5s
retries: 5
networks:
- xpeditis-network
# ─── log-exporter — REST export API ───────────────────────────────────────
log-exporter:
build:
context: ./apps/log-exporter
dockerfile: Dockerfile
container_name: xpeditis-log-exporter
restart: unless-stopped
ports:
- '3200:3200'
environment:
PORT: 3200
LOKI_URL: http://loki:3100
# Optional: set LOG_EXPORTER_API_KEY to require x-api-key header
# LOG_EXPORTER_API_KEY: your-secret-key-here
depends_on:
loki:
condition: service_healthy
networks:
- xpeditis-network
volumes:
loki_data:
driver: local
grafana_data:
driver: local
networks:
xpeditis-network:
name: xpeditis-network
# Re-uses the network created by docker-compose.yml / docker-compose.dev.yml.
# If starting this stack alone, the network is created automatically.

37
docker-compose.test.yml
View File

@ -1,37 +0,0 @@
version: '3.8'
services:
postgres:
image: postgres:15-alpine
container_name: xpeditis-test-db
environment:
POSTGRES_DB: xpeditis_test
POSTGRES_USER: xpeditis_test
POSTGRES_PASSWORD: xpeditis_test_password
PGDATA: /var/lib/postgresql/data/pgdata
ports:
- '5432:5432'
volumes:
- xpeditis_test_db:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U xpeditis_test"]
interval: 5s
timeout: 5s
retries: 5
redis:
image: redis:7-alpine
container_name: xpeditis-test-redis
ports:
- '6379:6379'
volumes:
- xpeditis_test_redis:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 5
volumes:
xpeditis_test_db:
xpeditis_test_redis:

67
docker-compose.yml
View File

@ -1,67 +0,0 @@
version: '3.8'
services:
postgres:
image: postgres:15-alpine
container_name: xpeditis-postgres
restart: unless-stopped
environment:
POSTGRES_USER: xpeditis
POSTGRES_PASSWORD: xpeditis_dev_password
POSTGRES_DB: xpeditis_dev
ports:
- '5432:5432'
volumes:
- postgres_data:/var/lib/postgresql/data
- ./infra/postgres/init.sql:/docker-entrypoint-initdb.d/init.sql
healthcheck:
test: ['CMD-SHELL', 'pg_isready -U xpeditis']
interval: 10s
timeout: 5s
retries: 5
redis:
image: redis:7-alpine
container_name: xpeditis-redis
restart: unless-stopped
ports:
- '6379:6379'
volumes:
- redis_data:/data
command: redis-server --appendonly yes --requirepass xpeditis_redis_password
healthcheck:
test: ['CMD', 'redis-cli', '--raw', 'incr', 'ping']
interval: 10s
timeout: 5s
retries: 5
minio:
image: minio/minio:latest
container_name: xpeditis-minio
restart: unless-stopped
ports:
- '9000:9000' # API port
- '9001:9001' # Console port
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: minioadmin
volumes:
- minio_data:/data
command: server /data --console-address ":9001"
healthcheck:
test: ['CMD', 'curl', '-f', 'http://localhost:9000/minio/health/live']
interval: 30s
timeout: 20s
retries: 3
volumes:
postgres_data:
driver: local
redis_data:
driver: local
minio_data:
driver: local
networks:
default:
name: xpeditis-network

97
docker/.env.production.example
View File

@ -1,97 +0,0 @@
# Xpeditis - Production Environment Variables
# Copy this file to .env.production and fill in the values
# ===================================
# DOCKER REGISTRY
# ===================================
DOCKER_REGISTRY=docker.io
BACKEND_IMAGE=xpeditis/backend
BACKEND_TAG=latest
FRONTEND_IMAGE=xpeditis/frontend
FRONTEND_TAG=latest
# ===================================
# DATABASE (PostgreSQL)
# ===================================
POSTGRES_DB=xpeditis_prod
POSTGRES_USER=xpeditis
POSTGRES_PASSWORD=CHANGE_ME_SECURE_PASSWORD_64_CHARS_MINIMUM
# ===================================
# REDIS CACHE
# ===================================
REDIS_PASSWORD=CHANGE_ME_REDIS_PASSWORD_64_CHARS_MINIMUM
# ===================================
# JWT AUTHENTICATION
# ===================================
JWT_SECRET=CHANGE_ME_JWT_SECRET_512_BITS_MINIMUM
# ===================================
# AWS CONFIGURATION
# ===================================
AWS_REGION=eu-west-3
AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
AWS_SES_REGION=eu-west-1
# S3 Buckets
S3_BUCKET_DOCUMENTS=xpeditis-prod-documents
S3_BUCKET_UPLOADS=xpeditis-prod-uploads
# ===================================
# EMAIL CONFIGURATION
# ===================================
EMAIL_SERVICE=ses
EMAIL_FROM=noreply@xpeditis.com
EMAIL_FROM_NAME=Xpeditis
# ===================================
# MONITORING (Sentry) - REQUIRED
# ===================================
SENTRY_DSN=https://your-sentry-dsn@sentry.io/project-id
NEXT_PUBLIC_SENTRY_DSN=https://your-sentry-dsn@sentry.io/project-id
# ===================================
# ANALYTICS (Google Analytics) - REQUIRED
# ===================================
NEXT_PUBLIC_GA_MEASUREMENT_ID=G-XXXXXXXXXX
# ===================================
# CARRIER APIs (Production) - REQUIRED
# ===================================
# Maersk Production
MAERSK_API_URL=https://api.maersk.com
MAERSK_API_KEY=your-maersk-production-api-key
# MSC Production
MSC_API_URL=https://api.msc.com
MSC_API_KEY=your-msc-production-api-key
# CMA CGM Production
CMA_CGM_API_URL=https://api.cma-cgm.com
CMA_CGM_API_KEY=your-cma-cgm-production-api-key
# Hapag-Lloyd Production
HAPAG_LLOYD_API_URL=https://api.hapag-lloyd.com
HAPAG_LLOYD_API_KEY=your-hapag-lloyd-api-key
# ONE (Ocean Network Express)
ONE_API_URL=https://api.one-line.com
ONE_API_KEY=your-one-api-key
# ===================================
# SECURITY BEST PRACTICES
# ===================================
# ✅ Use AWS Secrets Manager for production secrets
# ✅ Rotate credentials every 90 days
# ✅ Enable AWS CloudTrail for audit logs
# ✅ Use IAM roles with least privilege
# ✅ Enable MFA on all AWS accounts
# ✅ Use strong passwords (min 64 characters, random)
# ✅ Never commit this file with real credentials
# ✅ Restrict database access to VPC only
# ✅ Enable SSL/TLS for all connections
# ✅ Monitor failed login attempts (Sentry)
# ✅ Setup automated backups (daily, 30-day retention)
# ✅ Test disaster recovery procedures monthly

82
docker/.env.staging.example
View File

@ -1,82 +0,0 @@
# Xpeditis - Staging Environment Variables
# Copy this file to .env.staging and fill in the values
# ===================================
# DOCKER REGISTRY
# ===================================
DOCKER_REGISTRY=docker.io
BACKEND_IMAGE=xpeditis/backend
BACKEND_TAG=staging-latest
FRONTEND_IMAGE=xpeditis/frontend
FRONTEND_TAG=staging-latest
# ===================================
# DATABASE (PostgreSQL)
# ===================================
POSTGRES_DB=xpeditis_staging
POSTGRES_USER=xpeditis
POSTGRES_PASSWORD=CHANGE_ME_SECURE_PASSWORD_HERE
# ===================================
# REDIS CACHE
# ===================================
REDIS_PASSWORD=CHANGE_ME_REDIS_PASSWORD_HERE
# ===================================
# JWT AUTHENTICATION
# ===================================
JWT_SECRET=CHANGE_ME_JWT_SECRET_256_BITS_MINIMUM
# ===================================
# AWS CONFIGURATION
# ===================================
AWS_REGION=eu-west-3
AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
AWS_SES_REGION=eu-west-1
# S3 Buckets
S3_BUCKET_DOCUMENTS=xpeditis-staging-documents
S3_BUCKET_UPLOADS=xpeditis-staging-uploads
# ===================================
# EMAIL CONFIGURATION
# ===================================
EMAIL_SERVICE=ses
EMAIL_FROM=noreply@staging.xpeditis.com
EMAIL_FROM_NAME=Xpeditis Staging
# ===================================
# MONITORING (Sentry)
# ===================================
SENTRY_DSN=https://your-sentry-dsn@sentry.io/project-id
NEXT_PUBLIC_SENTRY_DSN=https://your-sentry-dsn@sentry.io/project-id
# ===================================
# ANALYTICS (Google Analytics)
# ===================================
NEXT_PUBLIC_GA_MEASUREMENT_ID=G-XXXXXXXXXX
# ===================================
# CARRIER APIs (Sandbox)
# ===================================
# Maersk Sandbox
MAERSK_API_URL_SANDBOX=https://sandbox.api.maersk.com
MAERSK_API_KEY_SANDBOX=your-maersk-sandbox-api-key
# MSC Sandbox
MSC_API_URL_SANDBOX=https://sandbox.msc.com/api
MSC_API_KEY_SANDBOX=your-msc-sandbox-api-key
# CMA CGM Sandbox
CMA_CGM_API_URL_SANDBOX=https://sandbox.cma-cgm.com/api
CMA_CGM_API_KEY_SANDBOX=your-cma-cgm-sandbox-api-key
# ===================================
# NOTES
# ===================================
# 1. Never commit this file with real credentials
# 2. Use strong passwords (min 32 characters, random)
# 3. Rotate secrets regularly (every 90 days)
# 4. Use AWS Secrets Manager or similar for production
# 5. Enable MFA on all AWS accounts

444
docker/DOCKER_BUILD_GUIDE.md
View File

@ -1,444 +0,0 @@
# Guide de Construction des Images Docker - Xpeditis
Ce guide explique comment construire les images Docker pour backend et frontend.
---
## 📋 Prérequis
### 1. Docker Installé
```bash
docker --version
# Docker version 24.0.0 ou supérieur
```
### 2. Docker Registry Access
- **Docker Hub**: Créer un compte sur https://hub.docker.com
- **Ou** GitHub Container Registry (GHCR)
- **Ou** Registry privé
### 3. Login au Registry
```bash
# Docker Hub
docker login
# GitHub Container Registry
echo $GITHUB_TOKEN | docker login ghcr.io -u USERNAME --password-stdin
# Registry privé
docker login registry.example.com
```
---
## 🚀 Méthode 1: Script Automatique (Recommandé)
### Build Staging
```bash
# Build seulement (pas de push)
./docker/build-images.sh staging
# Build ET push vers Docker Hub
./docker/build-images.sh staging --push
```
### Build Production
```bash
# Build seulement
./docker/build-images.sh production
# Build ET push
./docker/build-images.sh production --push
```
### Configuration du Registry
Par défaut, le script utilise `docker.io/xpeditis` comme registry.
Pour changer:
```bash
export DOCKER_REGISTRY=ghcr.io
export DOCKER_REPO=your-org
./docker/build-images.sh staging --push
```
---
## 🛠️ Méthode 2: Build Manuel
### Backend Image
```bash
cd apps/backend
# Staging
docker build \
--file Dockerfile \
--tag xpeditis/backend:staging-latest \
--platform linux/amd64 \
.
# Production
docker build \
--file Dockerfile \
--tag xpeditis/backend:latest \
--platform linux/amd64 \
.
```
### Frontend Image
```bash
cd apps/frontend
# Staging
docker build \
--file Dockerfile \
--tag xpeditis/frontend:staging-latest \
--build-arg NEXT_PUBLIC_API_URL=https://api-staging.xpeditis.com \
--build-arg NEXT_PUBLIC_APP_URL=https://staging.xpeditis.com \
--build-arg NEXT_PUBLIC_SENTRY_ENVIRONMENT=staging \
--platform linux/amd64 \
.
# Production
docker build \
--file Dockerfile \
--tag xpeditis/frontend:latest \
--build-arg NEXT_PUBLIC_API_URL=https://api.xpeditis.com \
--build-arg NEXT_PUBLIC_APP_URL=https://xpeditis.com \
--build-arg NEXT_PUBLIC_SENTRY_ENVIRONMENT=production \
--platform linux/amd64 \
.
```
### Push Images
```bash
# Backend
docker push xpeditis/backend:staging-latest
docker push xpeditis/backend:latest
# Frontend
docker push xpeditis/frontend:staging-latest
docker push xpeditis/frontend:latest
```
---
## 🧪 Tester les Images Localement
### 1. Créer un network Docker
```bash
docker network create xpeditis-test
```
### 2. Lancer PostgreSQL
```bash
docker run -d \
--name postgres-test \
--network xpeditis-test \
-e POSTGRES_DB=xpeditis_test \
-e POSTGRES_USER=xpeditis \
-e POSTGRES_PASSWORD=test123 \
-p 5432:5432 \
postgres:15-alpine
```
### 3. Lancer Redis
```bash
docker run -d \
--name redis-test \
--network xpeditis-test \
-p 6379:6379 \
redis:7-alpine \
redis-server --requirepass test123
```
### 4. Lancer Backend
```bash
docker run -d \
--name backend-test \
--network xpeditis-test \
-e NODE_ENV=development \
-e PORT=4000 \
-e DATABASE_HOST=postgres-test \
-e DATABASE_PORT=5432 \
-e DATABASE_NAME=xpeditis_test \
-e DATABASE_USER=xpeditis \
-e DATABASE_PASSWORD=test123 \
-e REDIS_HOST=redis-test \
-e REDIS_PORT=6379 \
-e REDIS_PASSWORD=test123 \
-e JWT_SECRET=test-secret-key-256-bits-minimum-length-required \
-e CORS_ORIGIN=http://localhost:3000 \
-p 4000:4000 \
xpeditis/backend:staging-latest
```
### 5. Lancer Frontend
```bash
docker run -d \
--name frontend-test \
--network xpeditis-test \
-e NODE_ENV=development \
-e NEXT_PUBLIC_API_URL=http://localhost:4000 \
-e NEXT_PUBLIC_APP_URL=http://localhost:3000 \
-e API_URL=http://backend-test:4000 \
-p 3000:3000 \
xpeditis/frontend:staging-latest
```
### 6. Vérifier
```bash
# Backend health check
curl http://localhost:4000/health
# Frontend
curl http://localhost:3000/api/health
# Ouvrir dans navigateur
open http://localhost:3000
```
### 7. Voir les logs
```bash
docker logs -f backend-test
docker logs -f frontend-test
```
### 8. Nettoyer
```bash
docker stop backend-test frontend-test postgres-test redis-test
docker rm backend-test frontend-test postgres-test redis-test
docker network rm xpeditis-test
```
---
## 📊 Optimisation des Images
### Tailles d'Images Typiques
- **Backend**: ~150-200 MB (après compression)
- **Frontend**: ~120-150 MB (après compression)
- **Total**: ~300 MB (pour les 2 images)
### Multi-Stage Build
Les Dockerfiles utilisent des builds multi-stage:
1. **Stage Dependencies**: Installation des dépendances
2. **Stage Builder**: Compilation TypeScript/Next.js
3. **Stage Production**: Image finale (seulement le nécessaire)
Avantages:
- ✅ Images légères (pas de dev dependencies)
- ✅ Build rapide (cache des layers)
- ✅ Sécurisé (pas de code source dans prod)
### Build Cache
Pour accélérer les builds:
```bash
# Build avec cache
docker build --cache-from xpeditis/backend:staging-latest -t xpeditis/backend:staging-latest .
# Ou avec BuildKit (plus rapide)
DOCKER_BUILDKIT=1 docker build -t xpeditis/backend:staging-latest .
```
### Scan de Vulnérabilités
```bash
# Scan avec Docker Scout (gratuit)
docker scout cves xpeditis/backend:staging-latest
# Scan avec Trivy
trivy image xpeditis/backend:staging-latest
```
---
## 🔄 CI/CD Integration
### GitHub Actions Example
Voir `.github/workflows/docker-build.yml` (à créer):
```yaml
name: Build and Push Docker Images
on:
push:
branches:
- main
- develop
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Login to Docker Hub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Build and Push
run: |
if [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
./docker/build-images.sh production --push
else
./docker/build-images.sh staging --push
fi
```
---
## 🐛 Dépannage
### Problème 1: Build échoue avec erreur "npm ci"
**Symptôme**: `npm ci` failed with exit code 1
**Solution**:
```bash
# Nettoyer le cache Docker
docker builder prune -a
# Rebuild sans cache
docker build --no-cache -t xpeditis/backend:staging-latest apps/backend/
```
### Problème 2: Image trop grosse (>500 MB)
**Symptôme**: Image très volumineuse
**Solution**:
- Vérifier que `.dockerignore` est présent
- Vérifier que `node_modules` n'est pas copié
- Utiliser `npm ci` au lieu de `npm install`
```bash
# Analyser les layers
docker history xpeditis/backend:staging-latest
```
### Problème 3: Next.js standalone build échoue
**Symptôme**: `Error: Cannot find module './standalone/server.js'`
**Solution**:
- Vérifier que `next.config.js` a `output: 'standalone'`
- Rebuild frontend:
```bash
cd apps/frontend
npm run build
# Vérifier que .next/standalone existe
ls -la .next/standalone
```
### Problème 4: CORS errors en production
**Symptôme**: Frontend ne peut pas appeler le backend
**Solution**:
- Vérifier `CORS_ORIGIN` dans backend
- Vérifier `NEXT_PUBLIC_API_URL` dans frontend
- Tester avec curl:
```bash
curl -H "Origin: https://staging.xpeditis.com" \
-H "Access-Control-Request-Method: GET" \
-X OPTIONS \
https://api-staging.xpeditis.com/health
```
### Problème 5: Health check fails
**Symptôme**: Container restart en boucle
**Solution**:
```bash
# Voir les logs
docker logs backend-test
# Tester health check manuellement
docker exec backend-test curl -f http://localhost:4000/health
# Si curl manque, installer:
docker exec backend-test apk add curl
```
---
## 📚 Ressources
- **Dockerfile Best Practices**: https://docs.docker.com/develop/dev-best-practices/
- **Next.js Docker**: https://nextjs.org/docs/deployment#docker-image
- **NestJS Docker**: https://docs.nestjs.com/recipes/docker
- **Docker Build Reference**: https://docs.docker.com/engine/reference/commandline/build/
---
## 🔐 Sécurité
### Ne PAS Inclure dans les Images
❌ Secrets (JWT_SECRET, API keys)
❌ Fichiers `.env`
❌ Code source TypeScript (seulement JS compilé)
❌ node_modules de dev
❌ Tests et mocks
❌ Documentation
### Utiliser
✅ Variables d'environnement au runtime
✅ Docker secrets (si Swarm)
✅ Kubernetes secrets (si K8s)
✅ AWS Secrets Manager / Vault
✅ Non-root user dans container
✅ Health checks
✅ Resource limits
---
## 📈 Métriques de Build
Après chaque build, vérifier:
```bash
# Taille des images
docker images | grep xpeditis
# Layers count
docker history xpeditis/backend:staging-latest | wc -l
# Scan vulnérabilités
docker scout cves xpeditis/backend:staging-latest
```
**Objectifs**:
- ✅ Backend < 200 MB
- ✅ Frontend < 150 MB
- ✅ Build time < 5 min
- ✅ Zéro vulnérabilité critique
---
*Dernière mise à jour*: 2025-10-14
*Version*: 1.0.0

539
docker/PORTAINER-DEPLOYMENT-GUIDE.md
View File

@ -1,539 +0,0 @@
# Guide de Déploiement Portainer - Xpeditis
Ce guide explique comment déployer l'application Xpeditis sur un serveur Docker Swarm avec Portainer et Traefik.
## Prérequis
- Docker Swarm initialisé sur votre serveur
- Traefik configuré et déployé avec le réseau `traefik_network`
- Portainer installé et accessible
- Noms de domaine configurés avec DNS pointant vers votre serveur :
- `app.xpeditis.com` - Frontend
- `api.xpeditis.com` - Backend API
- `s3.xpeditis.com` - MinIO API
- `minio.xpeditis.com` - MinIO Console
## Configuration DNS Requise
Configurez les enregistrements DNS suivants (type A) pour pointer vers l'IP de votre serveur :
```
app.xpeditis.com → IP_DU_SERVEUR
www.xpeditis.com → IP_DU_SERVEUR
api.xpeditis.com → IP_DU_SERVEUR
s3.xpeditis.com → IP_DU_SERVEUR
minio.xpeditis.com → IP_DU_SERVEUR
```
## Étape 1 : Préparer les Images Docker
### 1.1 Construire l'image Backend
```bash
cd /chemin/vers/xpeditis2.0
# Construire l'image backend
docker build -t xpeditis/backend:latest -f apps/backend/Dockerfile .
# Tag et push vers votre registre (optionnel)
docker tag xpeditis/backend:latest registry.xpeditis.com/xpeditis/backend:latest
docker push registry.xpeditis.com/xpeditis/backend:latest
```
### 1.2 Construire l'image Frontend
```bash
# Construire l'image frontend
docker build -t xpeditis/frontend:latest -f apps/frontend/Dockerfile .
# Tag et push vers votre registre (optionnel)
docker tag xpeditis/frontend:latest registry.xpeditis.com/xpeditis/frontend:latest
docker push registry.xpeditis.com/xpeditis/frontend:latest
```
### 1.3 Sauvegarder les Images (Alternative sans registre)
Si vous n'avez pas de registre Docker privé :
```bash
# Sauvegarder les images
docker save xpeditis/backend:latest | gzip > xpeditis-backend.tar.gz
docker save xpeditis/frontend:latest | gzip > xpeditis-frontend.tar.gz
# Transférer vers le serveur
scp xpeditis-backend.tar.gz user@server:/tmp/
scp xpeditis-frontend.tar.gz user@server:/tmp/
# Sur le serveur, charger les images
ssh user@server
docker load < /tmp/xpeditis-backend.tar.gz
docker load < /tmp/xpeditis-frontend.tar.gz
```
## Étape 2 : Vérifier Traefik
Assurez-vous que Traefik est correctement configuré avec :
- Network `traefik_network` externe
- Entrypoints `web` (port 80) et `websecure` (port 443)
- Certificat resolver `letsencrypt` configuré
Exemple de vérification :
```bash
# Vérifier le réseau Traefik
docker network inspect traefik_network
# Vérifier que Traefik fonctionne
docker service ls | grep traefik
```
## Étape 3 : Configurer les Variables d'Environnement
Avant de déployer, **CHANGEZ TOUS LES MOTS DE PASSE** dans le fichier `portainer-stack.yml` :
### Variables à modifier :
```yaml
# Database
POSTGRES_PASSWORD: xpeditis_prod_password_CHANGE_ME → Votre_Mot_De_Passe_Fort_DB
# Redis
REDIS_PASSWORD: xpeditis_redis_password_CHANGE_ME → Votre_Mot_De_Passe_Fort_Redis
# MinIO
MINIO_ROOT_USER: minioadmin_CHANGE_ME → Votre_Utilisateur_MinIO
MINIO_ROOT_PASSWORD: minioadmin_password_CHANGE_ME → Votre_Mot_De_Passe_Fort_MinIO
# JWT
JWT_SECRET: your-super-secret-jwt-key-CHANGE_ME-min-32-characters → Votre_Secret_JWT_32_Caracteres_Min
# Email (selon votre fournisseur)
EMAIL_HOST: smtp.example.com → smtp.votre-fournisseur.com
EMAIL_PORT: 587
EMAIL_USER: noreply@xpeditis.com → Votre_Email
EMAIL_PASSWORD: email_password_CHANGE_ME → Votre_Mot_De_Passe_Email
```
### Générer des mots de passe forts :
```bash
# Générer un mot de passe aléatoire de 32 caractères
openssl rand -base64 32
# Générer un secret JWT de 64 caractères
openssl rand -base64 64 | tr -d '\n'
```
## Étape 4 : Déployer avec Portainer
### 4.1 Accéder à Portainer
1. Ouvrez votre navigateur et accédez à Portainer (ex: `https://portainer.votre-domaine.com`)
2. Connectez-vous avec vos identifiants
3. Sélectionnez votre environnement Docker Swarm
### 4.2 Créer la Stack
1. Dans le menu latéral, cliquez sur **"Stacks"**
2. Cliquez sur **"+ Add stack"**
3. Donnez un nom à la stack : `xpeditis`
4. Choisissez **"Web editor"**
5. Copiez le contenu du fichier `portainer-stack.yml` (avec vos modifications)
6. Collez le contenu dans l'éditeur Portainer
7. Cliquez sur **"Deploy the stack"**
### 4.3 Vérifier le Déploiement
1. Attendez que tous les services soient déployés (statut vert)
2. Vérifiez les logs de chaque service :
- Cliquez sur **"Stacks"** → **"xpeditis"**
- Sélectionnez un service et consultez ses logs
## Étape 5 : Initialiser la Base de Données
### 5.1 Attendre que la DB soit prête
```bash
# Vérifier que PostgreSQL est prêt
docker service logs xpeditis_xpeditis-db --tail 50
# Vous devriez voir : "database system is ready to accept connections"
```
### 5.2 Exécuter les Migrations
```bash
# Trouver le conteneur backend
BACKEND_CONTAINER=$(docker ps --filter "name=xpeditis_xpeditis-backend" --format "{{.ID}}" | head -n 1)
# Exécuter les migrations
docker exec -it $BACKEND_CONTAINER npm run migration:run
# Vérifier que les migrations sont appliquées
docker exec -it $BACKEND_CONTAINER npm run migration:show
```
### 5.3 Créer un Bucket MinIO
```bash
# Accéder au conteneur MinIO
MINIO_CONTAINER=$(docker ps --filter "name=xpeditis_xpeditis-minio" --format "{{.ID}}" | head -n 1)
# Créer le bucket
docker exec -it $MINIO_CONTAINER mc mb local/xpeditis-documents
# Définir la politique publique en lecture pour les documents
docker exec -it $MINIO_CONTAINER mc anonymous set download local/xpeditis-documents
```
Ou via la console MinIO :
1. Accédez à `https://minio.xpeditis.com`
2. Connectez-vous avec vos identifiants MinIO
3. Créez un bucket nommé `xpeditis-documents`
## Étape 6 : Créer un Utilisateur Admin
### 6.1 Via l'API (avec curl)
```bash
# Créer une organisation
curl -X POST https://api.xpeditis.com/api/v1/organizations \
-H "Content-Type: application/json" \
-d '{
"name": "Xpeditis Admin",
"type": "FREIGHT_FORWARDER",
"address": {
"street": "123 Rue Exemple",
"city": "Paris",
"postalCode": "75001",
"country": "FR"
}
}'
# Récupérer l'ID de l'organisation dans la réponse (ex: org-id-123)
# Créer un utilisateur admin
curl -X POST https://api.xpeditis.com/api/v1/auth/register \
-H "Content-Type: application/json" \
-d '{
"email": "admin@xpeditis.com",
"password": "VotreMotDePasseAdmin123!",
"firstName": "Admin",
"lastName": "Xpeditis",
"organizationId": "org-id-123"
}'
```
### 6.2 Via la Base de Données (Direct SQL)
```bash
# Accéder à PostgreSQL
POSTGRES_CONTAINER=$(docker ps --filter "name=xpeditis_xpeditis-db" --format "{{.ID}}" | head -n 1)
docker exec -it $POSTGRES_CONTAINER psql -U xpeditis -d xpeditis_prod
# Dans psql, exécuter :
INSERT INTO organizations (id, name, type, address_street, address_city, address_postal_code, address_country, is_active)
VALUES (
gen_random_uuid(),
'Xpeditis Admin',
'FREIGHT_FORWARDER',
'123 Rue Exemple',
'Paris',
'75001',
'FR',
true
);
-- Récupérer l'ID de l'organisation
SELECT id, name FROM organizations;
-- Créer un utilisateur (remplacez ORG_ID_ICI par l'UUID réel)
INSERT INTO users (id, email, password, first_name, last_name, role, organization_id, is_active)
VALUES (
gen_random_uuid(),
'admin@xpeditis.com',
'$argon2id$v=19$m=65536,t=3,p=4$VOTRE_HASH_ARGON2',
'Admin',
'Xpeditis',
'ADMIN',
'ORG_ID_ICI',
true
);
\q
```
## Étape 7 : Tester l'Application
### 7.1 Vérifier les Services
```bash
# Vérifier que tous les services sont en cours d'exécution
docker service ls | grep xpeditis
# Vérifier les endpoints
curl -I https://api.xpeditis.com/health
curl -I https://app.xpeditis.com
curl -I https://minio.xpeditis.com
```
### 7.2 Tester l'Application Web
1. Ouvrez votre navigateur et accédez à `https://app.xpeditis.com`
2. Connectez-vous avec les identifiants admin créés
3. Testez les fonctionnalités principales :
- Recherche de tarifs
- Création de réservation CSV
- Upload de documents
### 7.3 Vérifier les Certificats SSL
```bash
# Vérifier le certificat SSL
curl -vI https://api.xpeditis.com 2>&1 | grep -i "SSL certificate"
curl -vI https://app.xpeditis.com 2>&1 | grep -i "SSL certificate"
```
## Étape 8 : Monitoring et Logs
### 8.1 Voir les Logs dans Portainer
1. **Stacks** → **xpeditis** → Sélectionnez un service
2. Cliquez sur **"Logs"**
3. Ajustez le nombre de lignes (ex: 500 dernières lignes)
### 8.2 Logs en Ligne de Commande
```bash
# Logs du backend
docker service logs xpeditis_xpeditis-backend -f --tail 100
# Logs du frontend
docker service logs xpeditis_xpeditis-frontend -f --tail 100
# Logs de la base de données
docker service logs xpeditis_xpeditis-db -f --tail 100
# Logs de Redis
docker service logs xpeditis_xpeditis-redis -f --tail 100
# Logs de MinIO
docker service logs xpeditis_xpeditis-minio -f --tail 100
```
### 8.3 Vérifier les Ressources
```bash
# Statistiques des conteneurs
docker stats
# État des services
docker service ls
# Détails d'un service
docker service inspect xpeditis_xpeditis-backend --pretty
```
## Étape 9 : Scaling (Optionnel)
### 9.1 Scaler le Backend
```bash
# Augmenter le nombre de répliques backend à 4
docker service scale xpeditis_xpeditis-backend=4
# Vérifier
docker service ps xpeditis_xpeditis-backend
```
### 9.2 Scaler le Frontend
```bash
# Augmenter le nombre de répliques frontend à 3
docker service scale xpeditis_xpeditis-frontend=3
```
### 9.3 Via Portainer
1. **Stacks** → **xpeditis** → Sélectionnez un service
2. Cliquez sur **"Scale"**
3. Ajustez le nombre de répliques
4. Cliquez sur **"Apply"**
## Étape 10 : Sauvegarde
### 10.1 Sauvegarde PostgreSQL
```bash
# Créer un script de sauvegarde
cat > /opt/backups/backup-xpeditis-db.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/opt/backups/xpeditis"
DATE=$(date +%Y%m%d_%H%M%S)
CONTAINER=$(docker ps --filter "name=xpeditis_xpeditis-db" --format "{{.ID}}" | head -n 1)
mkdir -p $BACKUP_DIR
docker exec $CONTAINER pg_dump -U xpeditis xpeditis_prod | gzip > $BACKUP_DIR/xpeditis_db_$DATE.sql.gz
# Garder seulement les 7 dernières sauvegardes
find $BACKUP_DIR -name "xpeditis_db_*.sql.gz" -mtime +7 -delete
echo "Backup completed: xpeditis_db_$DATE.sql.gz"
EOF
chmod +x /opt/backups/backup-xpeditis-db.sh
# Ajouter à crontab (sauvegarde quotidienne à 2h du matin)
(crontab -l 2>/dev/null; echo "0 2 * * * /opt/backups/backup-xpeditis-db.sh") | crontab -
```
### 10.2 Sauvegarde MinIO
```bash
# Créer un script de sauvegarde
cat > /opt/backups/backup-xpeditis-minio.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/opt/backups/xpeditis"
DATE=$(date +%Y%m%d_%H%M%S)
CONTAINER=$(docker ps --filter "name=xpeditis_xpeditis-minio" --format "{{.ID}}" | head -n 1)
mkdir -p $BACKUP_DIR
docker exec $CONTAINER tar czf - /data | cat > $BACKUP_DIR/xpeditis_minio_$DATE.tar.gz
# Garder seulement les 7 dernières sauvegardes
find $BACKUP_DIR -name "xpeditis_minio_*.tar.gz" -mtime +7 -delete
echo "Backup completed: xpeditis_minio_$DATE.tar.gz"
EOF
chmod +x /opt/backups/backup-xpeditis-minio.sh
# Ajouter à crontab (sauvegarde quotidienne à 3h du matin)
(crontab -l 2>/dev/null; echo "0 3 * * * /opt/backups/backup-xpeditis-minio.sh") | crontab -
```
## Mise à Jour de l'Application
### 1. Construire les Nouvelles Images
```bash
# Sur votre machine locale
cd /chemin/vers/xpeditis2.0
# Mettre à jour le code (git pull, etc.)
git pull origin main
# Construire les nouvelles images avec un nouveau tag
docker build -t xpeditis/backend:v1.1.0 -f apps/backend/Dockerfile .
docker build -t xpeditis/frontend:v1.1.0 -f apps/frontend/Dockerfile .
# Tag comme latest
docker tag xpeditis/backend:v1.1.0 xpeditis/backend:latest
docker tag xpeditis/frontend:v1.1.0 xpeditis/frontend:latest
# Push vers le registre ou sauvegarder et transférer
```
### 2. Mettre à Jour la Stack dans Portainer
1. **Stacks** → **xpeditis** → **"Editor"**
2. Modifiez les tags d'images si nécessaire
3. Cliquez sur **"Update the stack"**
4. Cochez **"Re-pull image and redeploy"**
5. Cliquez sur **"Update"**
Docker Swarm effectuera un rolling update sans downtime.
## Dépannage
### Le service ne démarre pas
```bash
# Vérifier les logs d'erreur
docker service logs xpeditis_xpeditis-backend --tail 100
# Vérifier les tâches échouées
docker service ps xpeditis_xpeditis-backend --no-trunc
# Inspecter le service
docker service inspect xpeditis_xpeditis-backend --pretty
```
### Certificat SSL non généré
```bash
# Vérifier les logs Traefik
docker service logs traefik --tail 200
# Vérifier que les DNS pointent bien vers le serveur
dig app.xpeditis.com
dig api.xpeditis.com
# Vérifier que le port 80 est accessible (Let's Encrypt challenge)
curl http://app.xpeditis.com
```
### Base de données ne se connecte pas
```bash
# Vérifier que PostgreSQL est prêt
docker service logs xpeditis_xpeditis-db --tail 50
# Tester la connexion depuis le backend
BACKEND_CONTAINER=$(docker ps --filter "name=xpeditis_xpeditis-backend" --format "{{.ID}}" | head -n 1)
docker exec -it $BACKEND_CONTAINER nc -zv xpeditis-db 5432
```
### MinIO ne fonctionne pas
```bash
# Vérifier les logs MinIO
docker service logs xpeditis_xpeditis-minio --tail 50
# Vérifier que le bucket existe
MINIO_CONTAINER=$(docker ps --filter "name=xpeditis_xpeditis-minio" --format "{{.ID}}" | head -n 1)
docker exec -it $MINIO_CONTAINER mc ls local/
```
## URLs de l'Application
Une fois déployée, l'application sera accessible via :
- **Frontend** : https://app.xpeditis.com
- **API** : https://api.xpeditis.com
- **API Docs (Swagger)** : https://api.xpeditis.com/api/docs
- **MinIO Console** : https://minio.xpeditis.com
- **MinIO API** : https://s3.xpeditis.com
## Sécurité
### Recommandations
1. **Changez tous les mots de passe** par défaut
2. **Utilisez des secrets Docker** pour les données sensibles
3. **Configurez un firewall** (UFW) pour limiter les ports ouverts
4. **Activez le monitoring** (Prometheus + Grafana)
5. **Configurez des alertes** pour les services en erreur
6. **Mettez en place des sauvegardes automatiques**
7. **Testez régulièrement la restauration** des sauvegardes
### Ports à Ouvrir
```bash
# Firewall UFW
sudo ufw allow 22/tcp # SSH
sudo ufw allow 80/tcp # HTTP (Traefik)
sudo ufw allow 443/tcp # HTTPS (Traefik)
sudo ufw enable
```
## Support
Pour plus d'informations, consultez :
- [Documentation Xpeditis](../README.md)
- [Architecture](../ARCHITECTURE.md)
- [Deployment Guide](../DEPLOYMENT.md)

419
docker/PORTAINER_DEPLOYMENT_GUIDE.md
View File

@ -1,419 +0,0 @@
# Guide de Déploiement Portainer - Xpeditis
Ce guide explique comment déployer les stacks Xpeditis (staging et production) sur Portainer avec Traefik.
---
## 📋 Prérequis
### 1. Infrastructure Serveur
- **Serveur VPS/Dédié** avec Docker installé
- **Minimum**: 4 vCPU, 8 GB RAM, 100 GB SSD
- **Recommandé Production**: 8 vCPU, 16 GB RAM, 200 GB SSD
- **OS**: Ubuntu 22.04 LTS ou Debian 11+
### 2. Traefik déjà déployé
- Network `traefik_network` doit exister
- Let's Encrypt configuré (`letsencrypt` resolver)
- Ports 80 et 443 ouverts
### 3. DNS Configuré
**Staging**:
- `staging.xpeditis.com` → IP du serveur
- `api-staging.xpeditis.com` → IP du serveur
**Production**:
- `xpeditis.com` → IP du serveur
- `www.xpeditis.com` → IP du serveur
- `api.xpeditis.com` → IP du serveur
### 4. Images Docker
Les images Docker doivent être buildées et pushées sur un registry (Docker Hub, GitHub Container Registry, ou privé):
```bash
# Build backend
cd apps/backend
docker build -t xpeditis/backend:staging-latest .
docker push xpeditis/backend:staging-latest
# Build frontend
cd apps/frontend
docker build -t xpeditis/frontend:staging-latest .
docker push xpeditis/frontend:staging-latest
```
---
## 🚀 Déploiement sur Portainer
### Étape 1: Créer le network Traefik (si pas déjà fait)
```bash
docker network create traefik_network
```
### Étape 2: Préparer les variables d'environnement
#### Pour Staging:
1. Copier `.env.staging.example` vers `.env.staging`
2. Remplir toutes les valeurs (voir section Variables d'environnement ci-dessous)
3. **IMPORTANT**: Utiliser des mots de passe forts (min 32 caractères)
#### Pour Production:
1. Copier `.env.production.example` vers `.env.production`
2. Remplir toutes les valeurs avec les credentials de production
3. **IMPORTANT**: Utiliser des mots de passe ultra-forts (min 64 caractères)
### Étape 3: Déployer via Portainer UI
#### A. Accéder à Portainer
- URL: `https://portainer.votre-domaine.com` (ou `http://IP:9000`)
- Login avec vos credentials admin
#### B. Créer la Stack Staging
1. **Aller dans**: Stacks → Add Stack
2. **Name**: `xpeditis-staging`
3. **Build method**: Web editor
4. **Copier le contenu** de `portainer-stack-staging.yml`
5. **Onglet "Environment variables"**:
- Cliquer sur "Load variables from .env file"
- Copier-coller le contenu de `.env.staging`
- OU ajouter manuellement chaque variable
6. **Cliquer**: Deploy the stack
7. **Vérifier**: Les 4 services doivent démarrer (postgres, redis, backend, frontend)
#### C. Créer la Stack Production
1. **Aller dans**: Stacks → Add Stack
2. **Name**: `xpeditis-production`
3. **Build method**: Web editor
4. **Copier le contenu** de `portainer-stack-production.yml`
5. **Onglet "Environment variables"**:
- Cliquer sur "Load variables from .env file"
- Copier-coller le contenu de `.env.production`
- OU ajouter manuellement chaque variable
6. **Cliquer**: Deploy the stack
7. **Vérifier**: Les 6 services doivent démarrer (postgres, redis, backend x2, frontend x2)
---
## 🔐 Variables d'environnement Critiques
### Variables Obligatoires (staging & production)
| Variable | Description | Exemple |
|----------|-------------|---------|
| `POSTGRES_PASSWORD` | Mot de passe PostgreSQL | `XpEd1t1s_pG_S3cur3_2024!` |
| `REDIS_PASSWORD` | Mot de passe Redis | `R3d1s_C4ch3_P4ssw0rd!` |
| `JWT_SECRET` | Secret pour JWT tokens | `openssl rand -base64 64` |
| `AWS_ACCESS_KEY_ID` | AWS Access Key | `AKIAIOSFODNN7EXAMPLE` |
| `AWS_SECRET_ACCESS_KEY` | AWS Secret Key | `wJalrXUtnFEMI/K7MDENG/...` |
| `SENTRY_DSN` | Sentry monitoring URL | `https://xxx@sentry.io/123` |
| `MAERSK_API_KEY` | Clé API Maersk | Voir portail Maersk |
### Générer des Secrets Sécurisés
```bash
# PostgreSQL password (64 chars)
openssl rand -base64 48
# Redis password (64 chars)
openssl rand -base64 48
# JWT Secret (512 bits)
openssl rand -base64 64
# Generic secure password
pwgen -s 64 1
```
---
## 🔍 Vérification du Déploiement
### 1. Vérifier l'état des conteneurs
Dans Portainer:
- **Stacks** → `xpeditis-staging` (ou production)
- Tous les services doivent être en status **running** (vert)
### 2. Vérifier les logs
Cliquer sur chaque service → **Logs** → Vérifier qu'il n'y a pas d'erreurs
```bash
# Ou via CLI
docker logs xpeditis-backend-staging -f
docker logs xpeditis-frontend-staging -f
```
### 3. Vérifier les health checks
```bash
# Backend health check
curl https://api-staging.xpeditis.com/health
# Réponse attendue: {"status":"ok","timestamp":"..."}
# Frontend health check
curl https://staging.xpeditis.com/api/health
# Réponse attendue: {"status":"ok"}
```
### 4. Vérifier Traefik
Dans Traefik dashboard:
- Routers: Doit afficher `xpeditis-backend-staging` et `xpeditis-frontend-staging`
- Services: Doit afficher les load balancers avec health checks verts
- Certificats: Let's Encrypt doit être vert
### 5. Vérifier SSL
```bash
# Vérifier certificat SSL
curl -I https://staging.xpeditis.com
# Header "Strict-Transport-Security" doit être présent
# Test SSL avec SSLLabs
# https://www.ssllabs.com/ssltest/analyze.html?d=staging.xpeditis.com
```
### 6. Test Complet
1. **Frontend**: Ouvrir `https://staging.xpeditis.com` dans un navigateur
2. **Backend**: Tester un endpoint: `https://api-staging.xpeditis.com/health`
3. **Login**: Créer un compte et se connecter
4. **Recherche de taux**: Tester une recherche Rotterdam → Shanghai
5. **Booking**: Créer un booking de test
---
## 🐛 Dépannage
### Problème 1: Service ne démarre pas
**Symptôme**: Conteneur en status "Exited" ou "Restarting"
**Solution**:
1. Vérifier les logs: Portainer → Service → Logs
2. Erreurs communes:
- `POSTGRES_PASSWORD` manquant → Ajouter la variable
- `Cannot connect to postgres` → Vérifier que postgres est en running
- `Redis connection refused` → Vérifier que redis est en running
- `Port already in use` → Un autre service utilise le port
### Problème 2: Traefik ne route pas vers le service
**Symptôme**: 404 Not Found ou Gateway Timeout
**Solution**:
1. Vérifier que le network `traefik_network` existe:
```bash
docker network ls | grep traefik
```
2. Vérifier que les services sont connectés au network:
```bash
docker inspect xpeditis-backend-staging | grep traefik_network
```
3. Vérifier les labels Traefik dans Portainer → Service → Labels
4. Restart Traefik:
```bash
docker restart traefik
```
### Problème 3: SSL Certificate Failed
**Symptôme**: "Your connection is not private" ou certificat invalide
**Solution**:
1. Vérifier que DNS pointe vers le serveur:
```bash
nslookup staging.xpeditis.com
```
2. Vérifier les logs Traefik:
```bash
docker logs traefik | grep -i letsencrypt
```
3. Vérifier que ports 80 et 443 sont ouverts:
```bash
sudo ufw status
sudo netstat -tlnp | grep -E '80|443'
```
4. Si nécessaire, supprimer le certificat et re-déployer:
```bash
docker exec traefik rm /letsencrypt/acme.json
docker restart traefik
```
### Problème 4: Database connection failed
**Symptôme**: Backend logs montrent "Cannot connect to database"
**Solution**:
1. Vérifier que PostgreSQL est en running
2. Vérifier les credentials:
```bash
docker exec -it xpeditis-postgres-staging psql -U xpeditis -d xpeditis_staging
```
3. Vérifier le network interne:
```bash
docker exec -it xpeditis-backend-staging ping postgres-staging
```
### Problème 5: High memory usage
**Symptôme**: Serveur lent, OOM killer
**Solution**:
1. Vérifier l'utilisation mémoire:
```bash
docker stats
```
2. Réduire les limites dans docker-compose (section `deploy.resources`)
3. Augmenter la RAM du serveur
4. Optimiser les queries PostgreSQL (indexes, explain analyze)
---
## 🔄 Mise à Jour des Stacks
### Update Rolling (Zero Downtime)
#### Staging:
1. Build et push nouvelle image:
```bash
docker build -t xpeditis/backend:staging-v1.2.0 .
docker push xpeditis/backend:staging-v1.2.0
```
2. Dans Portainer → Stacks → `xpeditis-staging` → Editor
3. Changer `BACKEND_TAG=staging-v1.2.0`
4. Cliquer "Update the stack"
5. Portainer va pull la nouvelle image et redémarrer les services
#### Production (avec High Availability):
La stack production a 2 instances de chaque service (backend-prod-1, backend-prod-2). Traefik va load balancer entre les deux.
**Mise à jour sans downtime**:
1. Stopper `backend-prod-2` dans Portainer
2. Update l'image de `backend-prod-2`
3. Redémarrer `backend-prod-2`
4. Vérifier health check OK
5. Stopper `backend-prod-1`
6. Update l'image de `backend-prod-1`
7. Redémarrer `backend-prod-1`
8. Vérifier health check OK
**OU via Portainer** (plus simple):
1. Portainer → Stacks → `xpeditis-production` → Editor
2. Changer `BACKEND_TAG=v1.2.0`
3. Cliquer "Update the stack"
4. Portainer va mettre à jour les services un par un (rolling update automatique)
---
## 📊 Monitoring
### 1. Portainer Built-in Monitoring
Portainer → Containers → Sélectionner service → **Stats**
- CPU usage
- Memory usage
- Network I/O
- Block I/O
### 2. Sentry (Error Tracking)
Toutes les erreurs backend et frontend sont envoyées à Sentry (configuré via `SENTRY_DSN`)
URL: https://sentry.io/organizations/xpeditis/projects/
### 3. Logs Centralisés
**Voir tous les logs en temps réel**:
```bash
docker logs -f xpeditis-backend-staging
docker logs -f xpeditis-frontend-staging
docker logs -f xpeditis-postgres-staging
docker logs -f xpeditis-redis-staging
```
**Rechercher dans les logs**:
```bash
docker logs xpeditis-backend-staging 2>&1 | grep "ERROR"
docker logs xpeditis-backend-staging 2>&1 | grep "booking"
```
### 4. Health Checks Dashboard
Créer un dashboard custom avec:
- Uptime Robot: https://uptimerobot.com (free tier: 50 monitors)
- Grafana + Prometheus (advanced)
---
## 🔒 Sécurité Best Practices
### 1. Mots de passe forts
✅ Min 64 caractères pour production
✅ Générés aléatoirement (openssl, pwgen)
✅ Stockés dans un gestionnaire de secrets (AWS Secrets Manager, Vault)
### 2. Rotation des credentials
✅ Tous les 90 jours
✅ Immédiatement si compromis
### 3. Backups automatiques
✅ PostgreSQL: Backup quotidien
✅ Retention: 30 jours staging, 90 jours production
✅ Test restore mensuel
### 4. Monitoring actif
✅ Sentry configuré
✅ Uptime monitoring actif
✅ Alertes email/Slack pour downtime
### 5. SSL/TLS
✅ HSTS activé (Strict-Transport-Security)
✅ TLS 1.2+ minimum
✅ Certificat Let's Encrypt auto-renew
### 6. Rate Limiting
✅ Traefik rate limiting configuré
✅ Application-level rate limiting (NestJS throttler)
✅ Brute-force protection active
### 7. Firewall
✅ Ports 80, 443 ouverts uniquement
✅ PostgreSQL/Redis accessibles uniquement depuis réseau interne Docker
✅ SSH avec clés uniquement (pas de mot de passe)
---
## 📞 Support
### En cas de problème critique:
1. **Vérifier les logs** dans Portainer
2. **Vérifier Sentry** pour les erreurs récentes
3. **Restart du service** via Portainer (si safe)
4. **Rollback**: Portainer → Stacks → Redeploy previous version
### Contacts:
- **Tech Lead**: david-henri.arnaud@3ds.com
- **DevOps**: ops@xpeditis.com
- **Support**: support@xpeditis.com
---
## 📚 Ressources
- **Portainer Docs**: https://docs.portainer.io/
- **Traefik Docs**: https://doc.traefik.io/traefik/
- **Docker Docs**: https://docs.docker.com/
- **Let's Encrypt**: https://letsencrypt.org/docs/
---
*Dernière mise à jour*: 2025-10-14
*Version*: 1.0.0
*Auteur*: Xpeditis DevOps Team

154
docker/build-images.sh
View File

@ -1,154 +0,0 @@
#!/bin/bash
# ================================================================
# Docker Image Build Script - Xpeditis
# ================================================================
# This script builds and optionally pushes Docker images for
# backend and frontend to a Docker registry.
#
# Usage:
# ./build-images.sh [staging|production] [--push]
#
# Examples:
# ./build-images.sh staging # Build staging images only
# ./build-images.sh production --push # Build and push production images
# ================================================================
set -e # Exit on error
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Default values
ENVIRONMENT=${1:-staging}
PUSH_IMAGES=${2:-}
REGISTRY=${DOCKER_REGISTRY:-docker.io}
REPO=${DOCKER_REPO:-xpeditis}
# Validate environment
if [[ "$ENVIRONMENT" != "staging" && "$ENVIRONMENT" != "production" ]]; then
echo -e "${RED}Error: Environment must be 'staging' or 'production'${NC}"
echo "Usage: $0 [staging|production] [--push]"
exit 1
fi
# Set tags based on environment
if [[ "$ENVIRONMENT" == "staging" ]]; then
BACKEND_TAG="staging-latest"
FRONTEND_TAG="staging-latest"
API_URL="https://api-staging.xpeditis.com"
APP_URL="https://staging.xpeditis.com"
SENTRY_ENV="staging"
else
BACKEND_TAG="latest"
FRONTEND_TAG="latest"
API_URL="https://api.xpeditis.com"
APP_URL="https://xpeditis.com"
SENTRY_ENV="production"
fi
echo -e "${BLUE}================================================${NC}"
echo -e "${BLUE} Building Xpeditis Docker Images${NC}"
echo -e "${BLUE}================================================${NC}"
echo -e "Environment: ${YELLOW}$ENVIRONMENT${NC}"
echo -e "Registry: ${YELLOW}$REGISTRY${NC}"
echo -e "Repository: ${YELLOW}$REPO${NC}"
echo -e "Backend Tag: ${YELLOW}$BACKEND_TAG${NC}"
echo -e "Frontend Tag: ${YELLOW}$FRONTEND_TAG${NC}"
echo -e "Push: ${YELLOW}${PUSH_IMAGES:-No}${NC}"
echo -e "${BLUE}================================================${NC}"
echo ""
# Navigate to project root
cd "$(dirname "$0")/.."
# ================================================================
# Build Backend Image
# ================================================================
echo -e "${GREEN}[1/2] Building Backend Image...${NC}"
echo "Image: $REGISTRY/$REPO/backend:$BACKEND_TAG"
docker build \
--file apps/backend/Dockerfile \
--tag $REGISTRY/$REPO/backend:$BACKEND_TAG \
--tag $REGISTRY/$REPO/backend:$(date +%Y%m%d-%H%M%S) \
--build-arg NODE_ENV=$ENVIRONMENT \
--platform linux/amd64 \
apps/backend/
echo -e "${GREEN}✓ Backend image built successfully${NC}"
echo ""
# ================================================================
# Build Frontend Image
# ================================================================
echo -e "${GREEN}[2/2] Building Frontend Image...${NC}"
echo "Image: $REGISTRY/$REPO/frontend:$FRONTEND_TAG"
docker build \
--file apps/frontend/Dockerfile \
--tag $REGISTRY/$REPO/frontend:$FRONTEND_TAG \
--tag $REGISTRY/$REPO/frontend:$(date +%Y%m%d-%H%M%S) \
--build-arg NEXT_PUBLIC_API_URL=$API_URL \
--build-arg NEXT_PUBLIC_APP_URL=$APP_URL \
--build-arg NEXT_PUBLIC_SENTRY_ENVIRONMENT=$SENTRY_ENV \
--platform linux/amd64 \
apps/frontend/
echo -e "${GREEN}✓ Frontend image built successfully${NC}"
echo ""
# ================================================================
# Push Images (if --push flag provided)
# ================================================================
if [[ "$PUSH_IMAGES" == "--push" ]]; then
echo -e "${BLUE}================================================${NC}"
echo -e "${BLUE} Pushing Images to Registry${NC}"
echo -e "${BLUE}================================================${NC}"
echo -e "${YELLOW}Pushing backend image...${NC}"
docker push $REGISTRY/$REPO/backend:$BACKEND_TAG
echo -e "${YELLOW}Pushing frontend image...${NC}"
docker push $REGISTRY/$REPO/frontend:$FRONTEND_TAG
echo -e "${GREEN}✓ Images pushed successfully${NC}"
echo ""
fi
# ================================================================
# Summary
# ================================================================
echo -e "${BLUE}================================================${NC}"
echo -e "${BLUE} Build Complete!${NC}"
echo -e "${BLUE}================================================${NC}"
echo ""
echo -e "Images built:"
echo -e " • Backend: ${GREEN}$REGISTRY/$REPO/backend:$BACKEND_TAG${NC}"
echo -e " • Frontend: ${GREEN}$REGISTRY/$REPO/frontend:$FRONTEND_TAG${NC}"
echo ""
if [[ "$PUSH_IMAGES" != "--push" ]]; then
echo -e "${YELLOW}To push images to registry, run:${NC}"
echo -e " $0 $ENVIRONMENT --push"
echo ""
fi
echo -e "To test images locally:"
echo -e " docker run -p 4000:4000 $REGISTRY/$REPO/backend:$BACKEND_TAG"
echo -e " docker run -p 3000:3000 $REGISTRY/$REPO/frontend:$FRONTEND_TAG"
echo ""
echo -e "To deploy with Portainer:"
echo -e " 1. Login to Portainer UI"
echo -e " 2. Go to Stacks → Add Stack"
echo -e " 3. Use ${YELLOW}docker/portainer-stack-$ENVIRONMENT.yml${NC}"
echo -e " 4. Fill environment variables from ${YELLOW}docker/.env.$ENVIRONMENT.example${NC}"
echo -e " 5. Deploy!"
echo ""
echo -e "${GREEN}✓ All done!${NC}"

146
docker/deploy-to-portainer.sh
View File

@ -1,146 +0,0 @@
#!/bin/bash
# ============================================================================
# Script de Déploiement Portainer - Xpeditis
# ============================================================================
# Ce script build et push les images Docker vers le registry Scaleway
# Usage: ./deploy-to-portainer.sh [backend|frontend|all]
# ============================================================================
set -e # Exit on error
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Configuration
REGISTRY="rg.fr-par.scw.cloud/weworkstudio"
TAG="preprod"
# Functions
print_header() {
echo -e "\n${BLUE}========================================${NC}"
echo -e "${BLUE}$1${NC}"
echo -e "${BLUE}========================================${NC}\n"
}
print_success() {
echo -e "${GREEN}✅ $1${NC}"
}
print_error() {
echo -e "${RED}❌ $1${NC}"
}
print_warning() {
echo -e "${YELLOW}⚠️ $1${NC}"
}
print_info() {
echo -e "${BLUE}ℹ️ $1${NC}"
}
# Check if Docker is running
check_docker() {
print_info "Checking Docker..."
if ! docker info > /dev/null 2>&1; then
print_error "Docker is not running. Please start Docker Desktop."
exit 1
fi
print_success "Docker is running"
}
# Build and push backend
build_backend() {
print_header "Building Backend Image"
cd apps/backend
print_info "Building image: ${REGISTRY}/xpeditis-backend:${TAG}"
docker build -t ${REGISTRY}/xpeditis-backend:${TAG} .
print_success "Backend image built successfully"
print_info "Pushing image to registry..."
docker push ${REGISTRY}/xpeditis-backend:${TAG}
print_success "Backend image pushed successfully"
cd ../..
}
# Build and push frontend
build_frontend() {
print_header "Building Frontend Image"
cd apps/frontend
print_info "Building image: ${REGISTRY}/xpeditis-frontend:${TAG}"
docker build -t ${REGISTRY}/xpeditis-frontend:${TAG} .
print_success "Frontend image built successfully"
print_info "Pushing image to registry..."
docker push ${REGISTRY}/xpeditis-frontend:${TAG}
print_success "Frontend image pushed successfully"
cd ../..
}
# Main script
main() {
print_header "Xpeditis Deployment Script"
# Check Docker
check_docker
# Get target from argument
TARGET=${1:-all}
case $TARGET in
backend)
build_backend
;;
frontend)
build_frontend
;;
all)
build_backend
build_frontend
;;
*)
print_error "Invalid target: $TARGET"
echo "Usage: $0 [backend|frontend|all]"
exit 1
;;
esac
print_header "Deployment Summary"
if [ "$TARGET" = "all" ] || [ "$TARGET" = "backend" ]; then
echo -e "Backend: ${GREEN}${REGISTRY}/xpeditis-backend:${TAG}${NC}"
fi
if [ "$TARGET" = "all" ] || [ "$TARGET" = "frontend" ]; then
echo -e "Frontend: ${GREEN}${REGISTRY}/xpeditis-frontend:${TAG}${NC}"
fi
echo ""
print_success "Images successfully built and pushed!"
echo ""
print_warning "Next Steps:"
echo " 1. Go to Portainer: https://portainer.weworkstudio.com"
echo " 2. Navigate to: Stacks → xpeditis-preprod"
echo " 3. Click 'Update the stack'"
echo " 4. Check '✅ Re-pull image and redeploy'"
echo " 5. Click 'Update'"
echo ""
print_info "Documentation: DEPLOYMENT_CHECKLIST.md"
}
# Run main
main "$@"

0
docker-compose.dev.yml → docker/docker-compose.dev.yml
View File

0
docker-compose.full.yml → docker/docker-compose.full.yml
View File

456
docker/portainer-stack-production.yml
View File

@ -1,456 +0,0 @@
version: '3.8'
# Xpeditis - Stack PRODUCTION
# Portainer Stack avec Traefik reverse proxy
# Domaines: xpeditis.com (frontend) | api.xpeditis.com (backend)
services:
# PostgreSQL Database
postgres-prod:
image: postgres:15-alpine
container_name: xpeditis-postgres-prod
restart: always
environment:
POSTGRES_DB: ${POSTGRES_DB:-xpeditis_prod}
POSTGRES_USER: ${POSTGRES_USER:-xpeditis}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?error}
PGDATA: /var/lib/postgresql/data/pgdata
volumes:
- postgres_data_prod:/var/lib/postgresql/data
- postgres_backups_prod:/backups
networks:
- xpeditis_internal_prod
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-xpeditis}"]
interval: 10s
timeout: 5s
retries: 5
deploy:
resources:
limits:
cpus: '2'
memory: 4G
reservations:
cpus: '1'
memory: 2G
# Redis Cache
redis-prod:
image: redis:7-alpine
container_name: xpeditis-redis-prod
restart: always
command: redis-server --requirepass ${REDIS_PASSWORD:?error} --maxmemory 1gb --maxmemory-policy allkeys-lru --appendonly yes
volumes:
- redis_data_prod:/data
networks:
- xpeditis_internal_prod
healthcheck:
test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
interval: 10s
timeout: 3s
retries: 5
deploy:
resources:
limits:
cpus: '1'
memory: 1.5G
reservations:
cpus: '0.5'
memory: 1G
# Backend API (NestJS) - Instance 1
backend-prod-1:
image: ${DOCKER_REGISTRY:-docker.io}/${BACKEND_IMAGE:-xpeditis/backend}:${BACKEND_TAG:-latest}
container_name: xpeditis-backend-prod-1
restart: always
depends_on:
postgres-prod:
condition: service_healthy
redis-prod:
condition: service_healthy
environment:
# Application
NODE_ENV: production
PORT: 4000
INSTANCE_ID: backend-prod-1
# Database
DATABASE_HOST: postgres-prod
DATABASE_PORT: 5432
DATABASE_NAME: ${POSTGRES_DB:-xpeditis_prod}
DATABASE_USER: ${POSTGRES_USER:-xpeditis}
DATABASE_PASSWORD: ${POSTGRES_PASSWORD:?error}
DATABASE_SYNC: "false"
DATABASE_LOGGING: "false"
DATABASE_POOL_MIN: 10
DATABASE_POOL_MAX: 50
# Redis
REDIS_HOST: redis-prod
REDIS_PORT: 6379
REDIS_PASSWORD: ${REDIS_PASSWORD:?error}
# JWT
JWT_SECRET: ${JWT_SECRET:?error}
JWT_ACCESS_EXPIRATION: 15m
JWT_REFRESH_EXPIRATION: 7d
# CORS
CORS_ORIGIN: https://xpeditis.com,https://www.xpeditis.com
# Sentry (Monitoring)
SENTRY_DSN: ${SENTRY_DSN:?error}
SENTRY_ENVIRONMENT: production
SENTRY_TRACES_SAMPLE_RATE: 0.1
SENTRY_PROFILES_SAMPLE_RATE: 0.05
# AWS S3
AWS_REGION: ${AWS_REGION:-eu-west-3}
AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID:?error}
AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY:?error}
S3_BUCKET_DOCUMENTS: ${S3_BUCKET_DOCUMENTS:-xpeditis-prod-documents}
S3_BUCKET_UPLOADS: ${S3_BUCKET_UPLOADS:-xpeditis-prod-uploads}
# Email (AWS SES)
EMAIL_SERVICE: ses
EMAIL_FROM: ${EMAIL_FROM:-noreply@xpeditis.com}
EMAIL_FROM_NAME: Xpeditis
AWS_SES_REGION: ${AWS_SES_REGION:-eu-west-1}
# Carrier APIs (Production)
MAERSK_API_URL: ${MAERSK_API_URL:-https://api.maersk.com}
MAERSK_API_KEY: ${MAERSK_API_KEY:?error}
MSC_API_URL: ${MSC_API_URL:-}
MSC_API_KEY: ${MSC_API_KEY:-}
CMA_CGM_API_URL: ${CMA_CGM_API_URL:-}
CMA_CGM_API_KEY: ${CMA_CGM_API_KEY:-}
# Security
RATE_LIMIT_GLOBAL: 100
RATE_LIMIT_AUTH: 5
RATE_LIMIT_SEARCH: 30
RATE_LIMIT_BOOKING: 20
volumes:
- backend_logs_prod:/app/logs
networks:
- xpeditis_internal_prod
- traefik_network
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
# HTTPS Route
- "traefik.http.routers.xpeditis-backend-prod.rule=Host(`api.xpeditis.com`)"
- "traefik.http.routers.xpeditis-backend-prod.entrypoints=websecure"
- "traefik.http.routers.xpeditis-backend-prod.tls=true"
- "traefik.http.routers.xpeditis-backend-prod.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-backend-prod.priority=200"
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.server.port=4000"
- "traefik.http.routers.xpeditis-backend-prod.middlewares=xpeditis-backend-prod-headers,xpeditis-backend-prod-security,xpeditis-backend-prod-ratelimit"
# HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-backend-prod-http.rule=Host(`api.xpeditis.com`)"
- "traefik.http.routers.xpeditis-backend-prod-http.entrypoints=web"
- "traefik.http.routers.xpeditis-backend-prod-http.priority=200"
- "traefik.http.routers.xpeditis-backend-prod-http.middlewares=xpeditis-backend-prod-redirect"
- "traefik.http.routers.xpeditis-backend-prod-http.service=xpeditis-backend-prod"
- "traefik.http.middlewares.xpeditis-backend-prod-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-backend-prod-redirect.redirectscheme.permanent=true"
# Middleware Headers
- "traefik.http.middlewares.xpeditis-backend-prod-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-backend-prod-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-backend-prod-headers.headers.customRequestHeaders.X-Real-IP="
# Security Headers (Strict Production)
- "traefik.http.middlewares.xpeditis-backend-prod-security.headers.frameDeny=true"
- "traefik.http.middlewares.xpeditis-backend-prod-security.headers.contentTypeNosniff=true"
- "traefik.http.middlewares.xpeditis-backend-prod-security.headers.browserXssFilter=true"
- "traefik.http.middlewares.xpeditis-backend-prod-security.headers.stsSeconds=63072000"
- "traefik.http.middlewares.xpeditis-backend-prod-security.headers.stsIncludeSubdomains=true"
- "traefik.http.middlewares.xpeditis-backend-prod-security.headers.stsPreload=true"
- "traefik.http.middlewares.xpeditis-backend-prod-security.headers.forceSTSHeader=true"
# Rate Limiting (Stricter in Production)
- "traefik.http.middlewares.xpeditis-backend-prod-ratelimit.ratelimit.average=50"
- "traefik.http.middlewares.xpeditis-backend-prod-ratelimit.ratelimit.burst=100"
- "traefik.http.middlewares.xpeditis-backend-prod-ratelimit.ratelimit.period=1m"
# Health Check
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.healthcheck.path=/health"
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.healthcheck.interval=30s"
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.healthcheck.timeout=5s"
# Load Balancing (Sticky Sessions)
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.sticky.cookie=true"
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.sticky.cookie.name=xpeditis_backend_route"
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.sticky.cookie.secure=true"
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.sticky.cookie.httpOnly=true"
healthcheck:
test: ["CMD", "node", "-e", "require('http').get('http://localhost:4000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
deploy:
resources:
limits:
cpus: '2'
memory: 2G
reservations:
cpus: '1'
memory: 1G
# Backend API (NestJS) - Instance 2 (High Availability)
backend-prod-2:
image: ${DOCKER_REGISTRY:-docker.io}/${BACKEND_IMAGE:-xpeditis/backend}:${BACKEND_TAG:-latest}
container_name: xpeditis-backend-prod-2
restart: always
depends_on:
postgres-prod:
condition: service_healthy
redis-prod:
condition: service_healthy
environment:
# Application
NODE_ENV: production
PORT: 4000
INSTANCE_ID: backend-prod-2
# Database
DATABASE_HOST: postgres-prod
DATABASE_PORT: 5432
DATABASE_NAME: ${POSTGRES_DB:-xpeditis_prod}
DATABASE_USER: ${POSTGRES_USER:-xpeditis}
DATABASE_PASSWORD: ${POSTGRES_PASSWORD:?error}
DATABASE_SYNC: "false"
DATABASE_LOGGING: "false"
DATABASE_POOL_MIN: 10
DATABASE_POOL_MAX: 50
# Redis
REDIS_HOST: redis-prod
REDIS_PORT: 6379
REDIS_PASSWORD: ${REDIS_PASSWORD:?error}
# JWT
JWT_SECRET: ${JWT_SECRET:?error}
JWT_ACCESS_EXPIRATION: 15m
JWT_REFRESH_EXPIRATION: 7d
# CORS
CORS_ORIGIN: https://xpeditis.com,https://www.xpeditis.com
# Sentry (Monitoring)
SENTRY_DSN: ${SENTRY_DSN:?error}
SENTRY_ENVIRONMENT: production
SENTRY_TRACES_SAMPLE_RATE: 0.1
SENTRY_PROFILES_SAMPLE_RATE: 0.05
# AWS S3
AWS_REGION: ${AWS_REGION:-eu-west-3}
AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID:?error}
AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY:?error}
S3_BUCKET_DOCUMENTS: ${S3_BUCKET_DOCUMENTS:-xpeditis-prod-documents}
S3_BUCKET_UPLOADS: ${S3_BUCKET_UPLOADS:-xpeditis-prod-uploads}
# Email (AWS SES)
EMAIL_SERVICE: ses
EMAIL_FROM: ${EMAIL_FROM:-noreply@xpeditis.com}
EMAIL_FROM_NAME: Xpeditis
AWS_SES_REGION: ${AWS_SES_REGION:-eu-west-1}
# Carrier APIs (Production)
MAERSK_API_URL: ${MAERSK_API_URL:-https://api.maersk.com}
MAERSK_API_KEY: ${MAERSK_API_KEY:?error}
MSC_API_URL: ${MSC_API_URL:-}
MSC_API_KEY: ${MSC_API_KEY:-}
CMA_CGM_API_URL: ${CMA_CGM_API_URL:-}
CMA_CGM_API_KEY: ${CMA_CGM_API_KEY:-}
# Security
RATE_LIMIT_GLOBAL: 100
RATE_LIMIT_AUTH: 5
RATE_LIMIT_SEARCH: 30
RATE_LIMIT_BOOKING: 20
volumes:
- backend_logs_prod:/app/logs
networks:
- xpeditis_internal_prod
- traefik_network
labels:
# Same Traefik labels as backend-prod-1 (load balanced)
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
- "traefik.http.routers.xpeditis-backend-prod.rule=Host(`api.xpeditis.com`)"
- "traefik.http.services.xpeditis-backend-prod.loadbalancer.server.port=4000"
healthcheck:
test: ["CMD", "node", "-e", "require('http').get('http://localhost:4000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
deploy:
resources:
limits:
cpus: '2'
memory: 2G
reservations:
cpus: '1'
memory: 1G
# Frontend (Next.js) - Instance 1
frontend-prod-1:
image: ${DOCKER_REGISTRY:-docker.io}/${FRONTEND_IMAGE:-xpeditis/frontend}:${FRONTEND_TAG:-latest}
container_name: xpeditis-frontend-prod-1
restart: always
depends_on:
- backend-prod-1
- backend-prod-2
environment:
NODE_ENV: production
NEXT_PUBLIC_API_URL: https://api.xpeditis.com
NEXT_PUBLIC_APP_URL: https://xpeditis.com
NEXT_PUBLIC_SENTRY_DSN: ${NEXT_PUBLIC_SENTRY_DSN:?error}
NEXT_PUBLIC_SENTRY_ENVIRONMENT: production
NEXT_PUBLIC_GA_MEASUREMENT_ID: ${NEXT_PUBLIC_GA_MEASUREMENT_ID:?error}
# Backend API for SSR (internal load balanced)
API_URL: http://backend-prod-1:4000
networks:
- xpeditis_internal_prod
- traefik_network
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
# HTTPS Route
- "traefik.http.routers.xpeditis-frontend-prod.rule=Host(`xpeditis.com`) || Host(`www.xpeditis.com`)"
- "traefik.http.routers.xpeditis-frontend-prod.entrypoints=websecure"
- "traefik.http.routers.xpeditis-frontend-prod.tls=true"
- "traefik.http.routers.xpeditis-frontend-prod.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-frontend-prod.priority=200"
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.server.port=3000"
- "traefik.http.routers.xpeditis-frontend-prod.middlewares=xpeditis-frontend-prod-headers,xpeditis-frontend-prod-security,xpeditis-frontend-prod-compress,xpeditis-frontend-prod-www-redirect"
# HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-frontend-prod-http.rule=Host(`xpeditis.com`) || Host(`www.xpeditis.com`)"
- "traefik.http.routers.xpeditis-frontend-prod-http.entrypoints=web"
- "traefik.http.routers.xpeditis-frontend-prod-http.priority=200"
- "traefik.http.routers.xpeditis-frontend-prod-http.middlewares=xpeditis-frontend-prod-redirect"
- "traefik.http.routers.xpeditis-frontend-prod-http.service=xpeditis-frontend-prod"
- "traefik.http.middlewares.xpeditis-frontend-prod-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-frontend-prod-redirect.redirectscheme.permanent=true"
# WWW → non-WWW Redirect
- "traefik.http.middlewares.xpeditis-frontend-prod-www-redirect.redirectregex.regex=^https://www\\.(.+)"
- "traefik.http.middlewares.xpeditis-frontend-prod-www-redirect.redirectregex.replacement=https://$${1}"
- "traefik.http.middlewares.xpeditis-frontend-prod-www-redirect.redirectregex.permanent=true"
# Middleware Headers
- "traefik.http.middlewares.xpeditis-frontend-prod-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-frontend-prod-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-frontend-prod-headers.headers.customRequestHeaders.X-Real-IP="
# Security Headers (Strict Production)
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.frameDeny=true"
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.contentTypeNosniff=true"
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.browserXssFilter=true"
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.stsSeconds=63072000"
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.stsIncludeSubdomains=true"
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.stsPreload=true"
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.forceSTSHeader=true"
- "traefik.http.middlewares.xpeditis-frontend-prod-security.headers.contentSecurityPolicy=default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://www.googletagmanager.com; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; connect-src 'self' https://api.xpeditis.com;"
# Compression
- "traefik.http.middlewares.xpeditis-frontend-prod-compress.compress=true"
# Health Check
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.healthcheck.path=/api/health"
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.healthcheck.interval=30s"
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.healthcheck.timeout=5s"
# Load Balancing (Sticky Sessions)
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.sticky.cookie=true"
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.sticky.cookie.name=xpeditis_frontend_route"
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.sticky.cookie.secure=true"
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.sticky.cookie.httpOnly=true"
healthcheck:
test: ["CMD-SHELL", "curl -f http://localhost:3000/api/health || exit 1"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
deploy:
resources:
limits:
cpus: '2'
memory: 2G
reservations:
cpus: '1'
memory: 1G
# Frontend (Next.js) - Instance 2 (High Availability)
frontend-prod-2:
image: ${DOCKER_REGISTRY:-docker.io}/${FRONTEND_IMAGE:-xpeditis/frontend}:${FRONTEND_TAG:-latest}
container_name: xpeditis-frontend-prod-2
restart: always
depends_on:
- backend-prod-1
- backend-prod-2
environment:
NODE_ENV: production
NEXT_PUBLIC_API_URL: https://api.xpeditis.com
NEXT_PUBLIC_APP_URL: https://xpeditis.com
NEXT_PUBLIC_SENTRY_DSN: ${NEXT_PUBLIC_SENTRY_DSN:?error}
NEXT_PUBLIC_SENTRY_ENVIRONMENT: production
NEXT_PUBLIC_GA_MEASUREMENT_ID: ${NEXT_PUBLIC_GA_MEASUREMENT_ID:?error}
# Backend API for SSR (internal load balanced)
API_URL: http://backend-prod-2:4000
networks:
- xpeditis_internal_prod
- traefik_network
labels:
# Same Traefik labels as frontend-prod-1 (load balanced)
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
- "traefik.http.routers.xpeditis-frontend-prod.rule=Host(`xpeditis.com`) || Host(`www.xpeditis.com`)"
- "traefik.http.services.xpeditis-frontend-prod.loadbalancer.server.port=3000"
healthcheck:
test: ["CMD-SHELL", "curl -f http://localhost:3000/api/health || exit 1"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
deploy:
resources:
limits:
cpus: '2'
memory: 2G
reservations:
cpus: '1'
memory: 1G
networks:
xpeditis_internal_prod:
driver: bridge
name: xpeditis_internal_prod
traefik_network:
external: true
volumes:
postgres_data_prod:
name: xpeditis_postgres_data_prod
postgres_backups_prod:
name: xpeditis_postgres_backups_prod
redis_data_prod:
name: xpeditis_redis_data_prod
backend_logs_prod:
name: xpeditis_backend_logs_prod

253
docker/portainer-stack-staging.yml
View File

@ -1,253 +0,0 @@
version: '3.8'
# Xpeditis - Stack STAGING/PREPROD
# Portainer Stack avec Traefik reverse proxy
# Domaines: staging.xpeditis.com (frontend) | api-staging.xpeditis.com (backend)
services:
# PostgreSQL Database
postgres-staging:
image: postgres:15-alpine
container_name: xpeditis-postgres-staging
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB:-xpeditis_staging}
POSTGRES_USER: ${POSTGRES_USER:-xpeditis}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?error}
PGDATA: /var/lib/postgresql/data/pgdata
volumes:
- postgres_data_staging:/var/lib/postgresql/data
networks:
- xpeditis_internal_staging
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-xpeditis}"]
interval: 10s
timeout: 5s
retries: 5
# Redis Cache
redis-staging:
image: redis:7-alpine
container_name: xpeditis-redis-staging
restart: unless-stopped
command: redis-server --requirepass ${REDIS_PASSWORD:?error} --maxmemory 512mb --maxmemory-policy allkeys-lru
volumes:
- redis_data_staging:/data
networks:
- xpeditis_internal_staging
healthcheck:
test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
interval: 10s
timeout: 3s
retries: 5
# Backend API (NestJS)
backend-staging:
image: ${DOCKER_REGISTRY:-docker.io}/${BACKEND_IMAGE:-xpeditis/backend}:${BACKEND_TAG:-staging-latest}
container_name: xpeditis-backend-staging
restart: unless-stopped
depends_on:
postgres-staging:
condition: service_healthy
redis-staging:
condition: service_healthy
environment:
# Application
NODE_ENV: staging
PORT: 4000
# Database
DATABASE_HOST: postgres-staging
DATABASE_PORT: 5432
DATABASE_NAME: ${POSTGRES_DB:-xpeditis_staging}
DATABASE_USER: ${POSTGRES_USER:-xpeditis}
DATABASE_PASSWORD: ${POSTGRES_PASSWORD:?error}
DATABASE_SYNC: "false"
DATABASE_LOGGING: "true"
# Redis
REDIS_HOST: redis-staging
REDIS_PORT: 6379
REDIS_PASSWORD: ${REDIS_PASSWORD:?error}
# JWT
JWT_SECRET: ${JWT_SECRET:?error}
JWT_ACCESS_EXPIRATION: 15m
JWT_REFRESH_EXPIRATION: 7d
# CORS
CORS_ORIGIN: https://staging.xpeditis.com,http://localhost:3000
# Sentry (Monitoring)
SENTRY_DSN: ${SENTRY_DSN:-}
SENTRY_ENVIRONMENT: staging
SENTRY_TRACES_SAMPLE_RATE: 0.1
SENTRY_PROFILES_SAMPLE_RATE: 0.05
# AWS S3 (or MinIO)
AWS_REGION: ${AWS_REGION:-eu-west-3}
AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID:?error}
AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY:?error}
S3_BUCKET_DOCUMENTS: ${S3_BUCKET_DOCUMENTS:-xpeditis-staging-documents}
S3_BUCKET_UPLOADS: ${S3_BUCKET_UPLOADS:-xpeditis-staging-uploads}
# Email (AWS SES or SMTP)
EMAIL_SERVICE: ${EMAIL_SERVICE:-ses}
EMAIL_FROM: ${EMAIL_FROM:-noreply@staging.xpeditis.com}
EMAIL_FROM_NAME: Xpeditis Staging
AWS_SES_REGION: ${AWS_SES_REGION:-eu-west-1}
# Carrier APIs (Sandbox)
MAERSK_API_URL: ${MAERSK_API_URL_SANDBOX:-https://sandbox.api.maersk.com}
MAERSK_API_KEY: ${MAERSK_API_KEY_SANDBOX:-}
MSC_API_URL: ${MSC_API_URL_SANDBOX:-}
MSC_API_KEY: ${MSC_API_KEY_SANDBOX:-}
# Security
RATE_LIMIT_GLOBAL: 200
RATE_LIMIT_AUTH: 10
RATE_LIMIT_SEARCH: 50
RATE_LIMIT_BOOKING: 30
volumes:
- backend_logs_staging:/app/logs
networks:
- xpeditis_internal_staging
- traefik_network
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
# HTTPS Route
- "traefik.http.routers.xpeditis-backend-staging.rule=Host(`api-staging.xpeditis.com`)"
- "traefik.http.routers.xpeditis-backend-staging.entrypoints=websecure"
- "traefik.http.routers.xpeditis-backend-staging.tls=true"
- "traefik.http.routers.xpeditis-backend-staging.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-backend-staging.priority=100"
- "traefik.http.services.xpeditis-backend-staging.loadbalancer.server.port=4000"
- "traefik.http.routers.xpeditis-backend-staging.middlewares=xpeditis-backend-staging-headers,xpeditis-backend-staging-security"
# HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-backend-staging-http.rule=Host(`api-staging.xpeditis.com`)"
- "traefik.http.routers.xpeditis-backend-staging-http.entrypoints=web"
- "traefik.http.routers.xpeditis-backend-staging-http.priority=100"
- "traefik.http.routers.xpeditis-backend-staging-http.middlewares=xpeditis-backend-staging-redirect"
- "traefik.http.routers.xpeditis-backend-staging-http.service=xpeditis-backend-staging"
- "traefik.http.middlewares.xpeditis-backend-staging-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-backend-staging-redirect.redirectscheme.permanent=true"
# Middleware Headers
- "traefik.http.middlewares.xpeditis-backend-staging-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-backend-staging-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-backend-staging-headers.headers.customRequestHeaders.X-Real-IP="
# Security Headers
- "traefik.http.middlewares.xpeditis-backend-staging-security.headers.frameDeny=true"
- "traefik.http.middlewares.xpeditis-backend-staging-security.headers.contentTypeNosniff=true"
- "traefik.http.middlewares.xpeditis-backend-staging-security.headers.browserXssFilter=true"
- "traefik.http.middlewares.xpeditis-backend-staging-security.headers.stsSeconds=31536000"
- "traefik.http.middlewares.xpeditis-backend-staging-security.headers.stsIncludeSubdomains=true"
- "traefik.http.middlewares.xpeditis-backend-staging-security.headers.stsPreload=true"
# Rate Limiting
- "traefik.http.middlewares.xpeditis-backend-staging-ratelimit.ratelimit.average=100"
- "traefik.http.middlewares.xpeditis-backend-staging-ratelimit.ratelimit.burst=200"
# Health Check
- "traefik.http.services.xpeditis-backend-staging.loadbalancer.healthcheck.path=/health"
- "traefik.http.services.xpeditis-backend-staging.loadbalancer.healthcheck.interval=30s"
- "traefik.http.services.xpeditis-backend-staging.loadbalancer.healthcheck.timeout=5s"
healthcheck:
test: ["CMD", "node", "-e", "require('http').get('http://localhost:4000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"]
interval: 30s
timeout: 10s
retries: 3
start_period: 40s
# Frontend (Next.js)
frontend-staging:
image: ${DOCKER_REGISTRY:-docker.io}/${FRONTEND_IMAGE:-xpeditis/frontend}:${FRONTEND_TAG:-staging-latest}
container_name: xpeditis-frontend-staging
restart: unless-stopped
depends_on:
- backend-staging
environment:
NODE_ENV: staging
NEXT_PUBLIC_API_URL: https://api-staging.xpeditis.com
NEXT_PUBLIC_APP_URL: https://staging.xpeditis.com
NEXT_PUBLIC_SENTRY_DSN: ${NEXT_PUBLIC_SENTRY_DSN:-}
NEXT_PUBLIC_SENTRY_ENVIRONMENT: staging
NEXT_PUBLIC_GA_MEASUREMENT_ID: ${NEXT_PUBLIC_GA_MEASUREMENT_ID:-}
# Backend API for SSR (internal)
API_URL: http://backend-staging:4000
networks:
- xpeditis_internal_staging
- traefik_network
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
# HTTPS Route
- "traefik.http.routers.xpeditis-frontend-staging.rule=Host(`staging.xpeditis.com`)"
- "traefik.http.routers.xpeditis-frontend-staging.entrypoints=websecure"
- "traefik.http.routers.xpeditis-frontend-staging.tls=true"
- "traefik.http.routers.xpeditis-frontend-staging.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-frontend-staging.priority=100"
- "traefik.http.services.xpeditis-frontend-staging.loadbalancer.server.port=3000"
- "traefik.http.routers.xpeditis-frontend-staging.middlewares=xpeditis-frontend-staging-headers,xpeditis-frontend-staging-security,xpeditis-frontend-staging-compress"
# HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-frontend-staging-http.rule=Host(`staging.xpeditis.com`)"
- "traefik.http.routers.xpeditis-frontend-staging-http.entrypoints=web"
- "traefik.http.routers.xpeditis-frontend-staging-http.priority=100"
- "traefik.http.routers.xpeditis-frontend-staging-http.middlewares=xpeditis-frontend-staging-redirect"
- "traefik.http.routers.xpeditis-frontend-staging-http.service=xpeditis-frontend-staging"
- "traefik.http.middlewares.xpeditis-frontend-staging-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-frontend-staging-redirect.redirectscheme.permanent=true"
# Middleware Headers
- "traefik.http.middlewares.xpeditis-frontend-staging-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-frontend-staging-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-frontend-staging-headers.headers.customRequestHeaders.X-Real-IP="
# Security Headers
- "traefik.http.middlewares.xpeditis-frontend-staging-security.headers.frameDeny=true"
- "traefik.http.middlewares.xpeditis-frontend-staging-security.headers.contentTypeNosniff=true"
- "traefik.http.middlewares.xpeditis-frontend-staging-security.headers.browserXssFilter=true"
- "traefik.http.middlewares.xpeditis-frontend-staging-security.headers.stsSeconds=31536000"
- "traefik.http.middlewares.xpeditis-frontend-staging-security.headers.stsIncludeSubdomains=true"
- "traefik.http.middlewares.xpeditis-frontend-staging-security.headers.stsPreload=true"
- "traefik.http.middlewares.xpeditis-frontend-staging-security.headers.customResponseHeaders.X-Robots-Tag=noindex,nofollow"
# Compression
- "traefik.http.middlewares.xpeditis-frontend-staging-compress.compress=true"
# Health Check
- "traefik.http.services.xpeditis-frontend-staging.loadbalancer.healthcheck.path=/api/health"
- "traefik.http.services.xpeditis-frontend-staging.loadbalancer.healthcheck.interval=30s"
- "traefik.http.services.xpeditis-frontend-staging.loadbalancer.healthcheck.timeout=5s"
healthcheck:
test: ["CMD-SHELL", "curl -f http://localhost:3000/api/health || exit 1"]
interval: 30s
timeout: 10s
retries: 3
start_period: 40s
networks:
xpeditis_internal_staging:
driver: bridge
name: xpeditis_internal_staging
traefik_network:
external: true
volumes:
postgres_data_staging:
name: xpeditis_postgres_data_staging
redis_data_staging:
name: xpeditis_redis_data_staging
backend_logs_staging:
name: xpeditis_backend_logs_staging

255
docker/portainer-stack-swarm.yml
View File

@ -1,255 +0,0 @@
version: '3.8'
services:
# PostgreSQL Database
xpeditis-db:
image: postgres:15-alpine
volumes:
- xpeditis_db_data:/var/lib/postgresql/data
environment:
POSTGRES_DB: xpeditis_preprod
POSTGRES_USER: xpeditis
POSTGRES_PASSWORD: 9Lc3M9qoPBeHLKHDXGUf1
PGDATA: /var/lib/postgresql/data/pgdata
networks:
- xpeditis_internal
healthcheck:
test: ["CMD-SHELL", "pg_isready -U xpeditis"]
interval: 10s
timeout: 5s
retries: 5
deploy:
restart_policy:
condition: on-failure
placement:
constraints:
- node.role == manager
# Redis Cache
xpeditis-redis:
image: redis:7-alpine
command: redis-server --requirepass hXiy5GMPswMtxMZujjS2O --appendonly yes
volumes:
- xpeditis_redis_data:/data
networks:
- xpeditis_internal
healthcheck:
test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
deploy:
restart_policy:
condition: on-failure
# MinIO S3 Storage
xpeditis-minio:
image: minio/minio:latest
command: server /data --console-address ":9001"
volumes:
- xpeditis_minio_data:/data
environment:
MINIO_ROOT_USER: minioadmin_preprod_CHANGE_ME
MINIO_ROOT_PASSWORD: RBJfD0QVXC5JDfAHCwdUW
networks:
- xpeditis_internal
- traefik_network
deploy:
restart_policy:
condition: on-failure
labels:
- "traefik.enable=true"
- "traefik.docker.lbswarm=true"
# MinIO API (S3) - HTTPS
- "traefik.http.routers.xpeditis-minio-api.rule=Host(`s3.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-minio-api.entrypoints=websecure"
- "traefik.http.routers.xpeditis-minio-api.tls=true"
- "traefik.http.routers.xpeditis-minio-api.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-minio-api.priority=50"
- "traefik.http.routers.xpeditis-minio-api.service=xpeditis-minio-api"
- "traefik.http.services.xpeditis-minio-api.loadbalancer.server.port=9000"
- "traefik.http.routers.xpeditis-minio-api.middlewares=xpeditis-minio-api-headers"
# MinIO API Headers
- "traefik.http.middlewares.xpeditis-minio-api-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-minio-api-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-minio-api-headers.headers.customRequestHeaders.X-Real-IP="
# MinIO API - HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-minio-api-http.rule=Host(`s3.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-minio-api-http.entrypoints=web"
- "traefik.http.routers.xpeditis-minio-api-http.priority=50"
- "traefik.http.routers.xpeditis-minio-api-http.middlewares=xpeditis-minio-api-redirect"
- "traefik.http.routers.xpeditis-minio-api-http.service=xpeditis-minio-api"
- "traefik.http.middlewares.xpeditis-minio-api-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-minio-api-redirect.redirectscheme.permanent=true"
# MinIO Console - HTTPS
- "traefik.http.routers.xpeditis-minio-console.rule=Host(`minio.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-minio-console.entrypoints=websecure"
- "traefik.http.routers.xpeditis-minio-console.tls=true"
- "traefik.http.routers.xpeditis-minio-console.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-minio-console.priority=50"
- "traefik.http.routers.xpeditis-minio-console.service=xpeditis-minio-console"
- "traefik.http.services.xpeditis-minio-console.loadbalancer.server.port=9001"
- "traefik.http.routers.xpeditis-minio-console.middlewares=xpeditis-minio-console-headers"
# MinIO Console Headers
- "traefik.http.middlewares.xpeditis-minio-console-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-minio-console-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-minio-console-headers.headers.customRequestHeaders.X-Real-IP="
# MinIO Console - HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-minio-console-http.rule=Host(`minio.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-minio-console-http.entrypoints=web"
- "traefik.http.routers.xpeditis-minio-console-http.priority=50"
- "traefik.http.routers.xpeditis-minio-console-http.middlewares=xpeditis-minio-console-redirect"
- "traefik.http.routers.xpeditis-minio-console-http.service=xpeditis-minio-console"
- "traefik.http.middlewares.xpeditis-minio-console-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-minio-console-redirect.redirectscheme.permanent=true"
# Backend API (NestJS)
xpeditis-backend:
image: rg.fr-par.scw.cloud/weworkstudio/xpeditis-backend:preprod
depends_on:
- xpeditis-db
- xpeditis-redis
healthcheck:
disable: true
environment:
NODE_ENV: production
PORT: "4000"
API_PREFIX: api/v1
# Database
DATABASE_HOST: xpeditis-db
DATABASE_PORT: "5432"
DATABASE_USER: xpeditis
DATABASE_PASSWORD: 9Lc3M9qoPBeHLKHDXGUf1
DATABASE_NAME: xpeditis_preprod
DATABASE_SYNC: "false"
DATABASE_LOGGING: "false"
# Redis
REDIS_HOST: xpeditis-redis
REDIS_PORT: "6379"
REDIS_PASSWORD: hXiy5GMPswMtxMZujjS2O
REDIS_DB: "0"
# JWT
JWT_SECRET: 4C4tQC8qym/evv4zI5DaUE1yy3kilEnm6lApOGD0GgNBLA0BLm2tVyUr1Lr0mTnV
JWT_ACCESS_EXPIRATION: 15m
JWT_REFRESH_EXPIRATION: 7d
# S3/MinIO
AWS_S3_ENDPOINT: http://xpeditis-minio:9000
AWS_REGION: us-east-1
AWS_ACCESS_KEY_ID: minioadmin_preprod_CHANGE_ME
AWS_SECRET_ACCESS_KEY: RBJfD0QVXC5JDfAHCwdUW
AWS_S3_BUCKET: xpeditis-csv-rates
# CORS
CORS_ORIGIN: https://app.preprod.xpeditis.com,https://www.preprod.xpeditis.com,https://api.preprod.xpeditis.com
# App URLs
APP_URL: https://app.preprod.xpeditis.com
FRONTEND_URL: https://app.preprod.xpeditis.com
API_URL: https://api.preprod.xpeditis.com
# Security
BCRYPT_ROUNDS: "10"
SESSION_TIMEOUT_MS: "7200000"
# Rate Limiting
RATE_LIMIT_TTL: "60"
RATE_LIMIT_MAX: "100"
networks:
- xpeditis_internal
- traefik_network
deploy:
restart_policy:
condition: on-failure
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
- "traefik.docker.lbswarm=true"
# Backend API - HTTPS
- "traefik.http.routers.xpeditis-api.rule=Host(`api.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-api.entrypoints=websecure"
- "traefik.http.routers.xpeditis-api.tls=true"
- "traefik.http.routers.xpeditis-api.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-api.priority=50"
- "traefik.http.routers.xpeditis-api.service=xpeditis-api"
- "traefik.http.services.xpeditis-api.loadbalancer.server.port=4000"
- "traefik.http.routers.xpeditis-api.middlewares=xpeditis-api-headers"
# Backend API Headers
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Real-IP="
# Backend API - HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-api-http.rule=Host(`api.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-api-http.entrypoints=web"
- "traefik.http.routers.xpeditis-api-http.priority=50"
- "traefik.http.routers.xpeditis-api-http.middlewares=xpeditis-api-redirect"
- "traefik.http.routers.xpeditis-api-http.service=xpeditis-api"
- "traefik.http.middlewares.xpeditis-api-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-api-redirect.redirectscheme.permanent=true"
# Frontend (Next.js)
xpeditis-frontend:
image: rg.fr-par.scw.cloud/weworkstudio/xpeditis-frontend:preprod
healthcheck:
disable: true
environment:
NODE_ENV: production
NEXT_PUBLIC_API_URL: https://api.preprod.xpeditis.com
NEXT_PUBLIC_WS_URL: wss://api.preprod.xpeditis.com
networks:
- traefik_network
deploy:
restart_policy:
condition: on-failure
labels:
- "traefik.enable=true"
- "traefik.docker.lbswarm=true"
# Frontend - HTTPS
- "traefik.http.routers.xpeditis-app.rule=Host(`app.preprod.xpeditis.com`) || Host(`www.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-app.entrypoints=websecure"
- "traefik.http.routers.xpeditis-app.tls=true"
- "traefik.http.routers.xpeditis-app.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-app.priority=50"
- "traefik.http.routers.xpeditis-app.service=xpeditis-app"
- "traefik.http.services.xpeditis-app.loadbalancer.server.port=3000"
- "traefik.http.routers.xpeditis-app.middlewares=xpeditis-app-headers"
# Frontend Headers
- "traefik.http.middlewares.xpeditis-app-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-app-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-app-headers.headers.customRequestHeaders.X-Real-IP="
# Frontend - HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-app-http.rule=Host(`app.preprod.xpeditis.com`) || Host(`www.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-app-http.entrypoints=web"
- "traefik.http.routers.xpeditis-app-http.priority=50"
- "traefik.http.routers.xpeditis-app-http.middlewares=xpeditis-app-redirect"
- "traefik.http.routers.xpeditis-app-http.service=xpeditis-app"
- "traefik.http.middlewares.xpeditis-app-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-app-redirect.redirectscheme.permanent=true"
volumes:
xpeditis_db_data:
xpeditis_redis_data:
xpeditis_minio_data:
networks:
traefik_network:
external: true
xpeditis_internal:
driver: overlay
internal: true

263
docker/portainer-stack.yml → docker/stack-portainer-preprod.yaml
View File

@ -4,7 +4,9 @@ services:
# PostgreSQL Database
xpeditis-db:
image: postgres:15-alpine
restart: unless-stopped
deploy:
restart_policy:
condition: on-failure
volumes:
- xpeditis_db_data:/var/lib/postgresql/data
environment:
@ -12,35 +14,37 @@ services:
POSTGRES_USER: xpeditis
POSTGRES_PASSWORD: 9Lc3M9qoPBeHLKHDXGUf1
PGDATA: /var/lib/postgresql/data/pgdata
networks:
- xpeditis_internal
healthcheck:
test: ["CMD-SHELL", "pg_isready -U xpeditis"]
interval: 10s
timeout: 5s
retries: 5
start_period: 10s
networks:
- xpeditis_internal
# Redis Cache
xpeditis-redis:
image: redis:7-alpine
restart: unless-stopped
deploy:
restart_policy:
condition: on-failure
command: redis-server --requirepass hXiy5GMPswMtxMZujjS2O --appendonly yes
volumes:
- xpeditis_redis_data:/data
networks:
- xpeditis_internal
healthcheck:
test: ["CMD", "redis-cli", "--auth", "hXiy5GMPswMtxMZujjS2O", "ping"]
test: ["CMD", "redis-cli", "-a", "hXiy5GMPswMtxMZujjS2O", "ping"]
interval: 10s
timeout: 5s
retries: 5
start_period: 10s
networks:
- xpeditis_internal
# MinIO S3 Storage
xpeditis-minio:
image: minio/minio:latest
restart: unless-stopped
deploy:
restart_policy:
condition: on-failure
command: server /data --console-address ":9001"
volumes:
- xpeditis_minio_data:/data
@ -50,12 +54,6 @@ services:
networks:
- xpeditis_internal
- traefik_network
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
interval: 30s
timeout: 10s
retries: 3
start_period: 20s
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
@ -111,14 +109,47 @@ services:
# Backend API (NestJS)
xpeditis-backend:
image: rg.fr-par.scw.cloud/weworkstudio/xpeditis-backend:preprod
restart: unless-stopped
healthcheck:
disable: true
deploy:
restart_policy:
condition: on-failure
depends_on:
- xpeditis-db
- xpeditis-redis
labels:
- "logging=promtail"
- "logging.service=backend"
- "traefik.enable=true"
# Backend API - HTTPS
- "traefik.http.routers.xpeditis-api.rule=Host(`api.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-api.entrypoints=websecure"
- "traefik.http.routers.xpeditis-api.tls=true"
- "traefik.http.routers.xpeditis-api.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-api.priority=50"
- "traefik.http.routers.xpeditis-api.service=xpeditis-api"
- "traefik.http.services.xpeditis-api.loadbalancer.server.port=4000"
- "traefik.http.routers.xpeditis-api.middlewares=xpeditis-api-headers"
# Backend API Headers
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Real-IP="
# Backend API - HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-api-http.rule=Host(`api.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-api-http.entrypoints=web"
- "traefik.http.routers.xpeditis-api-http.priority=50"
- "traefik.http.routers.xpeditis-api-http.middlewares=xpeditis-api-redirect"
- "traefik.http.routers.xpeditis-api-http.service=xpeditis-api"
- "traefik.http.middlewares.xpeditis-api-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-api-redirect.redirectscheme.permanent=true"
environment:
NODE_ENV: production
PORT: "4000"
API_PREFIX: api/v1
LOG_FORMAT: json
# Database
DATABASE_HOST: xpeditis-db
@ -129,6 +160,15 @@ services:
DATABASE_SYNC: "false"
DATABASE_LOGGING: "false"
# Email (SMTP)
# SMTP (Brevo)
SMTP_HOST: smtp-relay.brevo.com
SMTP_PORT: 587
SMTP_USER: 9637ef001@smtp-brevo.com
SMTP_PASS: xsmtpsib-8d965bda028cd63bed868a119f9e0330485204bf9f4e1f92a3a11c8e61000722-xUYUSrGGxhMqlUcu
SMTP_SECURE: "false"
SMTP_FROM: noreply@xpeditis.com
# Redis
REDIS_HOST: xpeditis-redis
REDIS_PORT: "6379"
@ -163,66 +203,34 @@ services:
RATE_LIMIT_TTL: "60"
RATE_LIMIT_MAX: "100"
# Stripe (Subscriptions & Payments)
STRIPE_SECRET_KEY: "sk_test_51R8p8R4atifoBlu1U9sMJh3rkQbO1G1xeguwFMQYMIMeaLNrTX7YFO5Ovu3P1VfbwcOoEmiy6I0UWi4DThNNzHG100YF75TnJr"
STRIPE_WEBHOOK_SECRET: "whsec_0BLJx3J2LXITCq1cgp9ArzBuMG1W3QMj"
# Stripe Price IDs (from Stripe Dashboard)
STRIPE_STARTER_MONTHLY_PRICE_ID: "price_1SrIrR4atifoBlu1ZplPEdkD"
STRIPE_STARTER_YEARLY_PRICE_ID: "price_1SrIsm4atifoBlu1ycMAXVGj"
STRIPE_PRO_MONTHLY_PRICE_ID: "price_1SrIs14atifoBlu1BDTlsbK7"
STRIPE_PRO_YEARLY_PRICE_ID: "price_1SrItG4atifoBlu1CiSKold0"
STRIPE_ENTERPRISE_MONTHLY_PRICE_ID: "price_1SrNj94atifoBlu1F6axOXrR"
STRIPE_ENTERPRISE_YEARLY_PRICE_ID: "price_1SrNiA4atifoBlu11RJD0ocG"
networks:
- xpeditis_internal
- traefik_network
healthcheck:
test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:4000/api/v1/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
# Backend API - HTTPS
- "traefik.http.routers.xpeditis-api.rule=Host(`api.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-api.entrypoints=websecure"
- "traefik.http.routers.xpeditis-api.tls=true"
- "traefik.http.routers.xpeditis-api.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-api.priority=50"
- "traefik.http.routers.xpeditis-api.service=xpeditis-api"
- "traefik.http.services.xpeditis-api.loadbalancer.server.port=4000"
- "traefik.http.routers.xpeditis-api.middlewares=xpeditis-api-headers"
# Backend API Headers
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-api-headers.headers.customRequestHeaders.X-Real-IP="
# Backend API - HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-api-http.rule=Host(`api.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-api-http.entrypoints=web"
- "traefik.http.routers.xpeditis-api-http.priority=50"
- "traefik.http.routers.xpeditis-api-http.middlewares=xpeditis-api-redirect"
- "traefik.http.routers.xpeditis-api-http.service=xpeditis-api"
- "traefik.http.middlewares.xpeditis-api-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-api-redirect.redirectscheme.permanent=true"
# Frontend (Next.js)
xpeditis-frontend:
image: rg.fr-par.scw.cloud/weworkstudio/xpeditis-frontend:preprod
restart: unless-stopped
environment:
NODE_ENV: production
NEXT_PUBLIC_API_URL: https://api.preprod.xpeditis.com
NEXT_PUBLIC_WS_URL: wss://api.preprod.xpeditis.com
networks:
- traefik_network
healthcheck:
test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:3000"]
interval: 30s
timeout: 10s
retries: 3
start_period: 40s
disable: true
deploy:
restart_policy:
condition: on-failure
labels:
- "logging=promtail"
- "logging.service=frontend"
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
# Frontend - HTTPS
- "traefik.http.routers.xpeditis-app.rule=Host(`app.preprod.xpeditis.com`) || Host(`www.preprod.xpeditis.com`)"
@ -247,15 +255,134 @@ services:
- "traefik.http.routers.xpeditis-app-http.service=xpeditis-app"
- "traefik.http.middlewares.xpeditis-app-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-app-redirect.redirectscheme.permanent=true"
environment:
NODE_ENV: production
NEXT_PUBLIC_API_URL: https://api.preprod.xpeditis.com
NEXT_PUBLIC_WS_URL: wss://api.preprod.xpeditis.com
networks:
- traefik_network
# ─── Logging Stack ─────────────────────────────────────────────────────────
# Loki - Log aggregation
xpeditis-loki:
image: grafana/loki:3.0.0
deploy:
restart_policy:
condition: on-failure
volumes:
- xpeditis_loki_data:/loki
configs:
- source: loki_config
target: /etc/loki/local-config.yaml
command: -config.file=/etc/loki/local-config.yaml
healthcheck:
test: ['CMD-SHELL', 'wget --quiet --tries=1 --spider http://localhost:3100/ready || exit 1']
interval: 15s
timeout: 5s
retries: 5
networks:
- xpeditis_internal
# Promtail - Log collector (scrapes Docker container logs)
xpeditis-promtail:
image: grafana/promtail:3.0.0
deploy:
restart_policy:
condition: on-failure
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
configs:
- source: promtail_config
target: /etc/promtail/config.yml
command: -config.file=/etc/promtail/config.yml
depends_on:
- xpeditis-loki
networks:
- xpeditis_internal
# Grafana - Log & metrics dashboards
xpeditis-grafana:
image: grafana/grafana:11.0.0
deploy:
restart_policy:
condition: on-failure
environment:
GF_SECURITY_ADMIN_USER: "David"
GF_SECURITY_ADMIN_PASSWORD: "G9N]71dT80l"
GF_USERS_ALLOW_SIGN_UP: 'false'
GF_AUTH_ANONYMOUS_ENABLED: 'false'
GF_SERVER_ROOT_URL: https://grafana.preprod.xpeditis.com
GF_ANALYTICS_REPORTING_ENABLED: 'false'
GF_ANALYTICS_CHECK_FOR_UPDATES: 'false'
volumes:
- xpeditis_grafana_data:/var/lib/grafana
depends_on:
- xpeditis-loki
networks:
- xpeditis_internal
- traefik_network
labels:
- "traefik.enable=true"
- "traefik.docker.network=traefik_network"
# Grafana - HTTPS
- "traefik.http.routers.xpeditis-grafana.rule=Host(`grafana.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-grafana.entrypoints=websecure"
- "traefik.http.routers.xpeditis-grafana.tls=true"
- "traefik.http.routers.xpeditis-grafana.tls.certresolver=letsencrypt"
- "traefik.http.routers.xpeditis-grafana.priority=50"
- "traefik.http.routers.xpeditis-grafana.service=xpeditis-grafana"
- "traefik.http.services.xpeditis-grafana.loadbalancer.server.port=3000"
- "traefik.http.routers.xpeditis-grafana.middlewares=xpeditis-grafana-headers"
# Grafana Headers
- "traefik.http.middlewares.xpeditis-grafana-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
- "traefik.http.middlewares.xpeditis-grafana-headers.headers.customRequestHeaders.X-Forwarded-For="
- "traefik.http.middlewares.xpeditis-grafana-headers.headers.customRequestHeaders.X-Real-IP="
# Grafana - HTTP → HTTPS Redirect
- "traefik.http.routers.xpeditis-grafana-http.rule=Host(`grafana.preprod.xpeditis.com`)"
- "traefik.http.routers.xpeditis-grafana-http.entrypoints=web"
- "traefik.http.routers.xpeditis-grafana-http.priority=50"
- "traefik.http.routers.xpeditis-grafana-http.middlewares=xpeditis-grafana-redirect"
- "traefik.http.routers.xpeditis-grafana-http.service=xpeditis-grafana"
- "traefik.http.middlewares.xpeditis-grafana-redirect.redirectscheme.scheme=https"
- "traefik.http.middlewares.xpeditis-grafana-redirect.redirectscheme.permanent=true"
# Log Exporter - HTTP API to push structured logs to Loki (internal only)
xpeditis-log-exporter:
image: rg.fr-par.scw.cloud/weworkstudio/xpeditis-log-exporter:preprod
deploy:
restart_policy:
condition: on-failure
environment:
PORT: "3200"
LOKI_URL: http://xpeditis-loki:3100
# LOG_EXPORTER_API_KEY: your-secret-key-here
depends_on:
- xpeditis-loki
networks:
- xpeditis_internal
volumes:
xpeditis_db_data:
xpeditis_redis_data:
xpeditis_minio_data:
xpeditis_loki_data:
driver: local
xpeditis_grafana_data:
driver: local
networks:
traefik_network:
external: true
xpeditis_internal:
driver: bridge
driver: overlay
internal: true
configs:
loki_config:
external: true
promtail_config:
external: true

628
docs/AUDIT-FINAL-REPORT.md
View File

@ -1,628 +0,0 @@
# 🎯 RAPPORT FINAL D'AUDIT & NETTOYAGE - Xpeditis
**Date**: 2025-12-22
**Version**: v0.1.0
**Projet**: Xpeditis - Plateforme B2B SaaS Maritime
**Auditeur**: Claude Code Architect Agent
---
## 📊 RÉSUMÉ EXÉCUTIF
### Scores globaux
| Composant | Score | Status |
|-----------|-------|--------|
| **Backend (NestJS)** | **95/100** | ✅ Excellent |
| **Frontend (Next.js)** | **65/100** | ⚠️ Améliorations requises |
| **Architecture globale** | **85/100** | ✅ Bon |
### Santé du projet
✅ **Points forts**:
- Architecture hexagonale bien implémentée (backend)
- Séparation claire des responsabilités
- 220+ fichiers TypeScript bien organisés
- Couverture de tests domaine ~90%+
- 21 modules NestJS correctement structurés
- 60+ endpoints API bien documentés
⚠️ **Points d'amélioration**:
- 1 violation critique architecture hexagonale (backend)
- TypeScript strict mode désactivé (frontend)
- Logique métier dans certaines pages (frontend)
- Incohérence pattern data fetching (frontend)
- 8-10 fichiers legacy à nettoyer (frontend)
- Pagination client-side pour 1000 items (frontend)
❌ **Problèmes critiques**:
1. `domain/services/booking.service.ts` dépend de NestJS
2. Clés de token localStorage incohérentes (`access_token` vs `accessToken`)
3. TypeScript `strict: false` en frontend
---
## 🏗️ ANALYSE ARCHITECTURE
### Backend: Architecture Hexagonale
**Conformité**: **95%** (1 violation sur 100 vérifications)
#### ✅ Points forts
1. **Séparation des couches exemplaire**:
```
Domain (13 entities, 9 VOs, 7 services)
↑
Application (17 controllers, 15 DTOs, 11 services)
↑
Infrastructure (13 repositories, 7 carriers, 4 adapters)
```
2. **Pattern Ports & Adapters parfaitement implémenté**:
- 21 ports définis (4 input, 17 output)
- Tous les ports ont une implémentation
- Aucune dépendance circulaire
3. **Modules NestJS bien organisés**:
- 14 feature modules (application)
- 7 infrastructure modules
- Tous importés dans AppModule
4. **Repository pattern propre**:
- Interfaces dans domain
- Implémentations dans infrastructure
- Mappers dédiés (Domain ↔ ORM)
#### ❌ Violation critique
**Fichier**: `apps/backend/src/domain/services/booking.service.ts`
**Problème**:
```typescript
import { Injectable, Inject, NotFoundException } from '@nestjs/common';
// ❌ Le domain ne doit PAS dépendre de NestJS
```
**Impact**:
- Couplage domain/framework
- Tests domain nécessitent NestJS TestingModule
- Réutilisabilité compromise
**Correction requise**: Voir [ADR-002](./decisions.md#adr-002)
### Frontend: Next.js App Router
**Conformité**: **65%** (plusieurs problèmes modérés)
#### ✅ Points forts
1. **API Client bien structuré**:
- 20 modules API dédiés
- Token management centralisé
- Type safety complète
- 60+ endpoints wrappés
2. **Composants React propres**:
- 29 composants organisés
- shadcn/ui bien intégré
- Feature folders (bookings/, rate-search/, admin/)
3. **Hooks customs utiles**:
- useBookings, useNotifications, useCompanies
- Abstraction logique métier
#### ❌ Problèmes critiques
1. **TypeScript strict mode désactivé**:
```json
{ "strict": false } // ❌ tsconfig.json ligne 6
```
- Permet erreurs de type silencieuses
- Risque bugs runtime
2. **Token management incohérent**:
```typescript
// auth-context.tsx
localStorage.getItem('access_token') // ✅
// useBookings.ts
localStorage.getItem('accessToken') // ❌ Différent !
```
3. **Logique métier dans pages**:
- `app/dashboard/bookings/page.tsx`: 463 lignes
- 50+ lignes de logique de filtrage
- Logique pagination client-side
4. **Patterns data fetching inconsistants**:
- React Query + API client ✅
- fetch() direct ❌
- Mix des deux partout
#### ⚠️ Code legacy
**Fichiers à supprimer** (8-10 fichiers):
- `/src/legacy-pages/` (3 fichiers, ~800 LOC)
- `/app/rates/csv-search/page.tsx` (doublon)
- `/src/pages/privacy.tsx`, `terms.tsx` (Pages Router ancien)
- `/src/components/examples/DesignSystemShowcase.tsx` (non utilisé)
- Pages de test: `/app/demo-carte/`, `/app/test-image/`
---
## 📋 PLAN D'ACTION DÉTAILLÉ
### 🔴 PRIORITÉ 1 - CRITIQUE (À faire cette semaine)
#### Backend
**1. Corriger violation architecture hexagonale**
**Fichier**: `apps/backend/src/domain/services/booking.service.ts`
**Actions**:
- [ ] Supprimer imports `@nestjs/common`
- [ ] Créer `domain/exceptions/rate-quote-not-found.exception.ts`
- [ ] Adapter `application/bookings/bookings.module.ts`
- [ ] Mettre à jour tests `booking.service.spec.ts`
- [ ] Vérifier que tous les tests passent
**Timeline**: 2-3 heures
**Risque**: ✅ FAIBLE
**Responsable**: Backend team
**Documentation**: [ADR-002](./decisions.md#adr-002)
#### Frontend
**2. Activer TypeScript strict mode**
**Fichier**: `apps/frontend/tsconfig.json`
**Actions**:
- [ ] Changer `"strict": false` → `"strict": true`
- [ ] Lister toutes les erreurs TypeScript
- [ ] Corriger les erreurs (estimation: 50-70 fichiers)
- [ ] Vérifier build production
**Timeline**: 2-3 jours
**Risque**: ⚠️ MOYEN (beaucoup de corrections)
**Responsable**: Frontend team
**Documentation**: [ADR-003](./decisions.md#adr-003)
**3. Fixer incohérence token localStorage**
**Fichiers**:
- `src/hooks/useBookings.ts` (ligne 45)
- Tous les endroits utilisant `accessToken`
**Actions**:
- [ ] Standardiser sur `access_token` partout
- [ ] Ou mieux: utiliser apiClient au lieu de fetch direct
- [ ] Tester authentification
**Timeline**: 30 minutes - 1 heure
**Risque**: ✅ FAIBLE
**Responsable**: Frontend team
---
### 🟡 PRIORITÉ 2 - IMPORTANT (À faire ce mois-ci)
#### Backend
**4. Documenter entités carrier portal**
**Fichiers**:
- `carrier-profile.orm-entity.ts`
- `carrier-activity.orm-entity.ts`
**Actions**:
- [ ] Vérifier utilisation dans carrier portal
- [ ] Ajouter commentaires de documentation
- [ ] Marquer avec `// TODO: Carrier portal phase`
**Timeline**: 30 minutes
#### Frontend
**5. Extraire logique métier des pages**
**Fichiers**:
- `app/dashboard/bookings/page.tsx` (463 lignes)
- `app/dashboard/page.tsx` (422 lignes)
**Actions**:
- [ ] Créer `hooks/useBookingFilters.ts`
- [ ] Créer `hooks/usePagination.ts`
- [ ] Créer `utils/booking-status.ts`
- [ ] Refactorer pages pour utiliser les hooks
**Timeline**: 2-3 heures
**Documentation**: [docs/frontend/cleanup-report.md](./frontend/cleanup-report.md)
**6. Implémenter pagination serveur**
**Fichier**: `app/dashboard/bookings/page.tsx` (ligne 29)
**Actions**:
- [ ] Changer `limit: 1000` → `limit: 20`
- [ ] Passer currentPage et filters à l'API
- [ ] Utiliser `keepPreviousData: true` (React Query)
- [ ] Tester avec 10,000+ bookings
**Timeline**: 2-3 heures
**Documentation**: [ADR-005](./decisions.md#adr-005)
**7. Standardiser pattern data fetching**
**Actions**:
- [ ] Refactorer `hooks/useBookings.ts` (supprimer fetch direct)
- [ ] Vérifier `hooks/useCsvRateSearch.ts`
- [ ] Vérifier `hooks/useNotifications.ts`
- [ ] Utiliser React Query partout
**Timeline**: 1 jour
**Documentation**: [ADR-004](./decisions.md#adr-004)
---
### 🟢 PRIORITÉ 3 - NETTOYAGE (À faire quand disponible)
**8. Supprimer code legacy frontend**
**Actions**:
- [ ] Supprimer `/src/legacy-pages/` (3 fichiers)
- [ ] Investiguer `/app/rates/csv-search/` (doublon ou redirection)
- [ ] Migrer ou supprimer `/src/pages/privacy.tsx`, `terms.tsx`
- [ ] Déplacer `DesignSystemShowcase` dans `/app/dev/`
- [ ] Protéger pages dev/test en production
- [ ] Supprimer composants non utilisés (DebugUser, etc.)
**Timeline**: Demi-journée
**9. Audits supplémentaires**
- [ ] Vérifier migrations appliquées en base
- [ ] Audit sécurité endpoints publics
- [ ] Optimiser requêtes TypeORM (N+1)
- [ ] Analyser bundle size frontend
- [ ] Vérifier dépendances npm inutilisées
**Timeline**: 1-2 jours
---
## 📈 MÉTRIQUES AVANT/APRÈS
### Backend
| Métrique | Avant | Après (cible) | Amélioration |
|----------|-------|---------------|--------------|
| Conformité hexagonale | 95% | 100% | +5% |
| Domain layer purity | ❌ 1 violation | ✅ 0 violation | 100% |
| Code mort | ~2-3 fichiers | 0 fichiers | 100% |
| Tests domaine | Dépend NestJS | ✅ Pure TS | +50% vitesse |
### Frontend
| Métrique | Avant | Après (cible) | Amélioration |
|----------|-------|---------------|--------------|
| TypeScript strict | ❌ Désactivé | ✅ Activé | N/A |
| Code mort | 8-10 fichiers | 0 fichiers | 100% |
| Logique pages | 463 lignes | ~80 lignes | -80% |
| Pagination | Client (1000) | Serveur (20) | -95% data |
| Pattern fetching | 3 patterns | 1 pattern | Unifié |
| Temps chargement | 2-3s | 300ms | -85% |
| Bundle transfert | 500KB | 20KB | -96% |
### Performance attendue
| Opération | Avant | Après | Gain |
|-----------|-------|-------|------|
| Chargement bookings | 2-3s | 300ms | **10x** |
| Navigation pages | 500ms | 100ms | **5x** |
| Tests domain | 5s | 2s | **2.5x** |
| Build TypeScript | - | - | +warnings |
---
## 🛠️ OUTILS & COMMANDES
### Backend
**Vérifier absence imports NestJS dans domain**:
```bash
grep -r "from '@nestjs" apps/backend/src/domain/
# Résultat attendu: Aucun résultat
```
**Détecter exports inutilisés**:
```bash
cd apps/backend
npm install --save-dev ts-prune
npx ts-prune --project tsconfig.json | grep -v "used in module"
```
**Analyser dépendances circulaires**:
```bash
npm install --save-dev madge
npx madge --circular --extensions ts src/
```
**Vérifier migrations en base**:
```bash
docker exec -it xpeditis-postgres psql -U xpeditis -d xpeditis_dev -c "SELECT * FROM migrations ORDER BY id DESC LIMIT 10;"
```
### Frontend
**Vérifier strict mode**:
```bash
cd apps/frontend
npm run type-check
# Avec strict: false → 0 erreurs
# Avec strict: true → 100-200 erreurs (à corriger)
```
**Détecter fichiers jamais importés**:
```bash
find apps/frontend/src -name "*.ts" -o -name "*.tsx" | while read file; do
filename=$(basename "$file")
count=$(grep -r "from.*$filename" apps/frontend/src apps/frontend/app | wc -l)
if [ $count -eq 0 ]; then
echo "❌ Jamais importé: $file"
fi
done
```
**Analyser bundle size**:
```bash
cd apps/frontend
npm run build
npx @next/bundle-analyzer
```
**Détecter dépendances inutilisées**:
```bash
cd apps/frontend
npx depcheck
```
---
## 📚 DOCUMENTATION CRÉÉE
### Structure docs/
```
docs/
├── architecture.md # ✅ Créé
├── AUDIT-FINAL-REPORT.md # ✅ Créé (ce fichier)
├── backend/
│ ├── cleanup-report.md # ✅ Créé
│ ├── overview.md # À créer
│ ├── domain.md # À créer
│ ├── application.md # À créer
│ └── infrastructure.md # À créer
├── frontend/
│ ├── cleanup-report.md # ✅ Créé
│ ├── overview.md # À créer
│ └── structure.md # À créer
└── decisions.md # ✅ Créé (5 ADRs)
```
### Fichiers créés
1. **docs/architecture.md** (3,800 mots)
- Vue d'ensemble architecture hexagonale
- Flux de données
- Diagrammes de dépendances
- Métriques d'architecture
2. **docs/backend/cleanup-report.md** (5,200 mots)
- Violation critique identifiée
- Plan de correction détaillé
- Code legacy analysis
- Checklist de nettoyage
3. **docs/frontend/cleanup-report.md** (6,800 mots)
- 5 problèmes critiques identifiés
- Plan d'action en 4 phases
- Refactoring patterns
- Métriques avant/après
4. **docs/decisions.md** (4,500 mots)
- 5 Architecture Decision Records
- Template pour nouvelles décisions
- Justifications et alternatives
5. **docs/AUDIT-FINAL-REPORT.md** (ce fichier)
- Synthèse exécutive
- Plan d'action global
- Métriques et outils
### Total documentation
**15,300+ mots** de documentation technique créée
---
## 🎓 ENSEIGNEMENTS & RECOMMANDATIONS
### Pour le Backend
#### ✅ À continuer
1. **Architecture hexagonale stricte**
- Excellente séparation des responsabilités
- Code domaine testable et réutilisable
- Pattern bien compris par l'équipe
2. **Repository pattern propre**
- Interfaces domain, implémentations infrastructure
- Mappers dédiés (propres et testables)
3. **Organisation modulaire**
- Feature modules bien définis
- Exports clairs via barrel files
#### ⚠️ À améliorer
1. **Supprimer toute dépendance NestJS du domain**
- Une seule violation actuellement
- Mais crucial de ne jamais la reproduire
2. **Documenter les entités carrier portal**
- Clarifier leur utilisation future
- Éviter confusion "code mort ou feature future"
3. **Ajouter ESLint rules pour hexagonal architecture**
```json
{
"rules": {
"no-restricted-imports": [
"error",
{
"patterns": [
{
"group": ["@nestjs/*"],
"message": "NestJS imports are forbidden in domain layer"
}
]
}
]
}
}
```
### Pour le Frontend
#### ✅ À continuer
1. **API client centralisé**
- Excellent pattern (60+ endpoints)
- Type safety complète
- Token management centralisé
2. **Composants shadcn/ui**
- Cohérence visuelle
- Accessibilité intégrée
3. **Feature folders**
- Organisation claire (bookings/, rate-search/, admin/)
#### ⚠️ À améliorer (Priorité HAUTE)
1. **Activer TypeScript strict mode IMMÉDIATEMENT**
- Évite accumulation de dette technique
- Détecte bugs avant production
2. **Extraire logique métier des pages**
- Pages doivent être des orchestrateurs
- Logique dans hooks/utils
3. **Standardiser data fetching**
- React Query partout
- Pas de fetch() direct
4. **Pagination serveur**
- Ne JAMAIS charger 1000+ items
- Toujours paginer côté serveur
### Règles d'or architecture
1. **Backend**: Domain layer = ZÉRO dépendance externe
2. **Frontend**: Pages = orchestration, hooks/utils = logique
3. **Partout**: TypeScript strict mode = obligatoire
4. **Partout**: Patterns cohérents (pas de mix & match)
5. **Partout**: Tests avant refactoring
---
## 📊 CHECKLIST GLOBALE
### Immédiat (Cette semaine)
**Backend**:
- [ ] Corriger `domain/services/booking.service.ts`
- [ ] Tous les tests passent après correction
**Frontend**:
- [ ] Activer strict mode TypeScript
- [ ] Corriger erreurs TypeScript (jour 1-3)
- [ ] Fixer incohérence token localStorage
### Court terme (Ce mois-ci)
**Backend**:
- [ ] Documenter carrier portal entities
- [ ] Vérifier migrations en base
**Frontend**:
- [ ] Extraire logique métier (hooks/utils)
- [ ] Implémenter pagination serveur
- [ ] Standardiser pattern React Query
- [ ] Supprimer code legacy
### Moyen terme (Trimestre)
**Backend**:
- [ ] ESLint rules hexagonal architecture
- [ ] Audit sécurité complet
- [ ] Optimiser requêtes TypeORM
**Frontend**:
- [ ] Audit bundle size
- [ ] Optimiser performances
- [ ] Ajouter tests E2E (Playwright)
### Continu
- [ ] Code review: vérifier conformité architecture
- [ ] Tests: maintenir couverture 90%+ domaine
- [ ] Documentation: mettre à jour ADRs
- [ ] Métriques: tracker performance et qualité
---
## 🎯 CONCLUSION
### État actuel
Le projet Xpeditis démontre une **excellente maîtrise architecturale** globale:
- ✅ **Backend**: Architecture hexagonale exemplaire (95% conformité)
- ⚠️ **Frontend**: Bonne base mais nécessite rigueur accrue (65% conformité)
### Priorités immédiates
1. **Backend**: Corriger la seule violation architecture (2-3h)
2. **Frontend**: Activer strict mode TypeScript (2-3 jours)
3. **Frontend**: Fixer token management (30min)
### Impact attendu
Après corrections prioritaires:
- **Backend**: 100% conformité hexagonale ✅
- **Frontend**: 85% conformité (après strict mode + refactoring) ✅
- **Performance**: 5-10x amélioration chargement bookings ✅
- **Qualité**: Moins de bugs runtime ✅
- **Maintenabilité**: Code plus propre et testable ✅
### Recommandation finale
**Le projet est en excellent état architectural**.
Les corrections proposées sont **mineures mais importantes**.
Aucune refonte majeure n'est nécessaire.
**Timeline recommandée**: 1 semaine pour priorité 1, 2-3 semaines pour priorité 2.
---
**Date du rapport**: 2025-12-22
**Prochaine révision**: Après corrections priorité 1
**Contact**: Architecture Team
**Signature**: Claude Code Architect Agent
**Version**: 1.0.0 (Audit final)

395
docs/CLEANUP-REPORT-2025-12-22.md
View File

@ -1,395 +0,0 @@
# 🧹 Rapport de Nettoyage et Réorganisation - 22 Décembre 2025
## 📋 Résumé Exécutif
**Objectif**: Nettoyer et organiser toute la documentation du projet dans une structure cohérente et facile à naviguer.
**Résultat**: ✅ **80 fichiers de documentation** réorganisés en **12 catégories thématiques**
**Gains**:
- 🎯 Navigation facilitée avec structure claire
- 📚 Documentation centralisée dans `docs/`
- 🗑️ Suppression de 11MB de fichiers inutilisés
- 📖 README complet avec index de toute la documentation
- 🔗 Toutes les références mises à jour
---
## 📊 Statistiques du Nettoyage
### Avant
```
Racine du projet/
├── 80+ fichiers .md dispersés
├── Fichiers non utilisés (SVG 11MB, scripts Python)
├── Documentation non organisée
└── Difficile de trouver l'information
```
### Après
```
Racine du projet/
├── 4 fichiers .md essentiels (README, CLAUDE, PRD, TODO)
├── docs/ (82 fichiers organisés)
│ ├── installation/ (5 fichiers)
│ ├── deployment/ (25 fichiers)
│ ├── phases/ (21 fichiers)
│ ├── testing/ (5 fichiers)
│ ├── architecture/ (6 fichiers)
│ ├── carrier-portal/ (2 fichiers)
│ ├── csv-system/ (5 fichiers)
│ ├── debug/ (4 fichiers)
│ ├── backend/ (1 fichier)
│ └── frontend/ (1 fichier)
├── scripts/ (scripts utilitaires)
└── docker/ (configurations Docker + scripts déploiement)
```
---
## 🗂️ Organisation Finale
### Structure du Dossier `docs/`
#### 1. 📖 Documentation Principale (racine docs/)
- **README.md** - Index complet avec guide de navigation
- **architecture.md** - Architecture globale du système
- **AUDIT-FINAL-REPORT.md** - Rapport d'audit complet
- **decisions.md** - Architecture Decision Records (ADRs)
- **CLEANUP-REPORT-2025-12-22.md** - Ce fichier
#### 2. 🔧 Installation (`docs/installation/`)
Guides pour installer et démarrer le projet:
- INSTALLATION-STEPS.md - Guide complet d'installation
- INSTALLATION-COMPLETE.md - Confirmation d'installation
- QUICK-START.md - Démarrage rapide
- START-HERE.md - Point de départ
- WINDOWS-INSTALLATION.md - Guide Windows spécifique
#### 3. 🚀 Déploiement (`docs/deployment/`)
Toute la documentation de déploiement et infrastructure:
**Guides principaux**:
- DEPLOYMENT.md - Guide principal
- DEPLOYMENT_CHECKLIST.md - Checklist pré-déploiement
- DEPLOYMENT_READY.md - Validation déploiement
- DEPLOY_README.md - README déploiement
**CI/CD et Registry**:
- CI_CD_MULTI_ENV.md - Multi-environnements
- CICD_REGISTRY_SETUP.md - Setup registry
- REGISTRY_PUSH_GUIDE.md - Guide push vers registry
**Docker** (13 fichiers):
- DOCKER_FIXES_SUMMARY.md
- DOCKER_CSS_FIX.md
- DOCKER_ARM64_FIX.md
- ARM64_SUPPORT.md
- FIX_DOCKER_PROXY.md
- FIX_404_SWARM.md
**Portainer** (11 fichiers):
- PORTAINER_DEPLOY_FINAL.md
- PORTAINER_MIGRATION_AUTO.md
- PORTAINER_CHECKLIST.md
- PORTAINER_DEBUG.md
- PORTAINER_DEBUG_COMMANDS.md
- PORTAINER_CRASH_DEBUG.md
- PORTAINER_FIX_QUICK.md
- PORTAINER_ENV_FIX.md
- PORTAINER_REGISTRY_NAMING.md
- PORTAINER_TRAEFIK_404.md
- PORTAINER_YAML_FIX.md
#### 4. 📈 Phases (`docs/phases/`)
Historique complet du développement (21 fichiers):
**Sprints**:
- SPRINT-0-SUMMARY.md
- SPRINT-0-COMPLETE.md
- SPRINT-0-FINAL.md
**Phase 1**:
- PHASE-1-PROGRESS.md
- PHASE-1-WEEK5-COMPLETE.md
**Phase 2** (6 fichiers):
- PHASE2_AUTHENTICATION_SUMMARY.md
- PHASE2_BACKEND_COMPLETE.md
- PHASE2_COMPLETE.md
- PHASE2_COMPLETE_FINAL.md
- PHASE2_FINAL_PAGES.md
- PHASE2_FRONTEND_PROGRESS.md
**Phase 3**:
- PHASE3_COMPLETE.md
**Phase 4**:
- PHASE4_SUMMARY.md
- PHASE4_REMAINING_TASKS.md
**Rapports de progrès**:
- PROGRESS.md - Progrès général
- CHANGES_SUMMARY.md
- COMPLETION-REPORT.md
- IMPLEMENTATION_COMPLETE.md
- IMPLEMENTATION_SUMMARY.md
- SESSION_SUMMARY.md
- READY.md
- READY_FOR_TESTING.md
- INDEX.md
- NEXT-STEPS.md
#### 5. 🧪 Tests (`docs/testing/`)
Documentation de tests et qualité:
- TEST_EXECUTION_GUIDE.md - Guide d'exécution
- TEST_COVERAGE_REPORT.md - Rapport de couverture
- GUIDE_TESTS_POSTMAN.md - Tests API Postman
- MANUAL_TEST_INSTRUCTIONS.md - Tests manuels
- LOCAL_TESTING.md - Tests en local
#### 6. 🏗️ Architecture (`docs/architecture/`)
Documentation technique et architecture:
- ARCHITECTURE.md - Architecture complète
- BOOKING_WORKFLOW_TODO.md - Workflow de réservation
- DASHBOARD_API_INTEGRATION.md - Intégration API dashboard
- EMAIL_IMPLEMENTATION_STATUS.md - Statut emails
- DISCORD_NOTIFICATIONS.md - Notifications Discord
- RESUME_FRANCAIS.md - Résumé en français
#### 7. 🚢 Portail Transporteur (`docs/carrier-portal/`)
Documentation du portail transporteur:
- CARRIER_PORTAL_IMPLEMENTATION_PLAN.md - Plan d'implémentation
- CARRIER_API_RESEARCH.md - Recherche API transporteurs
#### 8. 📊 Système CSV (`docs/csv-system/`)
Documentation du système CSV:
- CSV_RATE_SYSTEM.md - Système de tarifs CSV
- CSV_API_TEST_GUIDE.md - Guide de tests API
- CSV_BOOKING_WORKFLOW_TEST_PLAN.md - Plan de tests workflow
- ALGO_BOOKING_CSV_IMPLEMENTATION.md - Implémentation algorithme
- ALGO_BOOKING_SUMMARY.md - Résumé algorithme
#### 9. 🐛 Debug (`docs/debug/`)
Documentation de débogage:
- USER_DISPLAY_SOLUTION.md - Solution affichage utilisateur
- USER_INFO_DEBUG_ANALYSIS.md - Analyse debug infos utilisateur
- NOTIFICATION_IMPROVEMENTS.md - Améliorations notifications
- elementmissingphase2.md - Éléments manquants phase 2
#### 10. 🔧 Backend (`docs/backend/`)
Documentation backend:
- cleanup-report.md - Rapport de nettoyage backend
#### 11. 🎨 Frontend (`docs/frontend/`)
Documentation frontend:
- cleanup-report.md - Rapport de nettoyage frontend
#### 12. 📦 Legacy (`docs/legacy/`)
Dossier vide pour archiver future documentation obsolète
---
## 🗑️ Fichiers Supprimés
### Fichiers Non Utilisés
1. **1536w default.svg** (11MB)
- ❌ Fichier SVG non référencé
- ❌ 11MB d'espace libéré
- ✅ Supprimé
### Fichiers Déplacés
#### Scripts
1. **add-email-to-csv.py**
- ✅ Déplacé vers `scripts/`
- ✅ Référence mise à jour dans `docs/architecture/EMAIL_IMPLEMENTATION_STATUS.md`
2. **deploy-to-portainer.sh**
- ✅ Déplacé vers `docker/`
- ✅ Références mises à jour dans `docs/deployment/REGISTRY_PUSH_GUIDE.md`
---
## 📝 Mises à Jour de Références
### Fichiers Modifiés
1. **CLAUDE.md** (racine)
- ✅ Section "Documentation" complètement réécrite
- ✅ Ajout de liens vers `docs/` organisés par catégorie
- ✅ Ajout d'emojis pour faciliter la navigation
2. **docs/README.md**
- ✅ Création d'un index complet de toute la documentation
- ✅ Guide de navigation par scénario d'utilisation
- ✅ Commandes rapides de vérification
- ✅ FAQ et questions fréquentes
3. **docs/architecture/EMAIL_IMPLEMENTATION_STATUS.md**
- ✅ Mise à jour du chemin vers `scripts/add-email-to-csv.py`
4. **docs/deployment/REGISTRY_PUSH_GUIDE.md**
- ✅ Mise à jour des chemins vers `docker/deploy-to-portainer.sh`
- ✅ 5 occurrences mises à jour
---
## 🎯 Fichiers Essentiels Conservés à la Racine
Seuls **4 fichiers .md** restent à la racine pour faciliter l'accès:
1. **README.md**
- Vue d'ensemble du projet
- Premier fichier consulté sur GitHub
2. **CLAUDE.md**
- Guide complet d'implémentation
- Instructions pour Claude Code
- Référence vers la documentation complète dans `docs/`
3. **PRD.md**
- Product Requirements Document
- Document de référence du produit
4. **TODO.md**
- Feuille de route du projet
- 30 semaines de développement planifiées
---
## 🔍 Vérification de la Migration
### Commandes de Vérification
```bash
# Vérifier la structure docs/
find docs -type d | sort
# Compter les fichiers .md dans docs/
find docs -name "*.md" | wc -l
# Résultat: 82 fichiers
# Lister les fichiers .md restants à la racine
ls -1 *.md
# Résultat: CLAUDE.md, PRD.md, README.md, TODO.md
# Vérifier qu'aucun fichier n'a été perdu
git status --short
```
### Résultats Attendus
✅ **82 fichiers** dans `docs/`
✅ **4 fichiers** à la racine
✅ **0 fichier perdu** (tous déplacés ou supprimés intentionnellement)
✅ **Toutes les références mises à jour**
---
## 📚 Guide d'Utilisation de la Nouvelle Structure
### Pour Trouver de la Documentation
1. **Commencez par** [docs/README.md](README.md)
- Index complet de toute la documentation
- Guide de navigation par scénario
2. **Utilisez la navigation par thème**:
- Installation ? → `docs/installation/`
- Déploiement ? → `docs/deployment/`
- Tests ? → `docs/testing/`
- Architecture ? → `docs/architecture/`
- Historique ? → `docs/phases/`
3. **Recherche rapide**:
```bash
# Chercher dans toute la documentation
grep -r "mot-clé" docs/
# Chercher un fichier spécifique
find docs -name "*portainer*"
```
### Pour Ajouter de la Documentation
1. **Identifier la catégorie** appropriée dans `docs/`
2. **Créer le fichier** dans le bon dossier
3. **Utiliser SCREAMING_CASE** pour le nom du fichier
4. **Mettre à jour** [docs/README.md](README.md) si nouvelle catégorie
5. **Ajouter une section** "Dernière mise à jour" dans le document
---
## ✅ Checklist de Validation
- [x] Tous les fichiers .md déplacés vers `docs/`
- [x] Structure de dossiers créée (12 catégories)
- [x] README.md complet créé dans docs/
- [x] Fichiers non utilisés supprimés (1536w default.svg)
- [x] Scripts déplacés vers dossiers appropriés
- [x] Références mises à jour dans CLAUDE.md
- [x] Références mises à jour dans docs/architecture/
- [x] Références mises à jour dans docs/deployment/
- [x] Index de documentation créé
- [x] Guide de navigation créé
- [x] FAQ ajoutée
- [x] Commandes rapides documentées
- [x] Rapport de nettoyage créé (ce fichier)
---
## 🚀 Prochaines Étapes Recommandées
### Maintenance Continue
1. **Suivre la structure établie** pour toute nouvelle documentation
2. **Mettre à jour docs/README.md** si nouvelle catégorie ajoutée
3. **Archiver dans docs/legacy/** les documents obsolètes
4. **Réviser trimestriellement** la pertinence de chaque document
### Améliorations Futures
1. **Créer un script** pour valider les liens entre documents
2. **Ajouter un CI check** pour vérifier que les nouveaux .md vont dans docs/
3. **Générer un index automatique** à partir des fichiers
4. **Créer des templates** pour chaque type de documentation
---
## 📊 Métriques Finales
| Métrique | Avant | Après | Amélioration |
|----------|-------|-------|--------------|
| Fichiers .md à la racine | 80+ | 4 | -95% |
| Fichiers dans docs/ | ~10 | 82 | +720% |
| Catégories organisées | 2 | 12 | +500% |
| Espace disque libéré | 0 | 11MB | - |
| Temps pour trouver un doc | ~5min | ~30s | -90% |
| Documentation indexée | Non | Oui | ✅ |
| Références cassées | Plusieurs | 0 | ✅ |
---
## 🎉 Conclusion
La documentation du projet Xpeditis est maintenant **parfaitement organisée** et **facile à naviguer**.
**Points clés**:
- ✅ Structure claire et logique
- ✅ Tout centralisé dans `docs/`
- ✅ Index complet avec guide de navigation
- ✅ Références toutes mises à jour
- ✅ Espace disque optimisé (11MB libérés)
**Pour naviguer**:
👉 Commencez par [docs/README.md](README.md)
---
**Date**: 2025-12-22
**Version**: 1.0.0
**Auteur**: Claude Code
**Type**: Nettoyage et Réorganisation Complète
**Status**: ✅ **TERMINÉ**

367
docs/README.md
View File

@ -1,367 +0,0 @@
# 📚 Documentation Xpeditis
**Bienvenue dans la documentation centralisée de Xpeditis !**
Toute la documentation technique du projet a été réorganisée et consolidée dans ce dossier pour faciliter la navigation et la maintenance.
---
## 📂 Structure de la Documentation
```
docs/
├── README.md # Ce fichier (index de la documentation)
├── architecture.md # ⭐ Architecture globale
├── AUDIT-FINAL-REPORT.md # ⭐ Rapport d'audit complet
├── decisions.md # ⭐ Architecture Decision Records (ADRs)
│
├── installation/ # 🔧 Guides d'installation
│ ├── INSTALLATION-STEPS.md # Guide pas à pas d'installation
│ ├── INSTALLATION-COMPLETE.md # Confirmation d'installation complète
│ ├── QUICK-START.md # Démarrage rapide
│ ├── START-HERE.md # Point de départ pour nouveaux utilisateurs
│ └── WINDOWS-INSTALLATION.md # Guide spécifique Windows
│
├── deployment/ # 🚀 Déploiement et Infrastructure
│ ├── DEPLOYMENT.md # Guide principal de déploiement
│ ├── DEPLOYMENT_CHECKLIST.md # Checklist pré-déploiement
│ ├── DEPLOYMENT_READY.md # Validation déploiement
│ ├── DEPLOYMENT_FIX.md # Corrections déploiement
│ ├── DEPLOY_README.md # README déploiement
│ ├── REGISTRY_PUSH_GUIDE.md # Guide push vers registry
│ ├── CI_CD_MULTI_ENV.md # CI/CD multi-environnements
│ ├── CICD_REGISTRY_SETUP.md # Setup registry CI/CD
│ ├── ARM64_SUPPORT.md # Support architecture ARM64
│ │
│ ├── Docker/ # Configuration Docker
│ │ ├── DOCKER_FIXES_SUMMARY.md
│ │ ├── DOCKER_CSS_FIX.md
│ │ ├── DOCKER_ARM64_FIX.md
│ │ ├── FIX_DOCKER_PROXY.md
│ │ └── FIX_404_SWARM.md
│ │
│ └── Portainer/ # Déploiement Portainer
│ ├── PORTAINER_DEPLOY_FINAL.md
│ ├── PORTAINER_MIGRATION_AUTO.md
│ ├── PORTAINER_CHECKLIST.md
│ ├── PORTAINER_DEBUG.md
│ ├── PORTAINER_DEBUG_COMMANDS.md
│ ├── PORTAINER_CRASH_DEBUG.md
│ ├── PORTAINER_FIX_QUICK.md
│ ├── PORTAINER_ENV_FIX.md
│ ├── PORTAINER_REGISTRY_NAMING.md
│ ├── PORTAINER_TRAEFIK_404.md
│ └── PORTAINER_YAML_FIX.md
│
├── phases/ # 📈 Historique des phases de développement
│ ├── SPRINT-0-SUMMARY.md
│ ├── SPRINT-0-COMPLETE.md
│ ├── SPRINT-0-FINAL.md
│ ├── PHASE-1-PROGRESS.md
│ ├── PHASE-1-WEEK5-COMPLETE.md
│ ├── PHASE2_AUTHENTICATION_SUMMARY.md
│ ├── PHASE2_BACKEND_COMPLETE.md
│ ├── PHASE2_COMPLETE.md
│ ├── PHASE2_COMPLETE_FINAL.md
│ ├── PHASE2_FINAL_PAGES.md
│ ├── PHASE2_FRONTEND_PROGRESS.md
│ ├── PHASE3_COMPLETE.md
│ ├── PHASE4_SUMMARY.md
│ ├── PHASE4_REMAINING_TASKS.md
│ ├── PROGRESS.md # Progrès général du projet
│ ├── CHANGES_SUMMARY.md
│ ├── COMPLETION-REPORT.md
│ ├── IMPLEMENTATION_COMPLETE.md
│ ├── IMPLEMENTATION_SUMMARY.md
│ ├── READY.md
│ ├── READY_FOR_TESTING.md
│ ├── SESSION_SUMMARY.md
│ ├── INDEX.md
│ └── NEXT-STEPS.md
│
├── testing/ # 🧪 Tests et Qualité
│ ├── TEST_EXECUTION_GUIDE.md # Guide d'exécution des tests
│ ├── TEST_COVERAGE_REPORT.md # Rapport de couverture
│ ├── GUIDE_TESTS_POSTMAN.md # Tests API avec Postman
│ ├── MANUAL_TEST_INSTRUCTIONS.md # Instructions de tests manuels
│ └── LOCAL_TESTING.md # Tests en environnement local
│
├── architecture/ # 🏗️ Architecture Technique
│ ├── ARCHITECTURE.md # Documentation architecture complète
│ ├── BOOKING_WORKFLOW_TODO.md # Workflow de réservation
│ ├── DASHBOARD_API_INTEGRATION.md # Intégration API dashboard
│ ├── EMAIL_IMPLEMENTATION_STATUS.md # Statut implémentation emails
│ ├── DISCORD_NOTIFICATIONS.md # Notifications Discord
│ └── RESUME_FRANCAIS.md # Résumé en français
│
├── carrier-portal/ # 🚢 Portail Transporteur
│ ├── CARRIER_PORTAL_IMPLEMENTATION_PLAN.md
│ └── CARRIER_API_RESEARCH.md
│
├── csv-system/ # 📊 Système CSV
│ ├── CSV_RATE_SYSTEM.md
│ ├── CSV_API_TEST_GUIDE.md
│ ├── CSV_BOOKING_WORKFLOW_TEST_PLAN.md
│ ├── ALGO_BOOKING_CSV_IMPLEMENTATION.md
│ └── ALGO_BOOKING_SUMMARY.md
│
├── debug/ # 🐛 Debug et Résolution de Problèmes
│ ├── USER_DISPLAY_SOLUTION.md
│ ├── USER_INFO_DEBUG_ANALYSIS.md
│ ├── NOTIFICATION_IMPROVEMENTS.md
│ └── elementmissingphase2.md
│
├── backend/ # 🔧 Documentation Backend
│ └── cleanup-report.md
│
└── frontend/ # 🎨 Documentation Frontend
└── cleanup-report.md
```
---
## 🎯 Par où commencer ?
### 1️⃣ **Nouveau sur le projet** ?
**Commencez par ces fichiers dans cet ordre**:
1. 📖 [../README.md](../README.md) - Vue d'ensemble du projet
2. 📘 [../CLAUDE.md](../CLAUDE.md) - Guide complet d'implémentation (1000+ lignes)
3. 🏗️ [architecture.md](./architecture.md) - Architecture technique
4. 🔧 [installation/QUICK-START.md](./installation/QUICK-START.md) - Démarrage rapide
### 2️⃣ **Installation du projet** ?
**Suivez ces guides**:
1. [installation/INSTALLATION-STEPS.md](./installation/INSTALLATION-STEPS.md) - Guide complet
2. [installation/QUICK-START.md](./installation/QUICK-START.md) - Démarrage rapide
3. [installation/WINDOWS-INSTALLATION.md](./installation/WINDOWS-INSTALLATION.md) - Spécifique Windows
### 3️⃣ **Déploiement en production** ?
**Documentation de déploiement**:
1. [deployment/DEPLOYMENT.md](./deployment/DEPLOYMENT.md) - Guide principal
2. [deployment/DEPLOYMENT_CHECKLIST.md](./deployment/DEPLOYMENT_CHECKLIST.md) - Checklist
3. [deployment/PORTAINER_DEPLOY_FINAL.md](./deployment/PORTAINER_DEPLOY_FINAL.md) - Portainer
### 4️⃣ **Corriger les problèmes identifiés** ?
**Plan d'action**:
1. [AUDIT-FINAL-REPORT.md](./AUDIT-FINAL-REPORT.md) - Résumé exécutif
2. [backend/cleanup-report.md](./backend/cleanup-report.md) - Actions backend
3. [frontend/cleanup-report.md](./frontend/cleanup-report.md) - Actions frontend
4. [decisions.md](./decisions.md) - ADRs (Architecture Decision Records)
### 5️⃣ **Travailler sur une fonctionnalité spécifique** ?
**Par domaine**:
- 🚢 **Portail Transporteur**: [carrier-portal/](./carrier-portal/)
- 📊 **Système CSV**: [csv-system/](./csv-system/)
- 🧪 **Tests**: [testing/](./testing/)
- 🏗️ **Architecture**: [architecture/](./architecture/)
---
## 📚 Documentation Clé
### ⭐ Fichiers Essentiels (à lire en priorité)
| Fichier | Description | Quand le lire |
|---------|-------------|---------------|
| [architecture.md](./architecture.md) | Architecture globale du système | Onboarding, création module |
| [AUDIT-FINAL-REPORT.md](./AUDIT-FINAL-REPORT.md) | Rapport d'audit complet | Immédiatement si problèmes |
| [decisions.md](./decisions.md) | Décisions architecturales (ADRs) | Avant décision importante |
| [backend/cleanup-report.md](./backend/cleanup-report.md) | Plan de nettoyage backend | Travail sur backend |
| [frontend/cleanup-report.md](./frontend/cleanup-report.md) | Plan de nettoyage frontend | Travail sur frontend |
---
## 🔍 Recherche Rapide par Thème
### Installation & Setup
- [Installation complète](./installation/INSTALLATION-STEPS.md)
- [Démarrage rapide](./installation/QUICK-START.md)
- [Windows](./installation/WINDOWS-INSTALLATION.md)
### Déploiement
- [Guide déploiement](./deployment/DEPLOYMENT.md)
- [Checklist](./deployment/DEPLOYMENT_CHECKLIST.md)
- [Portainer](./deployment/PORTAINER_DEPLOY_FINAL.md)
- [Docker](./deployment/DOCKER_FIXES_SUMMARY.md)
- [CI/CD](./deployment/CI_CD_MULTI_ENV.md)
### Architecture & Développement
- [Architecture hexagonale](./architecture/ARCHITECTURE.md)
- [Workflow réservation](./architecture/BOOKING_WORKFLOW_TODO.md)
- [API Dashboard](./architecture/DASHBOARD_API_INTEGRATION.md)
- [Emails](./architecture/EMAIL_IMPLEMENTATION_STATUS.md)
### Tests
- [Guide d'exécution](./testing/TEST_EXECUTION_GUIDE.md)
- [Couverture de code](./testing/TEST_COVERAGE_REPORT.md)
- [Tests Postman](./testing/GUIDE_TESTS_POSTMAN.md)
- [Tests manuels](./testing/MANUAL_TEST_INSTRUCTIONS.md)
### Fonctionnalités Spécifiques
- [Portail Transporteur](./carrier-portal/CARRIER_PORTAL_IMPLEMENTATION_PLAN.md)
- [Système CSV](./csv-system/CSV_RATE_SYSTEM.md)
- [Notifications Discord](./architecture/DISCORD_NOTIFICATIONS.md)
### Historique du Projet
- [Phases de développement](./phases/)
- [Progrès général](./phases/PROGRESS.md)
- [Résumés de phases](./phases/)
---
## 🚀 Commandes Rapides
### Vérification Conformité Backend
```bash
# Aucun import NestJS dans domain
grep -r "from '@nestjs" apps/backend/src/domain/
# Résultat attendu: Aucun résultat
# Tous les tests passent
cd apps/backend && npm test
# Coverage
npm run test:cov
```
### Vérification Frontend
```bash
cd apps/frontend
# Vérification TypeScript
npm run type-check
# Analyser bundle
npm run build
npx @next/bundle-analyzer
# Détecter code mort
npx depcheck
```
### Tests
```bash
# Backend
cd apps/backend
npm test # Unit tests
npm run test:integration # Integration tests
npm run test:e2e # E2E tests
# Frontend
cd apps/frontend
npm test # Component tests
npx playwright test # E2E tests
```
---
## 📊 Métriques Clés
### Backend
| Métrique | Valeur Actuelle | Cible |
|----------|-----------------|-------|
| Conformité hexagonale | 95% | 100% |
| Coverage tests domain | 90%+ | 90%+ |
| Violations critiques | 1 | 0 |
| Code mort | 2-3 fichiers | 0 |
### Frontend
| Métrique | Valeur Actuelle | Cible |
|----------|-----------------|-------|
| TypeScript strict | ❌ | ✅ |
| Code mort | 8-10 fichiers | 0 |
| Pagination | Client (1000) | Serveur (20) |
| Temps chargement | 2-3s | 300ms |
---
## 🆘 Questions Fréquentes
**Q: Par où commencer pour corriger les problèmes ?**
A: Lire [AUDIT-FINAL-REPORT.md](./AUDIT-FINAL-REPORT.md) section "Priorité 1"
**Q: Comment vérifier que j'ai tout corrigé ?**
A: Utiliser les checklists dans cleanup-report.md et commandes de vérification
**Q: Je veux comprendre pourquoi cette décision ?**
A: Consulter [decisions.md](./decisions.md) pour l'ADR correspondant
**Q: C'est quoi l'architecture hexagonale ?**
A: Lire [architecture.md](./architecture.md) section "Architecture Hexagonale"
**Q: Je dois créer un nouveau module, comment faire ?**
A: Suivre [../CLAUDE.md](../CLAUDE.md) section "Adding a New Feature"
**Q: Comment déployer en production ?**
A: Suivre [deployment/DEPLOYMENT.md](./deployment/DEPLOYMENT.md) et la checklist
---
## 🔗 Liens Externes Utiles
### Références Techniques
- [Hexagonal Architecture - Alistair Cockburn](https://alistair.cockburn.us/hexagonal-architecture/)
- [Clean Architecture - Uncle Bob](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)
- [Architecture Decision Records](https://adr.github.io/)
- [React Query Best Practices](https://tkdodo.eu/blog/practical-react-query)
- [TypeScript Strict Mode](https://www.typescriptlang.org/tsconfig#strict)
### Documentation Projet
- [README Principal](../README.md)
- [CLAUDE.md - Guide Complet](../CLAUDE.md)
- [Product Requirements (PRD)](../PRD.md)
- [TODO du Projet](../TODO.md)
---
## 📝 Maintenance de la Documentation
### Quand Mettre à Jour
**architecture.md**:
- Ajout/suppression de modules
- Changement de pattern architectural majeur
- Nouveau pattern de sécurité
**AUDIT-FINAL-REPORT.md**:
- Après chaque audit complet (trimestriel recommandé)
- Après corrections majeures
- Changement de scores/métriques
**cleanup-report.md** (backend/frontend):
- Après nettoyage du code mort
- Après résolution violations
- Nouvelles violations identifiées
**decisions.md**:
- Chaque décision architecturale importante
- Utiliser template fourni
- Maintenir l'index à jour
### Comment Contribuer
1. Suivre la structure de dossiers établie
2. Utiliser des noms de fichiers descriptifs en SCREAMING_CASE
3. Inclure une section "Dernière mise à jour" dans chaque document
4. Mettre à jour ce README.md si nouvelle catégorie ajoutée
---
## 📅 Historique
- **2025-12-22**: Réorganisation complète de la documentation en dossiers thématiques
- **2025-12-22**: Création rapport d'audit complet et cleanup reports
- **2024-11-XX**: Phases 1-4 de développement complétées
---
**Version**: 2.0.0
**Dernière mise à jour**: 2025-12-22
**Maintenance**: Architecture Team
**Bon développement ! 🚀**

372
docs/architecture.md
View File

@ -1,372 +0,0 @@
# Architecture Globale - Xpeditis
**Date de l'audit**: 2025-12-22
**Version**: v0.1.0
**Architecte**: Audit automatisé Claude Code
---
## 📋 Vue d'ensemble
Xpeditis est une plateforme B2B SaaS de réservation de fret maritime construite avec une **architecture hexagonale stricte** (Ports & Adapters) côté backend et une architecture en couches côté frontend.
### Stack technique
**Backend**:
- NestJS 10+ (Framework)
- TypeScript 5+ (strict mode)
- PostgreSQL 15+ (Base de données)
- TypeORM 0.3+ (ORM)
- Redis 7+ (Cache)
- Architecture: **Hexagonale (Ports & Adapters)**
**Frontend**:
- Next.js 14+ (App Router)
- React 18+
- TypeScript 5+
- TanStack Query (Server state)
- shadcn/ui (Components)
- Architecture: **Layered + Feature-based**
---
## 🏗️ Architecture Hexagonale - Backend
### Principe fondamental
```
Infrastructure Layer → Application Layer → Domain Layer
(Adapters) (Use Cases) (Business Logic)
```
**Règle d'or**: Les dépendances pointent UNIQUEMENT vers l'intérieur (vers le domaine). Le domaine ne connaît RIEN des couches externes.
### Couches & Responsabilités
#### 1. **Domain Layer** (Cœur métier)
**Localisation**: `apps/backend/src/domain/`
**Contenu**:
- **Entities** (13 fichiers): Objets métier avec identité
- `booking.entity.ts`, `rate-quote.entity.ts`, `user.entity.ts`, etc.
- **Value Objects** (9 fichiers): Objets immuables sans identité
- `money.vo.ts`, `email.vo.ts`, `booking-number.vo.ts`, etc.
- **Services** (7 fichiers): Logique métier pure
- `rate-search.service.ts`, `booking.service.ts`, etc.
- **Ports** (21 fichiers):
- **In**: 4 ports (use cases exposés)
- **Out**: 17 ports (interfaces de dépendances externes)
- **Exceptions** (9 fichiers): Exceptions métier
**Contraintes STRICTES**:
- ❌ **AUCUN import de framework** (NestJS, TypeORM, etc.)
- ❌ **AUCUNE dépendance externe**
- ✅ **TypeScript pur uniquement**
- ✅ **Testable sans NestJS TestingModule**
#### 2. **Application Layer** (Orchestration)
**Localisation**: `apps/backend/src/application/`
**Contenu**:
- **Controllers** (17 fichiers): Points d'entrée HTTP
- **DTOs** (15 fichiers): Validation des requêtes/réponses
- **Services** (11 fichiers): Orchestration des cas d'usage
- **Mappers** (8 fichiers): Conversion DTO ↔ Domain
- **Guards** (4 fichiers): Sécurité (JWT, RBAC, Rate limiting)
- **Modules** (14 fichiers): Configuration NestJS
**Responsabilités**:
- Recevoir les requêtes HTTP
- Valider les entrées (DTOs)
- Appeler les services domaine
- Mapper les résultats
- Retourner les réponses HTTP
**Dépendances autorisées**:
- ✅ Domain layer (via imports `@domain/*`)
- ✅ NestJS (decorators, guards, interceptors)
- ❌ Infrastructure layer directement (uniquement via injection)
#### 3. **Infrastructure Layer** (Adapters externes)
**Localisation**: `apps/backend/src/infrastructure/`
**Contenu**:
- **Persistence/TypeORM**:
- ORM Entities (15 fichiers)
- Repositories (13 implémentations)
- Mappers ORM ↔ Domain (9 fichiers)
- Migrations (18 fichiers)
- **Carriers** (7 connecteurs): Maersk, MSC, CMA CGM, etc.
- **Cache**: Redis adapter
- **Email**: MJML templates + Nodemailer
- **Storage**: S3/MinIO adapter
- **PDF**: PDF generation adapter
- **Security**: Helmet, CORS config
**Responsabilités**:
- Implémenter les ports définis par le domaine
- Gérer les détails techniques (DB, API externes, cache, etc.)
- Mapper les données externes vers le domaine
**Pattern clé**: Chaque adapter implémente un port domaine
```typescript
// Domain port
export interface BookingRepository {
save(booking: Booking): Promise<Booking>;
findById(id: string): Promise<Booking | null>;
}
// Infrastructure implementation
export class TypeOrmBookingRepository implements BookingRepository {
async save(booking: Booking): Promise<Booking> {
const ormEntity = BookingOrmMapper.toOrm(booking);
const saved = await this.repository.save(ormEntity);
return BookingOrmMapper.toDomain(saved);
}
}
```
---
## 🎯 Flux de données typique
### Exemple: Recherche de tarifs
```
1. HTTP Request
↓
2. RatesController (@application/controllers/rates.controller.ts)
- Reçoit RateSearchRequestDto
- Valide avec class-validator
↓
3. RateSearchService (@domain/services/rate-search.service.ts)
- Logique métier pure
- Utilise CarrierConnectorPort (interface)
- Utilise CachePort (interface)
↓
4. Adapters (@infrastructure/)
- MaerskConnector implémente CarrierConnectorPort
- RedisCacheAdapter implémente CachePort
↓
5. Response
- Mapper Domain → DTO
- Retour JSON via RatesController
```
### Diagramme de dépendances
```
┌──────────────────────────────────────────────────┐
│ HTTP Client (Frontend) │
└────────────────────┬─────────────────────────────┘
│
↓
┌──────────────────────────────────────────────────┐
│ Controllers (@application) │
│ - Validation (DTOs) │
│ - Error handling │
└────────────────────┬─────────────────────────────┘
│
↓ (depends on)
┌──────────────────────────────────────────────────┐
│ Domain Services (@domain/services) │
│ - Pure business logic │
│ - No framework dependencies │
│ - Uses Ports (interfaces) │
└────────────────────┬─────────────────────────────┘
│
↓ (implemented by)
┌──────────────────────────────────────────────────┐
│ Infrastructure Adapters │
│ - TypeOrmRepository → BookingRepository │
│ - RedisCache → CachePort │
│ - MaerskAPI → CarrierConnectorPort │
└──────────────────────────────────────────────────┘
```
---
## 🌐 Architecture Frontend
### Structure en couches
```
apps/frontend/
├── app/ # Next.js App Router (Routing)
├── src/
│ ├── components/ # React components (UI Layer)
│ ├── lib/
│ │ ├── api/ # API clients (Infrastructure Layer)
│ │ └── context/ # Global state (Application Layer)
│ ├── hooks/ # Custom hooks (Application Logic)
│ ├── types/ # TypeScript types
│ └── utils/ # Utilities
```
### Séparation des responsabilités
| Couche | Responsabilité | Exemples |
|--------|----------------|----------|
| **Pages (app/)** | Routing + Layout | `app/dashboard/page.tsx` |
| **Components** | UI Rendering | `BookingsTable.tsx`, `Button.tsx` |
| **Hooks** | Application Logic | `useBookings()`, `useNotifications()` |
| **API Clients** | HTTP Communication | `api/bookings.ts`, `api/rates.ts` |
| **Context** | Global State | `auth-context.tsx` |
### Pattern de data fetching
**Recommandé**: React Query + API clients
```typescript
// API client
export const fetchBookings = async (filters: BookingFilters) => {
return apiClient.get<BookingListResponse>('/api/v1/bookings', { params: filters });
};
// Dans un composant
const { data, isLoading } = useQuery({
queryKey: ['bookings', filters],
queryFn: () => fetchBookings(filters),
});
```
---
## 📊 Modules NestJS - Organisation
Total: **21 modules NestJS**
### Feature Modules (Application Layer) - 14 modules
| Module | Contrôleur | Responsabilité |
|--------|-----------|----------------|
| `AuthModule` | `AuthController` | Authentication JWT |
| `RatesModule` | `RatesController` | Rate search |
| `BookingsModule` | `BookingsController` | Booking management |
| `PortsModule` | `PortsController` | Port search |
| `OrganizationsModule` | `OrganizationsController` | Organization CRUD |
| `UsersModule` | `UsersController` | User management |
| `DashboardModule` | `DashboardController` | KPIs & analytics |
| `NotificationsModule` | `NotificationsController` | User notifications |
| `AuditModule` | `AuditController` | Audit logs |
| `WebhooksModule` | `WebhooksController` | Webhook config |
| `GDPRModule` | `GDPRController` | GDPR compliance |
| `AdminModule` | `AdminController` | Admin features |
| `CsvBookingsModule` | `CsvBookingsController` | CSV imports |
### Infrastructure Modules - 7 modules
| Module | Adapter | Implémente |
|--------|---------|------------|
| `CacheModule` | `RedisCacheAdapter` | `CachePort` |
| `CarrierModule` | `MaerskConnector`, etc. | `CarrierConnectorPort` |
| `EmailModule` | `EmailAdapter` | `EmailPort` |
| `StorageModule` | `S3StorageAdapter` | `StoragePort` |
| `PdfModule` | `PdfAdapter` | `PdfPort` |
| `SecurityModule` | - | Configuration Helmet/CORS |
| `CsvRateModule` | `CsvRateLoaderAdapter` | `CsvRateLoaderPort` |
---
## 🔒 Patterns de sécurité
### Guards globaux
Configurés dans `app.module.ts`:
```typescript
{
provide: APP_GUARD,
useClass: JwtAuthGuard, // Toutes les routes protégées par défaut
},
{
provide: APP_GUARD,
useClass: CustomThrottlerGuard, // Rate limiting global
}
```
### Contournement pour routes publiques
```typescript
@Public() // Decorator pour bypass JWT
@Post('login')
async login(@Body() dto: AuthLoginDto) {
// ...
}
```
### RBAC (Role-Based Access Control)
```typescript
@Roles('ADMIN', 'MANAGER')
@Get('users')
async getUsers() {
// Accessible uniquement par ADMIN ou MANAGER
}
```
---
## 📈 Métriques d'architecture
### Backend
| Métrique | Valeur | Cible |
|----------|--------|-------|
| **Total fichiers TypeScript** | ~220+ | - |
| **Modules NestJS** | 21 | - |
| **Controllers** | 17 | - |
| **Domain Entities** | 13 | - |
| **Domain Value Objects** | 9 | - |
| **Domain Services** | 7 | - |
| **Ports (interfaces)** | 21 | - |
| **Repository Implementations** | 13 | - |
| **Migrations** | 18 | - |
| **Compliance hexagonale** | 95% | 100% |
| **Violations critiques** | 1 | 0 |
### Frontend
| Métrique | Valeur | Cible |
|----------|--------|-------|
| **Page routes** | 31 | - |
| **Components React** | 29 | - |
| **Custom hooks** | 5 | - |
| **API client modules** | 20 | - |
| **Type definitions** | 5 | - |
| **Strict TypeScript** | ❌ Non | ✅ Oui |
---
## 🎯 Objectifs de qualité
### Backend
- ✅ **Domain Layer purity**: 100% (1 violation à corriger)
- ✅ **Port/Adapter pattern**: 100%
- ✅ **Repository pattern**: 100%
- ✅ **DTO validation**: 100%
- ✅ **Test coverage domain**: 90%+
### Frontend
- ⚠️ **Strict TypeScript**: À activer
- ⚠️ **Business logic separation**: Amélioration nécessaire
- ⚠️ **Data fetching consistency**: Standardisation requise
- ✅ **Component composition**: Bon
- ✅ **API client coverage**: 100%
---
## 📚 Références
- [CLAUDE.md](../CLAUDE.md) - Guide complet d'implémentation
- [docs/backend/cleanup-report.md](backend/cleanup-report.md) - Rapport de nettoyage backend
- [docs/frontend/cleanup-report.md](frontend/cleanup-report.md) - Rapport de nettoyage frontend
- [docs/decisions.md](decisions.md) - Décisions architecturales
---
**Dernière mise à jour**: 2025-12-22
**Prochaine révision**: Après correction de la violation domain layer

0
apps/backend/DATABASE-SCHEMA.md → docs/backend/DATABASE-SCHEMA.md
View File

0
apps/backend/MINIO_SETUP_SUMMARY.md → docs/backend/MINIO_SETUP_SUMMARY.md
View File

16
docs/debug/elementmissingphase2.md
View File

@ -1,16 +0,0 @@
🎯 ÉLÉMENTS NON IMPLÉMENTÉS (Non critiques pour MVP)
Backend
❌ 2FA TOTP (marqué optionnel)
❌ Onboarding flow API (non critique)
Frontend
❌ Password strength meter (UX enhancement)
❌ Onboarding wizard (non critique)
❌ User profile page séparée (peut utiliser settings)
❌ 2FA setup UI (2FA non implémenté backend)
❌ Address autocomplete Google Maps (saisie manuelle suffit)
❌ Address book (feature future)
❌ HS Code autocomplete (feature future)
❌ Document upload dans booking form (peut upload après)
❌ Edit booking page (feature future)
❌ Cancel booking UI (feature future)
TOUS ces éléments sont des "nice-to-have" et ne bloquent PAS le lancement du MVP!

768
docs/decisions.md
View File

@ -1,768 +0,0 @@
# Décisions Architecturales - Xpeditis
**Projet**: Xpeditis - Plateforme B2B SaaS maritime
**Format**: Architecture Decision Records (ADR)
**Dernière mise à jour**: 2025-12-22
---
## Index des décisions
| ID | Date | Titre | Status |
|----|------|-------|--------|
| ADR-001 | 2025-12-22 | Adoption de l'architecture hexagonale | ✅ Acceptée |
| ADR-002 | 2025-12-22 | Suppression dépendances NestJS du domain layer | 🟡 Proposée |
| ADR-003 | 2025-12-22 | Activation TypeScript strict mode frontend | 🟡 Proposée |
| ADR-004 | 2025-12-22 | Standardisation pattern data fetching (React Query) | 🟡 Proposée |
| ADR-005 | 2025-12-22 | Migration pagination client-side vers serveur | 🟡 Proposée |
**Légende des status**:
- ✅ Acceptée: Décision implémentée
- 🟡 Proposée: En attente d'implémentation
- ❌ Rejetée: Décision écartée
- 🔄 Superseded: Remplacée par une autre décision
---
## ADR-001: Adoption de l'architecture hexagonale
**Date**: 2025-12-22 (rétroactif - décision initiale du projet)
**Status**: ✅ Acceptée et implémentée
### Contexte
L'application Xpeditis nécessite:
- Une séparation claire entre la logique métier et les détails techniques
- La capacité de changer de framework sans réécrire le métier
- Une testabilité maximale du code domaine
- L'indépendance vis-à-vis des bases de données et APIs externes
### Décision
Adopter l'**architecture hexagonale (Ports & Adapters)** pour le backend NestJS avec:
**3 couches strictement séparées**:
1. **Domain**: Logique métier pure (zéro dépendance externe)
2. **Application**: Orchestration et points d'entrée (controllers, DTOs)
3. **Infrastructure**: Adapters externes (DB, cache, email, APIs)
**Règles de dépendance**:
- Infrastructure → Application → Domain
- Jamais l'inverse
- Les interfaces (ports) sont définies dans le domain
- Les implémentations (adapters) sont dans l'infrastructure
### Conséquences
**Positives**:
- ✅ Domaine métier testable sans framework
- ✅ Changement de DB/ORM sans impact sur le métier
- ✅ Code domaine réutilisable
- ✅ Séparation claire des responsabilités
- ✅ Facilite l'onboarding des nouveaux développeurs
**Négatives**:
- ⚠️ Plus de fichiers à créer (ports, adapters, mappers)
- ⚠️ Courbe d'apprentissage initiale
- ⚠️ Verbosité accrue (mappers Domain ↔ ORM, Domain ↔ DTO)
**Risques**:
- ⚠️ Tentation de violer les règles (imports directs, shortcuts)
- ⚠️ Over-engineering pour des features simples
### Implémentation
**Structure adoptée**:
```
apps/backend/src/
├── domain/ # 🔵 Cœur métier (aucune dépendance)
│ ├── entities/
│ ├── value-objects/
│ ├── services/
│ ├── ports/
│ └── exceptions/
├── application/ # 🔌 Controllers & Use Cases
│ ├── controllers/
│ ├── dto/
│ ├── services/
│ └── mappers/
└── infrastructure/ # 🏗️ Adapters externes
├── persistence/
├── cache/
├── email/
└── carriers/
```
**Validation**:
- Tous les modules respectent la structure
- 95% de conformité (1 violation identifiée - voir ADR-002)
- Pattern Repository implémenté avec 13 repositories
### Alternatives considérées
**1. Clean Architecture (Uncle Bob)**
- Rejetée: Trop de couches (4-5) pour notre complexité
- Architecture hexagonale est plus simple et suffisante
**2. MVC traditionnel**
- Rejetée: Pas de séparation domaine/infrastructure
- Logique métier mélangée avec framework
**3. Feature Modules seuls (NestJS standard)**
- Rejetée: Domaine couplé à NestJS
- Difficile à tester et réutiliser
### Références
- [Hexagonal Architecture - Alistair Cockburn](https://alistair.cockburn.us/hexagonal-architecture/)
- [docs/architecture.md](./architecture.md)
- [CLAUDE.md](../CLAUDE.md)
---
## ADR-002: Suppression dépendances NestJS du domain layer
**Date**: 2025-12-22
**Status**: 🟡 Proposée
### Contexte
**Violation identifiée** lors de l'audit d'architecture:
- Le fichier `domain/services/booking.service.ts` importe `@nestjs/common`
- Utilise les decorators `@Injectable()` et `@Inject()`
- Utilise `NotFoundException` (exception NestJS, pas métier)
**Impact actuel**:
- Couplage du domain layer avec le framework NestJS
- Impossible de tester le service sans `TestingModule`
- Violation du principe d'inversion de dépendance
### Décision
**Supprimer toutes les dépendances NestJS du domain layer**:
1. Retirer `@Injectable()`, `@Inject()` de `BookingService`
2. Créer exception domaine `RateQuoteNotFoundException`
3. Adapter l'injection dans `bookings.module.ts`
4. Simplifier les tests unitaires
### Implémentation proposée
**Étape 1**: Refactoring du service domaine
```typescript
// domain/services/booking.service.ts
// AVANT
import { Injectable, Inject, NotFoundException } from '@nestjs/common';
@Injectable()
export class BookingService {
constructor(
@Inject(BOOKING_REPOSITORY)
private readonly bookingRepository: BookingRepository,
) {}
}
// APRÈS
import { RateQuoteNotFoundException } from '../exceptions';
export class BookingService {
constructor(
private readonly bookingRepository: BookingRepository,
private readonly rateQuoteRepository: RateQuoteRepository,
) {}
}
```
**Étape 2**: Nouvelle exception domaine
```typescript
// domain/exceptions/rate-quote-not-found.exception.ts
export class RateQuoteNotFoundException extends Error {
constructor(public readonly rateQuoteId: string) {
super(`Rate quote with id ${rateQuoteId} not found`);
this.name = 'RateQuoteNotFoundException';
}
}
```
**Étape 3**: Adapter le module application
```typescript
// application/bookings/bookings.module.ts
@Module({
providers: [
{
provide: BookingService,
useFactory: (bookingRepo, rateQuoteRepo) => {
return new BookingService(bookingRepo, rateQuoteRepo);
},
inject: [BOOKING_REPOSITORY, RATE_QUOTE_REPOSITORY],
},
],
})
```
### Conséquences
**Positives**:
- ✅ Conformité 100% architecture hexagonale
- ✅ Domain layer totalement indépendant du framework
- ✅ Tests plus simples et plus rapides
- ✅ Réutilisabilité du code domaine
**Négatives**:
- ⚠️ Légère verbosité dans la configuration des modules
- ⚠️ Besoin de mapper les exceptions (domaine → HTTP) dans application layer
**Risques**:
- ⚠️ **FAIBLE**: Risque de régression (tests doivent passer)
- ⚠️ **FAIBLE**: Impact sur les features dépendantes de BookingService
### Validation
**Critères d'acceptation**:
- [ ] ✅ Aucun import `@nestjs/*` dans `domain/`
- [ ] ✅ Tous les tests unitaires passent
- [ ] ✅ Tests d'intégration passent
- [ ] ✅ Tests E2E passent
- [ ] ✅ Pas de régression fonctionnelle
**Commande de vérification**:
```bash
# Vérifier l'absence d'imports NestJS dans domain
grep -r "from '@nestjs" apps/backend/src/domain/
# Résultat attendu: Aucun résultat
```
### Timeline
**Estimation**: 2-3 heures
- Refactoring: 1h
- Tests: 1h
- Review: 30min
### Références
- [docs/backend/cleanup-report.md](./backend/cleanup-report.md)
- [Hexagonal Architecture Principles](https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/)
---
## ADR-003: Activation TypeScript strict mode frontend
**Date**: 2025-12-22
**Status**: 🟡 Proposée
### Contexte
**Problème identifié**:
- `tsconfig.json` a `"strict": false`
- Permet les erreurs de type silencieuses
- Risque de bugs runtime (`undefined is not a function`, `Cannot read property of null`)
- Code non type-safe difficile à maintenir
**Exemples de bugs non détectés sans strict mode**:
```typescript
// ❌ Accepté sans strict mode
let user: User;
console.log(user.name); // user peut être undefined
function getBooking(id?: string) {
return bookings.find(b => b.id === id); // id peut être undefined
}
```
### Décision
**Activer TypeScript strict mode** dans `tsconfig.json`:
```json
{
"compilerOptions": {
"strict": true
}
}
```
Ou activer les flags individuellement:
```json
{
"compilerOptions": {
"strictNullChecks": true,
"strictFunctionTypes": true,
"strictBindCallApply": true,
"strictPropertyInitialization": true,
"noImplicitAny": true,
"noImplicitThis": true,
"alwaysStrict": true
}
}
```
### Conséquences
**Positives**:
- ✅ Détection des bugs au build time (pas runtime)
- ✅ Meilleure autocomplétion IDE (IntelliSense)
- ✅ Refactoring plus sûr
- ✅ Documentation implicite via les types
- ✅ Réduction des erreurs en production
**Négatives**:
- ⚠️ Corrections TypeScript nécessaires (estimation: 50-70% des fichiers)
- ⚠️ Apprentissage des patterns de null safety
- ⚠️ Code plus verbeux (guards, optional chaining)
**Risques**:
- ⚠️ **FAIBLE**: Pas de risque fonctionnel (corrections statiques)
- ⚠️ **MOYEN**: Temps de correction estimé à 2-3 jours
### Implémentation
**Phase 1: Activation progressive**
```bash
# 1. Activer strict mode
# tsconfig.json: "strict": true
# 2. Lister toutes les erreurs
npm run type-check 2>&1 | tee typescript-errors.log
# 3. Trier par fichier/type d'erreur
cat typescript-errors.log | sort | uniq -c
```
**Phase 2: Patterns de correction**
**Pattern 1**: Null checks
```typescript
// AVANT (strict: false)
function BookingDetails({ booking }) {
return <div>{booking.customerName}</div>;
}
// APRÈS (strict: true)
interface BookingDetailsProps {
booking: Booking | null;
}
function BookingDetails({ booking }: BookingDetailsProps) {
if (!booking) return <div>Loading...</div>;
return <div>{booking.customerName}</div>;
}
```
**Pattern 2**: Optional chaining
```typescript
// AVANT
const name = user.organization.name;
// APRÈS
const name = user?.organization?.name;
```
**Pattern 3**: Nullish coalescing
```typescript
// AVANT
const limit = params.limit || 20;
// APRÈS
const limit = params.limit ?? 20; // Gère correctement 0
```
**Phase 3: Validation**
```bash
# Vérifier qu'il n'y a plus d'erreurs TypeScript
npm run type-check
# Résultat attendu: Found 0 errors
# Build production
npm run build
# Résultat attendu: Build successful
```
### Timeline
**Estimation**: 2-3 jours
- Jour 1: Activer strict mode + lister erreurs
- Jour 2: Corriger 70% des erreurs
- Jour 3: Corriger les 30% restants + validation
### Alternatives considérées
**1. Garder strict: false**
- Rejetée: Accumulation de dette technique
- Risque de bugs en production
**2. Activation progressive flag par flag**
- Possible mais plus long
- Préférer activation directe (plus rapide)
**3. Migration vers Zod/io-ts pour runtime validation**
- Complémentaire (pas alternative)
- Peut être ajouté après strict mode
### Références
- [TypeScript Strict Mode Guide](https://www.typescriptlang.org/tsconfig#strict)
- [docs/frontend/cleanup-report.md](./frontend/cleanup-report.md)
---
## ADR-004: Standardisation pattern data fetching (React Query)
**Date**: 2025-12-22
**Status**: 🟡 Proposée
### Contexte
**Problème**: 3 patterns différents utilisés dans le frontend
**Pattern 1**: React Query + API client (✅ Recommandé)
```typescript
const { data } = useQuery({
queryKey: ['dashboard', 'kpis'],
queryFn: () => getDashboardKpis(),
});
```
**Pattern 2**: Custom hook avec fetch direct (❌ Problématique)
```typescript
const response = await fetch(`/api/v1/bookings/search`, {
headers: { Authorization: `Bearer ${localStorage.getItem('accessToken')}` },
});
```
**Pattern 3**: API client direct dans composant (⚠️ Acceptable)
```typescript
const { data } = useQuery({
queryKey: ['bookings'],
queryFn: () => listBookings({ page: 1, limit: 20 }),
});
```
**Problèmes identifiés**:
- Incohérence dans le codebase
- Token management en doublon
- Error handling différent partout
- Pas de cache centralisé
- Retry logic manquante
### Décision
**Standardiser sur Pattern 1**: **React Query + API client partout**
**Raisons**:
1. Token management centralisé (dans apiClient)
2. Error handling uniforme
3. Cache management automatique
4. Retry logic configurée
5. Type safety maximale
6. Optimistic updates possibles
### Implémentation
**Refactoring type**:
**AVANT** (useBookings.ts - Pattern 2):
```typescript
export function useBookings() {
const [bookings, setBookings] = useState([]);
const [loading, setLoading] = useState(false);
const searchBookings = async (filters) => {
setLoading(true);
const response = await fetch(`/api/v1/bookings/search`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${localStorage.getItem('accessToken')}`,
},
body: JSON.stringify(filters),
});
const data = await response.json();
setBookings(data);
setLoading(false);
};
return { bookings, loading, searchBookings };
}
```
**APRÈS** (useBookings.ts - Pattern 1):
```typescript
import { useQuery } from '@tanstack/react-query';
import { advancedSearchBookings } from '@/lib/api/bookings';
export function useBookings(filters: BookingFilters) {
return useQuery({
queryKey: ['bookings', 'search', filters],
queryFn: () => advancedSearchBookings(filters),
enabled: !!filters,
staleTime: 5 * 60 * 1000, // 5 minutes
});
}
// Usage dans composant
const { data, isLoading, error } = useBookings(filters);
```
**Configuration centralisée**:
```typescript
// lib/providers/query-provider.tsx
export function QueryProvider({ children }) {
const queryClient = new QueryClient({
defaultOptions: {
queries: {
staleTime: 60 * 1000, // 1 minute
retry: 3,
refetchOnWindowFocus: false,
},
mutations: {
retry: 1,
},
},
});
return (
<QueryClientProvider client={queryClient}>
{children}
</QueryClientProvider>
);
}
```
### Conséquences
**Positives**:
- ✅ Code plus maintenable
- ✅ Moins de bugs (error handling centralisé)
- ✅ Meilleures performances (cache)
- ✅ Meilleure UX (loading states, retry)
- ✅ Dev experience améliorée (React Query DevTools)
**Négatives**:
- ⚠️ Refactoring nécessaire (estimation: 5-6 fichiers)
- ⚠️ Dépendance à React Query (mais déjà présent)
### Timeline
**Estimation**: 1 jour
- Refactoring hooks: 4h
- Tests: 2h
- Documentation: 1h
### Fichiers à modifier
1. `src/hooks/useBookings.ts` (supprimer fetch direct)
2. `src/hooks/useCsvRateSearch.ts` (vérifier pattern)
3. `src/hooks/useNotifications.ts` (vérifier pattern)
4. Tout autre hook custom utilisant fetch direct
### Validation
**Checklist**:
- [ ] ✅ Aucun `fetch()` direct dans hooks/composants
- [ ] ✅ Tous les calls API passent par `@/lib/api/*`
- [ ] ✅ Tous les hooks utilisent `useQuery` ou `useMutation`
- [ ] ✅ Token management unifié (via apiClient)
**Commande de vérification**:
```bash
# Chercher les fetch directs
grep -r "fetch(" apps/frontend/src/ apps/frontend/app/ | grep -v "api/client.ts"
# Résultat attendu: Aucun résultat (sauf dans client.ts)
```
### Références
- [React Query Best Practices](https://tkdodo.eu/blog/practical-react-query)
- [docs/frontend/cleanup-report.md](./frontend/cleanup-report.md)
---
## ADR-005: Migration pagination client-side vers serveur
**Date**: 2025-12-22
**Status**: 🟡 Proposée
### Contexte
**Problème actuel**:
```typescript
// app/dashboard/bookings/page.tsx (ligne 29)
listCsvBookings({ page: 1, limit: 1000 }) // ❌ Charge 1000 bookings !
// Puis pagination client-side
const currentBookings = filteredBookings.slice(startIndex, endIndex);
```
**Impact**:
- ⚠️ Transfert ~500KB-1MB de données
- ⚠️ Temps de chargement initial: 2-3 secondes
- ⚠️ Non scalable (impossible avec 10,000+ bookings)
- ⚠️ UX dégradée (loading long)
### Décision
**Implémenter pagination côté serveur** avec:
1. Requêtes paginées (20 items par page)
2. Filtres appliqués côté serveur
3. Cache React Query pour navigation rapide
4. Smooth transitions avec `keepPreviousData`
### Implémentation
**AVANT**:
```typescript
const { data: csvBookings } = useQuery({
queryKey: ['csv-bookings'],
queryFn: () => listCsvBookings({ page: 1, limit: 1000 }), // ❌ Tout charger
});
// Filtrage client-side
const filteredBookings = bookings.filter(/* ... */);
// Pagination client-side
const currentBookings = filteredBookings.slice(startIndex, endIndex);
```
**APRÈS**:
```typescript
const { data: csvBookings } = useQuery({
queryKey: ['csv-bookings', currentPage, filters],
queryFn: () => listCsvBookings({
page: currentPage,
limit: 20, // ✅ Pagination serveur
...filters, // ✅ Filtres serveur
}),
keepPreviousData: true, // ✅ Smooth transition entre pages
});
// Plus besoin de pagination client-side
const currentBookings = csvBookings?.data || [];
const totalPages = csvBookings?.meta.totalPages || 1;
```
**Vérifier API backend**:
```typescript
// Backend: apps/backend/src/application/controllers/csv-bookings.controller.ts
@Get()
async listCsvBookings(
@Query('page') page: number = 1,
@Query('limit') limit: number = 20,
@Query() filters: CsvBookingFiltersDto,
): Promise<PaginatedResponse<CsvBooking>> {
// ✅ L'API supporte déjà la pagination
return this.csvBookingService.findAll({ page, limit, filters });
}
```
### Conséquences
**Positives**:
- ✅ Temps de chargement: 2s → 300ms
- ✅ Taille transfert: 500KB → 20KB
- ✅ Scalable: Supporte millions de records
- ✅ Meilleure UX: Chargement instantané
- ✅ Cache efficace: Une page = une requête
**Négatives**:
- ⚠️ Navigation entre pages = requête réseau
- Mitigé par `keepPreviousData` (pas de flash de loading)
- Mitigé par cache React Query (navigation arrière instantanée)
**Risques**:
- ⚠️ **FAIBLE**: Backend doit supporter les filtres serveur
### Validation
**Critères de performance**:
- [ ] ✅ Temps de chargement initial < 500ms
- [ ] ✅ Navigation entre pages < 300ms
- [ ] ✅ Taille transfert < 50KB par page
- [ ] ✅ Pas de flash de loading (keepPreviousData)
**Tests**:
```bash
# Test avec 10,000 bookings en base
# Avant: ~3s loading
# Après: ~300ms loading
```
### Timeline
**Estimation**: 2-3 heures
- Modification frontend: 1h
- Vérification backend: 30min
- Tests: 1h
### Fichiers à modifier
1. `app/dashboard/bookings/page.tsx` (refactoring pagination)
2. `lib/api/csv-bookings.ts` (vérifier support filtres serveur)
3. Potentiellement: `hooks/useBookings.ts` (si utilisé ailleurs)
### Références
- [React Query Pagination Guide](https://tanstack.com/query/latest/docs/react/guides/paginated-queries)
- [docs/frontend/cleanup-report.md](./frontend/cleanup-report.md)
---
## Template pour nouvelles décisions
```markdown
## ADR-XXX: [Titre de la décision]
**Date**: YYYY-MM-DD
**Status**: 🟡 Proposée / ✅ Acceptée / ❌ Rejetée / 🔄 Superseded
### Contexte
[Décrire le problème ou la situation qui nécessite une décision]
### Décision
[Décrire la décision prise et pourquoi]
### Implémentation
[Décrire comment la décision sera implémentée]
### Conséquences
**Positives**:
- [Liste des avantages]
**Négatives**:
- [Liste des inconvénients]
**Risques**:
- [Liste des risques]
### Alternatives considérées
[Décrire les autres options envisagées et pourquoi elles ont été rejetées]
### Validation
[Décrire comment valider que la décision est correctement implémentée]
### Timeline
[Estimation du temps nécessaire]
### Références
[Liens vers documentation, articles, ADRs liés]
```
---
**Fin du document**
Pour toute question ou proposition de nouvelle décision, contacter l'équipe architecture.

0
docs/STRIPE_SETUP.md → docs/deployment/STRIPE_SETUP.md
View File

0
docs/deployment/ARM64_SUPPORT.md → docs/deployment/portainer/ARM64_SUPPORT.md
View File

0
docs/deployment/AWS_COSTS_KUBERNETES.md → docs/deployment/portainer/AWS_COSTS_KUBERNETES.md
View File

0
docs/deployment/CICD_REGISTRY_SETUP.md → docs/deployment/portainer/CICD_REGISTRY_SETUP.md
View File

0
docs/deployment/CI_CD_MULTI_ENV.md → docs/deployment/portainer/CI_CD_MULTI_ENV.md
View File

0
docs/deployment/CLOUD_COST_COMPARISON.md → docs/deployment/portainer/CLOUD_COST_COMPARISON.md
View File

0
docs/deployment/DEPLOYMENT.md → docs/deployment/portainer/DEPLOYMENT.md
View File

0
docs/deployment/DEPLOYMENT_CHECKLIST.md → docs/deployment/portainer/DEPLOYMENT_CHECKLIST.md
View File

0
docs/deployment/DEPLOYMENT_FIX.md → docs/deployment/portainer/DEPLOYMENT_FIX.md
View File

0
docs/deployment/DEPLOYMENT_READY.md → docs/deployment/portainer/DEPLOYMENT_READY.md
View File

0
docs/deployment/DEPLOY_README.md → docs/deployment/portainer/DEPLOY_README.md
View File

0
docs/deployment/DOCKER_ARM64_FIX.md → docs/deployment/portainer/DOCKER_ARM64_FIX.md
View File

0
docs/deployment/DOCKER_CSS_FIX.md → docs/deployment/portainer/DOCKER_CSS_FIX.md
View File

0
docs/deployment/DOCKER_FIXES_SUMMARY.md → docs/deployment/portainer/DOCKER_FIXES_SUMMARY.md
View File

0
docs/deployment/FIX_404_SWARM.md → docs/deployment/portainer/FIX_404_SWARM.md
View File

0
docs/deployment/FIX_DOCKER_PROXY.md → docs/deployment/portainer/FIX_DOCKER_PROXY.md
View File

0
docs/deployment/PORTAINER_CHECKLIST.md → docs/deployment/portainer/PORTAINER_CHECKLIST.md
View File

0
docs/deployment/PORTAINER_CRASH_DEBUG.md → docs/deployment/portainer/PORTAINER_CRASH_DEBUG.md
View File

0
docs/deployment/PORTAINER_DEBUG.md → docs/deployment/portainer/PORTAINER_DEBUG.md
View File

0
docs/deployment/PORTAINER_DEBUG_COMMANDS.md → docs/deployment/portainer/PORTAINER_DEBUG_COMMANDS.md
View File

0
docs/deployment/PORTAINER_DEPLOY_FINAL.md → docs/deployment/portainer/PORTAINER_DEPLOY_FINAL.md
View File

0
docs/deployment/PORTAINER_ENV_FIX.md → docs/deployment/portainer/PORTAINER_ENV_FIX.md
View File

0
docs/deployment/PORTAINER_FIX_QUICK.md → docs/deployment/portainer/PORTAINER_FIX_QUICK.md
View File

0
docs/deployment/PORTAINER_MIGRATION_AUTO.md → docs/deployment/portainer/PORTAINER_MIGRATION_AUTO.md
View File

0
docs/deployment/PORTAINER_REGISTRY_NAMING.md → docs/deployment/portainer/PORTAINER_REGISTRY_NAMING.md
View File

0
docs/deployment/PORTAINER_TRAEFIK_404.md → docs/deployment/portainer/PORTAINER_TRAEFIK_404.md
View File

0
docs/deployment/PORTAINER_YAML_FIX.md → docs/deployment/portainer/PORTAINER_YAML_FIX.md
View File

0
docs/deployment/REGISTRY_PUSH_GUIDE.md → docs/deployment/portainer/REGISTRY_PUSH_GUIDE.md
View File

0
PRD.md → docs/phases/PRD.md
View File

0
START-HERE.md → docs/phases/START-HERE.md
View File

0
TODO.md → docs/phases/TODO.md
View File

0
WINDOWS-INSTALLATION.md → docs/phases/WINDOWS-INSTALLATION.md
View File

14
infra/postgres/init.sql
View File

@ -1,14 +0,0 @@
-- Initialize Xpeditis database
-- Create extensions
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pg_trgm"; -- For fuzzy search
-- Create schemas
CREATE SCHEMA IF NOT EXISTS public;
-- Grant permissions
GRANT ALL ON SCHEMA public TO xpeditis;
-- Initial comment
COMMENT ON DATABASE xpeditis_dev IS 'Xpeditis Maritime Freight Booking Platform - Development Database';