@mlagie/sql-connector 1.4.0 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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/src/models/Model.js

@@ -155,7 +155,6 @@ class Model {
                         fs.writeFileSync(backupPath, insertSQL, 'utf-8');
                         logs(`Sauvegarde SQL de la table '${dbTable}' effectuée dans '${backupPath}'.`);
                     } else {
-                        fs.writeFileSync(backupPath, '', 'utf-8');
                         logs(`Table '${dbTable}' vide, fichier '${backupPath}' créé.`);
                     }
                 } catch (err) {
@@ -191,7 +190,7 @@ class Model {
                         input: process.stdin,
                         output: process.stdout
                     });
-    
+
                     // Demande restauration
                     const answer = await new Promise((resolve) => {
                         rl.question(
@@ -201,7 +200,7 @@ class Model {
                             }
                         );
                     });
-    
+
                     if (answer === 'y') {
                         try {
                             const sqlContent = fs.readFileSync(latestBackup, 'utf-8');
@@ -211,7 +210,7 @@ class Model {
                             error(`Erreur lors de la restauration du backup pour '${model.name}': ${err}`);
                         }
                     }
-    
+
                     // Toujours demander la suppression après restauration ou non
                     await new Promise((resolve) => {
                         rl.question(
@@ -231,13 +230,13 @@ class Model {
                         );
                     });
                 }
-    
+
                 // 2. Synchronise les colonnes (renommage, ajout, suppression)
                 const [columns] = await conn.promise().query(
                     `SHOW COLUMNS FROM \`${model.name}\``
                 );
                 let existingCols = columns.map(col => col.Field);
-    
+
                 for (const [fieldName, field] of Object.entries(model.schema.schemaDict)) {
                     if (existingCols.includes(fieldName)) {
                         // 1. Récupère infos colonne
@@ -245,14 +244,14 @@ class Model {
                         const [indexes] = await conn.promise().query(
                             `SHOW INDEX FROM \`${model.name}\` WHERE Column_name = ?`, [fieldName]
                         );
-    
+
                         // 2. Vérifie les propriétés principales avec plus de précision
                         let needModify = false;
-    
+
                         // --- Vérification du TYPE ---
                         const fieldType = getFieldType(field);
                         let expectedTypeDef;
-    
+
                         if (Array.isArray(field.enum) && field.enum.length > 0) {
                             // Pour les ENUM, on compare la définition complète
                             const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
@@ -260,31 +259,31 @@ class Model {
                         } else {
                             // Pour les autres types
                             if (!sqlTypeMap[fieldType]) throw new Error(`Field ${fieldName} has unsupported type ${fieldType}.`);
-    
+
                             expectedTypeDef = sqlTypeMap[fieldType];
                             if (sqlTypeMap[fieldType] === "VARCHAR" || sqlTypeMap[fieldType] === "INT") {
                                 const length = field.length > 0 ? field.length : 255;
                                 expectedTypeDef += `(${length})`;
                             }
                         }
-    
+
                         // Normalisation pour la comparaison (minuscules, suppression des espaces)
                         const normalizeType = (typeStr) => {
                             return typeStr.toLowerCase().replace(/\s+/g, '').replace(/`/g, '');
                         };
-    
+
                         const currentTypeNormalized = normalizeType(currentCol.Type);
                         const expectedTypeNormalized = normalizeType(expectedTypeDef);
-    
+
                         if (currentTypeNormalized !== expectedTypeNormalized) {
                             logs(`Type mismatch for ${fieldName}: DB has '${currentCol.Type}', expected '${expectedTypeDef}'`);
                             needModify = true;
                         }
-    
+
                         // --- Vérification NULL/NOT NULL ---
                         const shouldBeNotNull = field.required === true || field.primary_key === true;
                         const isNullableInDB = currentCol.Null === "YES";
-    
+
                         if (shouldBeNotNull && isNullableInDB) {
                             logs(`Nullability mismatch for ${fieldName}: DB allows NULL, expected NOT NULL`);
                             needModify = true;
@@ -293,11 +292,11 @@ class Model {
                             logs(`Nullability mismatch for ${fieldName}: DB is NOT NULL, expected NULL allowed`);
                             needModify = true;
                         }
-    
+
                         // --- Vérification DEFAULT VALUE ---
                         const expectedDefault = field.default !== undefined ? field.default : null;
                         const currentDefault = currentCol.Default;
-    
+
                         // Gestion spéciale pour les valeurs par défaut
                         if (expectedDefault !== null && currentDefault === null) {
                             logs(`Default value mismatch for ${fieldName}: DB has NULL, expected '${expectedDefault}'`);
@@ -312,28 +311,28 @@ class Model {
                                 needModify = true;
                             }
                         }
-    
+
                         // --- Vérification UNIQUE constraint ---
                         const isUniqueInDB = indexes.some(idx => idx.Non_unique === 0 && idx.Key_name !== 'PRIMARY');
                         if (!!field.unique !== isUniqueInDB) {
                             logs(`Unique constraint mismatch for ${fieldName}: DB has unique=${isUniqueInDB}, expected=${!!field.unique}`);
                             needModify = true;
                         }
-    
+
                         // --- Vérification PRIMARY KEY ---
                         const isPrimaryInDB = indexes.some(idx => idx.Key_name === 'PRIMARY');
                         if (!!field.primary_key !== isPrimaryInDB) {
                             logs(`Primary key mismatch for ${fieldName}: DB has PK=${isPrimaryInDB}, expected=${!!field.primary_key}`);
                             needModify = true;
                         }
-    
+
                         // --- Vérification AUTO_INCREMENT ---
                         const isAutoIncrementInDB = currentCol.Extra.toLowerCase().includes('auto_increment');
                         if (!!field.auto_increment !== isAutoIncrementInDB) {
                             logs(`Auto increment mismatch for ${fieldName}: DB has AI=${isAutoIncrementInDB}, expected=${!!field.auto_increment}`);
                             needModify = true;
                         }
-    
+
                         // 3. Si différence, on modifie
                         if (needModify) {
                             try {
@@ -352,27 +351,27 @@ class Model {
                         logs(`⚠️  Pensez à retirer la propriété 'oldName' du champ '${fieldName}' dans le schéma JS de '${model.name}' pour éviter des renommages inutiles à l'avenir.`);
                     }
                 }
-    
+
                 // --- Étape 1 : Renommage des colonnes ---
                 for (const [fieldName, field] of Object.entries(model.schema.schemaDict)) {
                     if (field.oldName && existingCols.includes(field.oldName) && !existingCols.includes(fieldName)) {
                         // Génère la définition SQL de la nouvelle colonne
                         let colDef = getColumnDefinition(fieldName, field);
-    
+
                         // Renomme la colonne
-                        const alterSQL = `ALTER TABLE \`${model.name}\` CHANGE COLUMN \`${field.oldName}\` \`${fieldName}\` ${colDef}`;
+                        const alterSQL = `ALTER TABLE \`${model.name}\` CHANGE COLUMN \`${field.oldName}\` ${colDef}`;
                         await conn.promise().query(alterSQL);
                         logs(`Colonne ${field.oldName} renommée en ${fieldName} dans ${model.name}`);
                         // Mets à jour existingCols pour la suite
                         existingCols = existingCols.map(col => col === field.oldName ? fieldName : col);
                     }
                 }
-    
+
                 // --- Étape 2 : Ajout des colonnes manquantes ---
                 for (const [fieldName, field] of Object.entries(model.schema.schemaDict)) {
                     if (!existingCols.includes(fieldName)) {
                         let colDef = getColumnDefinition(fieldName, field);
-    
+
                         // Ajoute la colonne
                         const alterSQL = `ALTER TABLE \`${model.name}\` ADD COLUMN ${colDef}`;
                         await conn.promise().query(alterSQL);
@@ -380,7 +379,7 @@ class Model {
                         existingCols.push(fieldName);
                     }
                 }
-    
+
                 // --- Étape 3 : Suppression des colonnes orphelines (dangerousSync) ---
                 if (dangerousSync) {
                     for (const col of existingCols) {
@@ -459,7 +458,7 @@ class Model {
      * @param {Object} [options.where] - Filtres (clé/valeur).
      * @param {Array} [options.order] - Ex: [['points', 'DESC']]
      * @param {number} [options.limit] - Limite de résultats.
-     * @returns {Promise<Array<Object>>}
+     * @returns {Promise<Array<ModelInstance>>}
      */
     async findAll(options = {}) {
         const {
@@ -483,7 +482,8 @@ class Model {
 
         return new Promise((resolve, reject) => {
             getConnexion().promise().query(sql_request).then(([rows]) => {
-                resolve(rows);
+                const instances = rows.map(row => new ModelInstance(this.name, row, this.schema));
+                resolve(instances);
             }).catch((err) => {
                 error(`Error executing findAll: ${err}`);
                 resolve([]);
@@ -501,13 +501,12 @@ class Model {
         const sql_request = `SELECT ${fields.join(", ")} FROM ${this.name} WHERE ${generateCondition(formatObject(filter))}`;
 
         return new Promise((resolve, reject) => {
-            getConnexion().promise().query(sql_request).then((rows) => {
-                if (rows.length == 0) return resolve(0);
-
-                resolve(new ModelInstance(this.name, Object.values(rows[0])[0], this.schema));
+            getConnexion().promise().query(sql_request).then(([rows]) => {
+                if (!rows || rows.length === 0) return resolve(0);
+                resolve(new ModelInstance(this.name, rows[0], this.schema));
             }).catch((err) => {
                 error(`Error executing query: ${err}`);
-                return 0;
+                return resolve(0);
             });
         });
     }
@@ -589,7 +588,6 @@ class Model {
      */
     async delete(filter) {
         const sql_request = `DELETE FROM ${this.name} WHERE ${generateCondition(formatObject(filter))}`;
-
         return new Promise((resolve, reject) => {
             getConnexion().promise().query(sql_request).then((rows) => {
                 if (rows[1] != undefined) return resolve(0);