dbtasker 3.0.3 → 3.0.5

package/README.md

@@ -1,225 +1,46 @@
-# DBTASKER
+# 🗄️ DBTASKER
 
-DBTASKER is a powerful MySQL schema intelligence and query generation module. It allows developers to define database schemas declaratively in JSON. DBTASKER automatically validates, normalizes, and generates correct SQL for tables, columns, indexes, defaults, foreign keys, and more.
-It is engine-aware, handles MySQL constraints, and is fully compatible with ORMs or other automation tools.
+The Intelligent MySQL Schema Automation Engine
+`dbtasker` is a powerful, engine-aware MySQL schema intelligence and query generation module. It allows developers to define database structures declaratively using JSON, providing automated validation, normalization, and SQL generation for tables, columns, indexes, and foreign keys.
 
-#### Engine Awareness
-DBTASKER supports MySQL engines and handles constraints accordingly:
 
-- InnoDB
-- MyISAM
-- MEMORY
-- CSV
-- ARCHIVE
-- BLACKHOLE
-- FEDERATED
-- NDB / NDBCLUSTER
-- MRG_MYISAM
-- Spider
-- RocksDB
-- TokuDB
 
+## 🚀 Key Features
+- **Declarative Schema:** Define your entire database structure in a single JSON object.
+- **Engine Awareness:** Optimized for MySQL engines including InnoDB, MyISAM, RocksDB, and more.
+- **Validation First:** Validates and normalizes your schema before any SQL is executed.
+- **Intelligent Migration:** Safe handling of ALTER, DROP, and CREATE operations.
+- **Alias Flexibility:** Case-insensitive keys and multiple naming aliases (camelCase, snake_case, etc.).
 
-#### Design Philosophy
 
-- Schema-first, declarative JSON
-- Validation before SQL generation
-- Engine-aware and safe migrations
-- Flexible key aliases and metadata support
-- Supports both SQL-level and ORM-level annotations
 
-
-#### Compatibility
-- Node.js 16+
-- MySQL 5.7+ / 8+
-
-
-## Core Concept
-DBTASKER uses a JSON-driven design:
-```js 
-Database → Tables → Columns → Column Properties
-```
-
-- Database: Name of the MySQL database
-- Table: Table within the database
-- Column: Column within the table
-- Properties: Rules, types, defaults, and constraints
-
-
-DBTASKER normalizes keys case-insensitively, so multiple naming styles are supported (camelCase, snake_case, uppercase, lowercase).
-
-#### JSON Schema Structure
-```js
-{
-  DatabaseName: {
-    TableName: {
-      ColumnName: {
-        // Column properties
-      }
-    }
-  }
-}
-```
-Demo Schema Example
-```js
-{
-  DatabaseName: {
-    TableName: {
-      ColumnName: {
-        ColumnType: "varchar",
-        lengthvalue: 255,
-        Null: true,
-        defaults: "guest",
-        comment: "User email address"
-      },
-      ColumnTwo: {
-        type: "int",
-        zerofill: true,
-        index: "key",
-        Null: false,
-        foreign_key: {
-          table: "user",
-          column: "id",
-          delete: true,
-          update: true
-        }
-      }
-    }
-  }
-}
-```
-
-## Configuration File
-
-DBTASKER requires a configuration JSON file to connect to your MySQL database and define runtime behavior. This config file allows you to:
-
-- Set database connection credentials
-- Control whether databases, tables, or columns are dropped
-- Protect specific databases from accidental deletion
-- Customize separators or other runtime options
-
-**Basic Database Configuration**
+## 📦 Installation
+`Bash`
 ```js
-{
-  user: "root",
-  password: "password123",
-  host: "localhost",
-  port: 3306
-}
-```
-
-1. user: MySQL username
-2. password: MySQL password
-3. host: MySQL host
-4. port: MySQL port
-5. Drop database
-6. Do not delete database Array = []
-7. Drop Table
-8. Drop Column
-9. Database structure as JSON Object
-
-You can control dropping databases, tables, or columns using boolean flags. DBTASKER supports multiple aliases for each option.
-
-#### Drop Database
-
-### Aliases:
-You can use these as key when declearing on config JSON object without caring for case sensitivity.
-```js
-dropdb, dropdatabase, deletedb, deletedatabase,
-drop_db, drop_database, delete_db, delete_database,
-removedb, removedatabase, remove_db, remove_database
-```
-
-
-**Example:**
-```js
-dropdb: true
-```
-
-### Drop Table
-**Aliases:**
-You can use these as key when declearing on config JSON object without caring for case sensitivity.
-```js
-droptable, deletetable, drop_table, delete_table,
-removetable, remove_table,
-dropdbtable, deletedbtable, removedbtable,
-dropdatabasetable, deletedatabasetable, removedatabasetable,
-drop_db_table, delete_db_table, remove_db_table,
-drop_database_table, delete_database_table, remove_database_table
-```
-
-
-**Example:**
-```js
-droptable: true
-```
-
-
-### Drop Column
-**Aliases:**
-You can use these as key when declearing on config JSON object without caring for case sensitivity.
-```js
-dropcol, dropcolumn, deletecol, deletecolumn,
-removecol, removecolumn,
-drop_col, drop_column, delete_col, delete_column,
-remove_col, remove_column
-```
-
-
-**Example:**
-```js
-dropcol: false
-```
-
-**Protect Databases from Deletion**
-If you want to prevent certain databases from being dropped when dropdb is enabled, you can specify an array of database names under any of the aliases below:
-You can use these as key when declearing on config JSON object without caring for case sensitivity.
-```js
-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
-```
-
-**Example:**
-```js
-donttouch: ["production_db", "legacy_db"]
-```
-
-
-**Force Update Column**
-If you want to update column if it is referanced by another column as foreign key you can update it by adding another key to the config which is force update column which is turned on by default. You can turn it of if you think necessary.
-
-```js
-'forceupdatecol', 'forcemodifycol', 'forceupdatecolumn', 'forcemodifycolumn', 'force_update_col', 'force_modify_col', 'force_update_column', 'force_modify_column', 'forcealtercol', 'forcealtercolumn', 'force_alter_col', 'force_alter_column'
-```
-
-**Example:**
-```js
-forceupdatecol: true/1/\"1\"
+npm install dbtasker
 ```
 
