outlet-orm 5.5.1 → 5.5.3

package/README.md

@@ -3,14 +3,14 @@
 [![npm version](https://badge.fury.io/js/outlet-orm.svg)](https://www.npmjs.com/package/outlet-orm)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Un ORM JavaScript inspiré de Laravel Eloquent pour Node.js avec support pour MySQL, PostgreSQL et SQLite.
+A JavaScript ORM inspired by Laravel Eloquent for Node.js with support for MySQL, PostgreSQL and SQLite.
 
-📚 **[Documentation complète disponible dans `/docs`](./docs/INDEX.md)**
+📚 **[Complete documentation available in `/docs`](./docs/INDEX.md)**
 
-## ✅ Prérequis et compatibilité
+## ✅ Prerequisites and compatibility
 
-- Node.js >= 18 (recommandé/exigé)
-- Installez le driver de base de données correspondant à votre SGBD (voir ci-dessous)
+- Node.js >= 18 (recommended/required)
+- Install the database driver corresponding to your DBMS (see below)
 
 ## 🚀 Installation
 
@@ -18,61 +18,50 @@ Un ORM JavaScript inspiré de Laravel Eloquent pour Node.js avec support pour My
 npm install outlet-orm
 ```
 
-### Installer le driver de base de données
+### Install the database driver
 
-Outlet ORM utilise des peerDependencies optionnelles pour les drivers de base de données. Installez uniquement le driver dont vous avez besoin:
+Outlet ORM uses optional peer dependencies for database drivers. Install only the driver you need:
 
 - MySQL/MariaDB: `npm install mysql2`
 - PostgreSQL: `npm install pg`
 - SQLite: `npm install sqlite3`
 
-Si aucun driver n'est installé, un message d'erreur explicite vous indiquera lequel installer lors de la connexion.
+If no driver is installed, an explicit error message will tell you which one to install when connecting.
 
-## 📁 Structure de Projet Recommandée
+## 📁 Recommended Project Structure
 
-Organisez votre projet utilisant Outlet ORM avec une **architecture en couches** (recommandée pour la production) :
+Organise your project using Outlet ORM with a **2-layer architecture** — Controllers call Models directly, keeping the codebase lean and productive:
 
-> 🔐 **Sécurité** : Voir le [Guide de Sécurité](./docs/SECURITY.md) pour les bonnes pratiques.
+> 🔐 **Security**: See the [Security Guide](./docs/SECURITY.md) for best practices.
 
 ```
-mon-projet/
-├── .env                          # ⚠️ JAMAIS commité (dans .gitignore)
-├── .env.example                  # Template sans secrets
+my-project/
+├── .env                          # ⚠️ NEVER committed (in .gitignore)
+├── .env.example                  # Template without secrets
 ├── .gitignore
 ├── package.json
 │
-├── src/                          # 📦 Code source centralisé
-│   ├── index.js                  # Point d'entrée de l'application
+├── src/                          # 📦 Centralised source code
+│   ├── index.js                  # Application entry point
 │   │
 │   ├── config/                   # ⚙️ Configuration
-│   │   ├── app.js                # Config générale (port, env)
-│   │   ├── database.js           # Config DB (lit .env)
+│   │   ├── app.js                # General config (port, env)
+│   │   ├── database.js           # DB config (reads .env)
 │   │   └── security.js           # CORS, helmet, rate limit
 │   │
-│   ├── models/                   # 📊 Couche Data (Entities)
-│   │   ├── index.js              # Export centralisé des models
+│   ├── models/                   # 📊 outlet-orm Models (entities)
+│   │   ├── index.js              # Centralised model exports
 │   │   ├── User.js
 │   │   ├── Post.js
 │   │   └── Comment.js
 │   │
-│   ├── repositories/             # 🗄️ Couche Accès Données
-│   │   ├── BaseRepository.js     # Méthodes CRUD génériques
-│   │   ├── UserRepository.js     # Requêtes spécifiques User
-│   │   └── PostRepository.js
-│   │
-│   ├── services/                 # 💼 Couche Métier (Business Logic)
-│   │   ├── AuthService.js        # Logique d'authentification
-│   │   ├── UserService.js        # Logique métier utilisateur
-│   │   ├── PostService.js
-│   │   └── EmailService.js       # Service externe (emails)
-│   │
-│   ├── controllers/              # 🎮 Couche Présentation (HTTP)
+│   ├── controllers/              # 🎮 HTTP handling + business logic (direct ORM calls)
 │   │   ├── AuthController.js
 │   │   ├── UserController.js
 │   │   └── PostController.js
 │   │
-│   ├── routes/                   # 🛤️ Définition des routes
-│   │   ├── index.js              # Agrégateur de routes
+│   ├── routes/                   # 🛤️ Route definitions
+│   │   ├── index.js              # Route aggregator
 │   │   ├── auth.routes.js
 │   │   ├── user.routes.js
 │   │   └── post.routes.js
@@ -82,44 +71,42 @@ mon-projet/
 │   │   ├── authorize.js          # RBAC / permissions
 │   │   ├── rateLimiter.js        # Protection DDoS
 │   │   ├── validator.js          # Validation request body
-│   │   └── errorHandler.js       # Gestion centralisée erreurs
+│   │   └── errorHandler.js       # Centralised error handling
 │   │
-│   ├── validators/               # ✅ Schémas de validation
+│   ├── validators/               # ✅ Validation schemas
 │   │   ├── authValidator.js
 │   │   └── userValidator.js
 │   │
-│   └── utils/                    # 🔧 Utilitaires
+│   └── utils/                    # 🔧 Utilities
 │       ├── hash.js               # bcrypt wrapper
 │       ├── token.js              # JWT helpers
 │       ├── logger.js             # Winston/Pino config
-│       └── response.js           # Formatage réponses API
+│       └── response.js           # API response formatting
 │
 ├── database/
 │   ├── config.js                 # Config migrations (outlet-init)
-│   ├── migrations/               # Fichiers de migration
-│   └── seeds/                    # Données de test/démo
+│   ├── migrations/               # Migration files
+│   └── seeds/                    # Test/demo data
 │       └── UserSeeder.js
 │
-├── public/                       # ✅ Fichiers statiques publics
+├── public/                       # ✅ Public static files
 │   ├── images/
 │   ├── css/
 │   └── js/
 │
-├── uploads/                      # ⚠️ Fichiers uploadés
+├── uploads/                      # ⚠️ Uploaded files
 │
-├── logs/                         # 📋 Journaux (non versionnés)
+├── logs/                         # 📋 Logs (not versioned)
 │
 └── tests/                        # 🧪 Tests
-    ├── unit/                     # Tests unitaires
-    │   ├── services/
-    │   └── models/
-    ├── integration/              # Tests d'intégration
+    ├── unit/                     # Unit tests (models)
+    ├── integration/              # Integration tests (API)
     │   └── api/
-    └── fixtures/                 # Données de test
+    └── fixtures/                 # Test data
         └── users.json
 ```
 
-### 🏗️ Architecture en Couches
+### 🏗️ Architecture Flow
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
@@ -133,45 +120,32 @@ mon-projet/
                               │
                               ▼
 ┌─────────────────────────────────────────────────────────────┐
-│  ROUTES → CONTROLLERS (Couche Présentation)                 │
-│  Reçoit la requête, appelle le service, retourne réponse   │
-└─────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────┐
-│  SERVICES (Couche Métier / Business Logic)                  │
-│  Logique métier, orchestration, règles business            │
-└─────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────┐
-│  REPOSITORIES (Couche Accès Données)                        │
-│  Abstraction des requêtes DB, utilise les Models           │
+│  ROUTES → CONTROLLERS  HTTP handling + business logic       │
+│                        Direct outlet-orm Model calls        │
 └─────────────────────────────────────────────────────────────┘
                               │
                               ▼
 ┌─────────────────────────────────────────────────────────────┐
-│  MODELS (Outlet ORM) → DATABASE                             │
+│  MODELS (outlet-orm) → DATABASE                             │
 └─────────────────────────────────────────────────────────────┘
 ```
 
-### 📋 Rôle de chaque couche
+### 📋 Role of each layer
 
-| Couche | Dossier | Responsabilité | Dépend de |
-|--------|---------|----------------|-----------|
-| **Présentation** | `controllers/` | Traiter HTTP, valider entrées, formater réponses | Services |
-| **Métier** | `services/` | Logique business, orchestration, règles | Repositories |
-| **Données** | `repositories/` | Requêtes DB complexes, abstraction | Models |
-| **Entités** | `models/` | Définition des entités, relations, validations | Outlet ORM |
+| Layer | Folder | Responsibility | Security |
+|--------|---------|----------------|----------|
+| **Controllers** | `controllers/` | Handle HTTP, call ORM models, return responses | Input validation, ownership checks |
+| **Models** | `models/` | Entity definition, relationships, validations | `fillable`, `hidden`, rules |
+| **Middlewares** | `middlewares/` | Auth, rate limiting, error handling | 🔒 Critical |
 
-### ✅ Avantages de cette architecture
+### ✅ Benefits of this architecture
 
-- **Testabilité** : Chaque couche peut être testée indépendamment
-- **Maintenabilité** : Séparation claire des responsabilités
-- **Scalabilité** : Facile d'ajouter de nouvelles fonctionnalités
-- **Réutilisabilité** : Services utilisables depuis CLI, workers, etc.
+- **Simplicity**: Less files, less abstraction, faster to navigate
+- **Productivity**: Outlet ORM's expressive API handles data access directly
+- **Testability**: Integration tests with SQLite in-memory cover full request flows
+- **Flexibility**: Add a `services/` or `repositories/` layer later if complexity grows
 
-### 📝 Exemple de flux
+### 📝 Example workflow
 
 ```javascript
 // routes/user.routes.js
@@ -179,88 +153,88 @@ router.get('/users/:id', auth, UserController.show);
 
 // controllers/UserController.js
 async show(req, res) {
-  const user = await userService.findById(req.params.id);
+  const user = await User.with('posts').find(req.params.id);
+  if (!user) return res.status(404).json({ message: 'User not found' });
   res.json({ data: user });
 }
 
-// services/UserService.js
-async findById(id) {
-  const user = await userRepository.findWithPosts(id);
-  if (!user) throw new NotFoundError('User not found');
-  return user;
-}
+async store(req, res) {
+  const existing = await User.where('email', req.body.email).first();
+  if (existing) return res.status(409).json({ message: 'Email already in use' });
+
+  const data = { ...req.body };
+  data.password = await bcrypt.hash(data.password, 10);
 
-// repositories/UserRepository.js
-async findWithPosts(id) {
-  return User.with('posts').find(id);
+  const user = await User.create(data);
+  res.status(201).json({ success: true, data: user });
 }
 ```
 
-## ✨ Fonctionnalités clés
-
-- **API inspirée d'Eloquent** (Active Record) pour un usage fluide
-- **Query Builder expressif**: where/joins/order/limit/offset/paginate
-- **Filtres relationnels façon Laravel**: `whereHas()`, `has()`, `whereDoesntHave()`, `withCount()`
-- **Eager Loading** des relations via `.with(...)` avec contraintes et dot-notation
-- **Relations complètes**:
-  - `hasOne`, `hasMany`, `belongsTo`, `belongsToMany` (avec attach/detach/sync)
-  - `hasManyThrough`, `hasOneThrough` (relations transitives)
-  - `morphOne`, `morphMany`, `morphTo` (relations polymorphiques)
-- **Transactions** complètes: `beginTransaction()`, `commit()`, `rollback()`, `transaction()`
-- **Soft Deletes**: suppression logique avec `deleted_at`, `withTrashed()`, `onlyTrashed()`, `restore()`
-- **Scopes**: globaux et locaux pour réutiliser vos filtres
+## ✨ Key features
+
+- **Eloquent-inspired API** (Active Record) for a fluent developer experience
+- **Expressive Query Builder**: where/joins/order/limit/offset/paginate
+- **Laravel-style relationship filters**: `whereHas()`, `has()`, `whereDoesntHave()`, `withCount()`
+- **Eager Loading** of relationships via `.with(...)` with constraints and dot-notation
+- **Complete relations**:
+  - `hasOne`, `hasMany`, `belongsTo`, `belongsToMany` (with attach/detach/sync)
+  - `hasManyThrough`, `hasOneThrough` (transitive relationships)
+  - `morphOne`, `morphMany`, `morphTo` (polymorphic relationships)
+- **Complete Transactions**: `beginTransaction()`, `commit()`, `rollback()`, `transaction()`
+- **Soft Deletes**: soft deletion with `deleted_at`, `withTrashed()`, `onlyTrashed()`, `restore()`
+- **Scopes**: global and local, to reuse your query filters
 - **Events/Hooks**: `creating`, `created`, `updating`, `updated`, `deleting`, `deleted`, etc.
-- **Validation**: règles basiques intégrées (`required`, `email`, `min`, `max`, etc.)
-- **Query Logging**: mode debug avec `enableQueryLog()` et `getQueryLog()`
-- **Pool PostgreSQL**: connexions poolées pour de meilleures performances
-- **Protection SQL**: sanitization automatique des identifiants
-- **Casts automatiques** (int, float, boolean, json, date...)
-- **Attributs masqués** (`hidden`) et timestamps automatiques
-- **Contrôle de visibilité** des attributs cachés: `withHidden()` et `withoutHidden()`
-- **Incrément/Décrément atomiques**: `increment()` et `decrement()`
-- **Aliases ergonomiques**: `columns([...])`, `ordrer()` (alias typo de `orderBy`)
-- **Requêtes brutes**: `executeRawQuery()` et `execute()` (résultats natifs du driver)
-- **Migrations complètes** (create/alter/drop, index, foreign keys, batch tracking)
-- **CLI pratiques**: `outlet-init`, `outlet-migrate`, `outlet-convert`
-- **Configuration via `.env`** (chargée automatiquement)
-- **Multi-base de données**: MySQL, PostgreSQL et SQLite
-- **Types TypeScript complets** avec Generic Model et Schema Builder typé (v4.0.0+)
-
-## ⚡ Démarrage Rapide
-
-### Initialisation du projet
+- **Validation**: built-in basic rules (`required`, `email`, `min`, `max`, etc.)
+- **Query Logging**: debug mode with `enableQueryLog()` and `getQueryLog()`
+- **PostgreSQL Pool**: pooled connections for better performance
+- **SQL Protection**: automatic sanitisation of identifiers
+- **Automatic Casts** (int, float, boolean, json, date...)
+- **Hidden attributes** (`hidden`) and automatic timestamps
+- **Visibility control** of hidden attributes: `withHidden()` and `withoutHidden()`
+- **Atomic increment/decrement**: `increment()` and `decrement()`
+- **Ergonomic aliases**: `columns([...])`, `ordrer()` (typo alias for `orderBy`)
+- **Raw queries**: `executeRawQuery()` and `execute()` (native driver results)
+- **Complete Migrations** (create/alter/drop, index, foreign keys, batch tracking)
+- **Handy CLI tools**: `outlet-init`, `outlet-migrate`, `outlet-convert`
+- **`.env` configuration** (loaded automatically)
+- **Multi-database**: MySQL, PostgreSQL, and SQLite
+- **Complete TypeScript types** with Generic Model and typed Schema Builder (v4.0.0+)
+
+## ⚡ Quick Start
+
+### Project Initialisation
 
 ```bash
-# Créer la configuration initiale
+# Create initial configuration
 outlet-init
 
-# Créer une migration
+# Create a migration
 outlet-migrate make create_users_table
 
-# Exécuter les migrations
+# Run migrations
 outlet-migrate migrate
 ```
 
-### 🌱 Seeding rapide
+### 🌱 Quick Seeding
 
 ```bash
-# Créer un seeder
+# Create a seeder
 outlet-migrate make:seed UserSeeder
 
-# Exécuter les seeds (DatabaseSeeder prioritaire)
+# Run seeders (DatabaseSeeder runs first)
 outlet-migrate seed
 
-# Exécuter un seeder spécifique
+# Run a specific seeder
 outlet-migrate seed --class UserSeeder
 ```
 
-## 📖 Utilisation
+## 📖 Usage
 
-### Configuration de la connexion
+### Connection configuration
 
-Outlet ORM charge automatiquement la connexion depuis le fichier `.env`. **Plus besoin d'importer DatabaseConnection !**
+Outlet ORM automatically loads the connection from the `.env` file. **No need to import DatabaseConnection!**
 
-#### Fichier `.env`
+#### `.env` file
 
 ```env
 DB_DRIVER=mysql
@@ -271,7 +245,7 @@ DB_PASSWORD=secret
 DB_PORT=3306
 ```
 
-#### Utilisation simplifiée
+#### Simplified usage
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -280,21 +254,21 @@ class User extends Model {
   static table = 'users';
 }
 
-// C'est tout ! La connexion est automatique
+// That's it! The connection is automatic
 const users = await User.all();
 ```
 
-#### Configuration manuelle (optionnel)
+#### Manual configuration (optional)
 
-Si vous avez besoin de contrôler la connexion :
+If you need to control the connection :
 
 ```javascript
 const { DatabaseConnection, Model } = require('outlet-orm');
 
-// Option 1 – via .env (aucun paramètre nécessaire)
+// Option 1 – via .env (no parameters required)
 const db = new DatabaseConnection();
 
-// Option 2 – via objet de configuration
+// Option 2 – via configuration object
 const db = new DatabaseConnection({
   driver: 'mysql',
   host: 'localhost',
@@ -304,48 +278,48 @@ const db = new DatabaseConnection({
   port: 3306
 });
 
-// Définir la connexion manuellement (optionnel)
+// Set the connection manually (optional)
 Model.setConnection(db);
 ```
 
-#### Variables d'environnement (.env)
+#### Environment variables (.env)
 
-| Variable | Description | Par défaut |
+| Variable | Description | Default |
 |----------|-------------|------------|
 | `DB_DRIVER` | `mysql`, `postgres`, `sqlite` | `mysql` |
-| `DB_HOST` | Hôte de la base | `localhost` |
-| `DB_PORT` | Port de connexion | Selon driver |
-| `DB_USER` / `DB_USERNAME` | Identifiant | - |
-| `DB_PASSWORD` | Mot de passe | - |
-| `DB_DATABASE` / `DB_NAME` | Nom de la base | - |
-| `DB_FILE` / `SQLITE_DB` | Fichier SQLite | `:memory:` |
+| `DB_HOST` | Database host | `localhost` |
+| `DB_PORT` | Connection port | Driver default |
+| `DB_USER` / `DB_USERNAME` | Username | - |
+| `DB_PASSWORD` | Password | - |
+| `DB_DATABASE` / `DB_NAME` | Database name | - |
+| `DB_FILE` / `SQLITE_DB` | SQLite file | `:memory:` |
 
 ### Importation
 
 ```javascript
-// CommonJS - Import simple (connexion automatique via .env)
+// CommonJS - Simple import (automatic connection via .env)
 const { Model } = require('outlet-orm');
 
 // ES Modules
 import { Model } from 'outlet-orm';
 
-// Si besoin de contrôle manuel sur la connexion
+// If you need manual control over the connection
 const { DatabaseConnection, Model } = require('outlet-orm');
 ```
 
-### Définir un modèle
+### Define a model
 
 ```javascript
 const { Model } = require('outlet-orm');
 
-// Définition des modèles liés (voir Relations)
+// Define related models (see Relationships)
 class Post extends Model { static table = 'posts'; }
 class Profile extends Model { static table = 'profiles'; }
 
 class User extends Model {
   static table = 'users';
-  static primaryKey = 'id';           // Par défaut: 'id'
-  static timestamps = true;           // Par défaut: true
+  static primaryKey = 'id';           // Default: 'id'
+  static timestamps = true;           // Default: true
   static fillable = ['name', 'email', 'password'];
   static hidden = ['password'];
   static casts = {
@@ -366,19 +340,19 @@ class User extends Model {
 }
 ```
 
-### Opérations CRUD
+### CRUD operations
 
-#### Créer
+#### Create
 
 ```javascript
-// Méthode 1: create()
+// Method 1: create()
 const user = await User.create({
   name: 'John Doe',
   email: 'john@example.com',
   password: 'secret123'
 });
 
-// Méthode 2: new + save()
+// Method 2: new + save()
 const user = new User({
   name: 'Jane Doe',
   email: 'jane@example.com'
@@ -386,30 +360,30 @@ const user = new User({
 user.setAttribute('password', 'secret456');
 await user.save();
 
-// Insert brut (sans créer d'instance)
+// Raw insert (without creating an instance)
 await User.insert({ name: 'Bob', email: 'bob@example.com' });
 ```
 
-#### Lire
+#### Read
 
 ```javascript
-// Tous les enregistrements
+// All records
 const users = await User.all();
 
-// Par ID
+// By ID
 const user = await User.find(1);
-const user = await User.findOrFail(1); // Lance une erreur si non trouvé
+const user = await User.findOrFail(1); // Throws an error if not found
 
-// Premier résultat
+// First result
 const firstUser = await User.first();
 
-// Avec conditions
+// With conditions
 const activeUsers = await User
   .where('status', 'active')
   .where('age', '>', 18)
   .get();
 
-// Avec relations (Eager Loading)
+// With relationships (Eager Loading)
 const usersWithPosts = await User
   .with('posts', 'profile')
   .get();
@@ -421,7 +395,7 @@ const recentUsers = await User
   .get();
 ```
 
-#### Mettre à jour
+#### Update
 
 ```javascript
 // Instance
@@ -439,12 +413,12 @@ const updated = await User
   .where('id', 1)
   .updateAndFetch({ name: 'Neo' }, ['profile', 'posts']);
 
-// Helpers par ID
+// Helpers by ID
 const user = await User.updateAndFetchById(1, { name: 'Trinity' }, ['profile']);
 await User.updateById(2, { status: 'active' });
 ```
 
-#### Supprimer
+#### Delete
 
 ```javascript
 // Instance
@@ -494,37 +468,37 @@ const result = await User
   .select('users.*', 'profiles.bio', 'countries.name as country')
   .get();
 
-// Agrégations
+// Aggregations
 const stats = await User
   .distinct()
   .groupBy('status')
   .having('COUNT(*)', '>', 5)
   .get();
 
-// Incrément / Décrément atomique
+// Atomic increment / decrement
 await User.where('id', 1).increment('login_count');
 await User.where('id', 1).decrement('credits', 10);
 ```
 
-### Filtres relationnels
+### Relationship filters
 
 ```javascript
-// whereHas: Utilisateurs ayant au moins un post publié
+// whereHas: Users who have at least one published post
 const authors = await User
   .whereHas('posts', (q) => {
     q.where('status', 'published');
   })
   .get();
 
-// has: Au moins N enfants
+// has: At least N children
 const prolific = await User.has('posts', '>=', 10).get();
 
-// whereDoesntHave: Aucun enfant
+// whereDoesntHave: No children
 const noPostUsers = await User.whereDoesntHave('posts').get();
 
-// withCount: Ajouter une colonne {relation}_count
+// withCount: Add a {relation}_count column
 const withCounts = await User.withCount('posts').get();
-// Chaque user aura: user.getAttribute('posts_count')
+// Each user will have: user.getAttribute('posts_count')
 ```
 
 ## 🔗 Relations
@@ -609,15 +583,15 @@ class User extends Model {
 const user = await User.find(1);
 const roles = await user.roles().get();
 
-// Méthodes pivot
-await user.roles().attach([1, 2]);    // Attacher des rôles
-await user.roles().detach(2);          // Détacher un rôle
-await user.roles().sync([1, 3]);       // Synchroniser (remplace tout)
+// Pivot methods
+await user.roles().attach([1, 2]);    // Attach roles
+await user.roles().detach(2);          // Detach a role
+await user.roles().sync([1, 3]);       // Synchronise (replaces all)
 ```
 
 ### Has Many Through (hasManyThrough)
 
-Accéder à une relation distante via un modèle intermédiaire.
+Access a distant relationship via an intermediate model.
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -649,20 +623,20 @@ const user = await User.find(1);
 const country = await user.country().get();
 ```
 
-### Relations Polymorphiques
+### Polymorphic relationships
 
-Les relations polymorphiques permettent à un modèle d'appartenir à plusieurs autres modèles.
+Polymorphic relationships allow a model to belong to multiple other models.
 
 ```javascript
 const { Model } = require('outlet-orm');
 
-// Configuration du morph map
+// Set up the morph map
 Model.setMorphMap({
   'posts': Post,
   'videos': Video
 });
 
-// Modèles
+// Models
 class Post extends Model {
   comments() {
     return this.morphMany(Comment, 'commentable');
@@ -686,37 +660,37 @@ const post = await Post.find(1);
 const comments = await post.comments().get();
 
 const comment = await Comment.find(1);
-const parent = await comment.commentable().get(); // Post ou Video
+const parent = await comment.commentable().get(); // Post or Video
 ```
 
-**Relations polymorphiques disponibles:**
-- `morphOne(Related, 'morphName')` - One-to-One polymorphique
-- `morphMany(Related, 'morphName')` - One-to-Many polymorphique
-- `morphTo('morphName')` - Inverse polymorphique
+**Available polymorphic relationships:**
+- `morphOne(Related, 'morphName')` - One-to-One polymorphic
+- `morphMany(Related, 'morphName')` - One-to-Many polymorphic
+- `morphTo('morphName')` - Inverse polymorphic
 
 ### Eager Loading
 
 ```javascript
-// Charger plusieurs relations
+// Load multiple relationships
 const users = await User.with('posts', 'profile', 'roles').get();
 
-// Charger avec contraintes
+// Load with constraints
 const users = await User.with({
   posts: (q) => q.where('status', 'published').orderBy('created_at', 'desc')
 }).get();
 
-// Charger des relations imbriquées (dot notation)
+// Load nested relationships (dot notation)
 const users = await User.with('posts.comments.author').get();
 
-// Charger sur une instance existante
+// Load on an existing instance
 const user = await User.find(1);
 await user.load('posts', 'profile');
 await user.load(['roles', 'posts.comments']);
 
-// Accéder aux relations chargées
+// Access loaded relationships
 users.forEach(user => {
-  console.log(user.relations.posts);
-  console.log(user.relations.profile);
+  console.log(user.relationships.posts);
+  console.log(user.relationships.profile);
 });
 ```
 
@@ -724,7 +698,7 @@ users.forEach(user => {
 
 ### Casts
 
-Les casts convertissent automatiquement les attributs:
+Casts automatically convert attributes:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -736,13 +710,13 @@ class User extends Model {
     balance: 'float',       // ou 'double'
     email_verified: 'boolean', // ou 'bool'
     metadata: 'json',       // Parse JSON
-    settings: 'array',      // Parse JSON en array
-    birthday: 'date'        // Convertit en Date
+    settings: 'array',      // Parse JSON as array
+    birthday: 'date'        // Converts to Date
   };
 }
 ```
 
-### Attributs cachés
+### Hidden attributes
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -752,24 +726,24 @@ class User extends Model {
 }
 
 const user = await User.find(1);
-console.log(user.toJSON()); // password et secret_token exclus
+console.log(user.toJSON()); // password and secret_token excluded
 ```
 
-#### Afficher les attributs cachés
+#### Show hidden attributes
 
 ```javascript
-// Inclure les attributs cachés
+// Include hidden attributes
 const user = await User.withHidden().where('email', 'john@example.com').first();
-console.log(user.toJSON()); // password inclus
+console.log(user.toJSON()); // password included
 
-// Contrôler avec un booléen
-const user = await User.withoutHidden(true).first(); // true = afficher
-const user = await User.withoutHidden(false).first(); // false = masquer (défaut)
+// Control with a boolean
+const user = await User.withoutHidden(true).first(); // true = show
+const user = await User.withoutHidden(false).first(); // false = hide (default)
 
-// Cas d'usage: authentification
+// Use case: authentication
 const user = await User.withHidden().where('email', email).first();
 if (user && await bcrypt.compare(password, user.getAttribute('password'))) {
-  // Authentification réussie
+  // Authentication successful
 }
 ```
 
@@ -778,12 +752,12 @@ if (user && await bcrypt.compare(password, user.getAttribute('password'))) {
 ```javascript
 const { Model } = require('outlet-orm');
 
-// Activés par défaut (created_at, updated_at)
+// Enabled by default (created_at, updated_at)
 class User extends Model {
   static timestamps = true;
 }
 
-// Désactiver
+// Disable
 class Log extends Model {
   static timestamps = false;
 }
@@ -791,21 +765,21 @@ class Log extends Model {
 
 ## 🔄 Transactions
 
-Outlet ORM supporte les transactions pour garantir l'intégrité des données:
+Outlet ORM supports transactions to guarantee data integrity:
 
 ```javascript
 const { DatabaseConnection, Model } = require('outlet-orm');
 
-// Méthode 1: Callback automatique (recommandé)
+// Method 1: Automatic callback (recommended)
 const db = Model.connection;
 const result = await db.transaction(async (connection) => {
   const user = await User.create({ name: 'John', email: 'john@example.com' });
   await Account.create({ user_id: user.getAttribute('id'), balance: 0 });
   return user;
 });
-// Commit automatique, rollback si erreur
+// Automatic commit, rollback on error
 
-// Méthode 2: Contrôle manuel
+// Method 2: Manual control
 await db.beginTransaction();
 try {
   await User.create({ name: 'Jane' });
@@ -818,7 +792,7 @@ try {
 
 ## 🗑️ Soft Deletes
 
-Suppression logique avec colonne `deleted_at`:
+Soft deletion using a `deleted_at` column:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -826,31 +800,31 @@ const { Model } = require('outlet-orm');
 class Post extends Model {
   static table = 'posts';
   static softDeletes = true;
-  // static DELETED_AT = 'deleted_at'; // Personnalisable
+  // static DELETED_AT = 'deleted_at'; // Customisable
 }
 
-// Les requêtes excluent automatiquement les supprimés
-const posts = await Post.all(); // Seulement les non-supprimés
+// Queries automatically exclude soft-deleted records
+const posts = await Post.all(); // Only non-deleted records
 
-// Inclure les supprimés
+// Include deleted records
 const allPosts = await Post.withTrashed().get();
 
-// Seulement les supprimés
+// Only deleted records
 const trashedPosts = await Post.onlyTrashed().get();
 
-// Supprimer (soft delete)
+// Delete (soft delete)
 const post = await Post.find(1);
-await post.destroy(); // Met deleted_at à la date actuelle
+await post.destroy(); // Sets deleted_at to the current date
 
-// Vérifier si supprimé
+// Check if deleted
 if (post.trashed()) {
-  console.log('Ce post est supprimé');
+  console.log('This post is deleted');
 }
 
 // Restaurer
 await post.restore();
 
-// Supprimer définitivement
+// Delete permanently
 await post.forceDelete();
 ```
 
@@ -858,7 +832,7 @@ await post.forceDelete();
 
 ### Scopes Globaux
 
-Appliqués automatiquement à toutes les requêtes:
+Applied automatically to all queries:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -867,24 +841,24 @@ class Post extends Model {
   static table = 'posts';
 }
 
-// Ajouter un scope global
+// Add a global scope
 Post.addGlobalScope('published', (query) => {
   query.where('status', 'published');
 });
 
-// Toutes les requêtes filtrent automatiquement
-const posts = await Post.all(); // Seulement les publiés
+// All queries filter automatically
+const posts = await Post.all(); // Published only
 
-// Désactiver temporairement un scope
+// Temporarily disable a scope
 const allPosts = await Post.withoutGlobalScope('published').get();
 
-// Désactiver tous les scopes
+// Disable all scopes
 const rawPosts = await Post.withoutGlobalScopes().get();
 ```
 
 ## 📣 Events / Hooks
 
-Interceptez les opérations sur vos modèles:
+Intercept operations on your models:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -893,53 +867,53 @@ class User extends Model {
   static table = 'users';
 }
 
-// Avant création
+// Before creation
 User.creating((user) => {
   user.setAttribute('uuid', generateUUID());
-  // Retourner false pour annuler
+  // Return false to roll back
 });
 
-// Après création
+// After creation
 User.created((user) => {
-  console.log(`Utilisateur ${user.getAttribute('id')} créé`);
+  console.log(`User ${user.getAttribute('id')} created`);
 });
 
-// Avant mise à jour
+// Before update
 User.updating((user) => {
   user.setAttribute('updated_at', new Date());
 });
 
-// Après mise à jour
+// After update
 User.updated((user) => {
-  // Notifier les systèmes externes
+  // Notify external systems
 });
 
-// Événements saving/saved (création ET mise à jour)
+// saving/saved events (creation AND update)
 User.saving((user) => {
-  // Nettoyage des données
+  // Data cleanup
 });
 
 User.saved((user) => {
   // Cache invalidation
 });
 
-// Avant/après suppression
+// Before/after deletion
 User.deleting((user) => {
-  // Vérifications avant suppression
+  // Checks before deletion
 });
 
 User.deleted((user) => {
-  // Nettoyage des relations
+  // Clean up relationships
 });
 
-// Pour les soft deletes
+// For soft deletes
 User.restoring((user) => {});
 User.restored((user) => {});
 ```
 
 ## ✅ Validation
 
-Validation basique intégrée:
+Built-in basic validation:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -971,7 +945,7 @@ console.log(errors);
 //   age: ['age must not exceed 150']
 // }
 
-// Valider ou lancer une erreur
+// Validate or throw an error
 try {
   user.validateOrFail();
 } catch (error) {
@@ -979,24 +953,24 @@ try {
 }
 ```
 
-### Règles disponibles
+### Available rules
 
-| Règle | Description |
+| Rule | Description |
 |-------|-------------|
-| `required` | Champ obligatoire |
-| `string` | Doit être une chaîne |
-| `number` / `numeric` | Doit être un nombre |
-| `email` | Format email valide |
-| `boolean` | Doit être un booléen |
-| `date` | Date valide |
-| `min:N` | Minimum N (longueur ou valeur) |
-| `max:N` | Maximum N (longueur ou valeur) |
+| `required` | Required field |
+| `string` | Must be a string |
+| `number` / `numeric` | Must be a number |
+| `email` | Valid email format |
+| `boolean` | Must be a boolean |
+| `date` | Valid date |
+| `min:N` | Minimum N (longueur ou value) |
+| `max:N` | Maximum N (longueur ou value) |
 | `in:a,b,c` | Valeur parmi la liste |
 | `regex:pattern` | Match le pattern regex |
 
 ## 📊 Query Logging
 
-Mode debug pour analyser vos requêtes:
+Debug mode to analyse your queries:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -1005,11 +979,11 @@ const { Model } = require('outlet-orm');
 const db = Model.getConnection();
 db.enableQueryLog();
 
-// Exécuter des requêtes
+// Run queries
 await User.where('status', 'active').get();
 await Post.with('author').get();
 
-// Récupérer le log
+// Retrieve the log
 const queries = db.getQueryLog();
 console.log(queries);
 // [
@@ -1020,12 +994,12 @@ console.log(queries);
 // Vider le log
 db.flushQueryLog();
 
-// Désactiver le logging
+// Disable le logging
 db.disableQueryLog();
 
-// Vérifier si actif
+// Check if active
 if (db.isLogging()) {
-  console.log('Logging actif');
+  console.log('Logging active');
 }
 ```
 
@@ -1033,103 +1007,103 @@ if (db.isLogging()) {
 
 ### DatabaseConnection
 
-| Méthode | Description |
+| Method | Description |
 |---------|-------------|
-| `new DatabaseConnection(config?)` | Crée une connexion (lit `.env` si config omis) |
-| `connect()` | Établit la connexion (appelé automatiquement) |
-| `beginTransaction()` | Démarre une transaction |
-| `commit()` | Valide la transaction |
-| `rollback()` | Annule la transaction |
-| `transaction(callback)` | Exécute dans une transaction (auto commit/rollback) |
-| `select(table, query)` | Exécute un SELECT |
-| `insert(table, data)` | Insère un enregistrement |
-| `insertMany(table, data[])` | Insère plusieurs enregistrements |
-| `update(table, data, query)` | Met à jour des enregistrements |
-| `delete(table, query)` | Supprime des enregistrements |
-| `count(table, query)` | Compte les enregistrements |
-| `executeRawQuery(sql, params?)` | Requête brute (résultats normalisés) |
-| `execute(sql, params?)` | Requête brute (résultats natifs driver) |
-| `increment(table, column, query, amount?)` | Incrément atomique |
-| `decrement(table, column, query, amount?)` | Décrément atomique |
-| `close()` / `disconnect()` | Ferme la connexion |
+| `new DatabaseConnection(config?)` | Creates a connection (reads `.env` if config is omitted) |
+| `connect()` | Establishes the connection (called automatically) |
+| `beginTransaction()` | Starts a transaction |
+| `commit()` | Commits the transaction |
+| `rollback()` | Rolls back the transaction |
+| `transaction(callback)` | Runs in a transaction (auto commit/rollback) |
+| `select(table, query)` | Runs a SELECT |
+| `insert(table, data)` | Inserts a record |
+| `insertMany(table, data[])` | Inserts multiple records |
+| `update(table, data, query)` | Updates records |
+| `delete(table, query)` | Deletes records |
+| `count(table, query)` | Counts records |
+| `executeRawQuery(sql, params?)` | Raw query (normalised results) |
+| `execute(sql, params?)` | Raw query (native driver results) |
+| `increment(table, column, query, amount?)` | Atomic increment |
+| `decrement(table, column, query, amount?)` | Atomic decrement |
+| `close()` / `disconnect()` | Closes the connection |
 | **Query Logging (static)** | |
-| `enableQueryLog()` | Active le logging des requêtes |
-| `disableQueryLog()` | Désactive le logging |
-| `getQueryLog()` | Retourne le log des requêtes |
-| `flushQueryLog()` | Vide le log |
-| `isLogging()` | Vérifie si le logging est actif |
+| `enableQueryLog()` | Enables query logging |
+| `disableQueryLog()` | Disables logging |
+| `getQueryLog()` | Returns the query log |
+| `flushQueryLog()` | Clears the log |
+| `isLogging()` | Checks whether logging is active |
 
-### Model (méthodes statiques)
+### Model (static methods)
 
-| Méthode | Description |
+| Method | Description |
 |---------|-------------|
-| `setConnection(db)` | Définit la connexion par défaut |
-| `getConnection()` | Récupère la connexion (v3.0.0+) |
-| `setMorphMap(map)` | Définit le mapping polymorphique |
-| `query()` | Retourne un QueryBuilder |
-| `all()` | Tous les enregistrements |
-| `find(id)` | Trouve par ID |
-| `findOrFail(id)` | Trouve ou lance une erreur |
-| `first()` | Premier enregistrement |
+| `setConnection(db)` | Sets the default connection |
+| `getConnection()` | Gets the connection (v3.0.0+) |
+| `setMorphMap(map)` | Defines polymorphic mapping |
+| `query()` | Returns a QueryBuilder |
+| `all()` | All records |
+| `find(id)` | Finds by ID |
+| `findOrFail(id)` | Finds or throws an error |
+| `first()` | First record |
 | `where(col, op?, val)` | Clause WHERE |
 | `whereIn(col, vals)` | Clause WHERE IN |
 | `whereNull(col)` | Clause WHERE NULL |
 | `whereNotNull(col)` | Clause WHERE NOT NULL |
-| `create(attrs)` | Crée et sauvegarde |
-| `insert(data)` | Insert brut |
+| `create(attrs)` | Creates and saves |
+| `insert(data)` | Raw insert |
 | `update(attrs)` | Update bulk |
-| `updateById(id, attrs)` | Update par ID |
-| `updateAndFetchById(id, attrs, rels?)` | Update + fetch avec relations |
+| `updateById(id, attrs)` | Update by ID |
+| `updateAndFetchById(id, attrs, rels?)` | Update + fetch with relationships |
 | `delete()` | Delete bulk |
 | `with(...rels)` | Eager loading |
-| `withHidden()` | Inclut les attributs cachés |
-| `withoutHidden(show?)` | Contrôle visibilité |
-| `orderBy(col, dir?)` | Tri |
-| `limit(n)` / `offset(n)` | Limite/Offset |
+| `withHidden()` | Includes hidden attributes |
+| `withoutHidden(show?)` | Control attribute visibility |
+| `orderBy(col, dir?)` | Sort |
+| `limit(n)` / `offset(n)` | Limit/Offset |
 | `paginate(page, perPage)` | Pagination |
-| `count()` | Compte |
+| `count()` | Count |
 | **Soft Deletes** | |
-| `withTrashed()` | Inclut les supprimés |
-| `onlyTrashed()` | Seulement les supprimés |
+| `withTrashed()` | Includes soft-deleted records |
+| `onlyTrashed()` | Only soft-deleted records |
 | **Scopes** | |
-| `addGlobalScope(name, cb)` | Ajoute un scope global |
-| `removeGlobalScope(name)` | Supprime un scope |
-| `withoutGlobalScope(name)` | Requête sans un scope |
-| `withoutGlobalScopes()` | Requête sans tous les scopes |
+| `addGlobalScope(name, cb)` | Adds a global scope |
+| `removeGlobalScope(name)` | Removes a scope |
+| `withoutGlobalScope(name)` | Query without one scope |
+| `withoutGlobalScopes()` | Query without all scopes |
 | **Events** | |
-| `on(event, callback)` | Enregistre un listener |
-| `creating(cb)` / `created(cb)` | Events création |
-| `updating(cb)` / `updated(cb)` | Events mise à jour |
-| `saving(cb)` / `saved(cb)` | Events sauvegarde |
-| `deleting(cb)` / `deleted(cb)` | Events suppression |
-| `restoring(cb)` / `restored(cb)` | Events restauration |
+| `on(event, callback)` | Registers a listener |
+| `creating(cb)` / `created(cb)` | Creation events |
+| `updating(cb)` / `updated(cb)` | Update events |
+| `saving(cb)` / `saved(cb)` | Save events |
+| `deleting(cb)` / `deleted(cb)` | Delete events |
+| `restoring(cb)` / `restored(cb)` | Restore events |
 
-### Model (méthodes d'instance)
+### Model (instance methods)
 
-| Méthode | Description |
+| Method | Description |
 |---------|-------------|
-| `fill(attrs)` | Remplit les attributs |
-| `setAttribute(key, val)` | Définit un attribut |
-| `getAttribute(key)` | Récupère un attribut |
-| `save()` | Sauvegarde (insert ou update) |
-| `destroy()` | Supprime l'instance (soft si activé) |
-| `load(...rels)` | Charge des relations |
-| `getDirty()` | Attributs modifiés |
-| `isDirty()` | A été modifié? |
-| `toJSON()` | Convertit en objet |
+| `fill(attrs)` | Fills attributes |
+| `setAttribute(key, val)` | Sets an attribute |
+| `getAttribute(key)` | Gets an attribute |
+| `save()` | Save (insert or update) |
+| `destroy()` | Delete the instance (soft if enabled) |
+| `load(...rels)` | Load relationships |
+| `getDirty()` | Modified attributes |
+| `isDirty()` | Has been modified? |
+| `toJSON()` | Convert to plain object |
 | **Soft Deletes** | |
-| `trashed()` | Est supprimé? |
-| `restore()` | Restaure le modèle |
-| `forceDelete()` | Suppression définitive |
+| `trashed()` | Is deleted? |
+| `restore()` | Restore the model |
+| `forceDelete()` | Permanent deletion |
 | **Validation** | |
-| `validate()` | Valide selon les règles |
-| `validateOrFail()` | Valide ou lance erreur |
+| `validate()` | Validate against rules |
+| `validateOrFail()` | Validate or throw error |
 
 ### QueryBuilder
 
-| Méthode | Description |
+| Method | Description |
 |---------|-------------|
-| `select(...cols)` / `columns([...])` | Sélection de colonnes |
+| `select(...cols)` / `columns([...])` | Column selection |
 | `distinct()` | SELECT DISTINCT |
 | `where(col, op?, val)` | Clause WHERE |
 | `whereIn(col, vals)` | WHERE IN |
@@ -1139,70 +1113,70 @@ if (db.isLogging()) {
 | `orWhere(col, op?, val)` | OR WHERE |
 | `whereBetween(col, [min, max])` | WHERE BETWEEN |
 | `whereLike(col, pattern)` | WHERE LIKE |
-| `whereHas(rel, cb?)` | Filtre par relation |
-| `has(rel, op?, count)` | Existence relationnelle |
-| `whereDoesntHave(rel)` | Absence de relation |
-| `orderBy(col, dir?)` / `ordrer(...)` | Tri |
-| `limit(n)` / `take(n)` | Limite |
+| `whereHas(rel, cb?)` | Filter by existence of relation |
+| `has(rel, op?, count)` | Relational existence |
+| `whereDoesntHave(rel)` | Absence of relation |
+| `orderBy(col, dir?)` / `ordrer(...)` | Sort |
+| `limit(n)` / `take(n)` | Limit |
 | `offset(n)` / `skip(n)` | Offset |
 | `groupBy(...cols)` | GROUP BY |
 | `having(col, op, val)` | HAVING |
 | `join(table, first, op?, second)` | INNER JOIN |
 | `leftJoin(table, first, op?, second)` | LEFT JOIN |
 | `with(...rels)` | Eager loading |
-| `withCount(rels)` | Ajoute {rel}_count |
-| `withTrashed()` | Inclut les supprimés |
-| `onlyTrashed()` | Seulement les supprimés |
-| `withoutGlobalScope(name)` | Sans un scope global |
-| `withoutGlobalScopes()` | Sans tous les scopes |
-| `get()` | Exécute et retourne tous |
-| `first()` | Premier résultat |
+| `withCount(rels)` | Adds `{rel}_count` |
+| `withTrashed()` | Includes soft-deleted records |
+| `onlyTrashed()` | Only soft-deleted records |
+| `withoutGlobalScope(name)` | Without one global scope |
+| `withoutGlobalScopes()` | Without all global scopes |
+| `get()` | Runs and returns all |
+| `first()` | First result |
 | `firstOrFail()` | Premier ou erreur |
 | `paginate(page, perPage)` | Pagination |
 | `count()` | Compte |
-| `exists()` | Vérifie l'existence |
+| `exists()` | Checks existence |
 | `insert(data)` | Insert |
 | `update(attrs)` | Update |
 | `updateAndFetch(attrs, rels?)` | Update + fetch |
 | `delete()` | Delete |
-| `increment(col, amount?)` | Incrément atomique |
-| `decrement(col, amount?)` | Décrément atomique |
-| `clone()` | Clone le query builder |
+| `increment(col, amount?)` | Atomic increment |
+| `decrement(col, amount?)` | Atomic decrement |
+| `clone()` | Clones the query builder |
 
-## 🛠️ Outils CLI
+## 🛠️ CLI tools
 
 ### outlet-init
 
-Initialise un nouveau projet avec configuration de base de données.
+Initialises a new project with database configuration.
 
 ```bash
 outlet-init
 ```
 
-Génère:
-- Fichier de configuration `database/config.js`
-- Fichier `.env` avec les paramètres
-- Modèle exemple
-- Fichier d'utilisation
+Generates:
+- Configuration file `database/config.js`
+- `.env` file with settings
+- Example model
+- Usage file
 
 ### outlet-migrate
 
-Système complet de migrations.
+complete migration system.
 
 ```bash
-# Créer une migration
+# Create a migration
 outlet-migrate make create_users_table
 
-# Exécuter les migrations
+# Run migrations
 outlet-migrate migrate
 
-# Voir le statut
+# See migration status
 outlet-migrate status
 
-# Annuler la dernière migration
+# Roll back the latest migration
 outlet-migrate rollback --steps 1
 
-# Reset toutes les migrations
+# Reset all migrations
 outlet-migrate reset --yes
 
 # Refresh (reset + migrate)
@@ -1212,52 +1186,52 @@ outlet-migrate refresh --yes
 outlet-migrate fresh --yes
 ```
 
-**Fonctionnalités des Migrations:**
+**Migration Features:**
 
-- ✅ Création et gestion des migrations (create, alter, drop tables)
-- ✅ Types de colonnes: id, string, text, integer, boolean, date, datetime, timestamp, decimal, float, json, enum, uuid, foreignId
-- ✅ Modificateurs: nullable, default, unique, index, unsigned, autoIncrement, comment, after, first
-- ✅ Clés étrangères: foreign(), constrained(), onDelete(), onUpdate(), CASCADE
+- ✅ Creation and management of migrations (create, alter, drop tables)
+- ✅ Column types: id, string, text, integer, boolean, date, datetime, timestamp, decimal, float, json, enum, uuid, foreignId
+- ✅ Modifiers: nullable, default, unique, index, unsigned, autoIncrement, comment, after, first
+- ✅ Foreign keys: foreign(), constrained(), onDelete(), onUpdate(), CASCADE
 - ✅ Index: index(), unique(), fullText()
 - ✅ Manipulation: renameColumn(), dropColumn(), dropTimestamps()
-- ✅ Migrations réversibles: Méthodes up() et down()
-- ✅ Batch tracking: Rollback précis par batch
-- ✅ SQL personnalisé: execute() pour commandes avancées
+- ✅ Reversible migrations: up() and down() methods
+- ✅ Batch tracking: Precise rollback by batch
+- ✅ Custom SQL: execute() for advanced commands
 
 ### outlet-convert
 
-Convertit des schémas SQL en modèles ORM.
+Converts SQL schemas into ORM models.
 
 ```bash
 outlet-convert
 ```
 
 **Options:**
-1. Depuis un fichier SQL local
-2. Depuis une base de données connectée
+1. From a local SQL file
+2. From a connected database
 
-**Fonctionnalités:**
-- ✅ Détection automatique des types et casts
-- ✅ Génération automatique de TOUTES les relations (belongsTo, hasMany, hasOne, belongsToMany)
-- ✅ Relations récursives (auto-relations)
-- ✅ Détection des champs sensibles (password, token, etc.)
-- ✅ Support des timestamps automatiques
-- ✅ Conversion des noms en PascalCase
+**Features:**
+- ✅ Automatic type and cast detection
+- ✅ Automatic generation of ALL relationships (belongsTo, hasMany, hasOne, belongsToMany)
+- ✅ Recursive relationships (auto-relationships)
+- ✅ Detection of sensitive fields (password, token, etc.)
+- ✅ Automatic timestamps support
+- ✅ Class names converted to PascalCase
 
 ## 📚 Documentation
 
-- [Guide des Migrations](docs/MIGRATIONS.md)
-- [Conversion SQL](docs/SQL_CONVERSION.md)
-- [Détection des Relations](docs/RELATIONS_DETECTION.md)
-- [Guide de démarrage rapide](docs/QUICKSTART.md)
+- [Migrations Guide](docs/MIGRATIONS.md)
+- [SQL Conversion](docs/SQL_CONVERSION.md)
+- [Relation Detection](docs/RELATIONS_DETECTION.md)
+- [Quick Start Guide](docs/QUICKSTART.md)
 - [Architecture](docs/ARCHITECTURE.md)
 - [**TypeScript (complet)**](docs/TYPESCRIPT.md)
 
 ## 📘 TypeScript Support
 
-Outlet ORM v4.0.0 inclut des définitions TypeScript complètes avec support des **generics pour les attributs typés**.
+Outlet ORM v4.0.0 includes complete TypeScript definitions with support for **generics for typed model attributes**.
 
-### Modèles typés
+### Typed models
 
 ```typescript
 import { Model, HasManyRelation } from 'outlet-orm';
@@ -1281,11 +1255,11 @@ class User extends Model<UserAttributes> {
 
 // Type-safe getAttribute/setAttribute
 const user = await User.find(1);
-const name: string = user.getAttribute('name');     // ✅ Type inféré
+const name: string = user.getAttribute('name');     // ✅ Inferred type
 const role: 'admin' | 'user' = user.getAttribute('role');
 ```
 
-### Migrations typées
+### Migrations typedes
 
 ```typescript
 import { MigrationInterface, Schema, TableBuilder } from 'outlet-orm';
@@ -1310,16 +1284,16 @@ export const migration: MigrationInterface = {
 
 📖 [Guide TypeScript complet](docs/TYPESCRIPT.md)
 
-## 🤝 Contribution
+## 🤝 Contributions
 
-Les contributions sont les bienvenues! N'hésitez pas à ouvrir une issue ou un pull request.
+Contributions are welcome! Feel free to open an issue or pull request.
 
-Voir [CONTRIBUTING.md](CONTRIBUTING.md) pour les guidelines.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
 
 ## 📄 Licence
 
-MIT - Voir [LICENSE](LICENSE) pour plus de détails.
+MIT - See [LICENSE](LICENSE) for details.
 
 ---
 
-Créé par [omgbwa-yasse](https://github.com/omgbwa-yasse)
+Created by [omgbwa-yasse](https://github.com/omgbwa-yasse)