outlet-orm 5.5.1 → 5.5.2

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.
+Un ORM JavaScript inspired de Laravel Eloquent pour Node.js avec support pour MySQL, PostgreSQL et SQLite.
 
-📚 **[Documentation complète disponible dans `/docs`](./docs/INDEX.md)**
+📚 **[Documentation complete available dans `/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,61 @@ 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 utilise des peerDependencies optionnelles pour les drivers de database. Installez uniquement le driver dont vous avez besoin:
 
 - 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
+## 📁 Structure de Projet recommended
 
-Organisez votre projet utilisant Outlet ORM avec une **architecture en couches** (recommandée pour la production) :
+Organisez votre projet utilisant Outlet ORM avec une **architecture en couches** (recommended pour la production) :
 
-> 🔐 **Sécurité** : Voir le [Guide de Sécurité](./docs/SECURITY.md) pour les bonnes pratiques.
+> 🔐 **Sécurité** : See the [Security Guide](./docs/SECURITY.md) pour les bonnes pratiques.
 
 ```
 mon-projet/
-├── .env                          # ⚠️ JAMAIS commité (dans .gitignore)
-├── .env.example                  # Template sans secrets
+├── .env                          # ⚠️ JAMAIS committed (dans .gitignore)
+├── .env.example                  # Template without secrets
 ├── .gitignore
 ├── package.json
 │
 ├── src/                          # 📦 Code source centralisé
-│   ├── index.js                  # Point d'entrée de l'application
+│   ├── index.js                  # Entry point de l'application
 │   │
 │   ├── config/                   # ⚙️ Configuration
-│   │   ├── app.js                # Config générale (port, env)
+│   │   ├── app.js                # General config (port, env)
 │   │   ├── database.js           # Config DB (lit .env)
 │   │   └── security.js           # CORS, helmet, rate limit
 │   │
-│   ├── models/                   # 📊 Couche Data (Entities)
+│   ├── models/                   # 📊 Data Layer (Entities)
 │   │   ├── index.js              # Export centralisé des models
 │   │   ├── 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
+│   ├── repositories/             # 🗄️ Data Access Layer
+│   │   ├── BaseRepository.js     # Generic CRUD methods
+│   │   ├── UserRepository.js     # Specific queries User
 │   │   └── PostRepository.js
 │   │
-│   ├── services/                 # 💼 Couche Métier (Business Logic)
+│   ├── services/                 # 💼 Business Layer (Business Logic)
 │   │   ├── AuthService.js        # Logique d'authentification
-│   │   ├── UserService.js        # Logique métier utilisateur
+│   │   ├── UserService.js        # User business logic
 │   │   ├── PostService.js
 │   │   └── EmailService.js       # Service externe (emails)
 │   │
-│   ├── controllers/              # 🎮 Couche Présentation (HTTP)
+│   ├── controllers/              # 🎮 Presentation Layer (HTTP)
 │   │   ├── 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,9 +82,9 @@ mon-projet/
 │   │   ├── authorize.js          # RBAC / permissions
 │   │   ├── rateLimiter.js        # Protection DDoS
 │   │   ├── validator.js          # Validation request body
-│   │   └── errorHandler.js       # Gestion centralisée erreurs
+│   │   └── errorHandler.js       # Gestion centralisede erreurs
 │   │
-│   ├── validators/               # ✅ Schémas de validation
+│   ├── validators/               # ✅ Validation schemas
 │   │   ├── authValidator.js
 │   │   └── userValidator.js
 │   │
@@ -92,34 +92,34 @@ mon-projet/
 │       ├── 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/                         # 📋 Journaux (not versioned)
 │
 └── tests/                        # 🧪 Tests
     ├── unit/                     # Tests unitaires
     │   ├── services/
     │   └── models/
-    ├── integration/              # Tests d'intégration
+    ├── integration/              # Integration tests
     │   └── api/
-    └── fixtures/                 # Données de test
+    └── fixtures/                 # Test data
         └── users.json
 ```
 
-### 🏗️ Architecture en Couches
+### 🏗️ Layered Architecture
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
@@ -133,20 +133,20 @@ mon-projet/
                               │
                               ▼
 ┌─────────────────────────────────────────────────────────────┐
-│  ROUTES → CONTROLLERS (Couche Présentation)                 │
-│  Reçoit la requête, appelle le service, retourne réponse   │
+│  ROUTES → CONTROLLERS (Presentation Layer)                 │
+│  Receives the request, calls the service, returns a response   │
 └─────────────────────────────────────────────────────────────┘
                               │
                               ▼
 ┌─────────────────────────────────────────────────────────────┐
-│  SERVICES (Couche Métier / Business Logic)                  │
-│  Logique métier, orchestration, règles business            │
+│  SERVICES (Business Layer / Business Logic)                  │
+│  Logique métier, orchestration, rules business            │
 └─────────────────────────────────────────────────────────────┘
                               │
                               ▼
 ┌─────────────────────────────────────────────────────────────┐
-│  REPOSITORIES (Couche Accès Données)                        │
-│  Abstraction des requêtes DB, utilise les Models           │
+│  REPOSITORIES (Data Access Layer)                        │
+│  Abstraction des queries DB, utilise les Models           │
 └─────────────────────────────────────────────────────────────┘
                               │
                               ▼
@@ -155,23 +155,23 @@ mon-projet/
 └─────────────────────────────────────────────────────────────┘
 ```
 
-### 📋 Rôle de chaque couche
+### 📋 Role of each layer
 
-| Couche | Dossier | Responsabilité | Dépend de |
+| Layer | Folder | Responsibility | Depends on |
 |--------|---------|----------------|-----------|
-| **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 |
+| **Présentation** | `controllers/` | Handle HTTP, validate entrées, format responses | Services |
+| **Métier** | `services/` | Logique business, orchestration, rules | Repositories |
+| **Data** | `repositories/` | Complex DB queries, abstraction | Models |
+| **Entities** | `models/` | Entity definitions, relationships, validations | Outlet ORM |
 
-### ✅ 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.
+- **Testability** : Each layer can be tested independently
+- **Maintainability** : Clear separation of responsibilities
+- **Scalability** : Easy to add new features
+- **Reusability** : Services reusable from CLI, workers, etc.
 
-### 📝 Exemple de flux
+### 📝 Example workflow
 
 ```javascript
 // routes/user.routes.js
@@ -196,71 +196,71 @@ async findWithPosts(id) {
 }
 ```
 
-## ✨ Fonctionnalités clés
+## ✨ Key features
 
-- **API inspirée d'Eloquent** (Active Record) pour un usage fluide
+- **API inspirede 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**:
+- **Relationship filters Laravel-style**: `whereHas()`, `has()`, `whereDoesntHave()`, `withCount()`
+- **Eager Loading** des relationships via `.with(...)` avec constraints et dot-notation
+- **Relations completes**:
   - `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
+  - `hasManyThrough`, `hasOneThrough` (relationships transitives)
+  - `morphOne`, `morphMany`, `morphTo` (relationships polymorphiques)
+- **Transactions** completes: `beginTransaction()`, `commit()`, `rollback()`, `transaction()`
+- **Soft Deletes**: soft deletion avec `deleted_at`, `withTrashed()`, `onlyTrashed()`, `restore()`
+- **Scopes**: global and local to reuse your filters
 - **Events/Hooks**: `creating`, `created`, `updating`, `updated`, `deleting`, `deleted`, etc.
-- **Validation**: règles basiques intégrées (`required`, `email`, `min`, `max`, etc.)
+- **Validation**: rules built-in basic (`required`, `email`, `min`, `max`, etc.)
 - **Query Logging**: mode debug avec `enableQueryLog()` et `getQueryLog()`
-- **Pool PostgreSQL**: connexions poolées pour de meilleures performances
+- **Pool PostgreSQL**: pooled connections pour better performance
 - **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()`
+- **Hidden attributes** (`hidden`) et timestamps automatiques
+- **Visibility control** des attributs cachés: `withHidden()` et `withoutHidden()`
+- **Atomic increment/decrement**: `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)
+- **Raw queries**: `executeRawQuery()` et `execute()` (native driver results)
+- **Migrations completes** (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+)
+- **Configuration via `.env`** (loaded automatically)
+- **Multi-database**: MySQL, PostgreSQL et SQLite
+- **Complete TypeScript types** avec Generic Model et Schema Builder typed (v4.0.0+)
 
-## ⚡ Démarrage Rapide
+## ⚡ Quick Start
 
 ### Initialisation du projet
 
 ```bash
-# Créer la configuration initiale
+# Create la configuration initiale
 outlet-init
 
-# Créer une migration
+# Create une migration
 outlet-migrate make create_users_table
 
-# Exécuter les migrations
+# Run les migrations
 outlet-migrate migrate
 ```
 
 ### 🌱 Seeding rapide
 
 ```bash
-# Créer un seeder
+# Create un seeder
 outlet-migrate make:seed UserSeeder
 
-# Exécuter les seeds (DatabaseSeeder prioritaire)
+# Run les seeds (DatabaseSeeder prioritaire)
 outlet-migrate seed
 
-# Exécuter un seeder spécifique
+# Run un 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 charge automatiquement la connection depuis le file `.env`. **Plus besoin d'importer DatabaseConnection !**
 
-#### Fichier `.env`
+#### `.env` file
 
 ```env
 DB_DRIVER=mysql
@@ -271,7 +271,7 @@ DB_PASSWORD=secret
 DB_PORT=3306
 ```
 
-#### Utilisation simplifiée
+#### Simplified usage
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -280,18 +280,18 @@ class User extends Model {
   static table = 'users';
 }
 
-// C'est tout ! La connexion est automatique
+// C'est tout ! La connection est automatique
 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
@@ -304,48 +304,48 @@ const db = new DatabaseConnection({
   port: 3306
 });
 
-// Définir la connexion manuellement (optionnel)
+// Définir la connection manuellement (optionnel)
 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_PORT` | Port de connection | 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_FILE` / `SQLITE_DB` | SQLite file | `:memory:` |
 
 ### Importation
 
 ```javascript
-// CommonJS - Import simple (connexion automatique via .env)
+// CommonJS - Import simple (connection automatique via .env)
 const { Model } = require('outlet-orm');
 
 // ES Modules
 import { Model } from 'outlet-orm';
 
-// Si besoin de contrôle manuel sur la connexion
+// Si besoin de Manual control sur la 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 +366,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,7 +386,7 @@ const user = new User({
 user.setAttribute('password', 'secret456');
 await user.save();
 
-// Insert brut (sans créer d'instance)
+// Insert brut (sans create d'instance)
 await User.insert({ name: 'Bob', email: 'bob@example.com' });
 ```
 
@@ -398,9 +398,9 @@ const users = await User.all();
 
 // Par 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
@@ -409,7 +409,7 @@ const activeUsers = await User
   .where('age', '>', 18)
   .get();
 
-// Avec relations (Eager Loading)
+// Avec relationships (Eager Loading)
 const usersWithPosts = await User
   .with('posts', 'profile')
   .get();
@@ -421,7 +421,7 @@ const recentUsers = await User
   .get();
 ```
 
-#### Mettre à jour
+#### Update
 
 ```javascript
 // Instance
@@ -444,7 +444,7 @@ const user = await User.updateAndFetchById(1, { name: 'Trinity' }, ['profile']);
 await User.updateById(2, { status: 'active' });
 ```
 
-#### Supprimer
+#### Delete
 
 ```javascript
 // Instance
@@ -494,7 +494,7 @@ const result = await User
   .select('users.*', 'profiles.bio', 'countries.name as country')
   .get();
 
-// Agrégations
+// Aggregations
 const stats = await User
   .distinct()
   .groupBy('status')
@@ -506,7 +506,7 @@ 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é
@@ -519,7 +519,7 @@ const authors = await User
 // has: Au moins N enfants
 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
@@ -610,14 +610,14 @@ 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().attach([1, 2]);    // Attach roles
+await user.roles().detach(2);          // Detach a role
 await user.roles().sync([1, 3]);       // Synchroniser (remplace tout)
 ```
 
 ### 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,9 +649,9 @@ 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');
@@ -662,7 +662,7 @@ Model.setMorphMap({
   'videos': Video
 });
 
-// Modèles
+// Models
 class Post extends Model {
   comments() {
     return this.morphMany(Comment, 'commentable');
@@ -689,7 +689,7 @@ const comment = await Comment.find(1);
 const parent = await comment.commentable().get(); // Post ou Video
 ```
 
-**Relations polymorphiques disponibles:**
+**Relations polymorphiques availables:**
 - `morphOne(Related, 'morphName')` - One-to-One polymorphique
 - `morphMany(Related, 'morphName')` - One-to-Many polymorphique
 - `morphTo('morphName')` - Inverse polymorphique
@@ -697,15 +697,15 @@ const parent = await comment.commentable().get(); // Post ou Video
 ### Eager Loading
 
 ```javascript
-// Charger plusieurs relations
+// Charger plusieurs relationships
 const users = await User.with('posts', 'profile', 'roles').get();
 
-// Charger avec contraintes
+// Charger avec 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
@@ -713,10 +713,10 @@ 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);
 });
 ```
 
@@ -742,7 +742,7 @@ class User extends Model {
 }
 ```
 
-### Attributs cachés
+### Hidden attributes
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -755,21 +755,21 @@ const user = await User.find(1);
 console.log(user.toJSON()); // password et secret_token exclus
 ```
 
-#### 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
 
-// Contrôler avec un booléen
+// Control with a boolean
 const user = await User.withoutHidden(true).first(); // true = afficher
-const user = await User.withoutHidden(false).first(); // false = masquer (défaut)
+const user = await User.withoutHidden(false).first(); // false = hide (default)
 
 // Cas d'usage: authentification
 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 +778,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)