-### Separator Option
-
-You can define a custom separator for internal operations:
 
-**Aliases:**
-You can use these as key when declearing on config JSON object without caring for case sensitivity.
-sep, seperator
 
+## 🛠️ Configurationd
+btasker requires a configuration object to manage connection credentials and safety behaviors.
+Property | Description
+| :--- | :--- |
+| **host** | MySQL Host (e.g., `localhost`) |
+| **user** | Database Username |
+| **password** | Database Password |
+| **port** | Connection Port (Default: `3306`) |
+| **dropdb** | `Boolean`: If true, allows dropping databases. |
+| **droptable** | `Boolean`: If true, allows dropping tables. |
+| **dropcol** | `Boolean`: If true, allows dropping columns. |
+| **donttouch** | `Array`: List of database names protected from deletion. |
+| **forcedeletecolumn** | `Boolean`: If true, allow dropping column even if referanced by any other column. |
+| **forceupdatecolumn** | `Boolean`: If true, allow updating column even if referanced by any other column. `default: true` |
 
-**Example:**
+### Configuration Example
+`JavaScript`
 ```js
-sep: "_"
-```
-Full Example Config File
-```js
-{
+const config = {
   user: "root",
   password: "password123",
   host: "localhost",
@@ -228,88 +49,33 @@ Full Example Config File
   droptable: true,
   dropcol: false,
   donttouch: ["production_db", "analytics_db"],
-  sep: "_"
-}
-```
-
-This configuration will:
-
-- Connect to MySQL using the given credentials
-- Drop databases and tables if they exist
-- Preserve "production_db" and "analytics_db"
-- Avoid dropping columns
-- Use _ as a separator internally
-
-## Installation
-
-DBTASKER is available via npm.
-
-Install it using either of the following commands:
-```js
-npm install dbtasker
-```
-
-or
-```js
-npm i dbtasker
-```
-Usage
-
-DBTASKER is designed to be simple and declarative. You provide:
-
-1. A configuration object (database credentials + behavior options)
-
-2. A JSON schema object (database, tables, columns)
-
-DBTASKER handles the rest.
-
-#### Step 1: Import DBTASKER
-
-Create a JavaScript file (for example: index.js) and import DBTASKER.
-```js
-Using require (CommonJS)
-const dbtasker = require("dbtasker");
-
-Using import (ES Module)
-import dbtasker from "dbtasker";
-```
-
-#### Step 2: Create a Configuration Object
-
-This object defines how DBTASKER connects to the database and how it behaves.
-```js
-const config = {
-  host: "localhost",
-  user: "root",
-  password: "password",
-  port: 3306
+  sep: "_" 
 };
 ```
 
