@mlagie/sql-connector 1.4.7 → 1.4.8

package/README.md

@@ -1,31 +1,18 @@
-# sql-connector
-![GitHub package.json version](https://img.shields.io/github/package-json/v/lagie-marin/sql-connector?color=#008000) ![NPM Downloads](https://img.shields.io/npm/d18m/%40mlagie%2Fsql-connector?color=#008000) ![NPM Downloads](https://img.shields.io/npm/dw/%40mlagie%2Fsql-connector?color=#008000) ![GitHub followers](https://img.shields.io/github/followers/lagie-marin?style=plastic&color=color%3D%23008000) ![GitHub repo size](https://img.shields.io/github/repo-size/lagie-marin/sql-connector?color=%green)
- ![GitHub last commit](https://img.shields.io/github/last-commit/lagie-marin/sql-connector)
+# sql-connector documentation
 
-# Documentation du module `sql-connector`
+[Français](./docs/fr/README.md) | English
 
-Le module `sql-connector` permet de gérer les connexions à une base de données MySQL, de définir des schémas de tables, et d'interagir avec les données de manière simple et efficace.
+sql-connector helps manage MySQL connections, define table schemas, sync tables automatically, and work with database models through a small API.
 
-## Importation du module
+## Import
 
 ```javascript
-const { Schema, connect, logout, Model, client, sqlTypeMap } = require('sql-connector');
+const { Schema, connect, logout, Model, ModelInstance, client, sqlTypeMap } = require('sql-connector');
 ```
 
-### Fonctions
+## Database connection
 
-`connect(config)` Établit une connexion à la base de données.
-
-* Paramètres:
-    * `config` (Object) : La configuration de la connexion à la base de données.
-    * `host` (string) : L'hôte de la base de données.
-    * `port` (number) : Le port de la base de données.
-    * `user` (string) : Le nom d'utilisateur pour la connexion.
-    * `password` (string) : Le mot de passe pour la connexion.
-    * `database` (string) : Le nom de la base de données.
-    * `ect` pour en savoir plus vous pouvez vous rendre sur https://github.com/mysqljs/mysql dans la section `Connection options`
-
-* ### Exemple:
+`connect(config)` opens a MySQL connection using a configuration object compatible with mysql2.
 
 ```javascript
 const config = {
@@ -35,253 +22,137 @@ const config = {
   password: 'password',
   database: 'mydatabase'
 };
+
 await connect(config);
 ```
 
-`logout()` Ferme la connexion à la base de données.
-
-* ### Exemple:
+`logout()` closes the active connection.
 
 ```javascript
 await logout();
 ```
 
-### Interface `SchemaField`
-
-Décrit les propriétés d'un champ dans le schéma d'une table SQL. Chaque clé du dictionnaire passé au constructeur de `Schema` doit respecter cette interface.
+## Schema
 
-| Propriété        | Type                                 | Description                                                                 |
-|------------------|--------------------------------------|-----------------------------------------------------------------------------|
-| type             | `SqlType` ou `{ name: SqlType }`     | Type du champ (String, Number, Boolean, etc.)                               |
-| length           | `number`                             | Longueur maximale (pour VARCHAR ou INT)                                     |
-| required         | `boolean`                            | Si le champ est obligatoire (NOT NULL)                                      |
-| default          | `any`                                | Valeur par défaut                                                           |
-| unique           | `boolean`                            | Si le champ doit être unique                                                |
-| auto_increment   | `boolean`                            | Si le champ est auto-incrémenté                                             |
-| foreignKey       | `string`                             | Clé étrangère (ex: "otherTable(column)")                                   |
-| enum             | `string[]`                           | Liste de valeurs pour un champ ENUM                                         |
-| primary_key      | `boolean`                            | Si le champ est une clé primaire                                            |
-| customize        | `string`                             | Ajout d'options SQL personnalisées                                          |
+`Schema` describes the structure of a table. Each field can use the following properties.
 
-#### Exemple d'utilisation
+| Property | Type | Description |
+|---|---|---|
+| type | `SqlType` or `{ name: SqlType }` | SQL type for the field |
+| length | `number` | Maximum length |
+| required | `boolean` | Not null constraint |
+| default | `any` | Default value |
+| unique | `boolean` | Unique constraint |
+| auto_increment | `boolean` | Auto increment |
+| foreignKey | `string` | Foreign key reference |
+| enum | `string[]` | Allowed values |
+| primary_key | `boolean` | Primary key flag |
+| customize | `string` | Extra SQL options |
 
 ```javascript
 const userSchema = new Schema({
-    status: {
-        type: String,
-        enum: ["active", "inactive", "pending"], // champ ENUM
-        required: true,
-        default: "pending"
-    },
-    id: {
-        type: Number,
-        auto_increment: true,
-        primary_key: true
-    },
-    email: {
-        type: String,
-        length: 255,
-        unique: true,
-        required: true
-    }
+  id: {
+    type: Number,
+    auto_increment: true,
+    primary_key: true
+  },
+  email: {
+    type: String,
+    length: 255,
+    unique: true,
+    required: true
+  },
+  status: {
+    type: String,
+    enum: ['active', 'inactive', 'pending'],
+    default: 'pending'
+  }
 });
 ```
 
-### Classes `Schema`
+## Table synchronization
 
-Représente un schéma de base de données.
-* Constructeur:
-        * Schema(schemaDict) : Crée une instance de Schema.
-                * schemaDict (Object) : Un dictionnaire définissant le schéma.
+`Model.syncAllTables()` compares JS schemas with the database and applies only meaningful differences.
 
-* Exemple
+- New columns are added automatically.
+- Removed columns are only dropped with `dangerousSync: true`.
+- Column renames are supported through `oldName`.
+- Orphan tables are backed up to a `backup_*.sql` file before deletion.
 
 ```javascript
-const transferSchema = new Schema({
-    token: {
-        type: String,
-        length: 50
-    },
-    mdp: {
-        type: String,
-        length: 15
-    }
-});
+await Model.syncAllTables();
+await Model.syncAllTables({ dangerousSync: true });
 ```
 
-## Synchronisation automatique du schéma et gestion des migrations
-
-> **⚠️ Important : Synchronisation du schéma et sécurité**
->
-> Toutes les opérations de synchronisation avancée du schéma (modification de type, contraintes, renommage, suppression de colonnes, etc.) **ne sont effectuées que si vous activez explicitement l’option `{ dangerousSync: true }`** lors de l’appel à `Model.syncAllTables`.
->
-> Par défaut (`dangerousSync: false`), aucune modification de structure n’est appliquée sur les tables existantes pour garantir la sécurité de vos données en production.  
-> Utilisez `dangerousSync` uniquement dans un environnement de développement ou lors de migrations contrôlées.
-
-### Ajout, suppression et renommage de colonnes
-
-- **Ajout automatique de colonnes**  
-  Lorsque vous ajoutez un champ dans le schéma JS, la colonne correspondante est automatiquement ajoutée dans la base de données lors de la synchronisation avec :
-  ```js
-  await Model.syncAllTables();
-  ```
-
-- **Suppression automatique de colonnes**  
-  Si vous retirez un champ du schéma JS, la colonne reste dans la base par défaut.  
-  Pour supprimer automatiquement les colonnes disparues, utilisez :
-  ```js
-  await Model.syncAllTables({ dangerousSync: true });
-  ```
-  ⚠️ Attention, cela supprime les données de ces colonnes.
-
-- **Renommage de colonne sans perte de données**  
-  Pour renommer une colonne, ajoutez la propriété `oldName` dans le schéma :
-  ```js
-  const userSchema = new Schema({
-      role: { type: String, oldName: "rang" }
-  });
-  ```
-  Lors de la synchronisation, la colonne SQL sera renommée sans perte de données.  
-  Un avertissement s’affichera pour vous rappeler de retirer `oldName` du schéma après migration.
-
-### Suppression et sauvegarde des tables orphelines
-
-- Si une table SQL n’a plus de schéma JS associé, elle est supprimée automatiquement lors de la synchronisation.
-- **Avant suppression**, un fichier de backup SQL (INSERTs) est généré dans le dossier courant (ex : `backup_MaTable_1690000000000.sql`).
+Important: do not set both `primary_key: true` and `unique: true` on the same field. A primary key is already unique and not null.
 
-### Restauration et gestion des backups
+## Models
 
-- Si une table supprimée réapparaît dans le schéma, le module détecte la présence d’un backup et propose :
-  1. **De restaurer les données** (exécution du fichier SQL).
-  2. **De supprimer le backup** après restauration ou non.
-  3. Si vous refusez la suppression, le backup est renommé en `.ignored` et ne sera plus proposé.
+`Model` represents a SQL table.
 
-### Synchronisation intelligente des colonnes
+Main methods:
 
-Lors de la synchronisation (`Model.syncAllTables()`), le module compare chaque colonne existante avec la définition du schéma JS :
+- `save(data)` inserts a row
+- `findOne(filter, fields)` fetches a single row
+- `find(filter, fields)` fetches multiple rows
+- `findAll(options)` supports advanced queries
+- `count(filter)` counts rows
+- `customRequest(custom)` runs a custom SQL query
+- `delete(filter)` deletes a row
+- `dropTable()` drops the table
+- `generate_uuid()` generates a unique UUID
+- `Model.createAllTables()` creates tables in dependency order
 
-- **Type** : Si le type SQL attendu diffère de celui en base, la colonne est modifiée.
-- **Nullabilité** : Si la contrainte `NOT NULL` ou `NULL` diffère, la colonne est modifiée.  
-  > ⚠️ Une colonne `primary_key` est toujours considérée comme `NOT NULL` même si `required` n'est pas précisé.
-- **Valeur par défaut** : Si la valeur par défaut diffère, la colonne est modifiée.
-- **Unique** : Si la contrainte `UNIQUE` diffère, la colonne est modifiée.
-- **Primary key** : Si la contrainte `PRIMARY KEY` diffère, la colonne est modifiée.
-
-Seules les différences réelles entraînent une modification SQL, ce qui évite les migrations inutiles.
-
-> **Note :**  
-> Il est interdit de déclarer une colonne à la fois `primary_key: true` et `unique: true` dans le schéma JS.  
-> **Explication :** En SQL, une clé primaire (`PRIMARY KEY`) est déjà unique par définition et impose la contrainte `UNIQUE` et `NOT NULL` sur la colonne. Ajouter explicitement `unique: true` en plus de `primary_key: true` est redondant et provoque une erreur SQL ("Multiple primary key defined").  
->  
-> **En résumé :**  
-> - Utilisez seulement `primary_key: true` pour une colonne qui doit être la clé primaire.  
-> - Utilisez `unique: true` pour une colonne qui doit être unique mais n'est pas la clé primaire.
+```javascript
+const userModel = new Model('users', userSchema);
 
----
+await Model.createAllTables();
+await userModel.save({ email: 'user@example.com', status: 'active' });
 
+const user = await userModel.findOne({ email: 'user@example.com' });
+await userModel.delete({ email: 'user@example.com' });
+```
 
-#### Exemple d’utilisation
+## Model instances
 
-```js
-// Synchronisation simple (ajout/renommage de colonnes, suppression de tables orphelines avec backup)
-await Model.syncAllTables();
+`ModelInstance` represents a row already loaded from the database.
 
-// Synchronisation avec suppression automatique des colonnes disparues
-await Model.syncAllTables({ dangerousSync: true });
-```
+- `updateOne(model)` updates the row
+- `delete(model)` deletes the row using a filter
+- `deleteOne()` deletes the instance row
+- `customRequest(custom)` runs a custom query
 
----
-
-## Class Model
-Représente un modèle de base de données.
-* ### Constructeur :
-    * `Model(name, schema)` : Crée une instance de `Model`.
-    * `name (string)` : Le nom de la table de base de données.
-    * `schema (Schema)` : Le schéma de la table de base de données.
-* ### Méthodes :
-    * `generateCreateTableStatement(schema)` : Génère une requête SQL pour créer une table.
-    * `save(data)` : Sauvegarde des données dans la table.
-    * `findOne(filter, fields)` : Trouve une entrée unique dans la table.
-    * `find(filter, fields)` : Trouve des entrées dans la table.
-    * `customRequest(custom)` : Exécute une requête SQL personnalisée.
-    * `delete(filter)` : Supprime une entrée de la table.
-    * `dropTable()` : Supprime la table si elle existe.
-    * `generate_uuid()` : Génère un UUID unique pour le modèle.
-    * `createAllTables()` : **Crée toutes les tables dans le bon ordre selon les dépendances de clés étrangères.** (statique)
-* ### Exemple
 ```javascript
-const userModel = new Model('users', transferSchema);
-// Après avoir instancié tous les modèles :
-await Model.createAllTables(); // Crée toutes les tables dans le bon ordre
-
-// Sauvegarder des données
-await userModel.save({ token: 'abc123', mdp: 'password' });
+const userInstance = new ModelInstance('users', { email: 'user@example.com' });
 
-// Trouver une entrée
-const user = await userModel.findOne({ token: 'abc123' });
-
-// Supprimer une entrée
-await userModel.delete({ token: 'abc123' });
+await userInstance.updateOne({ status: 'inactive' });
+await userInstance.deleteOne();
 ```
-## Class ModelInstance
-Représente une instance d'un modèle de base de données.
-* ### Constructeur:
-    * `ModelInstance(name, data)` : Crée une instance de `ModelInstance`.
-    * `name (string)` : Le nom de la table de base de données.
-    * `data (Object)` : Les données de l'instance.
-* ### Méthodes :
-    * `updateOne(model)` : Met à jour une entrée unique dans la table.
-    * `delete(model)` : Supprime une entrée unique dans la table.
-    * `customRequest(custom)` : Exécute une requête SQL personnalisée.
-* ### Exemple
-```javascript
-const userInstance = new ModelInstance('users', { token: 'abc123', mdp: 'password' });
 
-// Mettre à jour des données
-await userInstance.updateOne({ mdp: 'newpassword' });
+## SQL types
+
+`sqlTypeMap` exposes the common SQL types.
 
-// Supprimer des données
-await userInstance.delete({ token: 'abc123' });
-```
-# Types SQL
-Le module fournit une map des types SQL courants via `sqlTypeMap`.
-## Type
-* String
-* Number
-* Boolean
-* Object
-* Array
-* Now
-* Float
-* Text
-* DateTime
-* Timestamp
-* ### Exemple
 ```javascript
 console.log(sqlTypeMap.String); // "VARCHAR"
 ```
-## Conclusion
-Le module `sql-connector` fournit une interface simple et efficace pour interagir avec une base de données MySQL, permettant de définir des schémas, de gérer des connexions, et de manipuler des données de manière intuitive.
 
-# Client
-Le module client est un objet utilisé pour stocker des fonctions. Il sert de conteneur centralisé pour diverses fonctions qui peuvent être utilisées dans différentes parties de l'application.
+## Client
+
+`client` is a shared object meant to host reusable application functions.
 
-### Utilisation
-Pour ajouter une fonction à l'objet client, vous pouvez simplement définir une nouvelle propriété sur l'objet et lui assigner une fonction.
-* ### Exemple
 ```javascript
 module.exports = client => {
-    client.checkServer() {
-        if (server.islaunch())
-            return 1;
-        return 0;
-    };
+  client.checkServer = () => {
+    if (server.isLaunch()) {
+      return 1;
+    }
+
+    return 0;
+  };
 };
 ```
-### Avantages
-* `Centralisation` : Toutes les fonctions liées à des opérations spécifiques peuvent être centralisées dans un seul objet, ce qui facilite la gestion et l'organisation du code.
-* `Réutilisabilité` : Les fonctions stockées dans l'objet `client` peuvent être facilement réutilisées dans différentes parties de l'application.
-* `Modularité` : En utilisant un objet pour stocker des fonctions, il est plus facile de maintenir et de mettre à jour le code, car les fonctions peuvent être ajoutées, modifiées ou supprimées sans affecter d'autres parties de l'application.
 
-## Conclusion
-L'objet `client` est un outil puissant pour organiser et centraliser les fonctions dans votre application. En stockant des fonctions dans cet objet, vous pouvez améliorer la modularité, la réutilisabilité et la maintenabilité de votre code.
+## Summary
+
+sql-connector provides a small layer to connect to MySQL, describe schemas, synchronize tables, and manipulate data with typed models.

package/docs/fr/README.md

@@ -0,0 +1,158 @@
+# Documentation du module sql-connector
+
+[English](../../README.md) | Français
+
+Le module sql-connector permet de gérer des connexions MySQL, de définir des schémas, de synchroniser automatiquement des tables et d'exposer des modèles pour manipuler les données simplement.
+
+## Importation
+
+```javascript
+const { Schema, connect, logout, Model, ModelInstance, client, sqlTypeMap } = require('sql-connector');
+```
+
+## Connexion à la base
+
+`connect(config)` ouvre une connexion MySQL à partir d'un objet de configuration compatible avec mysql2.
+
+```javascript
+const config = {
+  host: 'localhost',
+  port: 3306,
+  user: 'root',
+  password: 'password',
+  database: 'mydatabase'
+};
+
+await connect(config);
+```
+
+`logout()` ferme proprement la connexion.
+
+```javascript
+await logout();
+```
+
+## Schéma
+
+`Schema` décrit la structure d'une table. Chaque champ peut utiliser les propriétés suivantes.
+
+| Propriété | Type | Description |
+|---|---|---|
+| type | `SqlType` ou `{ name: SqlType }` | Type SQL du champ |
+| length | `number` | Longueur maximale |
+| required | `boolean` | Champ obligatoire |
+| default | `any` | Valeur par défaut |
+| unique | `boolean` | Valeur unique |
+| auto_increment | `boolean` | Auto-incrément |
+| foreignKey | `string` | Référence de clé étrangère |
+| enum | `string[]` | Liste de valeurs autorisées |
+| primary_key | `boolean` | Clé primaire |
+| customize | `string` | Options SQL additionnelles |
+
+```javascript
+const userSchema = new Schema({
+  id: {
+    type: Number,
+    auto_increment: true,
+    primary_key: true
+  },
+  email: {
+    type: String,
+    length: 255,
+    unique: true,
+    required: true
+  },
+  status: {
+    type: String,
+    enum: ['active', 'inactive', 'pending'],
+    default: 'pending'
+  }
+});
+```
+
+## Synchronisation des tables
+
+`Model.syncAllTables()` compare les schémas JS avec la base et applique uniquement les différences utiles.
+
+- Ajout de colonne: automatique.
+- Suppression de colonne: uniquement avec `dangerousSync: true`.
+- Renommage de colonne: possible avec `oldName`.
+- Tables orphelines: sauvegarde avant suppression dans un fichier `backup_*.sql`.
+
+```javascript
+await Model.syncAllTables();
+await Model.syncAllTables({ dangerousSync: true });
+```
+
+Point important: ne combinez pas `primary_key: true` et `unique: true` sur le même champ. Une clé primaire est déjà unique et non nulle.
+
+## Modèles
+
+`Model` représente une table SQL.
+
+Méthodes principales:
+
+- `save(data)` pour insérer une ligne
+- `findOne(filter, fields)` pour récupérer une seule entrée
+- `find(filter, fields)` pour récupérer plusieurs entrées
+- `findAll(options)` pour les recherches avancées
+- `count(filter)` pour compter les lignes
+- `customRequest(custom)` pour exécuter une requête SQL personnalisée
+- `delete(filter)` pour supprimer une entrée
+- `dropTable()` pour supprimer la table
+- `generate_uuid()` pour générer un UUID unique
+- `Model.createAllTables()` pour créer toutes les tables dans le bon ordre
+
+```javascript
+const userModel = new Model('users', userSchema);
+
+await Model.createAllTables();
+await userModel.save({ email: 'user@example.com', status: 'active' });
+
+const user = await userModel.findOne({ email: 'user@example.com' });
+await userModel.delete({ email: 'user@example.com' });
+```
+
+## Instances de modèle
+
+`ModelInstance` représente une ligne déjà chargée depuis la base.
+
+- `updateOne(model)` met à jour la ligne
+- `delete(model)` supprime la ligne avec un filtre
+- `deleteOne()` supprime la ligne de l'instance
+- `customRequest(custom)` exécute une requête personnalisée
+
+```javascript
+const userInstance = new ModelInstance('users', { email: 'user@example.com' });
+
+await userInstance.updateOne({ status: 'inactive' });
+await userInstance.deleteOne();
+```
+
+## Types SQL
+
+`sqlTypeMap` expose les types SQL les plus courants.
+
+```javascript
+console.log(sqlTypeMap.String); // "VARCHAR"
+```
+
+## Client
+
+`client` est un objet partagé pensé pour centraliser des fonctions applicatives réutilisables.
+
+```javascript
+module.exports = client => {
+  client.checkServer = () => {
+    if (server.isLaunch()) {
+      return 1;
+    }
+
+    return 0;
+  };
+};
+```
+
+## Résumé
+
+sql-connector fournit une couche simple pour connecter une base MySQL, décrire des schémas, synchroniser les tables et manipuler les données avec des modèles typés.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "description": "Le module sql-connector permet de gérer les connexions à une base de données MySQL, de définir des schémas de tables, et d'interagir avec les données de manière simple et efficace.",
   "main": "index.js",
   "scripts": {

package/releases/1.4.8.md

@@ -0,0 +1,43 @@
+# **Release v1.4.8 — sql-connector**
+
+## **Présentation**
+Cette version poursuit la refonte de `sql-connector` avec une documentation plus lisible, une séparation claire entre les langues, et plusieurs améliorations de fiabilité sur les modèles et la génération SQL.
+
+## **Nouveautés**
+
+### Documentation bilingue
+- La documentation a été restructurée pour séparer plus clairement le contenu en français et en anglais.
+- Le README racine sert désormais de point d'entrée rapide vers la documentation.
+- Le dossier `docs/` est utilisé pour regrouper les pages de documentation par langue.
+
+### Synchronisation et schémas
+- `Model.syncAllTables()` continue de comparer le schéma JS avec la base et applique les différences utiles de manière plus sûre.
+- La longueur par défaut est désormais gérée correctement pour les types `VARCHAR` et `INT` quand `length` n'est pas défini.
+- Une erreur explicite est levée si un champ est déclaré à la fois `primary_key` et `unique`.
+
+### Modèles et requêtes
+- `updateOne()` ignore automatiquement les champs `undefined`.
+- Les mises à jour utilisent une condition `WHERE` plus robuste, en privilégiant les clés primaires quand elles sont disponibles.
+- La génération des conditions SQL a été améliorée pour mieux normaliser les chaînes, les dates et les valeurs JSON.
+
+### Dépendances et maintenance
+- `glob` a été ajouté pour améliorer la détection des fichiers de backup SQL.
+- Les logs de synchronisation et d'exécution ont été renforcés pour faciliter le débogage.
+
+## **Migration depuis v1.4.5**
+
+### Points principaux
+1. La documentation a été réorganisée autour d'un accès plus simple par langue.
+2. Les opérations de mise à jour de modèles sont maintenant plus fiables.
+3. Les règles de génération SQL sont plus strictes et plus prévisibles.
+
+### Recommandation
+- Vérifiez vos schémas si vous utilisiez des champs sans `length`, des mises à jour avec des valeurs `undefined`, ou des colonnes déclarées à la fois `primary_key` et `unique`.
+
+## **Documentation**
+Pour plus de détails, consultez la documentation du projet dans `README.md` et le dossier `docs/`.
+
+## **Liens utiles**
+- [GitHub Repository](https://github.com/lagie-marin/sql-connector)
+- [npm Package](https://www.npmjs.com/package/@mlagie/sql-connector)
+- [Issues](https://github.com/lagie-marin/sql-connector/issues)

package/src/models/Model.js

@@ -604,7 +604,7 @@ class Model {
             getConnexion().promise().query(sql_request).then((rows) => {
                 if (rows.length == 0) return resolve(0);
 
-                resolve(new ModelInstance(this.name, Object.values(rows[0]), this.schema));
+                resolve(new ModelInstance(this.name, rows[0], this.schema));
             }).catch((err) => {
                 error(`Error executing query: ${err}`);
                 return;
@@ -632,7 +632,7 @@ class Model {
             await getConnexion().promise().query(custom).then((rows) => {
                 if (rows.length == 0) return resolve(0);
 
-                resolve(new ModelInstance(this.name, Object.values(rows[0]), this.schema));
+                resolve(new ModelInstance(this.name, rows[0], this.schema));
             }).catch((err) => {
                 error(`Error executing query: ${err}`);
                 return;

package/src/models/ModelInstance.js

@@ -1,7 +1,8 @@
-const { error } = require("@mlagie/logger");
+const { error, logs } = require("@mlagie/logger");
 const { getConnexion } = require("../db/connexion");
 const formatObject = require("../utils/formatObject");
 const generateCondition = require("../utils/generateCondition");
+const util = require("util");
 
 /**
  * Represents an instance of a database model.
@@ -15,23 +16,38 @@ class ModelInstance {
      * @param {Object|null} [schema=null] The schema for the instance, if available.
      */
     constructor(name, data, schema = null) {
-        /**
-         * The name of the database table.
-         * @type {string}
-         */
-        this.name = name;
-
-        /**
-         * The instance data.
-         * @type {Object}
-         */
-        this.data = data;
-
-        /**
-         * The schema for the instance.
-         * @type {Object|null}
-         */
-        this.schema = schema;
+        Object.defineProperties(this, {
+            name: {
+                value: name,
+                writable: true,
+                configurable: true,
+                enumerable: false
+            },
+            data: {
+                value: data,
+                writable: true,
+                configurable: true,
+                enumerable: true
+            },
+            schema: {
+                value: schema,
+                writable: true,
+                configurable: true,
+                enumerable: false
+            }
+        });
+    }
+
+    getRecordData() {
+        return Array.isArray(this.data) ? this.data[0] ?? this.data : this.data;
+    }
+
+    toJSON() {
+        return this.getRecordData();
+    }
+
+    [util.inspect.custom]() {
+        return this.getRecordData();
     }
 
     /**
@@ -42,13 +58,50 @@ class ModelInstance {
      * @throws {Error} Throws an error if the update fails.
      */
     async updateOne(model) {
-        const sql_request = `UPDATE ${this.name} SET ${generateCondition(formatObject(model), true)} WHERE ${generateCondition(formatObject(this.data[0] != undefined ? this.data[0] : this.data), false, this.schema)}`;
+        const setClause = generateCondition(formatObject(model), true);
+
+        // prefer primary key(s) in WHERE to avoid mismatches on nullable/text fields
+        let whereClause;
+        try {
+            const rec = this.getRecordData();
+            const schemaDict = this.schema && this.schema.schemaDict ? this.schema.schemaDict : null;
+            if (schemaDict) {
+                const pkKeys = Object.entries(schemaDict).filter(([k, v]) => v && v.primary_key === true).map(([k]) => k);
+                if (pkKeys.length > 0) {
+                    const pkObj = {};
+                    for (const k of pkKeys) {
+                        if (rec && Object.prototype.hasOwnProperty.call(rec, k)) pkObj[k] = rec[k];
+                    }
+                    if (Object.keys(pkObj).length > 0) whereClause = generateCondition(formatObject(pkObj), false, this.schema);
+                }
+            }
+            if (!whereClause) whereClause = generateCondition(formatObject(rec), false, this.schema);
+        } catch (e) {
+            whereClause = generateCondition(formatObject(this.getRecordData()), false, this.schema);
+        }
+        const sql_request = `UPDATE ${this.name} SET ${setClause} WHERE ${whereClause}`;
+
+        // log SQL for debugging why update may not match
+        try { logs(`ModelInstance.updateOne SQL -> ${sql_request}`); } catch (e) {}
 
-        await getConnexion().promise().query(sql_request).catch((err) => {
+        const [result] = await getConnexion().promise().query(sql_request).catch((err) => {
             error(`Error executing query: ${err}`);
             throw err;
         });
-        return 1;
+
+        const affected = result && (result.affectedRows !== undefined ? result.affectedRows : 0);
+
+        // Update in-memory data if DB was modified
+        if (affected > 0) {
+            const record = this.getRecordData();
+            if (Array.isArray(this.data)) {
+                if (this.data[0] && typeof this.data[0] === 'object') Object.assign(this.data[0], model);
+            } else if (record && typeof record === 'object') {
+                Object.assign(this.data, model);
+            }
+        }
+
+        return affected;
     }
 
     /**
@@ -79,7 +132,7 @@ class ModelInstance {
      * @throws {Error} Throws an error if the deletion fails.
      */
     async deleteOne() {
-        const sql_request = `DELETE FROM ${this.name} WHERE ${generateCondition(formatObject(this.data[0] != undefined ? this.data[0] : this.data))}`;
+        const sql_request = `DELETE FROM ${this.name} WHERE ${generateCondition(formatObject(this.getRecordData()))}`;
 
         return new Promise((resolve, reject) => {
             getConnexion().promise().query(sql_request).then((rows) => {
@@ -104,7 +157,7 @@ class ModelInstance {
             await getConnexion().promise().query(custom).then((rows) => {
                 if (rows.length == 0) return resolve(0);
 
-                resolve(new ModelInstance(this.name, Object.values(rows[0]), this.schema));
+                resolve(new ModelInstance(this.name, rows[0], this.schema));
             }).catch((err) => {
                 error(`Error executing query: ${err}`);
                 return;

package/src/utils/formatObject.js

@@ -2,13 +2,28 @@ module.exports = function (obj) {
     for (const key in obj) {
         if (obj.hasOwnProperty(key)) {
             const value = obj[key];
+            if (value instanceof Date) {
+                // convert Date to MySQL DATETIME (no timezone)
+                obj[key] = value.toISOString().slice(0, 19).replace('T', ' ');
+                continue;
+            }
+
             if (typeof value === "string") {
-                obj[key] = value.replace(/"/g, '\\"');
+                // remove surrounding quotes if present and unescape
+                let v = value.trim();
+                // remove wrapping double or single quotes
+                if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+                    v = v.slice(1, -1);
+                }
+                // unescape common escaped quotes
+                v = v.replace(/\\"/g, '"').replace(/\\'/g, "'");
+                obj[key] = v;
+                continue;
             }
+
             if (typeof value === "object") {
-                obj[key] = JSON.stringify(value)
-                    .replace(/"/g, '\\"')
-                    .replace(/'/g, "\\'");
+                // stringify objects and escape single quotes for SQL safety
+                obj[key] = JSON.stringify(value).replace(/'/g, "\\'");
             }
         }
     }

package/src/utils/generateCondition.js

@@ -29,37 +29,79 @@ module.exports = function (filter, isUpdate = false, schema = null) {
         });
         if (uniqueKeys.length > 0) {
             return uniqueKeys.map(key => {
-                const value = filter[key];
+                let value = filter[key];
+                // normalize strings that may contain surrounding quotes or escaped quotes
+                if (typeof value === 'string') {
+                    value = value.trim();
+                    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                        value = value.slice(1, -1);
+                    }
+                    value = value.replace(/\\"/g, '"').replace(/\\'/g, "'");
+                }
                 if (Array.isArray(value)) {
-                    return `${key} IN (${value.map(v => `"${v}"`).join(", ")})`;
+                    return `${key} IN (${value.map(v => `'${String(v).replace(/'/g, "\\'")}'`).join(", ")})`;
                 }
                 if (typeof value === "object" || (typeof value === "string" && value.trim().startsWith("{") && value.trim().endsWith("}"))) {
                     const jsonVal = typeof value === "string" ? value : JSON.stringify(value);
-                    return `JSON_CONTAINS(${key}, '${jsonVal}')`;
+                    return `JSON_CONTAINS(${key}, '${String(jsonVal).replace(/'/g, "\\'")}')`;
                 }
                 if (value === null || value === "null") return `${key} IS NULL`;
-                return `${key} = ${typeof value === "string" ? `"${value}"` : value}`;
+                // if string looks like an ISO datetime, convert to MySQL DATETIME format
+                if (typeof value === 'string' && /T/.test(value)) {
+                    let val = value.replace(/\.\d+Z$/,'').replace(/Z$/,'').replace('T',' ');
+                    return `${key} = '${String(val).replace(/'/g, "\\'")}'`;
+                }
+                return `${key} = ${typeof value === "string" ? `'${String(value).replace(/'/g, "\\'")}'` : value}`;
             }).join(" AND ");
         }
     }
 
     // Comportement par défaut
     const conditions = filteredKeys.map((key, index) => {
-        const value = filteredValues[index];
+        let value = filteredValues[index];
+        if (typeof value === 'string') {
+            value = value.trim();
+            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            value = value.replace(/\\"/g, '"').replace(/\\'/g, "'");
+        }
 
         if (Array.isArray(value)) {
-            return `${key} IN (${value.map(v => `"${v}"`).join(", ")})`;
+            return `${key} IN (${value.map(v => `'${String(v).replace(/'/g, "\\'")}'`).join(", ")})`;
         }
         if (typeof value === "object" || (typeof value === "string" && value.trim().startsWith("{") && value.trim().endsWith("}"))) {
             const jsonVal = typeof value === "string" ? value : JSON.stringify(value);
             if (isUpdate) {
-                return `${key} = '${jsonVal}'`;
+                return `${key} = '${String(jsonVal).replace(/'/g, "\\'")}'`;
             }
-            return `JSON_CONTAINS(${key}, '${jsonVal}')`;
+            return `JSON_CONTAINS(${key}, '${String(jsonVal).replace(/'/g, "\\'")}')`;
         }
 
         if ((value === null || value === "null") && isUpdate == false) return `${key} IS NULL`;
-        return `${key} = ${typeof value === "string" ? `"${value}"` : value}`;
+
+        // handle date-like strings when schema tells us the field is temporal
+        const fieldDef = schema && schema.schemaDict ? schema.schemaDict[key] : null;
+        let fieldType = null;
+        if (fieldDef) {
+            if (fieldDef.type && fieldDef.type.name !== undefined) fieldType = fieldDef.type.name;
+            else if (fieldDef.type !== undefined) fieldType = fieldDef.type;
+            else if (fieldDef && fieldDef.name !== undefined) fieldType = fieldDef.name;
+        }
+        const normalizedFieldType = String(fieldType ?? "").toLowerCase();
+        const isDateLike = ["date", "datetime", "timestamp", "now"].includes(normalizedFieldType);
+
+        if (typeof value === "string") {
+            let val = value;
+            // strip surrounding quotes if any (double safety)
+            if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) val = val.slice(1,-1);
+            // if ISO timestamp with Z, convert to MySQL DATETIME format
+            if (isDateLike && /T/.test(val)) {
+                val = val.replace(/\.\d+Z$/,'').replace(/Z$/,'').replace('T',' ');
+            }
+            return `${key} = '${String(val).replace(/'/g, "\\'")}'`;
+        }
+        return `${key} = ${value}`;
     }).join(` ${isUpdate == false ? "AND" : ","} `);
     return conditions;
 }