+// Activés Default (created_at, updated_at)
 class User extends Model {
   static timestamps = true;
 }
 
-// Désactiver
+// Disable
 class Log extends Model {
   static timestamps = false;
 }
@@ -791,21 +791,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' });
@@ -829,28 +829,28 @@ class Post extends Model {
   // static DELETED_AT = 'deleted_at'; // Personnalisable
 }
 
-// Les requêtes excluent automatiquement les supprimés
-const posts = await Post.all(); // Seulement les non-supprimés
+// Les queries excluent automatiquement les deleteds
+const posts = await Post.all(); // Seulement les non-deleteds
 
-// Inclure les supprimés
+// Inclure les deleteds
 const allPosts = await Post.withTrashed().get();
 
-// Seulement les supprimés
+// Seulement les deleteds
 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 +858,7 @@ await post.forceDelete();
 
 ### Scopes Globaux
 
-Appliqués automatiquement à toutes les requêtes:
+Applied automatically to all queries:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -872,19 +872,19 @@ Post.addGlobalScope('published', (query) => {
   query.where('status', 'published');
 });
 
-// Toutes les requêtes filtrent automatiquement
-const posts = await Post.all(); // Seulement les publiés
+// Toutes les queries filtrent automatiquement
+const posts = await Post.all(); // Published only
 
