@mlagie/sql-connector 1.1.4-beta → 1.2.0

package/README.md

@@ -1,3 +1,7 @@
+# sql-connector
+<img src="https://api.visitorbadge.io/api/VisitorHit?user=lagie-marin&repo=sql-connector-badge&countColor=%237B1E7A" height="20px"/> ![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) ![GitHub forks](https://img.shields.io/github/forks/lagie-marin/sql-connector?style=plastic&color=%green)
+
 # Documentation du module `sql-connector`
 
 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.
@@ -104,6 +108,59 @@ const transferSchema = new Schema({
     }
 });
 ```
+
+## Synchronisation automatique du schéma et gestion des migrations
+
+### 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`).
+
+### Restauration et gestion des backups
+
+- 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é.
+
+#### Exemple d’utilisation
+
+```js
+// Synchronisation simple (ajout/renommage de colonnes, suppression de tables orphelines avec backup)
+await Model.syncAllTables();
+
+// Synchronisation avec suppression automatique des colonnes disparues
+await Model.syncAllTables({ dangerousSync: true });
+```
+
+---
+
 ## Class Model
 Représente un modèle de base de données.
 * ### Constructeur :

package/index.d.ts

@@ -98,7 +98,7 @@ export class Model {
      * Crée toutes les tables dans l'ordre correct en fonction des foreign keys.
      * @returns {Promise<void>}
      */
-    static createAllTables(): Promise<void>;
+    static syncAllTables({ dangerousSync = false } = {}): Promise<void>;
     /**
      * Saves data to the database table.
      * @param {Object} data The data to insert into the table.

package/index.js

@@ -4,6 +4,7 @@ const { connect, logout } = require("./src/db/connect");
 const {Schema} = require("./src/models/Schema");
 const { sqlType } = require("./src/utils/sqlType");
 const { sqlTypeMap } = require("./src/utils/sqlTypeMap");
-const client = require("./client");
+
+let client = {};
 
 module.exports = { client, connect, logout, Schema, Model, ModelInstance, sqlType, sqlTypeMap }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "1.1.4-beta",
+  "version": "1.2.0",
   "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": {
@@ -10,7 +10,10 @@
     "type": "git",
     "url": "git+https://github.com/lagie-marin/sql-connector.git"
   },
-  "keywords": ["sql", "schema"],
+  "keywords": [
+    "sql",
+    "schema"
+  ],
   "author": "lagie-marin",
   "license": "MIT",
   "type": "commonjs",
@@ -21,6 +24,7 @@
   "private": false,
   "dependencies": {
     "@mlagie/logger": "1.0.1",
-    "mysql2": "^3.14.4"
+    "glob": "^11.0.3",
+    "mysql2": "3.14.5"
   }
 }

package/src/models/Model.js

@@ -45,6 +45,27 @@ function ifReservedKeywords(tableName) {
     return false;
 }
 
+function getColumnDefinition(fieldName, field) {
+    const fieldType = getFieldType(field);
+    let colDef = "";
+
+    if (Array.isArray(field.enum) && field.enum.length > 0) {
+        const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
+        colDef = `ENUM(${enumValues})`;
+    } else {
+        if (!sqlTypeMap[fieldType]) throw new Error(`Field ${fieldName} has unsupported type ${fieldType}.`);
+        colDef = `${sqlTypeMap[fieldType]}${(sqlTypeMap[fieldType] == "VARCHAR" || sqlTypeMap[fieldType] == "INT") ? `(${field.length > 0 ? field.length : 255})` : ""}`;
+    }
+    if (field.required) colDef += ' NOT NULL';
+    if (field.default !== undefined && field.default != null) colDef += ` DEFAULT "${field.default}"`;
+    if (field.default === null) colDef += ` DEFAULT NULL`;
+    if (field.unique) colDef += ' UNIQUE';
+    if (field.auto_increment) colDef += ' AUTO_INCREMENT';
+    if (field.primary_key) colDef += ' PRIMARY KEY';
+    if (typeof field.customize === 'string' && field.customize.length != 0) colDef += ` ${field.customize}`;
+    return colDef;
+}
+
 /**
  * Represents a database model.
  * @class
@@ -66,25 +87,33 @@ class Model {
     }
 
     /**
-     * Crée toutes les tables dans l'ordre correct en fonction des foreign keys.
+     * Synchronise toutes les tables avec leur schéma JS (création + ajout des colonnes manquantes).
      * @returns {Promise<void>}
      */
-    static async createAllTables() {
+    static async syncAllTables({ dangerousSync = false } = {}) {
+        const fs = require('fs');
+        const path = require('path');
+        const glob = require('glob');
+
         // Dépendances : {table: [tables dont elle dépend]}
         const dependencies = {};
         const modelMap = {};
         for (const model of Model.pendingModels) {
             modelMap[model.name] = model;
             dependencies[model.name] = [];
-            for (const [fieldName, field] of Object.entries(model.schema.schemaDict)) {
+            for (const [_, field] of Object.entries(model.schema.schemaDict)) {
                 if (field && field.foreignKey) {
-                    // field.foreignKey peut être "autreTable(colonne)"
                     const refTable = field.foreignKey.split('(')[0].trim();
                     dependencies[model.name].push(refTable);
                 }
             }
         }
 
+        // Récupère toutes les tables existantes dans la base
+        const conn = getConnexion();
+        const [dbTablesRows] = await conn.promise().query("SHOW TABLES");
+        const dbTables = dbTablesRows.map(row => Object.values(row)[0]);
+
         // Tri topologique
         const sorted = [];
         const visited = {};
@@ -102,19 +131,151 @@ class Model {
             if (!visited[table]) visit(table);
         }
 
-        // Création des tables dans l'ordre
+        // --- Détruit les tables qui n'ont plus de schéma ---
+        for (const dbTable of dbTables) {
+            if (!modelMap[dbTable]) {
+                try {
+                    const backupPath = `./backup_${dbTable}_${Date.now()}.sql`;
+                    // Sauvegarde rapide en SQL (INSERTs)
+                    const [rows] = await conn.promise().query(`SELECT * FROM \`${dbTable}\``);
+                    if (rows.length > 0) {
+                        const columns = Object.keys(rows[0]).map(col => `\`${col}\``).join(', ');
+                        const values = rows.map(row =>
+                            '(' + Object.values(row).map(val =>
+                                val === null ? 'NULL' : conn.escape(val)
+                            ).join(', ') + ')'
+                        ).join(',\n');
+                        const insertSQL = `INSERT INTO \`${dbTable}\` (${columns}) VALUES${values};\n`;
+                        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) {
+                    error(`Erreur lors de la sauvegarde SQL de la table '${dbTable}': ${err}`);
+                }
+                logs(`Table '${dbTable}' n'a plus de schéma associé, suppression...`);
+                await conn.promise().query(`DROP TABLE IF EXISTS \`${dbTable}\``);
+                logs(`Table '${dbTable}' supprimée.`);
+            }
+        }
+
+        // Création/synchronisation des tables dans l'ordre
         for (const table of sorted) {
             const model = modelMap[table];
-            await new Promise((resolve, reject) => {
-                getConnexion().query(model.generateCreateTableStatement(model.schema.schemaDict), (err) => {
-                    if (err) {
-                        error(`Error creating table: ${err} with table name: ${model.name}`);
-                        return reject(err);
+
+            // 1. Crée la table si elle n'existe pas (version avec promesses)
+            try {
+                await conn.promise().query(model.generateCreateTableStatement(model.schema.schemaDict));
+                await logs(`La table ${model.name} a été créée ou existe déjà`);
+            } catch (err) {
+                error(`Error creating table: ${err} with table name: ${model.name}`);
+                throw err;
+            }
+
+            // --- Restauration automatique si backup SQL trouvé ---
+            const backupPattern = `./backup_${model.name}_*.sql`;
+            const backupFiles = glob.sync(backupPattern).filter(f => !f.endsWith('.ignored'));
+            if (backupFiles.length > 0) {
+                const latestBackup = backupFiles.sort().reverse()[0];
+                const readline = require('readline');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
+                });
+
+                // Demande restauration
+                const answer = await new Promise((resolve) => {
+                    rl.question(
+                        `Un backup a été trouvé pour la table '${model.name}' (${latestBackup}). Voulez-vous restaurer les données ? (y/N) `,
+                        (answer) => {
+                            resolve(answer.trim().toLowerCase());
+                        }
+                    );
+                });
+
+                if (answer === 'y') {
+                    try {
+                        const sqlContent = fs.readFileSync(latestBackup, 'utf-8');
+                        await conn.promise().query(sqlContent);
+                        await logs(`Backup restauré pour la table '${model.name}'.`);
+                    } catch (err) {
+                        error(`Erreur lors de la restauration du backup pour '${model.name}': ${err}`);
                     }
-                    logs(`La table ${model.name} a été créé`);
-                    resolve();
+                }
+
+                // Toujours demander la suppression après restauration ou non
+                await new Promise((resolve) => {
+                    rl.question(
+                        `Voulez-vous supprimer le fichier de backup '${latestBackup}' ? (y/N) `,
+                        (delAnswer) => {
+                            if (delAnswer.trim().toLowerCase() === 'y') {
+                                fs.unlinkSync(latestBackup);
+                                logs(`Backup supprimé : ${latestBackup}`);
+                            } else {
+                                // Renomme le fichier pour ne plus proposer la restauration
+                                fs.renameSync(latestBackup, latestBackup + '.ignored');
+                                logs(`Backup ignoré pour la table '${model.name}'. Il ne sera plus proposé.`);
+                            }
+                            rl.close();
+                            resolve();
+                        }
+                    );
                 });
-            });
+            }
+
+            // 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);
+
+            // --- Warn si oldName est présent dans le schéma ---
+            for (const [fieldName, field] of Object.entries(model.schema.schemaDict)) {
+                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.`);
+                }
+            }
+
+            // --- É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}`;
+                    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 \`${fieldName}\` ${colDef}`;
+                    await conn.promise().query(alterSQL);
+                    logs(`Colonne ${fieldName} ajoutée à ${model.name}`);
+                    existingCols.push(fieldName);
+                }
+            }
+
+            // --- Étape 3 : Suppression des colonnes orphelines (dangerousSync) ---
+            if (dangerousSync) {
+                for (const col of existingCols) {
+                    if (!Object.keys(model.schema.schemaDict).includes(col)) {
+                        const alterSQL = `ALTER TABLE \`${model.name}\` DROP COLUMN \`${col}\``;
+                        await conn.promise().query(alterSQL);
+                        logs(`Colonne ${col} supprimée de ${model.name}`);
+                    }
+                }
+            }
         }
         // Vide la liste d'attente
         Model.pendingModels = [];
@@ -138,26 +299,8 @@ class Model {
 
             if (field.type && typeof field == "object") {
                 // Si c'est un enum, ne pas vérifier sqlTypeMap
-                let columnDefinition = "";
-                if (Array.isArray(field.enum) && field.enum.length > 0) {
-                    const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
-                    columnDefinition = `${fieldName} ENUM(${enumValues})`;
-                } else {
-                    if (!sqlTypeMap[fieldType]) throw new Error(`Field ${fieldName} has unsupported type ${fieldType}.`);
-                    columnDefinition = `${fieldName} ${sqlTypeMap[fieldType]}${sqlTypeMap[fieldType] == "VARCHAR" || sqlTypeMap[fieldType] == "INT" ? `(${field.length > 0 ? field.length : lengthDefault})` : ""}`;
-                }
-
-                if (field.required) columnDefinition += ' NOT NULL';
-                if (field.default !== undefined && field.default != null) columnDefinition += ` DEFAULT "${field.default}"`;
-                if (field.default === null) columnDefinition += ` DEFAULT NULL`;
-                if (field.unique) columnDefinition += ' UNIQUE';
-                if (field.auto_increment) columnDefinition += ' AUTO_INCREMENT';
-                if (field.foreignKey) foreignKey.push(`FOREIGN KEY (${fieldName}) REFERENCES ${field.foreignKey}`);
-                if (field.primary_key) columnDefinition += ' PRIMARY KEY';
-                if (typeof field.customize === 'string' && field.customize.length != 0) columnDefinition += ` ${field.customize}`;
-                return columnDefinition;
+                return getColumnDefinition(fieldName, field);
             }
-
             if (Array.isArray(field.enum) && field.enum.length > 0) {
                 const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
                 return `${fieldName} ENUM(${enumValues})`;
@@ -401,4 +544,4 @@ class Model {
     }
 }
 
-module.exports = {Model}
+module.exports = { Model }

package/client.d.ts

@@ -1,8 +0,0 @@
-declare module './client' {
-    interface Client {
-        [key: string]: any; // Dynamic methods added on the fly
-    }
-
-    const client: Client;
-    export = client;
-}

package/client.js

@@ -1,8 +0,0 @@
-/**
- * @typedef {Object} Client
- * @property {Object.<string, any>} [dynamicMethods] - Dynamic methods added on the fly
- */
-
-/** @type {Client} */
-const client = {};
-module.exports = client;