dbtasker 2.5.0 → 3.0.0

package/dbop.js

@@ -33,7 +33,7 @@ async function alterDatabaseCharsetCollate(config, databaseName, characterSet, c
         `;
 
         await connection.query(query);
-        console.log(`${cstyler.purple('Database:')} '${cstyler.blue(databaseName)}' character set changed to '${cstyler.yellow(characterSet)}' and collation to '${cstyler.yellow(collate)}'.`);
+        console.log(`${cstyler.blue('Database:')} '${cstyler.hex("#00d9ffff")(databaseName)}' character set changed to '${cstyler.yellow(characterSet)}' and collation to '${cstyler.yellow(collate)}'.`);
         return true;
     } catch (err) {
         console.error("Error altering database:", err.message);
@@ -73,7 +73,7 @@ async function createDatabase(config, databaseName, characterSet = null, collate
         await connection.query(query);
 
         console.log(
-            `${cstyler.purple('Database:')} '${cstyler.blue(databaseName)}'` +
+            `${cstyler.blue('Database:')} '${cstyler.hex("#00d9ffff")(databaseName)}'` +
             (characterSet ? ` created with CHARACTER SET '${cstyler.yellow(characterSet)}'` : "") +
             (collate ? ` and COLLATE '${cstyler.yellow(collate)}'` : "")
         );
@@ -85,42 +85,11 @@ async function createDatabase(config, databaseName, characterSet = null, collate
         if (connection) await connection.end();
     }
 }
-async function dropTable(config, json_data, seperator = "_") {
-    try {
-        console.log("Starting dropping the table.");
-        for (const jsondb of Object.keys(json_data)) {
-            let dbname = fncs.perseDatabaseNameWithLoop(jsondb, seperator);
-            if (dbname === false) {
-                console.error("There must be some mistake. Please re install the module.");
-            }
-            const alltables = await fncs.getTableNames(config, dbname.loopname);
-            if (alltables === null) {
-                console.error("Having problem getting all the table name of the Database: ", cstyler.yellow(dbname.loopname), ". Please re-install the module.");
-                return null;
-            }
-            let tables = {};
-            for (const tableName of (alltables)) {
-                const revlpnm = fncs.reverseLoopName(tableName);
-                if (!Object.keys(json_data[jsondb]).includes(revlpnm[0]) && !Object.keys(json_data[jsondb]).includes(revlpnm[1])) {
-                    const droptable = await fncs.dropTable(config, dbname.loopname, tableName);
-                    if (droptable === null) {
-                        console.error("Having problem dropping table. Please check database connection.");
-                        return null;
-                    }
-                    console.log(cstyler.purple("Database: "), cstyler.blue(dbname.loopname), cstyler.purple("Table: "), cstyler.blue(tableName), "- has dropped successfully.")
-                }
-            }
-            console.log(cstyler.green("Successfully dropped all unlisted tables."));
-            return true;
-        }
-    } catch (err) {
-        console.error(err.message);
-        return null;
-    }
-}
-async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, donttouchdb = [], seperator = "_") {
+
+async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, donttouchdb = [], separator = "_") {
     try {
         // lets add databases and drop databases
+        console.log(cstyler.bold.yellow("Starting database add/drop/alter process..."));
         let config;
         if (fncs.isValidMySQLConfig(allconfig)) {
             config = { "port": allconfig.port, "host": allconfig.host, "user": allconfig.user, "password": allconfig.password }
@@ -137,7 +106,7 @@ async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, dontt
         // Lets add databases
         for (const jsondb of jsondbnames) {
             let data = {};
-            data.name = fncs.perseDatabaseNameWithLoop(jsondb, seperator).loopname;
+            data.name = fncs.perseDatabaseNameWithLoop(jsondb, separator).loopname;
             if (fncs.isJsonObject(jsondata[jsondb])) {
                 if (jsondata[jsondb].hasOwnProperty("_collate_")) {
                     data.collate = jsondata[jsondb]._collate_;
@@ -155,14 +124,14 @@ async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, dontt
             }
             if (avldblist.includes(data.name)) {
                 // Let's Alter database if needed
-                console.log(cstyler.purple("Database Name: "), cstyler.blue(data.name), cstyler.green(" is exist. Checking for charactar set and collate configuration"));
+                console.log(cstyler.blue("Database Name: "), cstyler.hex("#00d9ffff")(data.name), " is exist. Checking for charactar set and collate configuration");
                 const dbdetails = await fncs.getDatabaseCharsetAndCollation(config, data.name);
                 if (!fncs.isJsonObject(dbdetails)) {
                     console.error(cstyler.bold("Having problem getting database character set and collate."));
                     return null;
                 } else {
                     if ((data.charset === null || dbdetails.characterSet === data.charset) && (data.collate === null || dbdetails.collation === data.collate)) {
-                        console.log(cstyler.purple("Database: "), cstyler.blue(data.name), " no changes needed.");
+                        console.log(cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(data.name), " no changes needed.");
                     } else {
                         // lets alter the database charset and collate
                         if (data.charset === null) {
@@ -180,14 +149,14 @@ async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, dontt
 
             } else {
                 // Let's Create database
-                console.log(cstyler.purple("Database Name: "), cstyler.blue(data.name), " do not exist.");
+                console.log(cstyler.blue("Database Name: "), cstyler.hex("#00d9ffff")(data.name), " do not exist.");
                 console.log("Lets create Database: ", cstyler.yellow(jsondb));
                 const createdb = await createDatabase(config, data.name, data.charset, data.collate);
                 if (createdb === true) {
-                    console.log(cstyler.purple("Database Name: "), cstyler.blue(jsondb), cstyler.green(" have created successfully"));
+                    console.log(cstyler.blue("Database Name: "), cstyler.hex("#00d9ffff")(jsondb), cstyler.green(" have created successfully"));
                 } else if (createdb === false) {
-                    console.error("Trying to create this ", cstyler.blue(jsondb), " database when it do not exist on the list all existing database. But when creating server says it already exist. There must be a database problem.");
-                    console.log(cstyler.purple("All available Database names are: "), cstyler.blue(avldblist.join(", ")));
+                    console.error("Trying to create this ", cstyler.hex("#00d9ffff")(jsondb), " database when it do not exist on the list all existing database. But when creating server says it already exist. There must be a database problem.");
+                    console.log(cstyler.blue("All available Database names are: "), cstyler.hex("#00d9ffff")(avldblist.join(", ")));
                     return null;
                 } else {
                     return null;
@@ -197,6 +166,7 @@ async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, dontt
         // Lets drop database
         if (dropdb) {
             // Lets get all database name
+            console.log(cstyler.bold.yellow("Initiating dropping the databases"));
             const avldblist = await fncs.getAllDatabaseNames(config);
             if (!Array.isArray(avldblist)) {
                 console.error(cstyler.red.bold("There is a problem connecting to the database. Please check database info or connection."));
@@ -205,23 +175,44 @@ async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, dontt
             // Let's arrange database names
             let arrngdbnms = {};
             for (const dbnms of avldblist) {
-                if ([...defaultdb, ...donttouchdb].includes(dbnms)) { continue }
+                if ([...defaultdb, ...donttouchdb].includes(dbnms)) {
+                    continue;
+                }
                 const getrev = fncs.reverseLoopName(dbnms);
-                if (arrngdbnms.hasOwnProperty(getrev)[0]) {
-                    arrngdbnms[getrev[0]].push(dbnms);
-                } else if (arrngdbnms.hasOwnProperty(getrev)[1]) {
-                    arrngdbnms[getrev[1]].push(dbnms);
+                if (Array.isArray(getrev)) {
+                    for(const item of getrev) {
+                        if(arrngdbnms.hasOwnProperty(item)) {
+                            arrngdbnms[item].push(dbnms);
+                            break;
+                        }
+                    }
                 } else {
                     arrngdbnms[getrev] = [dbnms];
                 }
             }
+            console.log("Lets start dropping");
+            let count = 0;
             for (const databaseName of Object.keys(arrngdbnms)) {
                 if (!jsondbnames.includes(databaseName)) {
                     for (const items of arrngdbnms[databaseName]) {
-                        await fncs.dropDatabase(config, items);
+                        console.log('dropping now', items);
+                        const isdropdb = await fncs.dropDatabase(config, items);
+                        if (isdropdb) {
+                            count += 1;
+                            console.log(`${cstyler.blue('Database')} '${cstyler.yellow(databaseName)}' ${cstyler.red('dropped')} ${cstyler.green('successfully.')}`);
+                        } else if (isdropdb === false) {
+                            console.log(`${cstyler.blue('Database')} '${cstyler.hex("#00d9ffff")(databaseName)}' does not exist.`);
+                        } else if (isdropdb === null) {
+                            return null;
+                        }
                     }
                 }
             }
+            if (count > 0) {
+                console.log(cstyler.green("All useless database have dropped"));
+            } else {
+                console.log(cstyler.green("No database found to be dropped"));
+            }
         }
         return true;
     } catch (err) {
@@ -231,6 +222,5 @@ async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, dontt
 }
 
 module.exports = {
-    databaseAddDeleteAlter,
-    dropTable
+    databaseAddDeleteAlter
 }

package/dropcolumn.js

@@ -0,0 +1,174 @@
+const fncs = require("./function");
+const cstyler = require("cstyler");
+
+
+
+
+
+
+async function dropcolumn(config, tableJson, forceDropColumn, separator = "_") {
+    try {
+        console.log(cstyler.bold.yellow("Initiating drop column operation"));
+
+        if (!fncs.isJsonObject(tableJson)) {
+            return false;
+        }
+
+        for (const jsDb of Object.keys(tableJson)) {
+            const parsedDb = fncs.perseDatabaseNameWithLoop(jsDb, separator);
+            if (!parsedDb) {
+                console.error(
+                    cstyler.bold.red("Cannot parse database name."),
+                    jsDb,
+                    parsedDb
+                );
+                return null;
+            }
+
+            const databaseName = parsedDb.loopname;
+            config.database = databaseName;
+
+            for (const jsTable of Object.keys(tableJson[jsDb])) {
+                const tableDef = tableJson[jsDb][jsTable];
+                if (!fncs.isJsonObject(tableDef)) continue;
+
+                const parsedTable = fncs.perseTableNameWithLoop(jsTable, separator);
+                if (!parsedTable) {
+                    console.error(
+                        cstyler.bold.red("Cannot parse table name."),
+                        jsTable
+                    );
+                    return null;
+                }
+
+                const tableName = parsedTable.loopname;
+
+                const existingColumns = await fncs.getColumnNames(
+                    config,
+                    databaseName,
+                    tableName
+                );
+
+                if (!existingColumns) {
+                    console.error(
+                        cstyler.bold.red("Failed to fetch columns for table:"),
+                        cstyler.hex("#00d9ffff")(tableName),
+                        cstyler.bold.red("from database:"),
+                        cstyler.hex("#00d9ffff")(databaseName)
+                    );
+                    return null;
+                }
+
+                for (const column of existingColumns) {
+                    const definedInJson = Object.prototype.hasOwnProperty.call(
+                        tableDef,
+                        column
+                    );
+
+                    const isValidDefinition =
+                        definedInJson && fncs.isJsonObject(tableDef[column]);
+
+                    if (isValidDefinition) continue;
+
+                    console.log(
+                        cstyler.bold.purple("Database:"),
+                        cstyler.hex("#00d9ffff")(databaseName),
+                        cstyler.bold.purple("Table:"),
+                        cstyler.hex("#00d9ffff")(tableName),
+                        cstyler.bold.yellow("Dropping column:"),
+                        cstyler.yellow(column)
+                    );
+
+                    const referencingColumns =
+                        await fncs.findReferencingFromColumns(
+                            config,
+                            databaseName,
+                            tableName,
+                            column
+                        );
+
+                    if (referencingColumns === null) {
+                        console.error(
+                            cstyler.bold.red("Failed to resolve FK references for column:"),
+                            cstyler.hex("#00d9ffff")(column)
+                        );
+                        return null;
+                    }
+
+                    if (referencingColumns.length > 0) {
+                        if (!forceDropColumn) {
+                            console.error(
+                                cstyler.bold.red("Column is referenced by other tables:"),
+                                cstyler.hex("#00d9ffff")(column),
+                                cstyler.bold.red("Enable forceDropColumn to proceed.")
+                            );
+                            continue;
+                        }
+
+                        let allFkRemoved = true;
+
+                        for (const ref of referencingColumns) {
+                            const removed = await fncs.removeForeignKeyFromColumn(
+                                config,
+                                ref.child_schema,
+                                ref.child_table,
+                                ref.child_columns[0]
+                            );
+
+                            if (removed === null) {
+                                console.error(
+                                    cstyler.bold.red("Failed to drop FK from:"),
+                                    cstyler.hex("#00d9ffff")(ref.child_table),
+                                    cstyler.bold.red("column:"),
+                                    cstyler.hex("#00d9ffff")(ref.child_columns[0])
+                                );
+                                allFkRemoved = false;
+                            }
+                        }
+
+                        if (!allFkRemoved) {
+                            console.error(
+                                cstyler.bold.red("Aborting column drop due to FK failures:"),
+                                cstyler.hex("#00d9ffff")(column)
+                            );
+                            continue;
+                        }
+                    }
+
+                    const dropped = await fncs.dropColumn(
+                        config,
+                        databaseName,
+                        tableName,
+                        column
+                    );
+
+                    if (dropped === null) {
+                        console.error(
+                            cstyler.bold.red("Failed to drop column:"),
+                            cstyler.hex("#00d9ffff")(column)
+                        );
+                        return null;
+                    }
+
+                    console.log(
+                        cstyler.bold.green("Successfully dropped column:"),
+                        cstyler.hex("#00d9ffff")(column),
+                        cstyler.bold.green("from table:"),
+                        cstyler.hex("#00d9ffff")(tableName)
+                    );
+                }
+            }
+        }
+
+        return true;
+    } catch (err) {
+        console.error(err?.message || err);
+        return null;
+    }
+}
+
+
+
+module.exports = {
+    dropcolumn
+}