updates

bin/engine/utils/camelJoinedtoCamelSpace.js

@@ -0,0 +1,52 @@
+// @ts-check
+
+/**
+ * Convert Camel Joined Text to Camel Spaced Text
+ * ==============================================================================
+ * @description this function takes a camel cased text without spaces, and returns
+ * a camel-case-spaced text
+ *
+ * @param {string} text - text string without spaces
+ *
+ * @returns {string | null}
+ */
+module.exports = function camelJoinedtoCamelSpace(text) {
+    if (!text?.match(/./)) {
+        return "";
+    }
+
+    if (text?.match(/ /)) {
+        return text;
+    }
+
+    if (text) {
+        let textArray = text.split("");
+
+        let capIndexes = [];
+
+        for (let i = 0; i < textArray.length; i++) {
+            const char = textArray[i];
+
+            if (i === 0) continue;
+            if (char.match(/[A-Z]/)) {
+                capIndexes.push(i);
+            }
+        }
+
+        let textChunks = [`${textArray[0].toUpperCase()}${text.substring(1, capIndexes[0])}`];
+
+        for (let j = 0; j < capIndexes.length; j++) {
+            const capIndex = capIndexes[j];
+            if (capIndex === 0) continue;
+
+            const startIndex = capIndex + 1;
+            const endIndex = capIndexes[j + 1];
+
+            textChunks.push(`${textArray[capIndex].toUpperCase()}${text.substring(startIndex, endIndex)}`);
+        }
+
+        return textChunks.join(" ");
+    } else {
+        return null;
+    }
+};

bin/engine/utils/createTable.js

@@ -0,0 +1,112 @@
+// @ts-check
+
+const generateColumnDescription = require("./generateColumnDescription");
+const supplementTable = require("./supplementTable");
+
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+
+module.exports = async function createTable({ dbFullName, tableName, tableInfoArray, varDatabaseDbHandler, dbSchema }) {
+    /**
+     * Format tableInfoArray
+     *
+     * @description Format tableInfoArray
+     */
+    const finalTable = supplementTable({ tableInfoArray: tableInfoArray });
+
+    /**
+     * Grab Schema
+     *
+     * @description Grab Schema
+     */
+    const createTableQueryArray = [];
+
+    createTableQueryArray.push(`CREATE TABLE IF NOT EXISTS \`${tableName}\` (`);
+
+    ////////////////////////////////////////
+
+    let primaryKeySet = false;
+    let foreignKeys = [];
+
+    ////////////////////////////////////////
+
+    for (let i = 0; i < finalTable.length; i++) {
+        const column = finalTable[i];
+        const { fieldName, dataType, nullValue, primaryKey, autoIncrement, defaultValue, defaultValueLiteral, foreignKey, updatedField } = column;
+
+        if (foreignKey) {
+            foreignKeys.push({
+                fieldName: fieldName,
+                ...foreignKey,
+            });
+        }
+
+        let { fieldEntryText, newPrimaryKeySet } = generateColumnDescription({ columnData: column, primaryKeySet: primaryKeySet });
+
+        primaryKeySet = newPrimaryKeySet;
+
+        ////////////////////////////////////////
+
+        if (fieldName?.match(/updated_timestamp/i)) {
+            fieldEntryText += " ON UPDATE CURRENT_TIMESTAMP";
+        }
+
+        ////////////////////////////////////////
+
+        const comma = (() => {
+            if (foreignKeys[0]) return ",";
+            if (i === finalTable.length - 1) return "";
+            return ",";
+        })();
+
+        createTableQueryArray.push("    " + fieldEntryText + comma);
+
+        ////////////////////////////////////////
+    }
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    if (foreignKeys[0]) {
+        foreignKeys.forEach((foreighKey, index, array) => {
+            const { fieldName, destinationTableName, destinationTableColumnName, cascadeDelete, cascadeUpdate, foreignKeyName } = foreighKey;
+
+            const comma = (() => {
+                if (index === foreignKeys.length - 1) return "";
+                return ",";
+            })();
+
+            createTableQueryArray.push(`    CONSTRAINT \`${foreignKeyName}\` FOREIGN KEY (\`${fieldName}\`) REFERENCES \`${destinationTableName}\`(${destinationTableColumnName})${cascadeDelete ? " ON DELETE CASCADE" : ""}${cascadeUpdate ? " ON UPDATE CASCADE" : ""}${comma}`);
+        });
+    }
+
+    ////////////////////////////////////////
+
+    createTableQueryArray.push(`) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;`);
+
+    const createTableQuery = createTableQueryArray.join("\n");
+
+    ////////////////////////////////////////
+
+    const newTable = await varDatabaseDbHandler({
+        queryString: createTableQuery,
+        database: dbFullName,
+    });
+
+    return newTable;
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+};
+
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */

