dbtasker 3.0.8 → 3.0.9

package/addcolumn.js

@@ -170,6 +170,7 @@ async function addColumnQuery(columndata, columnName, tableName, databaseName, c
 async function addColumnIfNeeded(config, jsondata, separator) {
     try {
         console.log(cstyler.bold.yellow("Let's initiate addColumn to table if needed..."));
+        let count = 0;
         for (const jsondb of Object.keys(jsondata)) {
             let remainfk = {};
             const loopdb = fncs.perseDatabaseNameWithLoop(jsondb, separator);
@@ -212,6 +213,8 @@ async function addColumnIfNeeded(config, jsondata, separator) {
                         console.error(cstyler.red(`Failed to add column ${jsoncolumn} to table ${tableName} in database ${databaseName}. Skipping...`));
                         return null;
                     }
+                    console.log(cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue(" Table: "), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column: "), cstyler.hex("#00d9ffff")(jsoncolumn), cstyler.green("- added successfully."))
+                    count += 1;
                     // check for foreign key
                     if (columndata.hasOwnProperty("foreign_key")) {
                         const fk = columndata.foreign_key;
@@ -249,7 +252,11 @@ async function addColumnIfNeeded(config, jsondata, separator) {
                 }
             }
         }
-        console.log(cstyler.bold.underline.hex("#b700ffff")("Adding Column to tables are completed successfully."));
+        if(count > 0){
+            console.log(cstyler.green.bold("Successfully added " + count + " columns."));
+        } else {
+            console.log("No column found to be added. All the column are added already.");
+        }
         return true;
     } catch (err) {
         console.error(err.message);

package/altercolumn.js

@@ -1,40 +1,22 @@
 const fncs = require("./function");
 const cstyler = require("cstyler");
+const crypto = require('crypto');
 
 
 
-function isValidToBeForeignkey(refColData, columnData) {
-    try {
-        if (refColData.columntype.toUpperCase() !== columnData.columntype.toUpperCase()) {
-            return false;
-        }
-        if (Array.isArray(refColData.length_values) !== Array.isArray(columnData.length_values)) {
-            return false;
-        } else if (Array.isArray(refColData.length_values) && Array.isArray(columnData.length_values)) {
-            if (!fncs.isSameArray(refColData.length_values, columnData.length_values)) {
-                return false;
-            }
-        } else {
-            if (refColData.length_values !== columnData.length_values) {
-                return false;
-            }
-        }
-        if ((refColData.unsigned || false) !== (columnData.unsigned || false)) {
-            return false;
-        }
-        if (["CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "SET"].includes(refColData.columntype.toUpperCase())) {
-            if ((refColData._charset_ || "") !== (columnData._charset_ || "")) {
-                return false;
-            }
-            if ((refColData._collate_ || "") !== (columnData._collate_ || "")) {
-                return false;
-            }
-        }
-        return true;
-    } catch (err) {
-        console.log(err);
-        return false;
-    }
+
+
+function generateSafeIndexName(prefix, table, column) {
+    const fullName = `${prefix}_${table}_${column}`;
+    
+    // If it fits, just return it
+    if (fullName.length <= 64) return fullName;
+
+    // If too long, hash the full string and append it to a slice
+    const hash = crypto.createHash('sha256').update(fullName).digest('hex').slice(0, 8);
+    
+    // 55 chars + 1 underscore + 8 chars hash = 64 chars total
+    return `${fullName.slice(0, 55)}_${hash}`;
 }
 async function isColumnDataSame(config, databaseName, tableName, columnName, columnData, columndetails, fkdetails,) {
     // 1. Column type
@@ -146,7 +128,7 @@ async function isColumnDataSame(config, databaseName, tableName, columnName, col
     } else if (idxA !== idxB && !realfk) {
         console.log(cstyler.blue("Table:"), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column:"), cstyler.hex("#00d9ffff")(columnName));
         console.log(cstyler.red("Index are not same"), cstyler.hex("#00b7ff")("Given data:"), cstyler.hex("#ffffff")(columnData.index), cstyler.hex("#00b7ff")("Server data:"), cstyler.hex("#ffffff")(columndetails.index),);
-        console.log("fk exist:", fkdetails)
+        console.log("Foreign key exist:", fkdetails)
         return false;
     }
 
@@ -186,7 +168,7 @@ async function isColumnDataSame(config, databaseName, tableName, columnName, col
 }
 // Identifier validator (letters, digits, underscore, dollar, max 64 chars)
 const validIdent = name => typeof name === 'string' && /^[A-Za-z0-9$_]{1,64}$/.test(name);
-async function alterColumnQuery(dbConfig, columndata, columnName, tableName, database, options = {}) {
+async function alterColumnQuery(dbConfig, columndata, columnName, tableName, database, options = {}, forceupdatecolumn) {
     try {
         // Basic validation
         if (!validIdent(columnName)) throw new Error('Invalid columnName');
@@ -320,14 +302,36 @@ async function alterColumnQuery(dbConfig, columndata, columnName, tableName, dat
             };
 
             if (wantsUnique) {
-                if (columnHasConstraint) {
-                    // Skip adding UNIQUE because column already participates in a constraint/index
-                    if (options.log !== false) {
-                        console.info(`Skipping ADD UNIQUE for ${database}.${tableName}.${columnName} because it already has constraints/indexes.`);
+                // Lets check for duplicates first
+                const hasdupes = await fncs.checkDuplicates(dbConfig, database, tableName, columnName);
+                if (hasdupes === null) {
+                    console.error("Having problem getting duplicate value of column from database");
+                    return null;
+                }
+                if (hasdupes === true) {
+                    if (forceupdatecolumn) {
+                        console.log(cstyler.bold.yellow("Cleaning duplicate rows before adding UNIQUE index..."));
+                        const cleancol = await fncs.cleanDuplicateRows(dbConfig, database, tableName, columnName);
+                        if (cleancol === null) {
+                            console.error("Having server connection problem cleaning duplicate rows from database");
+                            return null;
+                        }
+                    } else {
+                        console.error(`${cstyler.blue("Database:")} ${cstyler.hex("#00d9ffff")(database)} ${cstyler.blue("Table:")} ${cstyler.hex("#00d9ffff")(tableName)} ${cstyler.blue("Column:")} ${cstyler.hex("#00d9ffff")(columnName)} - Cannot add UNIQUE index because duplicate values exist. You need to turn on the ${cstyler.yellow("force_update_column")} option to true clean duplicates first.`);
+                        return false;
                     }
+                }
+                if (columnHasConstraint && info.constraints[0].constraintType === 'UNIQUE') {
+                    console.info(`Skipping: A Unique key already exists on ${columnName}.`);
                 } else {
+                    // Remove existing constraint/index first
+                    const remfkconstraint = await fncs.removeForeignKeyConstraintFromColumn(dbConfig, database, tableName, columnName);
+                    if (remfkconstraint === null) {
+                        console.error("Having problem removing constraint name from the column.");
+                        return null;
+                    }
                     // Add UNIQUE on the column (single-column unique)
-                    const idxName = (`uq_${tableName}_${columnName}`).slice(0, 64);
+                    const idxName = (`${generateSafeIndexName("un", tableName, columnName)}`).slice(0, 64);
                     actions.push(`ADD UNIQUE KEY ${quoteId(idxName)} (${quoteId(columnName)})`);
                 }
             } else {
@@ -355,6 +359,14 @@ async function alterColumnQuery(dbConfig, columndata, columnName, tableName, dat
                     else actions.push(`ADD ${type}${namePart} (${colsSql})`);
                 }
             }
+        } else {
+            if (columnHasConstraint) {
+                const rem = await fncs.removeForeignKeyConstraintFromColumn(dbConfig, database, tableName, columnName);
+                if (rem === null) {
+                    console.error("Having problem removing constraint name from the column.");
+                    return null;
+                }
+            }
         }
 
         // Return single ALTER TABLE statement (no multi-statement)
@@ -392,6 +404,7 @@ async function addForeignKeyWithIndexQuery(config, databaseName, tableName, colu
 async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separator) {
     try {
         console.log(cstyler.bold.yellow("Let's initiate Alter Column to table if needed..."));
+        let count = 0;
         for (const jsondb of Object.keys(jsondata)) {
             const loopdb = fncs.perseTableNameWithLoop(jsondb, separator);
             if (loopdb === false) {
@@ -471,11 +484,12 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
                                 }
                             }
                             // now alter the column
-                            const alterquery = await alterColumnQuery(config, columndata, jsoncolumn, tableName, databaseName);
+                            const alterquery = await alterColumnQuery(config, columndata, jsoncolumn, tableName, databaseName, {}, forceupdatecolumn);
                             if (alterquery === null) {
                                 console.error("There was an issue when creating alter column for", cstyler.blue("Database:"), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue("Table:"), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column:"), cstyler.hex("#00d9ffff")(jsoncolumn));
                                 return null;
                             }
+                            count += 1;
                             // now re add foreign key to the column if exist
                             if (columndata.hasOwnProperty("foreign_key")) {
                                 const fkdata = columndata.foreign_key;
@@ -516,11 +530,12 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
                                         return null;
                                     }
                                 }
-                                const alterquery = await alterColumnQuery(config, columndata, jsoncolumn, tableName, databaseName);
+                                const alterquery = await alterColumnQuery(config, columndata, jsoncolumn, tableName, databaseName, {}, forceupdatecolumn);
                                 if (alterquery === null) {
                                     console.error(cstyler.blue("Database:"), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue("Table:"), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column:"), cstyler.hex("#00d9ffff")(jsoncolumn), cstyler.red("There was an issue when modifying column",));
                                     return null;
                                 }
+                                count += 1;
                                 if (columndata.hasOwnProperty("foreign_key")) {
                                     const fkdata = columndata.foreign_key;
                                     const fkquery = await addForeignKeyWithIndexQuery(config, databaseName, tableName, jsoncolumn, fkdata.table, fkdata.column, {
@@ -535,9 +550,10 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
                             }
                         }
                     } else {
-                        console.log(cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue(" Table: "), cstyler.hex("#00d9ffff")(tableName), cstyler.blue(" Column Name: "), cstyler.hex("#00d9ffff")(jsoncolumn), cstyler.yellow("Given column data and server data are same."), "Let's check foreign key now.");
+                        console.log(cstyler.blue("Database:"), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue("Table:"), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column Name:"), cstyler.hex("#00d9ffff")(jsoncolumn), cstyler.yellow("- Given column data and server data are same."));
                         // lets check if foreign key need update
                         if (fkdetails === false && !columndata.hasOwnProperty("foreign_key")) {
+                            console.log(cstyler.underline("Column do not have foreign key."));
                             continue;
                         } else if (fkdetails === false && columndata.hasOwnProperty("foreign_key")) {
                             console.log(cstyler.yellow("Foreign key need to be added for "), cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue(" Table: "), cstyler.hex("#00d9ffff")(tableName), cstyler.blue(" Column Name: "), cstyler.hex("#00d9ffff")(jsoncolumn));
@@ -551,17 +567,18 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
                                 console.error("There was an issue when creating foreign key for", cstyler.blue("Database:"), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue("Table:"), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column:"), cstyler.hex("#00d9ffff")(jsoncolumn));
                                 return null;
                             }
+                            count += 1;
                         } else if (fncs.isJsonObject(fkdetails) && columndata.hasOwnProperty("foreign_key")) {
                             // need to check if foreign key details are same
                             const fkdt = columndata.foreign_key;
                             if (fkdetails.table === fkdt.table &&
                                 fkdetails.column === fkdt.column &&
                                 fkdetails.deleteOption === fkdt.deleteOption &&
-                                (fkdt.updateOption === undefined ||fkdetails.updateOption === fkdt.updateOption)) {
+                                (fkdt.updateOption === undefined || fkdetails.updateOption === fkdt.updateOption)) {
+                                console.log(cstyler.underline("Foreign key details are matched. No changes needed."))
                                 continue;
                             }
-                            console.log(cstyler.yellow("Foreign key need to be updated for "), cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue(" Table: "), cstyler.hex("#00d9ffff")(tableName), cstyler.blue(" Column Name: "), cstyler.hex("#00d9ffff")(jsoncolumn));
-                            console.log(cstyler.yellow("Foreign key details are different, updating foreign key for "), cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue(" Table: "), cstyler.hex("#00d9ffff")(tableName), cstyler.blue(" Column Name: "), cstyler.hex("#00d9ffff")(jsoncolumn));
+                            console.log(cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue(" Table: "), cstyler.hex("#00d9ffff")(tableName), cstyler.blue(" Column Name: "), cstyler.hex("#00d9ffff")(jsoncolumn), cstyler.yellow("- Foreign key details are different, updating foreign key."));
                             // need to update foreign key
                             const dropfk = await fncs.removeForeignKeyFromColumn(config, databaseName, tableName, jsoncolumn);
                             if (dropfk === null) {
@@ -577,12 +594,20 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
                                 console.error("There was an issue when creating foreign key for", cstyler.blue("Database:"), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue("Table:"), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column:"), cstyler.hex("#00d9ffff")(jsoncolumn));
                                 return null;
                             }
+                            count += 1;
+                        } else {
+                            console.log(cstyler.bold.red("There must be some issue when checking foreignkey details. Please contact support or re-install the module."))
                         }
                     }
                 }
             }
         }
-        console.log(cstyler.bold.underline.hex("#b700ffff")("Alter Column process to tables are completed successfully."));
+        if (count > 0) {
+            console.log(cstyler.bold.underline.green("Successfully altered " + count + " columns."))
+        } else {
+            console.log(cstyler.bold.underline("No column were altered at all."))
+        }
+        console.log(cstyler.bold.underline.hex("#00fff2ff")("Alter Column process to tables are completed successfully."));
         return true;
     } catch (err) {
         console.error(err.message);
@@ -592,4 +617,4 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
 
 module.exports = {
     alterColumnIfNeeded
-}
+}

package/dropcolumn.js

@@ -9,7 +9,7 @@ const cstyler = require("cstyler");
 async function dropcolumn(config, tableJson, forceDropColumn, separator = "_") {
     try {
         console.log(cstyler.bold.yellow("Initiating drop column operation"));
-
+        let count = 0;
         if (!fncs.isJsonObject(tableJson)) {
             return false;
         }
@@ -149,7 +149,8 @@ async function dropcolumn(config, tableJson, forceDropColumn, separator = "_") {
                         );
                         return null;
                     }
-
+                    console.log(cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(databaseName), cstyler.blue(" Table: "), cstyler.hex("#00d9ffff")(tableName), cstyler.blue("Column: "), cstyler.hex("#00d9ffff")(column), cstyler.green("- dropped successfully."))
+                    count += 1;
                     console.log(
                         cstyler.bold.green("Successfully dropped column:"),
                         cstyler.hex("#00d9ffff")(column),
@@ -159,7 +160,11 @@ async function dropcolumn(config, tableJson, forceDropColumn, separator = "_") {
                 }
             }
         }
-
+        if (count > 0) {
+            console.log(cstyler.green("Successfully dropped ", count, " columns."));
+        } else {
+            console.log("There is not column found to be dropped.");
+        }
         return true;
     } catch (err) {
         console.error(err?.message || err);

package/function.js

@@ -187,8 +187,9 @@ async function isMySQLDatabase(config) {
   }
 }
 async function checkDatabaseExists(config, dbName) {
+  let connection;
   try {
-    const connection = await mysql.createConnection({
+    connection = await mysql.createConnection({
       host: config.host,
       user: config.user,
       password: config.password,
@@ -202,6 +203,8 @@ async function checkDatabaseExists(config, dbName) {
   } catch (err) {
     console.error(err.message);
     return null;
+  } finally {
+    if (connection) await connection.end();
   }
 }
 async function dropDatabase(config, databaseName) {
@@ -1193,7 +1196,7 @@ async function inspectColumnConstraint(config, database, table, column, options
     console.error(err.message);
     return null;
   } finally {
-    await conn.end();
+    if (conn) await conn.end();
   }
 }
 async function _fetchIndexes(conn, database, tableName) {
@@ -1280,7 +1283,7 @@ async function checkIndexExists(config, database, tableName, indexKey) {
     console.error("Error in checkIndexExists:", err.message);
     return null;
   } finally {
-    await conn.end();
+    if (conn) await conn.end();
   }
 }
 async function columnHasKey(config, databaseName, tableName, columnName) {
@@ -1527,7 +1530,7 @@ async function findReferencingFromColumns(config, database, parentTable, parentC
     console.error("Error in findReferencingColumns:", err.message);
     return null;
   } finally {
-    await conn.end();
+    if (conn) await conn.end();
   }
 }
 async function addForeignKeyWithIndex(config, dbName, tableName, columnName, refTable, refColumn, options = {}) {
@@ -1851,8 +1854,64 @@ async function runQuery(config, databaseName, queryText) {
     if (connection) await connection.end();
   }
 }
+async function checkDuplicates(config, databaseName, tableName, columnName) {
+  let connection;
+
+  try {
+    connection = await mysql.createConnection({
+      ...config,
+      database: databaseName
+    });
+
+    const sql = `
+      SELECT COUNT(*) as duplicateCount 
+      FROM (
+        SELECT \`${columnName}\` 
+        FROM \`${tableName}\` 
+        GROUP BY \`${columnName}\` 
+        HAVING COUNT(\`${columnName}\`) > 1
+      ) AS dup_query`;
+
+    const [rows] = await connection.execute(sql);
+    
+    // Returns true if duplicates exist, false if not
+    return rows[0].duplicateCount > 0;
+
+  } catch (err) {
+    console.error(`Check Error: ${err.message}`);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function cleanDuplicateRows(config, databaseName, tableName, columnName) {
+  let connection;
 
+  try {
+    connection = await mysql.createConnection({
+      ...config,
+      database: databaseName
+    });
 
+    // We use a self-join to find rows with matching values but higher IDs
+    const sql = `
+      DELETE t1 FROM \`${tableName}\` t1
+      INNER JOIN \`${tableName}\` t2 
+      ON t1.\`${columnName}\` = t2.\`${columnName}\` 
+      AND t1.id > t2.id`;
+
+    const [result] = await connection.execute(sql);
+    
+    // Returns the number of deleted rows
+    return result.affectedRows;
+
+  } catch (err) {
+    console.error(`Clean Error: ${err.message}`);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
 
 
 module.exports = {
@@ -1903,4 +1962,6 @@ module.exports = {
   dropColumn,
   writeJsFile,
   runQuery,
+  checkDuplicates,
+  cleanDuplicateRows,
 }

package/index.js

@@ -148,7 +148,7 @@ module.exports = async function (allconfig, table_json) {
             return;
         }
         const jsondata = checking.data;
-        console.log(cstyler.bold.purple("Lets start operation on databases."));
+        console.log(cstyler.bold.underline.hex("#00fff2ff")("Lets start operation on databases."));
         const dbop = require("./dbop");
         const databaseop = await dbop.databaseAddDeleteAlter(config, jsondata, dropdatabase, donttouchdb, separator);
         if (databaseop === null) {
@@ -164,18 +164,18 @@ module.exports = async function (allconfig, table_json) {
         }
         // Drop tables
         if (droptable) {
-            console.log(cstyler.bold.purple("Lets drop unlisted table if needed."));
+            console.log(cstyler.bold.underline.hex("#00fff2ff")("Lets drop unlisted table if needed."));
             const droptableifneeded = await tableop.dropTable(config, jsondata, separator);
             if (droptableifneeded === null) {
                 console.log(cstyler.bold.underline.red("Error occurred during dropping tables."));
                 return;
             }
         }
-        console.log(cstyler.bold.purple("Lets start working on columns"));
+        console.log(cstyler.bold.underline.green("<<<Lets start working on columns>>>"));
         const colop = require("./dropcolumn");
 
         // lets drop columns if needed
-        console.log(cstyler.bold.purple("Lets drop unlisted columns if needed."));
+        console.log(cstyler.bold.underline.hex("#00fff2ff")("Lets drop unlisted columns if needed."));
         if (dropcolumn) {
             const dropcolifneeded = await colop.dropcolumn(config, jsondata, forcedropcolumn, separator);
             if (dropcolifneeded === null) {
@@ -185,7 +185,7 @@ module.exports = async function (allconfig, table_json) {
         }
         // lets add columns if needed
         const addcolumn = require("./addcolumn");
-        console.log(cstyler.bold.purple("Lets add columns if needed."));
+        console.log(cstyler.bold.underline.hex("#00fff2ff")("Lets add columns if needed."));
         const addcolifneeded = await addcolumn.addColumnIfNeeded(config, jsondata, separator);
         if (addcolifneeded === null) {
             console.log(cstyler.bold.underline.red("Error occurred during adding columns."));
@@ -193,17 +193,13 @@ module.exports = async function (allconfig, table_json) {
         }
         // lets alter columns if needed
         const altercolop = require("./altercolumn");
-        console.log(cstyler.bold.purple("Lets alter columns if needed."));
+        console.log(cstyler.bold.underline.hex("#00fff2ff")("Lets alter columns if needed."));
         const altercolifneeded = await altercolop.alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separator);
         if (altercolifneeded === null) {
             console.log(cstyler.bold.underline.red("Error occurred during altering columns."));
             return;
         }
 
-
-
-
-
         console.log(cstyler.bold.underline.green("<<<All database work is done perfectly>>>"));
     } catch (err) {
         console.error(err.message);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "dbtasker",
-  "version": "3.0.8",
+  "version": "3.0.9",
   "funding": {
     "type": "patreon",
-    "url": "https://www.patreon.com/cw/kormoi/membership"
+    "url": "https://www.patreon.com/kormoi/gift"
   },
   "description": "dbtasker is a powerful and developer-friendly MySQL schema automation tool that converts JSON-based definitions into validated SQL that allows developers to declaratively define databases, tables, columns, indexes, and foreign keys using a flexible, case-insensitive JSON schema.",
   "license": "ISC",
@@ -38,6 +38,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
+    "crypto": "^1.0.1",
     "cstyler": "^4.0.0",
     "fs": "^0.0.1-security",
     "mysql2": "^3.14.3",

package/tableop.js

@@ -158,7 +158,7 @@ async function createTableIfNeeded(config, jsondata, separator) {
             return false;
         }
         let foreignkeys = {};
-        console.log(cstyler.bold.purple("Lets start creating unlisted tables if needed."));
+        console.log(cstyler.bold.underline.hex("#00fff2ff")("Lets start creating unlisted tables if needed."));
         // Lets check config
         for (const jsdb of Object.keys(jsondata)) {
             let dbname = fncs.perseDatabaseNameWithLoop(jsdb, separator);
@@ -209,7 +209,7 @@ async function createTableIfNeeded(config, jsondata, separator) {
                 }
             }
         }
-        console.log(cstyler.bold.underline.hex("#b700ffff")("Create table if needed process completed successfully."));
+        console.log(cstyler.bold.underline.green("Create table if needed process completed successfully."));
         return true;
     } catch (err) {
         console.error(cstyler.bold.red("Error occurred in createTableIfNeeded function of ", moduleName, " module. Error details: "), err);
@@ -254,11 +254,11 @@ async function dropTable(config, json_data, separator = "_") {
                     }
                 }
             }
-            if (count > 0) {
-                console.log(cstyler.green("Successfully dropped ", count, " unlisted tables"));
-            } else {
-                console.log(cstyler.underline("No table found to be dropped"));
-            }
+        }
+        if (count > 0) {
+            console.log(cstyler.green("Successfully dropped ", count, " unlisted tables"));
+        } else {
+            console.log(cstyler.underline("No table found to be dropped"));
         }
         return true;
     } catch (err) {