@mlagie/sql-connector 1.2.4 → 1.3.1

package/README.md

@@ -149,6 +149,30 @@ const transferSchema = new Schema({
   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é.
 
+### Synchronisation intelligente des colonnes
+
+Lors de la synchronisation (`Model.syncAllTables()`), le module compare chaque colonne existante avec la définition du schéma JS :
+
+- **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.
+
+---
+
+
 #### Exemple d’utilisation
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "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

@@ -52,6 +52,10 @@ function ifReservedKeywords(tableName) {
 }
 
 function getColumnDefinition(fieldName, field) {
+    if (field.primary_key && field.unique) {
+        throw new Error(`Field '${fieldName}' cannot be both PRIMARY KEY and UNIQUE.`);
+    }
+
     const fieldType = getFieldType(field);
     let colDef = "";
 
@@ -233,8 +237,116 @@ class Model {
             );
             let existingCols = columns.map(col => col.Field);
 
-            // --- Warn si oldName est présent dans le schéma ---
             for (const [fieldName, field] of Object.entries(model.schema.schemaDict)) {
+                if (existingCols.includes(fieldName)) {
+                    // 1. Récupère infos colonne
+                    const currentCol = columns.find(col => col.Field === fieldName);
+                    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(", ");
+                        expectedTypeDef = `enum(${enumValues})`;
+                    } 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;
+                    }
+                    if (!shouldBeNotNull && !isNullableInDB) {
+                        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}'`);
+                        needModify = true;
+                    } else if (expectedDefault === null && currentDefault !== null) {
+                        logs(`Default value mismatch for ${fieldName}: DB has '${currentDefault}', expected NULL`);
+                        needModify = true;
+                    } else if (expectedDefault !== null && currentDefault !== null) {
+                        // Comparaison stringifiée pour éviter les problèmes de type
+                        if (String(expectedDefault) !== String(currentDefault)) {
+                            logs(`Default value mismatch for ${fieldName}: DB has '${currentDefault}', expected '${expectedDefault}'`);
+                            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 {
+                            const newColDef = getColumnDefinition(fieldName, field);
+                            const alterSQL = `ALTER TABLE \`${model.name}\` MODIFY COLUMN ${newColDef}`;
+                            logs(`Modifying column ${fieldName}: ${alterSQL}`);
+                            await conn.promise().query(alterSQL);
+                            logs(`Column ${fieldName} modified successfully`);
+                        } catch (err) {
+                            error(`Error modifying column ${fieldName}: ${err}`);
+                        }
+                    }
+                }
+                // --- Warn si oldName est présent dans le schéma ---
                 if (field.oldName) {
                     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.`);
                 }