bin/engine/utils/dbHandler.js

@@ -0,0 +1,126 @@
+// @ts-check
+
+////////////////////////////////////////
+////////////////////////////////////////
+////////////////////////////////////////
+
+const fs = require("fs");
+const mysql = require("mysql");
+const endConnection = require("./endConnection");
+
+const connection = mysql.createConnection({
+    host: process.env.DSQL_HOST,
+    user: process.env.DSQL_USER,
+    database: process.env.DSQL_DB_NAME,
+    password: process.env.DSQL_PASS,
+    charset: "utf8mb4",
+    port: process.env.DSQL_PORT?.match(/.../) ? parseInt(process.env.DSQL_PORT) : undefined,
+});
+
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Main DB Handler Function
+ * ==============================================================================
+ * @async
+ * @param {object} params - Single Param object containing params
+ * @param {string} params.query - Query String
+ * @param {(string | number)[]} [params.values] - Values
+ * @param {object} [params.dbSchema] - Database Schema
+ * @param {string} [params.database] - Target Database
+ *
+ * @returns {Promise<object | null>}
+ */
+module.exports = async function dbHandler({ query, values, database }) {
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let changeDbError;
+
+    if (database) {
+        connection.changeUser({ database: database }, (error) => {
+            if (error) {
+                console.log("DB handler error in switching database:", error.message);
+                changeDbError = error.message;
+            }
+        });
+    }
+
+    if (changeDbError) {
+        return { error: changeDbError };
+    }
+
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let results;
+
+    /**
+     * Fetch from db
+     *
+     * @description Fetch data from db if no cache
+     */
+    try {
+        results = await new Promise((resolve, reject) => {
+            if (connection.state !== "disconnected") {
+                if (values) {
+                    connection.query(query, values, (error, results, fields) => {
+                        if (error) {
+                            console.log("DB handler error:", error.message);
+                            resolve({
+                                error: error.message,
+                            });
+                        } else {
+                            resolve(JSON.parse(JSON.stringify(results)));
+                        }
+                        setTimeout(() => {
+                            endConnection(connection);
+                        }, 500);
+                    });
+                } else {
+                    connection.query(query, (error, results, fields) => {
+                        if (error) {
+                            console.log("DB handler error:", error.message);
+                            resolve({
+                                error: error.message,
+                            });
+                        } else {
+                            resolve(JSON.parse(JSON.stringify(results)));
+                        }
+                        setTimeout(() => {
+                            endConnection(connection);
+                        }, 500);
+                    });
+                }
+            }
+        });
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+    } catch (error) {
+        console.log("DB handler error:", error.message);
+
+        results = null;
+    }
+
+    /**
+     * Return results
+     *
+     * @description Return results add to cache if "req" param is passed
+     */
+    if (results) {
+        return results;
+    } else {
+        return null;
+    }
+};

bin/engine/utils/defaultFieldsRegexp.js

@@ -0,0 +1,12 @@
+/**
+ * Regular expression to match default fields
+ *
+ * @description Regular expression to match default fields
+ */
+const defaultFieldsRegexp = /^id$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
+
+////////////////////////////////////////
+////////////////////////////////////////
+////////////////////////////////////////
+
+module.exports = defaultFieldsRegexp;

bin/engine/utils/endConnection.js

@@ -0,0 +1,14 @@
+// @ts-check
+
+const mysql = require("mysql");
+
+/**
+ * @param {mysql.Connection} connection - the active MYSQL connection
+ */
+module.exports = function endConnection(connection) {
+    if (connection.state !== "disconnected") {
+        connection.end((err) => {
+            console.log(err?.message);
+        });
+    }
+};

bin/engine/utils/generateColumnDescription.js