-You can later extend this config with options like:
 
-- Drop database
-- Drop tables
-- Drop columns
-- Reserved / protected databases
 
-#### Step 3: Define Your Schema JSON Object
+## 📐 Schema Structure
+The schema follows a strict nested hierarchy:
+
+```Database ➔ Table ➔ Column ➔ Properties```
 
-Your schema is defined declaratively using a nested JSON structure:
+`JavaScript`
 ```js
 const schema = {
-  MyDatabase: {
+  app_db: {
     users: {
       id: {
         type: "int",
-        autoincrement: true,
-        primarykey: true
+        primarykey: true,
+        autoincrement: true
       },
       email: {
         type: "varchar",
         length: 255,
         required: true,
-        unique: true
+        unique: true,
+        comment: "User email address"
       },
       created_at: {
         type: "timestamp",
@@ -320,215 +86,89 @@ const schema = {
 };
 ```
 
-DBTASKER supports multiple aliases for column keys and is case-insensitive.
 
-#### Step 4: Run DBTASKER
 
-Call DBTASKER by passing the config first, then the schema object.
+## 🔗 Foreign Keys
+Foreign keys are defined inline within the column property to reference another table's column.
+`JavaScript`
 ```js
-dbtasker(config, schema);
-```
-
-That’s it.
-
-**DBTASKER will:**
-- Connect to MySQL
-- Validate your schema
-- Create or alter databases, tables, and columns
-- Apply indexes, foreign keys, defaults, and constraints
-
-### Full Minimal Example
-```js
-const DBTASKER = require("dbtasker");
-
-const config = {
-  host: "localhost",
-  user: "root",
-  password: "password",
-  port: 3306,
-  droptable: true,
-  droptable: true,
-  dropcolumn: true,
-  donotdelete: ['test', 'example']
-};
-
-const schema = {
-  app_db: {
-    users: {
-      id: {
-        type: "int",
-        primarykey: true,
-        autoincrement: true
-      },
-      name: {
-        type: "varchar",
-        length: 100,
-        required: true
-      }
-    }
+ColumnTwo: {
+  type: "int",
+  index: "key",
+  foreign_key: {
+    table: "user",
+    column: "id",
+    delete: "CASCADE", // Options: true, "SET NULL", "RESTRICT", etc.
+    update: true
   }
-};
-
-DBTASKER(config, schema);
-```
-
-**Notes**
-
-### Important:
-- The config object must always come first
-- The schema JSON object must come second
-- All keys are case-insensitive
-- Multiple aliases are supported for maximum flexibility
-
-
-## Column Key Aliases (Case-Insensitive)
-DBTASKER allows multiple aliases for each column property. Keys are normalized internally.
-
-**Length / Size / Precision**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-lengthvalue, length_value, size, scale, lengths,
-length, value, values, range, maxlength, max_length, precision
-```
-
-**Column Type / Data Type**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-type, columntype, column_type,
-datatype, data_type, typename, type_name
-```
-
-**Zerofill**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-zerofill, zero_fill, iszerofill, zerofillup
+}
 ```
+### Foreign Key Properties
+| Property | Description |
+| :---: | :--- |
+| `table` | Referenced table name |
+| `column` | Referenced column name |
+| `delete` | `ON DELETE` behavior (CASCADE, SET NULL, RESTRICT, NO ACTION) |
+| `update` | `ON UPDATE` behavior (CASCADE, SET NULL, RESTRICT, NO ACTION) |
 
-**Auto Increment / Identity**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-autoincrement, auto_increment, increment,
-serial, generated, isidentity, identity
-```
 
-**Signed / Unsigned**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-signed, issigned, numericunsigned, numeric_unsigned,
-unsigned, isunsigned
-```
 
-**Defaults / Default Value**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-default, defaults, defaultvalue, default_value,
-example, sample, columndefault, column_default
-```
+## 📑 Property Aliases
+`dbtasker` is highly flexible and accepts multiple aliases for each column property. All keys are **case-insensitive.**
 
