dbtasker 2.1.0 → 2.5.0

package/README.md

@@ -1,4 +1,521 @@
-# dbtasker
-**Ongoing project. Any one can contribute**
+# 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.
+
+#### Engine Awareness
+DBTASKER supports MySQL engines and handles constraints accordingly:
+
+- InnoDB
+- MyISAM
+- MEMORY
+- CSV
+- ARCHIVE
+- BLACKHOLE
+- FEDERATED
+- NDB / NDBCLUSTER
+- MRG_MYISAM
+- Spider
+- RocksDB
+- TokuDB
+
+
+#### 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**
+```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"]
+```
+
+### 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
+
+
+**Example:**
+```js
+sep: "_"
+```
+Full Example Config File
+```js
+{
+  user: "root",
+  password: "password123",
+  host: "localhost",
+  port: 3306,
+  dropdb: true,
+  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
+};
+```
+
+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
+
+Your schema is defined declaratively using a nested JSON structure:
+```js
+const schema = {
+  MyDatabase: {
+    users: {
+      id: {
+        type: "int",
+        autoincrement: true,
+        primarykey: true
+      },
+      email: {
+        type: "varchar",
+        length: 255,
+        required: true,
+        unique: true
+      },
+      created_at: {
+        type: "timestamp",
+        defaults: "CURRENT_TIMESTAMP"
+      }
+    }
+  }
+};
+```
+
+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.
+```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
+      }
+    }
+  }
+};
+
+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
+```
+
+**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
+```
+
+**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
+```
+
+**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
+```
+
+
+**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", "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**
+```js
+"column", "fkcolumn", "fk_column", "foreignkeycolumn", "foreign_key_column"
+```
+Referenced column name
+
+**delete**
+```js
+"delete", "ondelete", "on_delete", "when_Delete", "whenDelete", 'ifdelete', 'if_delete'
+```
+ON DELETE CASCADE behavior
+
+**update**
+```js
+"update", "onupdate", "on_update", "ifupdate", "if_update", "when_update", "whenupdate"
+```
+ON UPDATE CASCADE behavior
+
+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"
+```
+
+> 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.
+
 
-Do operation to your database autometically

package/index.js

@@ -29,9 +29,7 @@ module.exports = async function(allconfig, table_json) {
             'host': allconfig.host,
             'user': allconfig.user,
             'password': allconfig.password,
-            'port': allconfig.port,
-            'waitForConnections': true,
-            'connectionLimit': 100
+            'port': allconfig.port
         }
         // get don't touch database
         let donttouchdb = [];
@@ -54,9 +52,9 @@ module.exports = async function(allconfig, table_json) {
         }
         // Declare seperator
         let seperator = "_";