@@ -0,0 +1,68 @@
+// @ts-check
+
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+
+/**
+ * Generate SQL text for Field
+ * ==============================================================================
+ * @param {object} params - Single object params
+ * @param {import("../../../types/database-schema.td").DSQL_FieldSchemaType} params.columnData - Field object
+ * @param {boolean} [params.primaryKeySet] - Table Name(slug)
+ *
+ * @returns {{fieldEntryText: string, newPrimaryKeySet:  boolean}}
+ */
+module.exports = function generateColumnDescription({ columnData, primaryKeySet }) {
+    /**
+     * Format tableInfoArray
+     *
+     * @description Format tableInfoArray
+     */
+    const { fieldName, dataType, nullValue, primaryKey, autoIncrement, defaultValue, defaultValueLiteral, notNullValue } = columnData;
+
+    let fieldEntryText = "";
+
+    fieldEntryText += `\`${fieldName}\` ${dataType}`;
+
+    ////////////////////////////////////////
+
+    if (nullValue) {
+        fieldEntryText += " DEFAULT NULL";
+    } else if (defaultValueLiteral) {
+        fieldEntryText += ` DEFAULT ${defaultValueLiteral}`;
+    } else if (defaultValue) {
+        fieldEntryText += ` DEFAULT '${defaultValue}'`;
+    } else if (notNullValue) {
+        fieldEntryText += ` NOT NULL`;
+    }
+
+    ////////////////////////////////////////
+
+    if (primaryKey && !primaryKeySet) {
+        fieldEntryText += " PRIMARY KEY";
+        primaryKeySet = true;
+    }
+
+    ////////////////////////////////////////
+
+    if (autoIncrement) {
+        fieldEntryText += " AUTO_INCREMENT";
+        primaryKeySet = true;
+    }
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    return { fieldEntryText, newPrimaryKeySet: primaryKeySet || false };
+};
+
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */

bin/engine/utils/noDatabaseDbHandler.js

@@ -0,0 +1,90 @@
+// @ts-check
+
+const fs = require("fs");
+const dbHandler = require("./dbHandler");
+const mysql = require("mysql");
+const endConnection = require("./endConnection");
+
+const connection = mysql.createConnection({
+    host: process.env.DSQL_HOST,
+    user: process.env.DSQL_USER,
+    password: process.env.DSQL_PASS,
+    charset: "utf8mb4",
+    port: process.env.DSQL_PORT?.match(/.../) ? parseInt(process.env.DSQL_PORT) : undefined,
+});
+
+/**
+ * Create database from Schema Function
+ * ==============================================================================
+ * @param {object} params - Single Param object containing params
+ * @param {string} params.query - Query String
+ * @param {string[]} [params.values] - Values
+ *
+ * @returns {Promise<object[] | null>}
+ */
+module.exports = async function noDatabaseDbHandler({ query, values }) {
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let results;
+
+    /**
+     * Fetch from db
+     *
+     * @description Fetch data from db if no cache
+     */
+    try {
+        /** ********************* Run Query */
+        results = await new Promise((resolve, reject) => {
+            if (connection.state !== "disconnected") {
+                if (values) {
+                    connection.query(query, values, (error, results, fields) => {
+                        if (error) {
+                            console.log("NO-DB handler error:", error.message);
+                            resolve({
+                                error: error.message,
+                            });
+                        } else {
+                            resolve(JSON.parse(JSON.stringify(results)));
+                        }
+                        setTimeout(() => {
+                            endConnection(connection);
+                        }, 500);
+                    });
+                } else {
+                    connection.query(query, (error, results, fields) => {
+                        if (error) {
+                            console.log("NO-DB handler error:", error.message);
+                            resolve({
+                                error: error.message,
+                            });
+                        } else {
+                            resolve(JSON.parse(JSON.stringify(results)));
+                        }
+                        setTimeout(() => {
+                            endConnection(connection);
+                        }, 500);
+                    });
+                }
+            }
+        });
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+    } catch (error) {
+        console.log("ERROR in noDatabaseDbHandler =>", error.message);
+    }
+
+    /**
+     * Return results
+     *
+     * @description Return results add to cache if "req" param is passed
+     */
+    if (results) {
+        return results;
+    } else {
+        return null;
+    }
+};

bin/engine/utils/parseDbResults.js