-**Null / Not Null**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-Disallow NULL / Required
-```js
-notnull, not_null, nonnullable, notnullable,
-required, disallownull, non_nullable, not_nullable, disallow_null
-```
+| Feature | Supported Aliases |
+| :--- | :--- |
+| **Type** | `type, columntype, column_type, datatype, data_type, typename, type_name` |
+| **Length** | `length, size, scale, value, range, precision, maxlength, lengthvalue` |
+| **Zerofill** | `zerofill, zero_fill, iszerofill, zerofillup, zero, fillzero, fill_zero, iszero` |
+| **Unsigned** | `unsigned, signed, issigned, isunsigned, numericsigned, numericunsigned` |
+| **Identity** | `autoincrement, auto_increment, increment, generated, isidentity, serial, identity` |
+| **Default** | `default, defaults, defaultvalue, default_value, example, sample, columndefault, column_default` |
+| **Index** | `index, indexkey, index_key, indexing` |
+| `PrimaryKey` | `primarykey, primary_key, primary, isprimary, isprimarykey` |
+| `UniqueKey` | `unique, isunique, isuniquekey, uniqueindex, uniquekey, unique_index, unique_key` |
+| `FulltextKey` | `fulltext, fulltextindex, isfulltextkey, fulltextkey, fulltext_key, isfulltext` |
+| `SpatialKey` | `spatial, spatialindex, isspatialkey, spatialkey, spatial_key, isspatial` |
+| **Nullability** | `null, nulls, nullable, optional, isnulable, allownull, canbenull, notnull, not_null, nonnullable, notnullable, required, disallownull, non_nullable, not_nullable, disallow_null` |
+| **Comments** | `comment, comments, columncomment, column_comment, description, label, helptext, hint, note` |
+| **ForeignKey** | `fk, fuck, foreign_key, foreignkey` |
 
-**Allow NULL / Optional**
-```js
-null, nulls, nullable, optional, isnulable, allownull, canbenull
-```
 
-**Index / Key**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-index, spatial, isspatial, fulltext, isfulltext,
-isunique, isuniquekey, uniqueindex, uniquekey,
-unique_index, unique_key,
-primarykey, primary_key, primary, isprimary, isprimarykey,
-indexkey, index_key, indexing
-```
-
-**Comments / Description / Notes**
-You can use these as key when declearing column property inside table object inside JSON object without caring for case sensitivity.
-```js
-comment, comments, columncomment, column_comment,
-description, label, helptext, hint, note
-```
 
+## 🛡️ Compatibility & Engines
+- **Node.js:** 16.x or higher
+- **MySQL:** 5.7+ / 8.0+
+- **Engines:** InnoDB, MyISAM, MEMORY, RocksDB, TokuDB, and more.
 
-**Foreign Key Definition**
-Foreign keys are defined inline to reference another table’s column:
-```js
-foreign_key: {
-  table: "user",
-  column: "id",
-  delete: true,
-  update: true
-}
-```
-## Foreign Key Aliases (Case-Insensitive)
-DBTASKER accepts:
-```js
-"fk", "fuck", "foreign_key", "foreignkey"
-```
 
-Foreign Key Properties & Aliases
-Property
-### Alias Options
-#### Purpose
-**Table**
-```js
-"table", "fktable", "fk_table", "foreignkeytable", "foreign_key_table"
-```
-Referenced table name
 
-**column**
+## 🏁 Quick Start
+`JavaScript`
 ```js