-        const sepkeys = ['sep', 'Sep', 'Seperator', 'seperator'];
-        for (const item of sepkeys) {
-            if (allconfig.hasOwnProperty(item)) {
+        const sepkeys = ['sep', 'seperator'];
+        for (const item of Object.keys(allconfig)) {
+            if (sepkeys.includes(item.toLowerCase())) {
                 seperator = allconfig[item];
                 break;
             }
@@ -77,7 +75,7 @@ module.exports = async function(allconfig, table_json) {
             dropdatabase = false;
         }
         let droptable;
-        const droptablekeys = ['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',];
+        const droptablekeys = ['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'];
         for (const item of Object.keys(allconfig)) {
             if (droptablekeys.includes(item.toLowerCase())) {
                 droptable = allconfig[item];
@@ -89,7 +87,7 @@ module.exports = async function(allconfig, table_json) {
             droptable = false;
         }
         let dropcolumn;
-        const dropcolkeys = ['dropcol', 'dropcolumn', 'deletecol', 'deletecolumn', 'removecol', 'removecolumn', 'drop_col', 'drop_column', 'delete_col', 'delete_column', 'remove_col', 'remove_column',];
+        const dropcolkeys = ['dropcol', 'dropcolumn', 'deletecol', 'deletecolumn', 'removecol', 'removecolumn', 'drop_col', 'drop_column', 'delete_col', 'delete_column', 'remove_col', 'remove_column'];
         for (const item of Object.keys(allconfig)) {
             if (dropcolkeys.includes(item.toLowerCase())) {
                 dropcolumn = allconfig[item];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbtasker",
-  "version": "2.1.0",
+  "version": "2.5.0",
   "description": "You can create database and table on your own with a lot of functionality.",
   "license": "ISC",
   "author": "Md Nasiruddin Ahmed",

package/validation.js

@@ -304,54 +304,32 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                  * ColumnType
                                  * COLUMNTYPE
                                  */
-                                if (deepColumn.hasOwnProperty("type")) {
-                                    columntype = deepColumn.type;
-                                } else if (deepColumn.hasOwnProperty("Type")) {
-                                    columntype = deepColumn.Type;
-                                } else if (deepColumn.hasOwnProperty("TYPE")) {
-                                    columntype = deepColumn.TYPE;
-                                } else if (deepColumn.hasOwnProperty("columntype")) {
-                                    columntype = deepColumn.columntype;
-                                } else if (deepColumn.hasOwnProperty("column_type")) {
-                                    columntype = deepColumn.column_type;
-                                } else if (deepColumn.hasOwnProperty("Column_Type")) {
-                                    columntype = deepColumn.Column_Type;
-                                } else if (deepColumn.hasOwnProperty("ColumnType")) {
-                                    columntype = deepColumn.ColumnType;
-                                } else if (deepColumn.hasOwnProperty("COLUMNTYPE")) {
-                                    columntype = deepColumn.COLUMNTYPE;
+                                const coltypekeys = ['type', 'columntype', 'column_type', 'datatype', 'data_type', 'typename', 'type_name'];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (coltypekeys.includes(item.toLowerCase())) {
+                                        columntype = deepColumn[item];
+                                        break;
+                                    }
                                 }
                                 if (typeof columntype !== "string" && columntype !== undefined) {
                                     columntype = null;
                                 }
                                 /**
-                                 * LengthValue
-                                 * lengthvalue
-                                 * LENGTHVALUE
-                                 * length_value
                                  * Length_Value
                                  */
-                                if (deepColumn.hasOwnProperty("LengthValue")) {
-                                    length_value = deepColumn.LengthValue;
-                                } else if (deepColumn.hasOwnProperty("lengthvalue")) {
-                                    length_value = deepColumn.lengthvalue;
-                                } else if (deepColumn.hasOwnProperty("length_value")) {
-                                    length_value = deepColumn.length_value;
-                                } else if (deepColumn.hasOwnProperty("LENGTHVALUE")) {
-                                    length_value = deepColumn.LENGTHVALUE;
-                                } else if (deepColumn.hasOwnProperty("Length_Value")) {
-                                    length_value = deepColumn.Length_Value;
+                                const legnthkeys = ["lengthvalue", "length_value", 'size', 'scale', 'lengths', 'length', 'value', 'values', 'range', 'maxlength', 'max_length', 'precision'];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (legnthkeys.includes(item.toLowerCase())) {
+                                        length_value = deepColumn[item];
+                                        break;
+                                    }
                                 }
                                 /**
-                                 * autoIncrement
-                                 * autoincrement
-                                 * auto_increment
                                  * AUTO_INCREMENT
-                                 * AUTOINCREMENT
                                  */
-                                const autoincrementkeys = ["autoIncrement", "autoincrement", "auto_increment", "AUTO_INCREMENT", "AUTOINCREMENT", "increment", "INCREMENT"]
-                                for (const item of autoincrementkeys) {
-                                    if (deepColumn.hasOwnProperty(item)) {
+                                const autoincrementkeys = ['autoincrement', 'auto_increment', 'increment', 'serial', 'generated', 'isidentity', 'identity']
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (autoincrementkeys.includes(item.toLowerCase())) {
                                         autoincrement = deepColumn[item];
                                         break;
                                     }
@@ -370,16 +348,52 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                  * INDEX
                                  * Index
                                  */
-                                const indexkey = ["index", "INDEX", "Index"];
-                                for (const item of indexkey) {
-                                    if (deepColumn.hasOwnProperty(item)) {
+                                let indexvalue = undefined;
+                                const indexkey = ["index", 'indexkey', 'index_key', 'indexing'];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (indexkey.includes(item.toLowerCase())) {
                                         indexes = deepColumn[item];
+                                        break;
+                                    } else if (['primarykey', 'primary_key', 'primary', 'isprimary', 'isprimarykey'].includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            indexes = "PRIMARY KEY";
+                                            break;
+                                        } else {
+                                            indexes = undefined;
+                                        }
+                                    } else if (['isunique', 'isuniquekey', 'uniqueindex', 'uniquekey', 'unique_index', 'unique_key'].includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            indexes = "UNIQUE";
+                                            break;
+                                        } else {
+                                            indexes = undefined;
+                                        }
+                                    } else if (['fulltext', 'isfulltext'].includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            indexes = "FULLTEXT";
+                                            break;
+                                        } else {
+                                            indexes = undefined;
+                                        }
+                                    } else if (['spatial', 'isspatial'].includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            indexes = "SPATIAL";
+                                            break;
+                                        } else {
+                                            indexes = undefined;
+                                        }
+                                    } else if (['index'].includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            indexes = "INDEX";
+                                            break;
+                                        } else {
+                                            indexes = undefined;
+                                        }
                                     }
                                 }
-                                if (indexes !== undefined) indexes = fncs.stringifyAny(indexes).toUpperCase();
-                                if (indexes === "PRIMARY" || indexes === "KEY") {
-                                    indexes = "PRIMARY KEY"
-                                } else if (indexes === "FULL") {
+                                if (indexes !== undefined) { indexes = fncs.stringifyAny(indexes).toUpperCase(); }
+                                else if (indexes === "PRIMARY") { indexes = "PRIMARY KEY" }
+                                else if (indexes === "FULL") {
                                     indexes = "FULLTEXT";
                                 }
                                 /**
@@ -387,12 +401,31 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                  * NULL
                                  * Null
                                  */
-                                if (deepColumn.hasOwnProperty("null")) {
-                                    nulls = deepColumn.null;
-                                } else if (deepColumn.hasOwnProperty("NULL")) {
-                                    nulls = deepColumn.NULL;
-                                } else if (deepColumn.hasOwnProperty("Null")) {
-                                    nulls = deepColumn.Null;
+                                const nullkeys = ['null', 'nulls', 'nullable', 'optional', 'isnulable', 'allownull', 'canbenull'];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (nullkeys.includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            nulls = true;
+                                            break;
+                                        } else if (falsers.includes(deepColumn[item])) {
+                                            nulls = false;
+                                            break;
+                                        } else {
+                                            nulls = true;
+                                            break;
+                                        }
+                                    } else if (['notnull', 'not_null', 'nonnullable', 'notnullable', 'required', 'disallownull', 'non_nullable', 'not_nullable', 'disallow_null'].includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            nulls = false;
+                                            break;
+                                        } else if (falsers.includes(deepColumn[item])) {
+                                            nulls = true;
+                                            break;
+                                        } else {
+                                            nulls = true;
+                                            break;
+                                        }
+                                    }
                                 }
                                 if (truers.includes(nulls)) {
                                     nulls = true;
@@ -407,93 +440,64 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                     );
                                 }
                                 /**
-                                 * comment
                                  * COMMENT
-                                 * Comment
                                  */
-                                if (deepColumn.hasOwnProperty("comment")) {
-                                    comment = deepColumn.comment;
-                                } else if (deepColumn.hasOwnProperty("COMMENT")) {
-                                    comment = deepColumn.COMMENT;
-                                } else if (deepColumn.hasOwnProperty("Comment")) {
-                                    comment = deepColumn.Comment;
+                                const commentkeys = ['comment', 'comments', 'columncomment', 'column_comment', 'description', 'label', 'helptext', 'hint', 'note'];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (commentkeys.includes(item.toLowerCase())) {
+                                        comment = deepColumn[item];
+                                        break;
+                                    }
                                 }
                                 /**
-                                 * unsigned
                                  * UNSIGNED
-                                 * Unsigned
-                                 * signed
-                                 * Signed
-                                 * SIGNED
                                  */
-
+                                const unsignekey = ['numericunsigned', 'numeric_unsigned', 'unsigned', 'isunsigned'];
                                 let signed = undefined;
-                                if (deepColumn.hasOwnProperty("unsigned")) {
-                                    unsigned = deepColumn.unsigned;
-                                } else if (deepColumn.hasOwnProperty("UNSIGNED")) {
-                                    unsigned = deepColumn.UNSIGNED;
-                                } else if (deepColumn.hasOwnProperty("Unsigned")) {
-                                    unsigned = deepColumn.Unsigned;
-                                } else if (deepColumn.hasOwnProperty("signed")) {
-                                    signed = deepColumn.signed;
-                                } else if (deepColumn.hasOwnProperty("Signed")) {
-                                    signed = deepColumn.Signed;
-                                } else if (deepColumn.hasOwnProperty("SIGNED")) {
-                                    signed = deepColumn.SIGNED;
-                                }
-                                if (unsigned !== undefined) {
-                                    if (truers.includes(unsigned)) {
-                                        unsigned = true;
-                                    } else if (falsers.includes(unsigned)) {
-                                        unsigned = false;
-                                    } else if (unsigned === undefined) {
-                                        unsigned = undefined;
-                                    } else {
-                                        unsigned = null;
-                                    }
-                                } else if (signed !== undefined) {
-                                    if (truers.includes(signed)) {
-                                        unsigned = false;
-                                    } else if (falsers.includes(signed)) {
-                                        unsigned = true;
-                                    } else if (signed === undefined) {
-                                        unsigned = undefined;
-                                    } else {
-                                        unsigned = null;
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (unsignekey.includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            unsigned = true;
+                                            break;
+                                        } else if (falsers.includes(deepColumn[item])) {
+                                            unsigned = false;
+                                            break;
+                                        } else {
+                                            unsigned = null;
+                                            break;
+                                        }
+                                    } else if (['signed', 'issigned'].includes(item.toLowerCase())) {
+                                        if (truers.includes(deepColumn[item])) {
+                                            unsigned = false;
+                                            break;
+                                        } else if (falsers.includes(deepColumn[item])) {
+                                            unsigned = true;
+                                            break;
+                                        } else {
+                                            unsigned = null;
+                                            break;
+                                        }
                                     }
                                 }
                                 /**
-                                 * default
                                  * DEFAULT
-                                 * Default
                                  */
-                                if (deepColumn.hasOwnProperty("default")) {
-                                    defaults = deepColumn.default;
-                                } else if (deepColumn.hasOwnProperty("DEFAULT")) {
-                                    defaults = deepColumn.DEFAULT;
-                                } else if (deepColumn.hasOwnProperty("Default")) {
-                                    defaults = deepColumn.Default;
+                                const defaultkeys = ['default', 'defaults', 'defaultvalue', 'default_value', 'example', 'sample', 'columndefault', 'column_default'];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (defaultkeys.includes(item.toLowerCase())) {
+                                        defaults = deepColumn[item];
+                                        break;
+                                    }
                                 }
                                 /**
-                                 * zerofill
-                                 * ZeroFill
-                                 * Zerofill
                                  * ZEROFILL
-                                 * zero_fill
-                                 * Zero_Fill
                                  */
-                                if (deepColumn.hasOwnProperty("zerofill")) {
-                                    zerofill = deepColumn.zerofill;
-                                } else if (deepColumn.hasOwnProperty("ZeroFill")) {
-                                    zerofill = deepColumn.ZeroFill;
-                                } else if (deepColumn.hasOwnProperty("Zerofill")) {
-                                    zerofill = deepColumn.Zerofill;
-                                } else if (deepColumn.hasOwnProperty("ZEROFILL")) {
-                                    zerofill = deepColumn.ZEROFILL;
-                                } else if (deepColumn.hasOwnProperty("zero_fill")) {
-                                    zerofill = deepColumn.zero_fill;
-                                } else if (deepColumn.hasOwnProperty("Zero_Fill")) {
-                                    zerofill = deepColumn.Zero_Fill;
+                                const zerofkeys = ['zerofill', 'zero_fill', 'iszerofill', 'zerofillup'];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (zerofkeys.includes(item.toLowerCase())) {
+                                        zerofill = deepColumn[item];
+                                        break;
+                                    }
                                 }
                                 if (truers.includes(zerofill)) {
                                     zerofill = true;
@@ -898,9 +902,9 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                 let fktable = undefined;
                                 let fkcolumn = undefined;
                                 let foreign_key = {};
-                                const fk_variations = ["fk", "Fk", "FK", "foreign_key", "foreign_Key", "Foreign_Key", "FOREIGN_KEY", "foreignkey", "foreignKey", "ForeignKey", "FOREIGNKEY"];
-                                for (const item of fk_variations) {
-                                    if (deepColumn.hasOwnProperty(item)) {
+                                const fk_variations = ["fk", "foreign_key", "foreignkey"];
+                                for (const item of Object.keys(deepColumn)) {
+                                    if (fk_variations.includes(item.toLowerCase())) {
                                         foreign_key = deepColumn[item];
                                         break;
                                     }
@@ -914,9 +918,9 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                      * RESTRICT:	    Prevents update if any matching child exists.
                                      * NO ACTION:	    Like RESTRICT (timing differences in some DB engines).
                                      */
-                                    const deleteVariations = ["delete", "Delete", "DELETE", "ondelete", "OnDelete", "onDelete", "ONDELETE", "on_delete", "ON_DELETE", "On_Delete", "on_Delete"]
-                                    for (const item of deleteVariations) {
-                                        if (foreign_key.hasOwnProperty(item)) {
+                                    const deleteVariations = ["delete", "ondelete", "on_delete", "when_Delete", "whenDelete", 'ifdelete', 'if_delete']
+                                    for (const item of Object.keys(foreign_key)) {
+                                        if (deleteVariations.includes(item.toLowerCase())) {
                                             deleteOption = foreign_key[item];
                                             if (typeof deleteOption === "string") {
                                                 deleteOption = deleteOption.toUpperCase();
@@ -925,9 +929,9 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                         }
                                     }
                                     // Lets get update options
-                                    const onupdatevariations = ["update", "Update", "UPDATE", "onupdate", "OnUpdate", "onUpdate", "ONUPDATE", "on_update", "ON_UPDATE", "On_Update", "on_Update"];
-                                    for (const item of onupdatevariations) {
-                                        if (foreign_key.hasOwnProperty(item)) {
+                                    const onupdatevariations = ["update", "onupdate", "on_update", "ifupdate", "if_update", "when_update", "whenupdate"];
+                                    for (const item of Object.keys(foreign_key)) {
+                                        if (onupdatevariations.includes(item.toLowerCase())) {
                                             updateOption = foreign_key[item];
                                             if (typeof updateOption === "string") {
                                                 updateOption = updateOption.toUpperCase();
@@ -1006,17 +1010,17 @@ async function JSONchecker(table_json, config, seperator = "_") {
                                     }
                                     // check reference table and column
                                     // lets add foreign key table to variable
-                                    const tableKeyVariation = ["table", "Table", "TABLE", "fktable", "fkTable", "fkTABLE", "Fktable", "FkTable", "FkTABLE", "FKTable", "FKTABLE", "fk_table", "fk_Table", "fk_TABLE", "Fk_table", "Fk_Table", "Fk_TABLE", "FK_Table", "FK_TABLE", "foreignkeytable", "foreignKeyTable", "ForeignKeyTable", "FOREIGNKEYTABLE", "foreign_key_table", "foreign_Key_Table", "FOREIGN_KEY_TABLE", "Foreign_Key_Table"]
-                                    for (const item of tableKeyVariation) {
-                                        if (foreign_key.hasOwnProperty(item)) {
+                                    const tableKeyVariation = ["table", "fktable", "fk_table", "foreignkeytable", "foreign_key_table"]
+                                    for (const item of Object.keys(foreign_key)) {
+                                        if (tableKeyVariation.includes(item.toLowerCase())) {
                                             fktable = foreign_key[item];
                                             break;
                                         }
                                     }
                                     // lets add foreign key column to variable
-                                    const columnKeyVariation = ["column", "Column", "COLUMN", "fkcolumn", "fkColumn", "fkCOLUMN", "Fkcolumn", "FkColumn", "FkCOLUMN", "FKColumn", "FKCOLUMN", "fk_column", "fk_Column", "fk_COLUMN", "Fk_column", "Fk_Column", "Fk_COLUMN", "FK_Column", "FK_COLUMN", "foreignkeycolumn", "foreignKeyColumn", "ForeignKeyColumn", "FOREIGNKEYCOLUMN", "foreign_key_column", "foreign_Key_Column", "FOREIGN_KEY_COLUMN", "Foreign_Key_Column"]
-                                    for (const item of (columnKeyVariation)) {
-                                        if (foreign_key.hasOwnProperty(item)) {
+                                    const columnKeyVariation = ["column", "fkcolumn", "fk_column", "foreignkeycolumn", "foreign_key_column"]
+                                    for (const item of Object.keys(foreign_key)) {
+                                        if (columnKeyVariation.includes(item.toLowerCase())) {
                                             fkcolumn = foreign_key[item];
                                             break;
                                         }