@@ -0,0 +1,73 @@
+// @ts-check
+
+const decrypt = require("../../../functions/decrypt");
+const defaultFieldsRegexp = require("./defaultFieldsRegexp");
+
+/**
+ * Parse Database results
+ * ==============================================================================
+ * @description this function takes a database results array gotten from a DB handler
+ * function, decrypts encrypted fields, and returns an updated array with no encrypted
+ * fields
+ *
+ * @param {object} params - Single object params
+ * @param {{}[]} params.unparsedResults - Array of data objects containing Fields(keys)
+ * and corresponding values of the fields(values)
+ * @param {import("../../../types/database-schema.td").DSQL_TableSchemaType} [params.tableSchema] - Table schema
+ * @returns {Promise<object[]|null>}
+ */
+module.exports = async function parseDbResults({ unparsedResults, tableSchema }) {
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let parsedResults = [];
+
+    try {
+        /**
+         * Declare variables
+         *
+         * @description Declare "results" variable
+         */
+        for (let pr = 0; pr < unparsedResults.length; pr++) {
+            let result = unparsedResults[pr];
+
+            let resultFieldNames = Object.keys(result);
+
+            for (let i = 0; i < resultFieldNames.length; i++) {
+                const resultFieldName = resultFieldNames[i];
+                let resultFieldSchema = tableSchema?.fields[i];
+
+                if (resultFieldName?.match(defaultFieldsRegexp)) {
+                    continue;
+                }
+
+                let value = result[resultFieldName];
+
+                if (typeof value !== "number" && !value) {
+                    // parsedResults.push(result);
+                    continue;
+                }
+
+                if (resultFieldSchema?.encrypted) {
+                    if (value?.match(/./)) {
+                        result[resultFieldName] = decrypt(value);
+                    }
+                }
+            }
+
+            parsedResults.push(result);
+        }
+
+        /**
+         * Declare variables
+         *
+         * @description Declare "results" variable
+         */
+        return parsedResults;
+    } catch (error) {
+        console.log("ERROR in parseDbResults Function =>", error.message);
+        return unparsedResults;
+    }
+};

bin/engine/utils/slugToCamelTitle.js

@@ -0,0 +1,16 @@
+// @ts-check
+
+module.exports = function slugToCamelTitle(text) {
+    if (text) {
+        let addArray = text.split("-").filter((item) => item !== "");
+        let camelArray = addArray.map((item) => {
+            return item.substr(0, 1).toUpperCase() + item.substr(1).toLowerCase();
+        });
+
+        let parsedAddress = camelArray.join(" ");
+
+        return parsedAddress;
+    } else {
+        return null;
+    }
+};

bin/engine/utils/supplementTable.js

@@ -0,0 +1,48 @@
+// @ts-check
+
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+
+module.exports = function supplementTable({ tableInfoArray }) {
+    /**
+     * Format tableInfoArray
+     *
+     * @description Format tableInfoArray
+     */
+    let finalTableArray = tableInfoArray;
+    const defaultFields = require("../data/defaultFields.json");
+
+    ////////////////////////////////////////
+
+    let primaryKeyExists = finalTableArray.filter((_field) => _field.primaryKey);
+
+    ////////////////////////////////////////
+
+    defaultFields.forEach((field) => {
+        let fieldExists = finalTableArray.filter((_field) => _field.fieldName === field.fieldName);
+
+        if (fieldExists && fieldExists[0]) {
+            return;
+        } else if (field.fieldName === "id" && !primaryKeyExists[0]) {
+            finalTableArray.unshift(field);
+        } else {
+            finalTableArray.push(field);
+        }
+    });
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    return finalTableArray;
+};
+
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */
+/** ****************************************************************************** */

bin/engine/utils/updateTable.js