-// Désactiver temporairement un scope
+// Disable temporairement un scope
 const allPosts = await Post.withoutGlobalScope('published').get();
 
-// Désactiver tous les scopes
+// Disable tous les 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,30 +893,30 @@ class User extends Model {
   static table = 'users';
 }
 
-// Avant création
+// Before creation
 User.creating((user) => {
   user.setAttribute('uuid', generateUUID());
-  // Retourner false pour annuler
+  // Retourner false pour rollback
 });
 
-// Après création
+// After creation
 User.created((user) => {
   console.log(`Utilisateur ${user.getAttribute('id')} créé`);
 });
 
-// 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
 });
 
-// Événements saving/saved (création ET mise à jour)
+// saving/saved events (creation AND update)
 User.saving((user) => {
-  // Nettoyage des données
+  // Nettoyage des data
 });
 
 User.saved((user) => {
@@ -925,11 +925,11 @@ User.saved((user) => {
 
 // Avant/après suppression
 User.deleting((user) => {
-  // Vérifications avant suppression
+  // Checks before deletion
 });
 
 User.deleted((user) => {
-  // Nettoyage des relations
+  // Nettoyage des relationships
 });
 
 // Pour les soft deletes
@@ -939,7 +939,7 @@ User.restored((user) => {});
 
 ## ✅ Validation
 
-Validation basique intégrée:
+Built-in basic validation:
 
 ```javascript
 const { Model } = require('outlet-orm');
@@ -979,24 +979,24 @@ try {
 }
 ```
 
-### Règles disponibles
+### Available rules
 
 | Règle | Description |
 |-------|-------------|
 | `required` | Champ obligatoire |
-| `string` | Doit être une chaîne |
-| `number` / `numeric` | Doit être un nombre |
+| `string` | Must be a string |
+| `number` / `numeric` | Must be a number |
 | `email` | Format email valide |
-| `boolean` | Doit être un booléen |
+| `boolean` | Must be a boolean |
 | `date` | Date valide |
-| `min:N` | Minimum N (longueur ou valeur) |
-| `max:N` | Maximum N (longueur ou valeur) |
+| `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 +1005,11 @@ const { Model } = require('outlet-orm');
 const db = Model.getConnection();
 db.enableQueryLog();
 
-// Exécuter des requêtes
+// Run des 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,10 +1020,10 @@ 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');
 }
@@ -1033,39 +1033,39 @@ 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 |
+| `new DatabaseConnection(config?)` | Creates a connection (lit `.env` si config omis) |
+| `connect()` | Establishes the connection (appelé automatiquement) |
+| `beginTransaction()` | Starts a 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 |
+| `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)` | 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 |
+| `close()` / `disconnect()` | Ferme la connection |
 | **Query Logging (static)** | |
-| `enableQueryLog()` | Active le logging des requêtes |
+| `enableQueryLog()` | Active le logging des queries |
 | `disableQueryLog()` | Désactive le logging |
-| `getQueryLog()` | Retourne le log des requêtes |
+| `getQueryLog()` | Returns the query log |
 | `flushQueryLog()` | Vide le log |
-| `isLogging()` | Vérifie si le logging est actif |
+| `isLogging()` | Checks whether logging is active |
 
-### Model (méthodes statiques)
+### Model (methods statiques)
 
-| 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 |
+| `setConnection(db)` | Définit la connection Default |
+| `getConnection()` | Gets the connection (v3.0.0+) |
+| `setMorphMap(map)` | Defines polymorphic mapping |
 | `query()` | Retourne un QueryBuilder |
 | `all()` | Tous les enregistrements |
 | `find(id)` | Trouve par ID |
@@ -1075,61 +1075,61 @@ if (db.isLogging()) {
 | `whereIn(col, vals)` | Clause WHERE IN |
 | `whereNull(col)` | Clause WHERE NULL |
 | `whereNotNull(col)` | Clause WHERE NOT NULL |
-| `create(attrs)` | Crée et sauvegarde |
+| `create(attrs)` | Creates and saves |
 | `insert(data)` | Insert brut |
 | `update(attrs)` | Update bulk |
 | `updateById(id, attrs)` | Update par ID |
-| `updateAndFetchById(id, attrs, rels?)` | Update + fetch avec relations |
+| `updateAndFetchById(id, attrs, rels?)` | Update + fetch avec relationships |
 | `delete()` | Delete bulk |
 | `with(...rels)` | Eager loading |
-| `withHidden()` | Inclut les attributs cachés |
+| `withHidden()` | Includes hidden attributes |
 | `withoutHidden(show?)` | Contrôle visibilité |
 | `orderBy(col, dir?)` | Tri |
 | `limit(n)` / `offset(n)` | Limite/Offset |
 | `paginate(page, perPage)` | Pagination |
 | `count()` | Compte |
 | **Soft Deletes** | |
-| `withTrashed()` | Inclut les supprimés |
-| `onlyTrashed()` | Seulement les supprimés |
+| `withTrashed()` | Inclut les deleteds |
+| `onlyTrashed()` | Seulement les deleteds |
 | **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 |
+| `creating(cb)` / `created(cb)` | Creation events |
+| `updating(cb)` / `updated(cb)` | Update events |
 | `saving(cb)` / `saved(cb)` | Events sauvegarde |
 | `deleting(cb)` / `deleted(cb)` | Events suppression |
 | `restoring(cb)` / `restored(cb)` | Events restauration |
 
-### Model (méthodes d'instance)
+### Model (methods d'instance)
 
-| Méthode | Description |
+| Method | Description |
 |---------|-------------|
-| `fill(attrs)` | Remplit les attributs |
-| `setAttribute(key, val)` | Définit un attribut |
-| `getAttribute(key)` | Récupère un attribut |
+| `fill(attrs)` | Fills attributes |
+| `setAttribute(key, val)` | Sets an attribute |
+| `getAttribute(key)` | Gets an attribute |
 | `save()` | Sauvegarde (insert ou update) |
 | `destroy()` | Supprime l'instance (soft si activé) |
-| `load(...rels)` | Charge des relations |
+| `load(...rels)` | Charge des relationships |
 | `getDirty()` | Attributs modifiés |
-| `isDirty()` | A été modifié? |
+| `isDirty()` | Has been modified? |
 | `toJSON()` | Convertit en objet |
 | **Soft Deletes** | |
-| `trashed()` | Est supprimé? |
-| `restore()` | Restaure le modèle |
-| `forceDelete()` | Suppression définitive |
+| `trashed()` | Is deleted? |
+| `restore()` | Restore le model |
+| `forceDelete()` | Permanent deletion |
 | **Validation** | |
-| `validate()` | Valide selon les règles |
+| `validate()` | Valide selon les rules |
 | `validateOrFail()` | Valide ou lance erreur |
 
 ### 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 |
@@ -1151,16 +1151,16 @@ if (db.isLogging()) {
 | `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 |
+| `withTrashed()` | Inclut les deleteds |
+| `onlyTrashed()` | Seulement les deleteds |
 | `withoutGlobalScope(name)` | Sans un scope global |
 | `withoutGlobalScopes()` | Sans tous les scopes |
-| `get()` | Exécute et retourne tous |
-| `first()` | Premier résultat |
+| `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 |
@@ -1169,37 +1169,37 @@ if (db.isLogging()) {
 | `decrement(col, amount?)` | Décrément atomique |
 | `clone()` | Clone le query builder |
 
-## 🛠️ Outils CLI
+## 🛠️ CLI tools
 
 ### outlet-init
 
-Initialise un nouveau projet avec configuration de base de données.
+Initialise un nouveau projet avec configuration de database.
 
 ```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 une migration
 outlet-migrate make create_users_table
 
-# Exécuter les migrations
+# Run les migrations
 outlet-migrate migrate
 
-# Voir le statut
+# See le statut
 outlet-migrate status
 
-# Annuler la dernière migration
+# Roll back the latest migration
 outlet-migrate rollback --steps 1
 
 # Reset toutes les migrations
@@ -1212,35 +1212,35 @@ outlet-migrate refresh --yes
 outlet-migrate fresh --yes
 ```
 
-**Fonctionnalités des Migrations:**
+**Features des Migrations:**
 
-- ✅ Création et gestion des migrations (create, alter, drop tables)
+- ✅ Creation and management of 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
+- ✅ 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: Méthodes up() et down()
+- ✅ Batch tracking: Precise rollback by batch
+- ✅ Custom SQL: execute() pour 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
-
-**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.)
+1. Depuis un file SQL local
+2. From a connected database
+
+**Features:**
+- ✅ Detection automatique des types et casts
+- ✅ Automatic generation of ALL relationships (belongsTo, hasMany, hasOne, belongsToMany)
+- ✅ Recursive relationships (auto-relationships)
+- ✅ Detection des champs sensibles (password, token, etc.)
 - ✅ Support des timestamps automatiques
 - ✅ Conversion des noms en PascalCase
 
@@ -1248,16 +1248,16 @@ outlet-convert
 
 - [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)
+- [Detection des Relations](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 inclut des définitions TypeScript completes avec support des **generics pour les attributs typeds**.
 
-### Modèles typés
+### Typed models
 
 ```typescript
 import { Model, HasManyRelation } from 'outlet-orm';
@@ -1281,11 +1281,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 +1310,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "outlet-orm",
-  "version": "5.5.1",
+  "version": "5.5.2",
   "description": "A Laravel Eloquent-inspired ORM for Node.js with support for MySQL, PostgreSQL, and SQLite",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -21,6 +21,8 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
+    "check:version": "node scripts/check-changelog-version.js",
+    "prepublishOnly": "npm run check:version",
     "lint": "eslint \"{src,bin}/**/*.js\"",
     "lint:fix": "eslint \"{src,bin}/**/*.js\" --fix",
     "migrate": "node bin/migrate.js migrate",