-"column", "fkcolumn", "fk_column", "foreignkeycolumn", "foreign_key_column"
-```
-Referenced column name
+const dbtasker = require("dbtasker");
 
-**delete**
-```js
-"delete", "ondelete", "on_delete", "when_Delete", "whenDelete", 'ifdelete', 'if_delete'
-```
-ON DELETE CASCADE behavior
+const config = { 
+  host: "localhost", 
+  user: "root", 
+  password: "password" 
+};
 
-**update**
-```js
-"update", "onupdate", "on_update", "ifupdate", "if_update", "when_update", "whenupdate"
-```
-ON UPDATE CASCADE behavior
+const schema = {
+  store_db: {
+    products: {
+      id: { type: "int", primarykey: true, autoincrement: true },
+      name: { type: "varchar", length: 100, required: true }
+    }
+  }
+};
 
-You can use value of delete and update option as:
-**values**
-```js
-null, "NULL", "SET NULL", true, "DL", "DEL", "DELETE", "CASCADE", "DEFAULT", "SET DEFAULT", "RESTRICT", "NO ACTION"
+// Connect, Validate, and Automate
+dbtasker(config, schema);
 ```
 
-> Notes:
-> DBTASKER automatically normalizes all keys internally.
-
-Foreign key constraints are generated safely and include necessary values automatically.
-
-
-
-#### Use Cases
-Schema builders and migration tools
-
-
-#### Admin dashboards
-Low-code / no-code backends
-
-
-
-#### License
-MIT
-
-
-#### Author
-Md Nasiruddin Ahmed (Manik)
 
----Designed for safe, flexible, and high-quality MySQL schema automation.
 
+## 👨‍💻 Author
+**Md Nasiruddin Ahmed (Manik)** Designed for safe, flexible, and high-quality MySQL schema automation. 🌐 Visit us at: kormoi.com
 
+**License:** MIT

package/addcolumn.js

@@ -249,7 +249,7 @@ async function addColumnIfNeeded(config, jsondata, separator) {
                 }
             }
         }
-        console.log(cstyler.cyan("Adding Column to tables are completed successfully."));
+        console.log(cstyler.bold.underline.hex("#b700ffff")("Adding Column to tables are completed successfully."));
         return true;
     } catch (err) {
         console.error(err.message);

package/altercolumn.js

@@ -582,7 +582,7 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
                 }
             }
         }
-        console.log(cstyler.cyan("Altering Column to tables are completed successfully."));
+        console.log(cstyler.bold.underline.hex("#b700ffff")("Alter Column process to tables are completed successfully."));
         return true;
     } catch (err) {
         console.error(err.message);

package/dbop.js

@@ -209,9 +209,9 @@ async function databaseAddDeleteAlter(allconfig, jsondata, dropdb = false, dontt
                 }
             }
             if (count > 0) {
-                console.log(cstyler.green("All useless database have dropped"));
+                console.log(cstyler.bold.underline.hex("#b700ffff")("All useless database have dropped"));
             } else {
-                console.log(cstyler.green("No database found to be dropped"));
+                console.log(cstyler.bold.underline.hex("#b700ffff")("No database found to be dropped"));
             }
         }
         return true;

package/index.js

@@ -157,7 +157,7 @@ module.exports = async function (allconfig, table_json) {
         }
         // lets create tables if needed
         const tableop = require("./tableop");
-        const createtable = await tableop.createTableifNeeded(config, jsondata, separator);
+        const createtable = await tableop.createTableIfNeeded(config, jsondata, separator);
         if (createtable === null) {
             console.log(cstyler.bold.underline.red("Error occurred during creating tables."));
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbtasker",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "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",
   "author": "Md Nasiruddin Ahmed",
@@ -8,13 +8,27 @@
   "main": "index.js",
   "keywords": [
     "database",
+    "db",
     "mysql",
     "table",
     "create",
-    "mysql2",
     "alter",
     "modify",
-    "mysql2"
+    "mysql2",
+    "dbtasker",
+    "automation",
+    "schema",
+    "dbtask",
+    "database-automation",
+    "schema-sync",
+    "schema-builder",
+    "database-task",
+    "database-utility",
+    "database-tool",
+    "create-table",
+    "alter-table",
+    "drop-table",
+    "foreign-key"
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/tableop.js

@@ -152,7 +152,7 @@ async function createTableQuery(config, tabledata, tableName, dbname) {
         return null;
     }
 }
-async function createTableifNeeded(config, jsondata, separator) {
+async function createTableIfNeeded(config, jsondata, separator) {
     try {
         if (!fncs.isJsonObject(jsondata)) {
             return false;
@@ -209,9 +209,10 @@ async function createTableifNeeded(config, jsondata, separator) {
                 }
             }
         }
+        console.log(cstyler.bold.underline.hex("#b700ffff")("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);
+        console.error(cstyler.bold.red("Error occurred in createTableIfNeeded function of ", moduleName, " module. Error details: "), err);
         return null;
     }
 }
@@ -268,6 +269,6 @@ async function dropTable(config, json_data, separator = "_") {
 
 
 module.exports = {
-    createTableifNeeded,
+    createTableIfNeeded,
     dropTable
 };

package/validation.js

@@ -236,7 +236,7 @@ async function JSONchecker(table_json, config, separator = "_") {
         return null;
     }
     // get all mysql table engines
-    const mysqlEngines = await fncs.getMySQLEngines(config);
+    let mysqlEngines = await fncs.getMySQLEngines(config);
     if (!fncs.isJsonObject(mysqlEngines)) {
         console.error(cstyler.red.bold("There is a problem connecting to the database. Please check database info or connection."));
         return null;
@@ -496,7 +496,7 @@ async function JSONchecker(table_json, config, separator = "_") {
                                 /**
                                  * ZEROFILL
                                  */
-                                const zerofkeys = ['zerofill', 'zero_fill', 'iszerofill', 'zerofillup'];
+                                const zerofkeys = ['zerofill', 'zero_fill', 'iszerofill', 'zerofillup', 'zero', 'fillzero', 'fill_zero', 'iszero'];
                                 for (const item of Object.keys(deepColumn)) {
                                     if (zerofkeys.includes(item.toLowerCase())) {
                                         zerofill = deepColumn[item];
@@ -1220,9 +1220,16 @@ async function JSONchecker(table_json, config, separator = "_") {
                                     }
                                 } else if (enginekey.includes(columnName.toLowerCase())) {
                                     const engvalue = table_json[databaseName][tableName][columnName];
-                                    if (Object.keys(mysqlEngines).includes(engvalue)) {
-                                        if (mysqlEngines[engvalue].support === "YES") {
-                                            contentObj[databaseName][tableName]._engine_ = engvalue;
+                                    if (Object.keys(mysqlEngines).map(e => e.toUpperCase()).includes(fncs.stringifyAny(engvalue).toUpperCase())) {
+                                        let ifyes;
+                                        for(const key of Object.keys(mysqlEngines)) {
+                                            if(key.toUpperCase() === fncs.stringifyAny(engvalue).toUpperCase()) {
+                                                ifyes = key;
+                                                break;
+                                            }
+                                        }
+                                        if (mysqlEngines[ifyes].support === "YES") {
+                                            contentObj[databaseName][tableName]._engine_ = ifyes;
                                         } else {
                                             badengine.push(
                                                 `${cstyler.blue('Database:')} ${cstyler.hex("#00d9ffff")(databaseName)} ${cstyler.blue('> Table:')} ${cstyler.hex("#00d9ffff")(tableName)} ${cstyler.blue('> Engine key:')} ${cstyler.hex("#00d9ffff")(columnName)} ${cstyler.blue("Engine name: ")} ${cstyler.hex("#00d9ffff")(engvalue)} ${cstyler.red('- The storage engine exists in MySQL source code but is not available on this server.')}`
@@ -1230,7 +1237,7 @@ async function JSONchecker(table_json, config, separator = "_") {
                                         }
                                     } else {
                                         badengine.push(
-                                            `${cstyler.blue('Database:')} ${cstyler.hex("#00d9ffff")(databaseName)} ${cstyler.blue('> Table:')} ${cstyler.hex("#00d9ffff")(tableName)} ${cstyler.blue('> Engine key:')} ${cstyler.hex("#00d9ffff")(columnName)} ${cstyler.blue("Engine name:")} ${cstyler.hex("#00d9ffff")(engvalue)} ${cstyler.red('- must have a valid engine value')}`
+                                            `${cstyler.blue('Database:')} ${cstyler.hex("#00d9ffff")(databaseName)} ${cstyler.blue('> Table:')} ${cstyler.hex("#00d9ffff")(tableName)} ${cstyler.blue('> Engine key:')} ${cstyler.hex("#00d9ffff")(columnName)} ${cstyler.blue("Engine name:")} ${cstyler.underline.bold.hex("#00d9ffff")(engvalue)} ${cstyler.bold.red('- is not a valid MySQL storage engine name.')}`
                                         );
                                     }
                                 } else if (commetnkey.includes(columnName.toLowerCase())) {