@@ -0,0 +1,457 @@
+// @ts-check
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+///////////////////////// - Update Table Function - ////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+const fs = require("fs");
+const path = require("path");
+
+const defaultFieldsRegexp = /^id$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
+
+const generateColumnDescription = require("./generateColumnDescription");
+const varDatabaseDbHandler = require("./varDatabaseDbHandler");
+
+const schemaPath = path.resolve(process.cwd(), "dsql.schema.json");
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Update table function
+ * ==============================================================================
+ * @param {object} params - Single object params
+ * @param {string} params.dbFullName - Database full name => "datasquirel_user_4394_db_name"
+ * @param {string} params.tableName - Table Name(slug)
+ * @param {import("../../../types/database-schema.td").DSQL_FieldSchemaType[]} params.tableInfoArray - Table Info Array
+ * @param {import("../../../types/database-schema.td").DSQL_DatabaseSchemaType[]} params.dbSchema - Single post
+ * @param {import("../../../types/database-schema.td").DSQL_IndexSchemaType[]} [params.tableIndexes] - Table Indexes
+ * @param {boolean} [params.clone] - Is this a newly cloned table?
+ * @param {number} [params.tableIndex] - The number index of the table in the dbSchema array
+ *
+ * @returns {Promise<string|object[]|null>}
+ */
+module.exports = async function updateTable({ dbFullName, tableName, tableInfoArray, dbSchema, tableIndexes, clone, tableIndex }) {
+    /**
+     * Initialize
+     * ==========================================
+     * @description Initial setup
+     */
+
+    /**
+     * @description Initialize table info array. This value will be
+     * changing depending on if a field is renamed or not.
+     */
+    let upToDateTableFieldsArray = tableInfoArray;
+
+    /**
+     * Handle Table updates
+     *
+     * @description Try to undate table, catch error if anything goes wrong
+     */
+    try {
+        /**
+         * @type {string[]}
+         * @description Table update query string array
+         */
+        const updateTableQueryArray = [];
+
+        /**
+         * @type {string[]}
+         * @description Constriants query string array
+         */
+        const constraintsQueryArray = [];
+
+        /**
+         * @description Push the query initial value
+         */
+        updateTableQueryArray.push(`ALTER TABLE \`${tableName}\``);
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+
+        /**
+         * @type {DSQL_MYSQL_SHOW_INDEXES_Type[] | null}
+         * @description All indexes from MYSQL db
+         */
+        const allExistingIndexes = await varDatabaseDbHandler({
+            queryString: `SHOW INDEXES FROM \`${tableName}\``,
+            database: dbFullName,
+        });
+
+        /**
+         * @type {DSQL_MYSQL_SHOW_COLUMNS_Type[] | null}
+         * @description All columns from MYSQL db
+         */
+        const allExistingColumns = await varDatabaseDbHandler({
+            queryString: `SHOW COLUMNS FROM \`${tableName}\``,
+            database: dbFullName,
+        });
+
+        ////////////////////////////////////////
+
+        /**
+         * @type {string[]}
+         * @description Updated column names Array
+         */
+        const updatedColumnsArray = [];
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+
+        /**
+         * @description Iterate through every existing column
+         */
+        if (allExistingColumns)
+            for (let e = 0; e < allExistingColumns.length; e++) {
+                const { Field } = allExistingColumns[e];
+
+                if (Field.match(defaultFieldsRegexp)) continue;
+
+                /**
+                 * @description This finds out whether the fieldName corresponds with the MSQL Field name
+                 * if the fildName doesn't match any MYSQL Field name, the field is deleted.
+                 */
+                let existingEntry = upToDateTableFieldsArray.filter((column) => column.fieldName === Field || column.originName === Field);
+
+                if (existingEntry && existingEntry[0]) {
+                    /**
+                     * @description Check if Field name has been updated
+                     */
+                    if (existingEntry[0].updatedField) {
+                        updatedColumnsArray.push(existingEntry[0].fieldName);
+
+                        const renameColumn = await varDatabaseDbHandler({
+                            queryString: `ALTER TABLE ${tableName} RENAME COLUMN \`${existingEntry[0].originName}\` TO \`${existingEntry[0].fieldName}\``,
+                            database: dbFullName,
+                        });
+
+                        console.log(`Column Renamed from "${existingEntry[0].originName}" to "${existingEntry[0].fieldName}"`);
+
+                        /**
+                         * Update Db Schema
+                         * ===================================================
+                         * @description Update Db Schema after renaming column
+                         */
+                        try {
+                            const userSchemaData = dbSchema;
+
+                            const targetDbIndex = userSchemaData.findIndex((db) => db.dbFullName === dbFullName);
+                            const targetTableIndex = userSchemaData[targetDbIndex].tables.findIndex((table) => table.tableName === tableName);
+                            const targetFieldIndex = userSchemaData[targetDbIndex].tables[targetTableIndex].fields.findIndex((field) => field.fieldName === existingEntry[0].fieldName);
+
+                            delete userSchemaData[targetDbIndex].tables[targetTableIndex].fields[targetFieldIndex]["originName"];
+                            delete userSchemaData[targetDbIndex].tables[targetTableIndex].fields[targetFieldIndex]["updatedField"];
+
+                            /**
+                             * @description Set New Table Fields Array
+                             */
+                            upToDateTableFieldsArray = userSchemaData[targetDbIndex].tables[targetTableIndex].fields;
+
+                            fs.writeFileSync(schemaPath, JSON.stringify(userSchemaData), "utf8");
+                        } catch (error) {
+                            console.log("Error in updating Table =>", error.message);
+                        }
+
+                        ////////////////////////////////////////
+                    }
+
+                    ////////////////////////////////////////
+
+                    continue;
+
+                    ////////////////////////////////////////
+                } else {
+                    // console.log("Column Deleted =>", Field);
+                    await varDatabaseDbHandler({
+                        queryString: `ALTER TABLE ${tableName} DROP COLUMN \`${Field}\``,
+                        database: dbFullName,
+                    });
+                }
+            }
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+
+        /**
+         * Handle MYSQL Table Indexes
+         * ===================================================
+         * @description Iterate through each table index(if available)
+         * and perform operations
+         */
+        if (allExistingIndexes)
+            for (let f = 0; f < allExistingIndexes.length; f++) {
+                const { Key_name, Index_comment } = allExistingIndexes[f];
+
+                /**
+                 * @description Check if this index was specifically created
+                 * by datasquirel
+                 */
+                if (Index_comment?.match(/schema_index/)) {
+                    try {
+                        const existingKeyInSchema = tableIndexes ? tableIndexes.filter((indexObject) => indexObject.alias === Key_name) : null;
+                        if (!existingKeyInSchema?.[0]) throw new Error(`This Index(${Key_name}) Has been Deleted!`);
+                    } catch (error) {
+                        /**
+                         * @description Drop Index: This happens when the MYSQL index is not
+                         * present in the datasquirel DB schema
+                         */
+                        await varDatabaseDbHandler({
+                            queryString: `ALTER TABLE ${tableName} DROP INDEX \`${Key_name}\``,
+                            database: dbFullName,
+                        });
+                    }
+                }
+            }
+
+        /**
+         * Handle DATASQUIREL Table Indexes
+         * ===================================================
+         * @description Iterate through each datasquirel schema
+         * table index(if available), and perform operations
+         */
+        if (tableIndexes && tableIndexes[0]) {
+            for (let g = 0; g < tableIndexes.length; g++) {
+                const { indexType, indexName, indexTableFields, alias } = tableIndexes[g];
+
+                if (!alias?.match(/./)) continue;
+
+                /**
+                 * @description Check for existing Index in MYSQL db
+                 */
+                try {
+                    const existingKeyInDb = allExistingIndexes?.filter((indexObject) => indexObject.Key_name === alias);
+                    if (!existingKeyInDb?.[0]) throw new Error("This Index Does not Exist");
+                } catch (error) {
+                    /**
+                     * @description Create new index if determined that it
+                     * doesn't exist in MYSQL db
+                     */
+                    await varDatabaseDbHandler({
+                        queryString: `CREATE${indexType.match(/fullText/i) ? " FULLTEXT" : ""} INDEX \`${alias}\` ON ${tableName}(${indexTableFields
+                            .map((nm) => nm.value)
+                            .map((nm) => `\`${nm}\``)
+                            .join(",")}) COMMENT 'schema_index'`,
+                        database: dbFullName,
+                    });
+                }
+            }
+        }
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+
+        /**
+         * Handle MYSQL Foreign Keys
+         * ===================================================
+         * @description Iterate through each datasquirel schema
+         * table index(if available), and perform operations
+         */
+
+        /**
+         *  @description All MSQL Foreign Keys
+         * @type {DSQL_MYSQL_FOREIGN_KEYS_Type[] | null}
+         */
+        const allForeignKeys = await varDatabaseDbHandler({
+            queryString: `SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = '${dbFullName}' AND TABLE_NAME='${tableName}' AND CONSTRAINT_TYPE='FOREIGN KEY'`,
+            database: dbFullName,
+        });
+
+        if (allForeignKeys)
+            for (let c = 0; c < allForeignKeys.length; c++) {
+                const { CONSTRAINT_NAME } = allForeignKeys[c];
+
+                /**
+                 *  @description Skip if Key is the PRIMARY Key
+                 */
+                if (CONSTRAINT_NAME.match(/PRIMARY/)) continue;
+
+                /**
+                 *  @description Drop all foreign Keys to avoid MYSQL errors when adding/updating
+                 * Foreign keys
+                 */
+                const dropForeignKey = await varDatabaseDbHandler({
+                    queryString: `ALTER TABLE ${tableName} DROP FOREIGN KEY \`${CONSTRAINT_NAME}\``,
+                    database: dbFullName,
+                });
+            }
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+
+        /**
+         * Handle DATASQUIREL schema fields for current table
+         * ===================================================
+         * @description Iterate through each field object and
+         * perform operations
+         */
+        for (let i = 0; i < upToDateTableFieldsArray.length; i++) {
+            const column = upToDateTableFieldsArray[i];
+            const prevColumn = upToDateTableFieldsArray[i - 1];
+            const nextColumn = upToDateTableFieldsArray[i + 1];
+
+            const { fieldName, dataType, nullValue, primaryKey, autoIncrement, defaultValue, defaultValueLiteral, foreignKey, updatedField } = column;
+
+            ////////////////////////////////////////
+
+            /**
+             * @description Skip default fields
+             */
+            if (fieldName.match(/^id$|^date_/)) continue;
+            /**
+             * @description Skip columns that have been updated recently
+             */
+            // if (updatedColumnsArray.includes(fieldName)) continue;
+
+            ////////////////////////////////////////
+
+            let updateText = "";
+
+            ////////////////////////////////////////
+
+            let existingColumnIndex;
+
+            /**
+             * @description Existing MYSQL field object
+             */
+            let existingColumn =
+                allExistingColumns && allExistingColumns[0]
+                    ? allExistingColumns.filter((_column, _index) => {
+                          if (_column.Field === fieldName) {
+                              existingColumnIndex = _index;
+                              return true;
+                          }
+                      })
+                    : null;
+
+            /**
+             * @description Construct SQL text snippet for this field
+             */
+            let { fieldEntryText } = generateColumnDescription({ columnData: column });
+
+            /**
+             * @description Modify Column(Field) if it already exists
+             * in MYSQL database
+             */
+            if (existingColumn && existingColumn[0]?.Field) {
+                const { Field, Type, Null, Key, Default, Extra } = existingColumn[0];
+
+                let isColumnReordered = existingColumnIndex ? i < existingColumnIndex : false;
+
+                if (Field === fieldName && !isColumnReordered && dataType.toUpperCase() === Type.toUpperCase()) {
+                    updateText += `MODIFY COLUMN ${fieldEntryText}`;
+                    // continue;
+                } else {
+                    updateText += `MODIFY COLUMN ${fieldEntryText}${isColumnReordered ? (prevColumn?.fieldName ? " AFTER `" + prevColumn.fieldName + "`" : nextColumn?.fieldName ? " BEFORE `" + nextColumn.fieldName + "`" : "") : ""}`;
+                    // if (userId) {
+                    // } else {
+                    //     updateText += `MODIFY COLUMN ${fieldEntryText}`;
+                    // }
+                }
+            } else if (prevColumn && prevColumn.fieldName) {
+                /**
+                 * @description Add new Column AFTER previous column, if
+                 * previous column exists
+                 */
+                updateText += `ADD COLUMN ${fieldEntryText} AFTER \`${prevColumn.fieldName}\``;
+            } else if (nextColumn && nextColumn.fieldName) {
+                /**
+                 * @description Add new Column BEFORE next column, if
+                 * next column exists
+                 */
+                updateText += `ADD COLUMN ${fieldEntryText} BEFORE \`${nextColumn.fieldName}\``;
+            } else {
+                /**
+                 * @description Append new column to the end of existing columns
+                 */
+                updateText += `ADD COLUMN ${fieldEntryText}`;
+            }
+
+            ////////////////////////////////////////
+
+            /**
+             * @description Pust SQL code snippet to updateTableQueryArray Array
+             * Add a comma(,) to separate from the next snippet
+             */
+            updateTableQueryArray.push(updateText + ",");
+
+            ////////////////////////////////////////
+            ////////////////////////////////////////
+            ////////////////////////////////////////
+
+            /**
+             * @description Handle foreing keys if available, and if there is no
+             * "clone" boolean = true
+             */
+            if (!clone && foreignKey) {
+                const { destinationTableName, destinationTableColumnName, cascadeDelete, cascadeUpdate, foreignKeyName } = foreignKey;
+
+                const foreinKeyText = `ADD CONSTRAINT \`${foreignKeyName}\` FOREIGN KEY (${fieldName}) REFERENCES ${destinationTableName}(${destinationTableColumnName})${cascadeDelete ? " ON DELETE CASCADE" : ""}${cascadeUpdate ? " ON UPDATE CASCADE" : ""}`;
+                // const foreinKeyText = `ADD CONSTRAINT \`${foreignKeyName}\` FOREIGN KEY (${fieldName}) REFERENCES ${destinationTableName}(${destinationTableColumnName})${cascadeDelete ? " ON DELETE CASCADE" : ""}${cascadeUpdate ? " ON UPDATE CASCADE" : ""}` + ",";
+
+                const finalQueryString = `ALTER TABLE \`${tableName}\` ${foreinKeyText}`;
+
+                const addForeignKey = await varDatabaseDbHandler({
+                    database: dbFullName,
+                    queryString: finalQueryString,
+                });
+            }
+
+            ////////////////////////////////////////
+        }
+
+        /**
+         * @description Construct final SQL query by combning all SQL snippets in
+         * updateTableQueryArray Arry, and trimming the final comma(,)
+         */
+        const updateTableQuery = updateTableQueryArray.join(" ").replace(/,$/, "");
+
+        ////////////////////////////////////////
+
+        /**
+         * @description Check if SQL snippets array has more than 1 entries
+         * This is because 1 entry means "ALTER TABLE table_name" only, without any
+         * Alter directives like "ADD COLUMN" or "MODIFY COLUMN"
+         */
+        if (updateTableQueryArray.length > 1) {
+            const updateTable = await varDatabaseDbHandler({
+                queryString: updateTableQuery,
+                database: dbFullName,
+            });
+
+            return updateTable;
+        } else {
+            /**
+             * @description If only 1 SQL snippet is left in updateTableQueryArray, this
+             * means that no updates have been made to the table
+             */
+            return "No Changes Made to Table";
+        }
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+    } catch (error) {
+        console.log('Error in "updateTable" function =>', error.message);
+
+        return "Error in Updating Table";
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////

bin/engine/utils/varDatabaseDbHandler.js

@@ -0,0 +1,88 @@
+// @ts-check
+
+const fs = require("fs");
+const mysql = require("mysql");
+const parseDbResults = require("./parseDbResults");
+const dbHandler = require("./dbHandler");
+
+/**
+ * DB handler for specific database
+ * ==============================================================================
+ * @async
+ * @param {object} params - Single object params
+ * @param {string} params.queryString - SQL string
+ * @param {string[]} [params.queryValuesArray] - Values Array
+ * @param {string} params.database - Database name
+ * @param {import("../../../types/database-schema.td").DSQL_TableSchemaType} [params.tableSchema] - Table schema
+ * @returns {Promise<any[]|null>}
+ */
+module.exports = async function varDatabaseDbHandler({ queryString, queryValuesArray, database, tableSchema }) {
+    /**
+     * Create Connection
+     *
+     * @description Create Connection
+     */
+    const connection = mysql.createConnection({
+        host: process.env.DSQL_SOCKET_HOST,
+        user: process.env.DSQL_SOCKET_USER,
+        password: process.env.DSQL_SOCKET_PASS || "",
+        database: process.env.DSQL_SOCKET_DB_NAME,
+        charset: "utf8mb4",
+        port: parseInt(process.env.DSQL_SOCKET_DB_NAME || "") || undefined,
+    });
+
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let results;
+
+    /**
+     * Fetch from db
+     *
+     * @description Fetch data from db if no cache
+     */
+    try {
+        if (queryString && queryValuesArray && Array.isArray(queryValuesArray) && queryValuesArray[0]) {
+            results = await dbHandler({ query: queryString, values: queryValuesArray, database: database });
+        } else {
+            results = await dbHandler({ query: queryString, database: database });
+        }
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+    } catch (error) {
+        console.log("\x1b[31mvarDatabaseDbHandler ERROR\x1b[0m =>", database, error);
+    }
+
+    /**
+     * Return results
+     *
+     * @description Return results add to cache if "req" param is passed
+     */
+    if (results && tableSchema) {
+        try {
+            const unparsedResults = results;
+            // deepcode ignore reDOS: <please specify a reason of ignoring this>
+            const parsedResults = await parseDbResults({ unparsedResults: unparsedResults, tableSchema: tableSchema });
+            return parsedResults;
+        } catch (error) {
+            console.log("\x1b[31mvarDatabaseDbHandler ERROR\x1b[0m =>", database, error);
+            return null;
+        }
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+    } else if (results) {
+        return results;
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+    } else {
+        return null;
+    }
+};

bin/engine/utils/varReadOnlyDatabaseDbHandler.js

@@ -0,0 +1,57 @@
+// @ts-check
+
+const fs = require("fs");
+const parseDbResults = require("./parseDbResults");
+const dbHandler = require("./dbHandler");
+
+/**
+ *
+ * @param {object} param0
+ * @param {string} param0.queryString
+ * @param {object} param0.database
+ * @param {object[]} [param0.queryValuesArray]
+ * @param {object | null} [param0.tableSchema]
+ * @returns
+ */
+module.exports = async function varReadOnlyDatabaseDbHandler({ queryString, database, queryValuesArray, tableSchema }) {
+    /**
+     * Declare variables
+     *
+     * @description Declare "results" variable
+     */
+    let results;
+
+    /**
+     * Fetch from db
+     *
+     * @description Fetch data from db if no cache
+     */
+    try {
+        results = await dbHandler({ query: queryString, values: queryValuesArray, database: database });
+
+        ////////////////////////////////////////
+    } catch (error) {
+        ////////////////////////////////////////
+
+        console.log("\x1b[31mvarReadOnlyDatabaseDbHandler ERROR\x1b[0m =>", database, error.message);
+
+        /**
+         * Return error
+         */
+        return error.message;
+    }
+
+    /**
+     * Return results
+     *
+     * @description Return results add to cache if "req" param is passed
+     */
+    if (results) {
+        const unparsedResults = results;
+        // deepcode ignore reDOS: <please specify a reason of ignoring this>
+        const parsedResults = await parseDbResults({ unparsedResults: unparsedResults, tableSchema: tableSchema });
+        return parsedResults;
+    } else {
+        return null;
+    }
+};