dbtasker 2.5.1 → 3.0.0

package/index.js

@@ -1,5 +1,5 @@
 const fncs = require("./function");
-const recordedjson = require("./tables");
+const recordedjson = require("./tableop");
 const cstyler = require("cstyler");
 const checker = require("./validation");
 
@@ -8,10 +8,11 @@ const checker = require("./validation");
 
 const moduleName = "dbtasker";
 const truers = [true, 1, "1", "true", "True", "TRUE"];
+const falsers = [false, 0, "0", "false", "False", "FALSE"];
 
-module.exports = async function(allconfig, table_json) {
+module.exports = async function (allconfig, table_json) {
     try {
-        console.log(cstyler.blue("Initializing DBTASKER..."))
+        console.log(cstyler.hex("#00d9ffff")("Initializing DBTASKER..."))
         // check if enough database available on table json
         const databaseNames = Object.keys(table_json);
         if (databaseNames.length === 0) {
@@ -31,6 +32,29 @@ module.exports = async function(allconfig, table_json) {
             'password': allconfig.password,
             'port': allconfig.port
         }
+        // lets check database type
+        const ifmysqldatabase = await fncs.isMySQLDatabase(config);
+        if (ifmysqldatabase === false) {
+            console.error("My SQL database is required to run ", moduleName, " module. Please install mysql2 to use this module. To install run this code on the terminal > npm install mysql2");
+            return;
+        }
+        const isvalidmysqlversion = await fncs.isMySQL578OrAbove(config);
+        if (isvalidmysqlversion === false) {
+            console.error("My SQL version 5.7.8 or above is required. Please check if you have installed mysql2. To install: npm install mysql2");
+            return;
+        }
+        // Declare separator
+        let separator = "_";
+        const sepkeys = ['sep', 'separator'];
+        for (const item of Object.keys(allconfig)) {
+            if (sepkeys.includes(item.toLowerCase())) {
+                separator = allconfig[item];
+                break;
+            }
+        }
+        if (!fncs.isValidMySQLIdentifier(separator)) {
+            separator = "_";
+        }
         // get don't touch database
         let donttouchdb = [];
         const donttouchkeys = ['donttouch', 'donottouch', 'donttouchdb', 'donottouchdb', 'donttouchdatabase', 'donottouchdatabase', 'dontdelete', 'donotdelete', 'dontdeletedb', 'donotdeletedb', 'dontdeletedatabase', 'donotdeletedatabase', 'dont_touch', 'do_not_touch', 'dont_touch_db', 'do_not_touch_db', 'dont_touch_database', 'do_not_touch_database', 'dont_delete', 'do_not_delete', 'dont_delete_db', 'do_not_delete_db', 'dont_delete_database', 'do_not_delete_database', 'reserveddb', 'reserved_db'];
@@ -50,18 +74,6 @@ module.exports = async function(allconfig, table_json) {
                 }
             }
         }
-        // Declare seperator
-        let seperator = "_";
-        const sepkeys = ['sep', 'seperator'];
-        for (const item of Object.keys(allconfig)) {
-            if (sepkeys.includes(item.toLowerCase())) {
-                seperator = allconfig[item];
-                break;
-            }
-        }
-        if (!fncs.isValidMySQLIdentifier(seperator)) {
-            seperator = "_";
-        }
         let dropdatabase;
         const dropdbkeys = ['dropdb', 'dropdatabase', 'deletedb', 'deletedatabase', 'drop_db', 'drop_database', 'delete_db', 'delete_database', 'removedb', 'removedatabase', 'remove_db', 'remove_database'];
         for (const item of Object.keys(allconfig)) {
@@ -95,23 +107,42 @@ module.exports = async function(allconfig, table_json) {
         }
         if (truers.includes(dropcolumn)) {
             dropcolumn = true;
-        } else {
+        } else if (falsers.includes(dropcolumn)) {
             dropcolumn = false;
+        } else {
+            dropcolumn = true;
         }
-        // lets check database type
-        const ifmysqldatabase = await fncs.isMySQLDatabase(config);
-        if (ifmysqldatabase === false) {
-            console.error("My SQL database is required to run ", moduleName, " module. Please install mysql2 to use this module. To install run this code on the terminal > npm install mysql2");
-            return;
+        let forcedropcolumn;
+        const frocedropcolkey = ['forcedropcol', 'forcedropcolumn', 'forcedeletecol', 'forcedeletecolumn', 'forceremovecol', 'forceremovecolumn', 'force_drop_col', 'force_drop_column', 'force_delete_col', 'force_delete_column', 'force_remove_col', 'force_remove_column'];
+        for (const item of Object.keys(allconfig)) {
+            if (frocedropcolkey.includes(item.toLowerCase())) {
+                forcedropcolumn = allconfig[item];
+            }
         }
-        const isvalidmysqlversion = await fncs.isMySQL578OrAbove(config);
-        if (isvalidmysqlversion === false) {
-            console.error("My SQL version 5.7.8 or above is required. Please check if you have installed mysql2. To install: npm install mysql2");
-            return;
+        if (truers.includes(forcedropcolumn)) {
+            forcedropcolumn = true;
+        } else if (falsers.includes(forcedropcolumn)) {
+            forcedropcolumn = false;
+        } else {
+            forcedropcolumn = false;
+        }
+        let forceupdatecolumn;
+        const forceupdatecolkey = ['forceupdatecol', 'forcemodifycol', 'forceupdatecolumn', 'forcemodifycolumn', 'force_update_col', 'force_modify_col', 'force_update_column', 'force_modify_column', 'forcealtercol', 'forcealtercolumn', 'force_alter_col', 'force_alter_column'];
+        for (const item of Object.keys(allconfig)) {
+            if (forceupdatecolkey.includes(item.toLowerCase())) {
+                forceupdatecolumn = allconfig[item];
+            }
+        }
+        if (truers.includes(forceupdatecolumn)) {
+            forceupdatecolumn = true;
+        } else if (falsers.includes(forceupdatecolumn)) {
+            forceupdatecolumn = false;
+        } else {
+            forceupdatecolumn = true;
         }
         console.log(cstyler.bold.underline.yellow("Lets check if the table need an upgrade"))
         // lets check all table name and column name
-        const checking = await checker.JSONchecker(table_json, config, seperator);
+        const checking = await checker.JSONchecker(table_json, config, separator);
         if (checking.status === false) {
             console.log(cstyler.bold.underline.red("Please correct those information and try again."))
             return;
@@ -119,25 +150,60 @@ module.exports = async function(allconfig, table_json) {
         const jsondata = checking.data;
         console.log(cstyler.bold.purple("Lets start operation on databases."));
         const dbop = require("./dbop");
-        const databaseop = await dbop.databaseAddDeleteAlter(config, jsondata, dropdatabase, donttouchdb, seperator);
+        const databaseop = await dbop.databaseAddDeleteAlter(config, jsondata, dropdatabase, donttouchdb, separator);
         if (databaseop === null) {
+            console.log(cstyler.bold.underline.red("Error occurred during database operation."));
+            return;
+        }
+        // lets create tables if needed
+        const tableop = require("./tableop");
+        const createtable = await tableop.createTableifNeeded(config, jsondata, separator);
+        if (createtable === null) {
+            console.log(cstyler.bold.underline.red("Error occurred during creating tables."));
             return;
         }
         // Drop tables
         if (droptable) {
             console.log(cstyler.bold.purple("Lets drop unlisted table if needed."));
-            const droptableifneeded = await dbop.dropTable(config, jsondata, seperator);
+            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"));
-        const colop = require("./columnop");
-        const columnop = await colop.columnAddDeleteAlter(config, jsondata, dropcolumn, seperator);
-        if (columnop === null) {
+        const colop = require("./dropcolumn");
+
+        // lets drop columns if needed
+        console.log(cstyler.bold.purple("Lets drop unlisted columns if needed."));
+        if (dropcolumn) {
+            const dropcolifneeded = await colop.dropcolumn(config, jsondata, forcedropcolumn, separator);
+            if (dropcolifneeded === null) {
+                console.log(cstyler.bold.underline.red("Error occurred during dropping columns."));
+                return;
+            }
+        }
+        // lets add columns if needed
+        const addcolumn = require("./addcolumn");
+        console.log(cstyler.bold.purple("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."));
             return;
         }
+        // lets alter columns if needed
+        const altercolop = require("./altercolumn");
+        console.log(cstyler.bold.purple("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,6 +1,6 @@
 {
   "name": "dbtasker",
-  "version": "2.5.1",
+  "version": "3.0.0",
   "description": "You can create database and table on your own with a lot of functionality.",
   "license": "ISC",
   "author": "Md Nasiruddin Ahmed",

package/tableop.js

@@ -0,0 +1,273 @@
+const fncs = require("./function");
+const cstyler = require("cstyler");
+
+const moduleName = "dbtasker";
+const truers = [true, 1, "1", "true", "True", "TRUE"];
+const falsers = [false, 0, "0", "false", "False", "FALSE"];
+
+
+
+
+
+async function createTableQuery(config, tabledata, tableName, dbname) {
+    try {
+        //let queryText = `CREATE TABLE ${tableName} ( `;
+        let quries = [];
+        let foreignkeys = {};
+        for (const columnName of Object.keys(tabledata)) {
+            let queryText = "";
+            if (["_engine_", "_charset_", "_collate_"].includes(columnName)) {
+                continue;
+            }
+            queryText += `\`${columnName}\``;
+            if (tabledata[columnName].hasOwnProperty("columntype")) {
+                queryText += ` ${tabledata[columnName].columntype}`
+            }
+            if (tabledata[columnName].hasOwnProperty("length_value")) {
+                const lengthval = tabledata[columnName].length_value;
+
+                // INT, VARCHAR, CHAR, BIT, etc.
+                if (typeof lengthval === "number") {
+                    queryText += `(${lengthval})`;
+                }
+
+                // DECIMAL, FLOAT, DOUBLE → [precision, scale]
+                else if (
+                    Array.isArray(lengthval) &&
+                    lengthval.length === 2 &&
+                    lengthval.every(v => typeof v === "number")
+                ) {
+                    queryText += `(${lengthval[0]},${lengthval[1]})`;
+                }
+
+                // ENUM / SET → ['a','b','c']
+                else if (
+                    Array.isArray(lengthval) &&
+                    lengthval.every(v => typeof v === "string")
+                ) {
+                    const escaped = lengthval.map(v => `'${v.replace(/'/g, "''")}'`);
+                    queryText += `(${escaped.join(",")})`;
+                }
+            }
+            queryText += " ";
+            if (tabledata[columnName].hasOwnProperty("unsigned") && tabledata[columnName].unsigned === true) {
+                queryText += `UNSIGNED `
+            }
+            if (tabledata[columnName].zerofill === true) {
+                queryText += `ZEROFILL `
+            }
+            if (tabledata[columnName].autoincrement === true) {
+                queryText += `AUTO_INCREMENT `
+            }
+            if (tabledata[columnName].hasOwnProperty("index")) {
+                queryText += `${tabledata[columnName].index} `
+            }
+            if (tabledata[columnName].hasOwnProperty("_charset_")) {
+                queryText += `CHARACTER SET ${tabledata[columnName]._charset_} `
+            }
+            if (tabledata[columnName].hasOwnProperty("_collate_")) {
+                queryText += `COLLATE ${tabledata[columnName]._collate_} `
+            }
+            if (tabledata[columnName].hasOwnProperty("nulls")) {
+                if (tabledata[columnName].nulls === true) {
+                    queryText += `NULL `
+                } else {
+                    queryText += `NOT NULL `
+                }
+            }
+            if (tabledata[columnName].hasOwnProperty("defaults")) {
+                const d = tabledata[columnName].defaults;
+                if (d === null) queryText += "DEFAULT NULL ";
+                else if (typeof d === "number") queryText += `DEFAULT ${d} `;
+                else if (/^CURRENT_TIMESTAMP$/i.test(d)) queryText += `DEFAULT ${d} `;
+                else queryText += `DEFAULT '${d.replace(/'/g, "''")}' `;
+            }
+            if (tabledata[columnName].hasOwnProperty("comment")) {
+                queryText += `COMMENT '${tabledata[columnName].comment}' `
+            }
+            quries.push(queryText);
+            // lets sotore foreing keys
+            if (tabledata[columnName].hasOwnProperty("foreign_key")) {
+                foreignkeys[columnName] = tabledata[columnName].foreign_key;
+            }
+        }
+        // foreign keys
+        let fkquery = [];
+        let keyidx = [];
+        if (Object.keys(foreignkeys).length > 0) {
+            for (const fks in foreignkeys) {
+                const ifexist = await fncs.columnExists(config, dbname, tabledata[fks].foreign_key.table, tabledata[fks].foreign_key.column);
+                if (ifexist === false) {
+                    console.log(cstyler.red("Foreign key column do not exist."));
+                } else if (ifexist === true) {
+                    let fktext = "";
+                    fktext +=
+                        `CONSTRAINT fk_${tableName}_${foreignkeys[fks].table}_${foreignkeys[fks].column} ` +
+                        `FOREIGN KEY (\`${fks}\`) REFERENCES \`${foreignkeys[fks].table}\`(\`${foreignkeys[fks].column}\`) `;
+
+                    if (foreignkeys[fks].hasOwnProperty("deleteOption")) {
+                        fktext += `ON DELETE ${foreignkeys[fks].deleteOption} `
+                    }
+                    if (foreignkeys[fks].hasOwnProperty("updateOption")) {
+                        console.log(cstyler.red("has update option"), foreignkeys[fks].updateOption)
+                        fktext += `ON UPDATE ${foreignkeys[fks].updateOption} `
+                    }
+                    fkquery.push(fktext);
+                    keyidx.push(`KEY \`idx_${tableName}_${fks}\` (\`${fks}\`)`);
+                    // lets delete used item from the foreign key
+                    delete foreignkeys[fks];
+                } else {
+                    console.error("Having problem connecting to database.");
+                    return null;
+                }
+            }
+        }
+        let lastqueryText = ``;
+        if (tabledata.hasOwnProperty("_engine_")) {
+            lastqueryText += `ENGINE=${tabledata._engine_}\n`;
+        }
+        if (tabledata.hasOwnProperty("_charset_")) {
+            lastqueryText += `DEFAULT CHARSET=${tabledata._charset_}\n`;
+        }
+        if (tabledata.hasOwnProperty("_collate_")) {
+            lastqueryText += `COLLATE=${tabledata._collate_}\n`;
+        }
+        if (tabledata.hasOwnProperty("_comment_")) {
+            lastqueryText += `COMMENT=${tabledata._comment_}\n`;
+        }
+        const fullqueryText = `
+            CREATE TABLE IF NOT EXISTS \`${tableName}\` (
+            ${[...quries, ...keyidx, ...fkquery].join(",\n  ")}
+            ) ${lastqueryText};
+            `;
+        console.log("Running query: ", cstyler.green(fullqueryText));
+        const runquery = await fncs.runQuery(config, dbname, fullqueryText);
+        if (runquery === null) {
+            return null;
+        }
+        console.log(cstyler.green("Successfully created "), cstyler.blue("Table: "), cstyler.hex("#00d9ffff")(tableName), " on ", cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(dbname));
+        return foreignkeys;
+    } catch (err) {
+        console.error(err.message);
+        return null;
+    }
+}
+async function createTableifNeeded(config, jsondata, separator) {
+    try {
+        if (!fncs.isJsonObject(jsondata)) {
+            return false;
+        }
+        let foreignkeys = {};
+        console.log(cstyler.bold.purple("Lets start creating unlisted tables if needed."));
+        // Lets check config
+        for (const jsdb of Object.keys(jsondata)) {
+            let dbname = fncs.perseDatabaseNameWithLoop(jsdb, separator);
+            if (dbname === false) {
+                console.error(cstyler.bold.red("There must be some mistake. Please re install the module."));
+                return null;
+            }
+            const getalltables = await fncs.getTableNames(config, dbname.loopname);
+            if (getalltables === null) {
+                console.error(cstyler.bold.red("Having problem getting all the table names of Database: ", dbname.loopname, ". Please re-install the module."));
+                return null;
+            }
+            for (const dbtableName of Object.keys(jsondata[jsdb])) {
+                // check if table data is json object
+                if (fncs.isJsonObject(jsondata[jsdb][dbtableName]) === false) { continue }
+                const tableName = fncs.perseTableNameWithLoop(dbtableName, separator);
+                if (tableName === false) {
+                    console.error(cstyler.bold.red("Can not parse table name from json. There must be some mistake in table name. Please re install the module."));
+                    return null;
+                }
+                if (getalltables.includes(tableName.loopname)) {
+                    console.log(cstyler.blue("Database:"), cstyler.hex("#00d9ffff")(dbname.loopname), cstyler.blue("Table: "), cstyler.hex("#00d9ffff")(tableName.loopname), cstyler.green(" already exists in Database"));
+                    continue;
+                }
+                const createtable = await createTableQuery(config, jsondata[jsdb][dbtableName], tableName.loopname, dbname.loopname);
+                if (createtable === null) {
+                    console.error(cstyler.bold.red("Having problem creating table: ", tableName.loopname, " on Database: ", dbname.loopname, ". Please check database connection."));
+                    return null;
+                }
+                if (createtable && Object.keys(createtable).length > 0) {
+                    foreignkeys = fncs.JoinJsonObjects(foreignkeys, createtable);
+                }
+            }
+            // lets create foreign keys if any
+            if (Object.keys(foreignkeys).length > 0) {
+                for (const fkcol of Object.keys(foreignkeys)) {
+                    const addfk = await fncs.addForeignKeyWithIndex(config, dbname.loopname, tableName.loopname, fkcol, foreignkeys[fkcol].table, foreignkeys[fkcol].column, { onDelete: foreignkeys[fkcol].deleteOption, onUpdate: foreignkeys[fkcol].updateOption });
+                    if (addfk === null) {
+                        console.error(cstyler.bold.red("Having problem adding foreign key constraint on column: ", fkcol, " on Database: ", dbname.loopname, ". Please check database connection."));
+                        return null;
+                    }
+                    else if (addfk === true) {
+                        console.log(cstyler.green("Successfully added foreign key constraint on column: "), cstyler.hex("#00d9ffff")(fkcol), cstyler.green(" on Table: "), cstyler.hex("#00d9ffff")(tableName.loopname), cstyler.green(" on Database: "), cstyler.hex("#00d9ffff")(dbname.loopname));
+                    }
+                    else if (addfk === false) {
+                        console.log(cstyler.blue("Foreign key constraint on column: "), cstyler.hex("#00d9ffff")(fkcol), cstyler.blue(" on Table: "), cstyler.hex("#00d9ffff")(tableName.loopname), cstyler.blue(" on Database: "), cstyler.hex("#00d9ffff")(dbname.loopname), cstyler.blue(" already exists. So, skipping."));
+                    }
+                }
+            }
+        }
+        return true;
+    } catch (err) {
+        console.error(cstyler.bold.red("Error occurred in createTableifNeeded function of ", moduleName, " module. Error details: "), err);
+        return null;
+    }
+}
+async function dropTable(config, json_data, separator = "_") {
+    try {
+        console.log(cstyler.bold.yellow("Initiating drop table operation"));
+        let count = 0;
+        for (const jsondb of Object.keys(json_data)) {
+            let dbname = fncs.perseDatabaseNameWithLoop(jsondb, separator);
+            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.blue(dbname.loopname), ". Please re-install the module.");
+                return null;
+            }
+            for (const tableName of (alltables)) {
+                const revlpnm = fncs.reverseLoopName(tableName);
+                if (Array.isArray(revlpnm)) {
+                    if (!Object.keys(json_data[jsondb]).includes(revlpnm[0]) && !Object.keys(json_data[jsondb]).includes(revlpnm[1]) && !Object.keys(json_data[jsondb]).includes(revlpnm[2]) && !Object.keys(json_data[jsondb]).includes(revlpnm[3])) {
+                        const droptable = await fncs.dropTable(config, dbname.loopname, tableName);
+                        if (droptable === null) {
+                            console.error("Having problem dropping table. Please check database connection.");
+                            return null;
+                        } else if (droptable === true) {
+                            count += 1;
+                            console.log(cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(dbname.loopname), cstyler.blue("Table: "), cstyler.hex("#00d9ffff")(tableName), "- has dropped successfully.");
+                        }
+                    }
+                } else if (!Object.keys(json_data[jsondb]).includes(revlpnm)) {
+                    const droptable = await fncs.dropTable(config, dbname.loopname, tableName);
+                    if (droptable === null) {
+                        console.error("Having problem dropping table. Please check database connection.");
+                        return null;
+                    } else if (droptable === true) {
+                        count += 1;
+                        console.log(cstyler.blue("Database: "), cstyler.hex("#00d9ffff")(dbname.loopname), cstyler.blue("Table: "), cstyler.hex("#00d9ffff")(tableName), "- has dropped successfully.");
+                    }
+                }
+            }
+            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) {
+        console.error(err.message);
+        return null;
+    }
+}
+
+
+module.exports = {
+    createTableifNeeded,
+    dropTable
+};