dbtasker 1.0.0 → 2.5.0

package/function.js

@@ -1,7 +1,23 @@
 const mysql = require('mysql2/promise');
+const fs = require("fs/promises");  // Importing fs.promises for async operations
+const path = require("path");  // Importing Node's path module
+const cstyler = require("cstyler");
 
 
-function getDateTime(seperator) {
+
+function isNumber(str) {
+  if (str === null || str === undefined) {
+    return false;
+  }
+  if (typeof str === "number") {
+    return true;
+  }
+  if (Array.isArray(str) || typeof str === "object") {
+    return false;
+  }
+  return !isNaN(str) && str.trim() !== "";
+}
+function getDateTime(seperator = "/") {
   const today = new Date();
   const formattedDateTime =
     today.getFullYear() +
@@ -40,7 +56,120 @@ function getDateTime(seperator) {
     datetime: formattedDateTime,
   };
 }
+async function getMySQLVersion(config) {
+  const connection = await mysql.createConnection(config);
+  try {
+    const [rows] = await connection.execute('SELECT VERSION() AS version');
+    const version = rows[0].version;
+    console.log("Mysql database version is: ", cstyler.green(version));
+    return version;
+  } finally {
+    await connection.end();
+  }
+}
+async function isMySQL578OrAbove(config) {
+  const versionStr = await getMySQLVersion(config); // e.g., '5.7.9-log' or '8.0.34'
+  // Extract numeric version
+  const match = versionStr.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return false;
+  const [major, minor, patch] = match.slice(1).map(Number);
+
+  if (major > 5) return true;
+  if (major < 5) return false;
+  if (minor > 7) return true;
+  if (minor < 7) return false;
+  // major==5, minor==7
+  return patch >= 8;
+}
+async function getCharsetAndCollations(config) {
+  try {
+    const conn = await mysql.createConnection(config);
+
+    const [charsetRows] = await conn.query("SHOW CHARACTER SET");
+    const characterSets = charsetRows.map(row => row.Charset);
+
+    const [collationRows] = await conn.query("SHOW COLLATION");
+    const collations = collationRows.map(row => row.Collation);
+
+    await conn.end();
+    return { characterSets, collations };
+  } catch (err) {
+    return null;
+  }
+}
+async function isCharsetCollationValid(config, charset, collation) {
+    let connection;
+
+    try {
+        connection = await mysql.createConnection(config);
+
+        const [rows] = await connection.execute(`
+            SELECT 1
+            FROM information_schema.COLLATIONS
+            WHERE COLLATION_NAME = ?
+              AND CHARACTER_SET_NAME = ?
+        `, [collation, charset]);
+
+        return rows.length > 0;
+
+    } catch (err) {
+        return null;
+    } finally {
+        if (connection) await connection.end();
+    }
+}
+async function getMySQLEngines(config) {
+  let connection;
+
+  try {
+    connection = await mysql.createConnection(config);
+
+    const [rows] = await connection.query("SHOW ENGINES");
+
+    const engines = {};
+
+    for (const row of rows) {
+      engines[row.Engine] = {
+        support: row.Support,
+        comment: row.Comment
+      };
+    }
+
+    return engines;
+
+  } catch (err) {
+    console.error(`Failed to fetch MySQL engines: ${err.message}`);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+function isValidMySQLConfig(config) {
+  if (typeof config !== 'object' || config === null) return false;
+
+  const requiredKeys = ['host', 'user', 'password', 'port'];
+
+  for (const key of requiredKeys) {
+    if (!(key in config)) return false;
+
+    const value = config[key];
+    const type = typeof value;
+
+    // Allow string, number, boolean
+    if (!['string', 'number', 'boolean'].includes(type)) return false;
+
+    // Extra string validation
+    if (type === 'string' && value.trim() === '') return false;
+  }
+
+  return true;
+}
 async function isMySQLDatabase(config) {
+  const isvalidconfig = isValidMySQLConfig(config);
+  if (isvalidconfig === false) {
+    throw new Error("There is some information missing in config.");
+  }
+  console.log("Config is okay. We are good to go.");
   let connection;
   try {
     connection = await mysql.createConnection(config);
@@ -75,26 +204,152 @@ async function checkDatabaseExists(config, dbName) {
     return null;
   }
 }
-async function createDatabase(config, dbName) {
+async function dropDatabase(config, databaseName) {
   let connection;
+  try {
+    // Connect to server without specifying database
+    connection = await mysql.createConnection({
+      host: config.host,
+      user: config.user,
+      password: config.password
+    });
 
+    // Check if database exists
+    const [rows] = await connection.query(
+      `SELECT SCHEMA_NAME 
+       FROM INFORMATION_SCHEMA.SCHEMATA 
+       WHERE SCHEMA_NAME = ?`,
+      [databaseName]
+    );
+
+    if (rows.length === 0) {
+      console.log(`Database '${databaseName}' does not exist.`);
+      return false;
+    }
+
+    // Drop the database
+    await connection.query(`DROP DATABASE \`${databaseName}\``);
+    console.log(`Database '${databaseName}' dropped successfully.`);
+    return true;
+  } catch (err) {
+    console.error("Error dropping database:", err.message);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function dropTable(config, databaseName, tableName) {
+  let connection;
   try {
-    connection = await mysql.createConnection(config);
-    await connection.query(`CREATE DATABASE \`${dbName}\``);
-    console.log(`✅ Database '${dbName}' created successfully.`);
+    config.database = databaseName;
+    connection = await mysql.createConnection({ ...config, database: databaseName });
+
+    // Check if table exists
+    const [tables] = await connection.query(
+      `SELECT TABLE_NAME 
+       FROM INFORMATION_SCHEMA.TABLES 
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`,
+      [databaseName, tableName]
+    );
+
+    if (tables.length === 0) {
+      console.log(`Table '${tableName}' does not exist in ${databaseName}`);
+      return false;
+    }
+
+    // Drop foreign keys from other tables referencing this table
+    const [fkRefs] = await connection.query(
+      `SELECT TABLE_NAME, CONSTRAINT_NAME 
+       FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE 
+       WHERE REFERENCED_TABLE_SCHEMA = ? AND REFERENCED_TABLE_NAME = ?`,
+      [databaseName, tableName]
+    );
+
+    for (const ref of fkRefs) {
+      console.log(`Dropping foreign key '${ref.CONSTRAINT_NAME}' from table '${ref.TABLE_NAME}'`);
+      await connection.query(
+        `ALTER TABLE \`${ref.TABLE_NAME}\` DROP FOREIGN KEY \`${ref.CONSTRAINT_NAME}\``
+      );
+    }
+
+    // Drop the table
+    await connection.query(`DROP TABLE \`${tableName}\``);
+
+    console.log(`Table '${tableName}' dropped successfully from ${databaseName}`);
     return true;
   } catch (err) {
-    if (err.code === 'ER_DB_CREATE_EXISTS') {
-      console.log(`⚠️  Database '${dbName}' already exists.`);
+    console.error("Error dropping table:", err.message);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function dropColumn(config, databaseName, tableName, columnName) {
+  let connection;
+  try {
+    config.database = databaseName;
+    connection = await mysql.createConnection(config);
+
+    // 1️⃣ Check if column exists
+    const [columns] = await connection.query(
+      `SELECT COLUMN_NAME, COLUMN_KEY
+       FROM INFORMATION_SCHEMA.COLUMNS
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND COLUMN_NAME = ?`,
+      [databaseName, tableName, columnName]
+    );
+
+    // ❌ Column does not exist → return false
+    if (columns.length === 0) {
+      console.log(
+        `Column '${columnName}' does not exist in ${databaseName}.${tableName}`
+      );
       return false;
-    } else {
-      console.error(`❌ Error creating database:`, err.message);
-      return null;
     }
+
+    const columnKey = columns[0].COLUMN_KEY;
+
+    // 2️⃣ Drop foreign key constraints
+    const [fkConstraints] = await connection.query(
+      `SELECT CONSTRAINT_NAME
+       FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+       WHERE TABLE_SCHEMA = ?
+         AND TABLE_NAME = ?
+         AND COLUMN_NAME = ?
+         AND REFERENCED_TABLE_NAME IS NOT NULL`,
+      [databaseName, tableName, columnName]
+    );
+
+    for (const fk of fkConstraints) {
+      await connection.query(
+        `ALTER TABLE \`${tableName}\` DROP FOREIGN KEY \`${fk.CONSTRAINT_NAME}\``
+      );
+    }
+
+    // 3️⃣ Drop primary key if needed
+    if (columnKey === "PRI") {
+      await connection.query(
+        `ALTER TABLE \`${tableName}\` DROP PRIMARY KEY`
+      );
+    }
+
+    // 4️⃣ Drop column
+    await connection.query(
+      `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\``
+    );
+
+    console.log(
+      `Column '${columnName}' dropped successfully from ${databaseName}.${tableName}`
+    );
+
+    return true;
+  } catch (err) {
+    console.error("Error dropping column:", err.message);
+    return null;
   } finally {
     if (connection) await connection.end();
   }
 }
+
 async function getAllDatabaseNames(config) {
   let connection;
 
@@ -112,6 +367,10 @@ async function getAllDatabaseNames(config) {
     if (connection) await connection.end();
   }
 }
+function isValidMySQLIdentifier(name) {
+  if (typeof name !== "string") return false;
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
 function isValidDatabaseName(name) {
   if (typeof name !== 'string') return false;
 
@@ -177,7 +436,7 @@ function isValidTableName(name) {
 }
 function isValidColumnName(name) {
   if (typeof name !== 'string') return false;
-
+  if (name.length === 0) return false;
   const maxLength = 64;
 
   const reservedKeywords = new Set([
@@ -201,51 +460,136 @@ function isValidColumnName(name) {
 
   return true;
 }
-function parseColumnWithOptionalLoopStrict(text) {
-  if (typeof text !== 'string') return false;
-
+function createloopname(text, seperator = "_") {
+  if (!isJsonObject(text)) {
+    return null;
+  }
+  seperator = seperator.toString();
+  if (text.loop === null) {
+    return text.name;
+  } else if (['year', 'years'].includes(text.loop)) {
+    return text.name + seperator + getDateTime().year + seperator;
+  } else if (['month', 'months'].includes(text.loop)) {
+    return text.name + seperator + getDateTime().year + seperator + getDateTime().month + seperator;
+  } else if (['day', 'days'].includes(text.loop)) {
+    return text.name + seperator + getDateTime().year + seperator + getDateTime().month + seperator + getDateTime().day + seperator;
+  } else {
+    return false;
+  }
+}
+function getloop(text) {
+  if (typeof text !== "string") {
+    return null;
+  }
+  if (text.startsWith("(year)") || text.endsWith("(year)")) {
+    return { name: text.replace("(year)", ""), loop: "year" };
+  } else if (text.startsWith("(years)") || text.endsWith("(years)")) {
+    return { name: text.replace("(years)", ""), loop: "year" };
+  } else if (text.startsWith("(month)") || text.endsWith("(month)")) {
+    return { name: text.replace("(month)", ""), loop: "month" };
+  } else if (text.startsWith("(months)") || text.endsWith("(months)")) {
+    return { name: text.replace("(months)", ""), loop: "month" };
+  } else if (text.startsWith("(day)") || text.endsWith("(day)")) {
+    return { name: text.replace("(day)", ""), loop: "day" };
+  } else if (text.startsWith("(days)") || text.endsWith("(days)")) {
+    return { name: text.replace("(days)", ""), loop: "day" };
+  } else {
+    return { name: text, loop: null }
+  }
+}
+function perseTableNameWithLoop(text, seperator = "_") {
+  if (typeof text !== 'string') return null;
   text = text.trim();
-
-  // Case 1: product(year)
-  let match = text.match(/^([a-zA-Z_][\w]*)\(([^()]+)\)$/);
-  if (match) {
-    const name = match[1];
-    const loop = match[2];
-    if (isValidColumnName(name) && isValidColumnName(loop)) {
-      return { name, loop };
+  let gtlp = getloop(text);
+  if (gtlp.loop === null) {
+    if (isValidTableName(gtlp.name)) {
+      gtlp.loopname = gtlp.name;
+      return gtlp;
+    } else {
+      return false;
     }
+  } else if (gtlp === null) {
     return false;
+  } else {
+    const loopname = createloopname(gtlp, seperator);
+    if (isValidTableName(loopname)) {
+      return { name: gtlp.name, loop: gtlp.loop, loopname: loopname }
+    } else {
+      return false;
+    }
   }
-
-  // Case 2: (year)product
-  match = text.match(/^\(([^()]+)\)([a-zA-Z_][\w]*)$/);
-  if (match) {
-    const loop = match[1];
-    const name = match[2];
-    if (isValidColumnName(name) && isValidColumnName(loop)) {
-      return { name, loop };
+}
+function perseDatabaseNameWithLoop(text, seperator = "_") {
+  if (typeof text !== 'string') return false;
+  text = text.trim();
+  let gtlp = getloop(text);
+  if (gtlp.loop === null) {
+    if (isValidDatabaseName(gtlp.name)) {
+      gtlp.loopname = gtlp.name;
+      return gtlp;
+    } else {
+      return false;
     }
+  } else if (gtlp === null) {
     return false;
+  } else {
+    const loopname = createloopname(gtlp, seperator);
+    if (isValidDatabaseName(loopname)) {
+      return { name: gtlp.name, loop: gtlp.loop, loopname: loopname }
+    } else {
+      return false;
+    }
   }
-
-  // Case 3: just a column name without loop
-  if (isValidColumnName(text)) {
-    return { name: text, loop: null };
+}
+function reverseLoopName(text) {
+  if (typeof text !== "string") return text;
+  let a = text.split(text[text.length - 1]);
+  while (a.includes("")) {
+    a = fncs.removefromarray(a);
   }
-
-  // Any invalid format or invalid name
-  return false;
+  if (fncs.isNumber(a[a.length - 1])) {
+    if (a[a.length - 1].length === 2 && Number(a[a.length - 1]) <= 31) {
+      if (a[a.length - 2].length === 2 && Number(a[a.length - 2]) <= 12) {
+        if (a[a.length - 3].length === 4) {
+          const year = new Date().getFullYear();
+          if (Number(a[a.length - 3]) <= year && Number(a[a.length - 2]) <= 12 && Number(a[a.length - 1]) <= 31) {
+            let y = "";
+            for (let i = 0; i < text.length - 12; i++) {
+              y += text[i];
+            }
+            return [y + "(day)", y + "(days)"];
+          }
+          return text;
+        }
+      } else if (a[a.length - 2].length === 4) {
+        const year = new Date().getFullYear();
+        if (Number(a[a.length - 2]) <= year && Number(a[a.length - 1]) <= 12) {
+          let y = "";
+          for (let i = 0; i < text.length - 9; i++) {
+            y += text[i];
+          }
+          return [y + "(month)", y + "(months)"];
+        }
+        return text;
+      }
+    } else if (a[a.length - 1].length === 4) {
+      const year = new Date().getFullYear();
+      if (Number(a[a.length - 1]) <= year) {
+        let y = "";
+        for (let i = 0; i < text.length - 6; i++) {
+          y += text[i];
+        }
+        return [y + "(year)", y + "(years)"];
+      }
+      return text;
+    }
+    return text;
+  }
+  return text;
 }
 
 
 
-
-
-
-
-
-
-
 async function getLastSavedFile(directory) {
   try {
     // Read the directory
@@ -367,7 +711,6 @@ async function writeJsonFile(filePath, data) {
     return null;
   }
 }
-//Write js file
 const writeJsFile = async (filePath, content) => {
   try {
     await fs.access(filePath).catch(() => fs.mkdir(path.dirname(filePath), { recursive: true }));
@@ -376,11 +719,61 @@ const writeJsFile = async (filePath, content) => {
     return true;
   } catch (error) {
     console.error(`Error writing file at ${filePath}:`, error);
+    return false;
   }
 };
-function removefromarray(arr, text) {
+
+
+function stringifyAny(data) {
+  // If the data is undefined or a symbol, handle it explicitly.
+  if (typeof data === 'undefined') {
+    return 'undefined';
+  } else if (data === null) {
+    return 'null';
+  } else if (data === true) {
+    return "true";
+  } else if (data === false) {
+    return "false";
+  }
+  if (typeof data === 'symbol') {
+    return data.toString();
+  }
+  // For non-objects (primitives) that are not undefined, simply convert them.
+  if (typeof data !== 'object' && typeof data !== 'function') {
+    return String(data);
+  }
+  if (typeof data === "string") {
+    return data;
+  }
+  // Handle objects and functions using JSON.stringify with a custom replacer.
+  const seen = new WeakSet();
+  const replacer = (key, value) => {
+    if (typeof value === 'function') {
+      // Convert functions to their string representation.
+      return value.toString();
+    }
+    if (typeof value === 'undefined') {
+      return 'undefined';
+    }
+    if (typeof value === 'object' && value !== null) {
+      // Check for circular references
+      if (seen.has(value)) {
+        return '[Circular]';
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+  try {
+    return JSON.stringify(data, replacer, 2);
+  } catch (error) {
+    // Fallback to a simple string conversion if JSON.stringify fails
+    return String(data);
+  }
+}
+function removefromarray(arr, text = "") {
   if (!Array.isArray(arr)) {
-    throw new Error("data must be an array.");
+    return false;
   }
   let index = arr.indexOf(text);
   if (index !== -1) {
@@ -424,6 +817,27 @@ function isJsonSame(a, b) {
 
   return true;
 }
+function JoinJsonObjects(target = {}, source = {}) {
+  const result = { ...target };
+
+  for (const key of Object.keys(source)) {
+    if (
+      typeof source[key] === "object" &&
+      source[key] !== null &&
+      !Array.isArray(source[key]) &&
+      typeof target[key] === "object" &&
+      target[key] !== null &&
+      !Array.isArray(target[key])
+    ) {
+      result[key] = deepJoinObjects(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+}
+
 function bypassQuotes(data) {
   let stringData = "";
 
@@ -439,18 +853,6 @@ function bypassQuotes(data) {
   // Now escape all quotes and backslashes
   return stringData.replace(/(["'\\])/g, "\\$1");
 }
-function isNumber(str) {
-  if (str === null || str === undefined) {
-    return false;
-  }
-  if (typeof str === "number") {
-    return true;
-  }
-  if (Array.isArray(str) || typeof str === "object") {
-    return false;
-  }
-  return !isNaN(str) && str.trim() !== "";
-}
 async function getTableNames(config, databaseName) {
   const dbName = databaseName || config.database;
 
@@ -462,7 +864,7 @@ async function getTableNames(config, databaseName) {
     WHERE table_schema = ?
   `;
 
-  const pool = await mysql.createPool(config);
+  const pool = mysql.createPool(config);
   try {
     const [results] = await pool.query(query, [dbName]);
     return results.map(row => row.TABLE_NAME || row.table_name);
@@ -497,53 +899,219 @@ async function getColumnNames(config, databaseName, tableName) {
     if (connection) await connection.end(); // Ensure connection is closed
   }
 }
-async function getColumnDetails(config, databaseName, tableName, columnName = null) {
+async function getDatabaseCharsetAndCollation(config, databaseName) {
   let connection;
+  try {
+    // Connect to the server (not to a specific database)
+    connection = await mysql.createConnection(config);
 
-  const query = `
-    SELECT 
-      COLUMN_NAME AS column_name,
-      DATA_TYPE AS data_type,
-      COLUMN_TYPE AS column_type,
-      CHARACTER_MAXIMUM_LENGTH AS character_maximum_length,
-      IS_NULLABLE AS is_nullable,
-      COLUMN_DEFAULT AS default_value,
-      COLUMN_COMMENT AS column_comment,
-      COLLATION_NAME AS collation_name
-    FROM INFORMATION_SCHEMA.COLUMNS
-    WHERE 
-      TABLE_SCHEMA = ?
-      AND TABLE_NAME = ?
-      ${columnName ? "AND COLUMN_NAME = ?" : ""}
-  `;
+    // Query the information_schema for the given database
+    const [rows] = await connection.execute(
+      `SELECT DEFAULT_CHARACTER_SET_NAME AS characterSet, DEFAULT_COLLATION_NAME AS collation 
+       FROM information_schema.SCHEMATA 
+       WHERE SCHEMA_NAME = ?`,
+      [databaseName]
+    );
+
+    if (rows.length === 0) {
+      console.error(`Database "${databaseName}" not found.`);
+      return null;
+    }
+
+    return {
+      characterSet: rows[0].characterSet,
+      collation: rows[0].collation,
+    };
+  } catch (err) {
+    console.error("Error fetching charset/collation:", err.message);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function getColumnDetails(config, dbName, tableName, columnName) {
+  let connection;
+  try {
+    connection = await mysql.createConnection({ ...config, database: dbName });
+
+    // 1. Column metadata
+    const [cols] = await connection.execute(
+      `
+      SELECT 
+        COLUMN_TYPE,
+        DATA_TYPE,
+        CHARACTER_MAXIMUM_LENGTH,
+        NUMERIC_PRECISION,
+        NUMERIC_SCALE,
+        IS_NULLABLE,
+        COLUMN_DEFAULT,
+        EXTRA,
+        COLUMN_KEY,
+        CHARACTER_SET_NAME,
+        COLLATION_NAME,
+        COLUMN_COMMENT
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+        AND COLUMN_NAME = ?
+      `,
+      [dbName, tableName, columnName]
+    );
+
+    if (!cols.length) return false;
+    const c = cols[0];
+
+    // 2. Parse ENUM / SET
+    let length_value = null;
+    // DECIMAL / FLOAT / DOUBLE ONLY
+    if (["decimal", "float", "double"].includes(c.DATA_TYPE)) {
+      length_value =
+        c.NUMERIC_SCALE !== null
+          ? [c.NUMERIC_PRECISION, c.NUMERIC_SCALE]
+          : c.NUMERIC_PRECISION;
+    }
 
-  const params = columnName
-    ? [databaseName, tableName, columnName]
-    : [databaseName, tableName];
+    // INTEGER TYPES → no length_value
+    else if (
+      ["tinyint", "smallint", "mediumint", "int", "bigint"].includes(c.DATA_TYPE)
+    ) {
+      length_value = null;
+    }
+    else if (c.DATA_TYPE === "enum" || c.DATA_TYPE === "set") {
+      length_value = c.COLUMN_TYPE
+        .slice(c.DATA_TYPE.length + 1, -1)
+        .split(",")
+        .map(v => v.trim().replace(/^'(.*)'$/, "$1"));
+    }
+    // CHAR / VARCHAR
+    else if (c.CHARACTER_MAXIMUM_LENGTH !== null) {
+      length_value = c.CHARACTER_MAXIMUM_LENGTH;
+    }
 
+    return {
+      columntype: c.DATA_TYPE.toUpperCase(),
+      length_value,
+      unsigned: /unsigned/i.test(c.COLUMN_TYPE),
+      zerofill: /zerofill/i.test(c.COLUMN_TYPE),
+      nulls: c.IS_NULLABLE === "YES",
+      defaults: c.COLUMN_DEFAULT,
+      autoincrement: c.EXTRA.includes("auto_increment"),
+      index:
+        c.COLUMN_KEY === "PRI" ? "PRIMARY KEY" :
+          c.COLUMN_KEY === "UNI" ? "UNIQUE" :
+            c.COLUMN_KEY === "MUL" ? "KEY" : "",
+      _charset_: c.CHARACTER_SET_NAME,
+      _collate_: c.COLLATION_NAME,
+      comment: c.COLUMN_COMMENT
+    };
+
+  } catch (err) {
+    console.error(err.message);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function columnHasKey(config, databaseName, tableName, columnName) {
+  let connection;
   try {
     connection = await mysql.createConnection({ ...config, database: databaseName });
-    const [rows] = await connection.execute(query, params);
-
-    // Process ENUM and SET types
-    rows.forEach((row) => {
-      if (row.data_type === "enum" || row.data_type === "set") {
-        row.enum_set_values = row.column_type
-          .replace(/(enum|set)\((.*)\)/i, "$2")
-          .split(",")
-          .map((val) => val.replace(/'/g, ""));
-      }
+
+    // Query for PRIMARY and UNIQUE keys
+    const [indexRows] = await connection.execute(`
+            SELECT INDEX_NAME
+            FROM information_schema.STATISTICS
+            WHERE TABLE_SCHEMA = ?
+              AND TABLE_NAME = ?
+              AND COLUMN_NAME = ?
+        `, [databaseName, tableName, columnName]);
+
+    // Query for FOREIGN KEY constraints
+    const [fkRows] = await connection.execute(`
+            SELECT CONSTRAINT_NAME
+            FROM information_schema.KEY_COLUMN_USAGE
+            WHERE TABLE_SCHEMA = ?
+              AND TABLE_NAME = ?
+              AND COLUMN_NAME = ?
+              AND REFERENCED_TABLE_NAME IS NOT NULL
+        `, [databaseName, tableName, columnName]);
+
+    const keys = [
+      ...indexRows.map(row => row.INDEX_NAME),
+      ...fkRows.map(row => row.CONSTRAINT_NAME)
+    ];
+
+    return { hasKey: keys.length > 0, keys };
+  } catch (err) {
+    throw err;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function getForeignKeyDetails(config, databaseName, tableName, columnName = null) {
+  let connection;
+  try {
+    connection = await mysql.createConnection({
+      ...config,
+      database: databaseName
     });
 
-    return rows;
-  } catch (error) {
-    console.error("Error fetching column details:", error.message);
+    const sql = `
+      SELECT
+        kcu.CONSTRAINT_NAME,
+        kcu.REFERENCED_TABLE_NAME,
+        kcu.REFERENCED_COLUMN_NAME,
+        rc.DELETE_RULE,
+        rc.UPDATE_RULE,
+        kcu.COLUMN_NAME
+      FROM information_schema.KEY_COLUMN_USAGE kcu
+      JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+        ON rc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
+       AND rc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+      WHERE kcu.TABLE_SCHEMA = ?
+        AND kcu.TABLE_NAME = ?
+        AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
+        ${columnName ? "AND kcu.COLUMN_NAME = ?" : ""}
+    `;
+
+    const params = columnName
+      ? [databaseName, tableName, columnName]
+      : [databaseName, tableName];
+
+    const [rows] = await connection.query(sql, params);
+
+    if (!rows.length) return false;
+
+    // single-column FK
+    if (columnName) {
+      const r = rows[0];
+      return {
+        table: r.REFERENCED_TABLE_NAME,
+        column: r.REFERENCED_COLUMN_NAME,
+        deleteOption: r.DELETE_RULE,
+        updateOption: r.UPDATE_RULE,
+        constraintName: r.CONSTRAINT_NAME
+      };
+    }
+
+    // multiple FKs
+    return rows.map(r => ({
+      column: r.COLUMN_NAME,
+      table: r.REFERENCED_TABLE_NAME,
+      referencedColumn: r.REFERENCED_COLUMN_NAME,
+      deleteOption: r.DELETE_RULE,
+      updateOption: r.UPDATE_RULE,
+      constraintName: r.CONSTRAINT_NAME
+    }));
+
+  } catch (err) {
+    console.error("FK lookup error:", err.message);
     return null;
   } finally {
     if (connection) await connection.end();
   }
 }
-async function getForeignKeyDetails(config, databaseName, tableName) {
+async function getAllForeignKeyDetails(config, databaseName, tableName) {
   let connection;
 
   const query = `
@@ -574,100 +1142,302 @@ async function getForeignKeyDetails(config, databaseName, tableName) {
     if (connection) await connection.end();
   }
 }
-async function dropTables(databaseName, tableNames) {
-  if (typeof databaseName !== "string" || !databaseName.trim()) {
-    throw new Error("databaseName must be a non-empty string.");
-  }
-  if (!Array.isArray(tableNames)) {
-    throw new Error("tableNames must be an array of strings.");
-  }
-  if (tableNames.length === 0) return;
+async function addForeignKeyWithIndex(config, dbname, tableName, columnName, refTable, refColumn, options = {}) {
+  const {
+    onDelete = "RESTRICT",
+    onUpdate = "RESTRICT"
+  } = options;
 
-  try {
-    console.log(`Attempting to drop tables in database ${databaseName}: ${tableNames.join(", ")}`);
+  const indexName = `idx_${tableName}_${columnName}`;
+  const fkName = `fk_${tableName}_${refTable}_${columnName}`;
 
-    // Escape table names and prefix with database name, safely quoted
-    const escapedTables = tableNames
-      .map(t => `\`${databaseName.replace(/`/g, "``")}\`.\`${t.replace(/`/g, "``")}\``)
-      .join(", ");
-
-    const query = `DROP TABLE IF EXISTS ${escapedTables}`;
-    await pool.query(query);
+  let connection;
+  try {
+    connection = await mysql.createConnection({ ...config, database: dbname });
+
+    // 1. Add index if it does not exist
+    await connection.query(`
+      ALTER TABLE \`${tableName}\`
+      ADD INDEX \`${indexName}\` (\`${columnName}\`)
+    `).catch(() => { }); // ignore if index already exists
+
+    // 2. Add foreign key
+    await connection.query(`
+      ALTER TABLE \`${tableName}\`
+      ADD CONSTRAINT \`${fkName}\`
+      FOREIGN KEY (\`${columnName}\`)
+      REFERENCES \`${refTable}\` (\`${refColumn}\`)
+      ON DELETE ${onDelete}
+      ON UPDATE ${onUpdate}
+    `);
 
-    console.log(`Tables dropped successfully in database ${databaseName}: ${tableNames.join(", ")}`);
-  } catch (error) {
-    console.error(`Error dropping tables in database ${databaseName}:`, error.message);
+    return true;
+  } catch (err) {
+    const errmess = err.message;
+    console.error("FK add error:", errmess);
+    if (errmess.toLowerCase().includes("duplicate")) {
+      return false;
+    }
+    return null;
+  } finally {
+    if (connection) await connection.end();
   }
 }
-async function createOrModifyTable(queryText, databaseName) {
+async function removeForeignKeyFromColumn(config, databaseName, tableName, columnName) {
+  let connection;
+
   try {
-    if (databaseName && typeof databaseName === "string" && databaseName.trim()) {
-      // Add databaseName prefix to the table name(s) inside queryText
-
-      // This is a naive regex that finds first table name after CREATE TABLE or ALTER TABLE
-      // and prefixes it with databaseName.
-      queryText = queryText.replace(
-        /(CREATE TABLE IF NOT EXISTS|CREATE TABLE|ALTER TABLE)\s+(`?)(\w+)(`?)/i,
-        (match, p1, p2, p3, p4) => {
-          const dbNameEscaped = `\`${databaseName.replace(/`/g, "``")}\``;
-          const tableNameEscaped = `${p2}${p3}${p4}`;
-          return `${p1} ${dbNameEscaped}.${tableNameEscaped}`;
-        }
-      );
+    connection = await mysql.createConnection({
+      ...config,
+      database: databaseName
+    });
+
+    // 1️⃣ Find FK constraint(s) for this column
+    const fkRowsSql = `
+      SELECT
+        CONSTRAINT_NAME,
+        ORDINAL_POSITION
+      FROM information_schema.KEY_COLUMN_USAGE
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+        AND COLUMN_NAME = ?
+        AND REFERENCED_TABLE_NAME IS NOT NULL
+    `;
+
+    const [fkRows] = await connection.query(fkRowsSql, [
+      databaseName,
+      tableName,
+      columnName
+    ]);
+
+    if (!fkRows.length) {
+      return false; // no FK
     }
 
-    await pool.query(queryText);
+    // Multiple rows possible for composite FKs
+    const constraintName = fkRows[0].CONSTRAINT_NAME;
 
-    function getTableName(input) {
-      if (typeof input !== "string") {
-        throw new Error("Query text must be a string");
-      }
-      const words = input.trim().split(/\s+/);
-      if (words.length < 5) {
-        return "";
+    // 2️⃣ Get all columns in this FK constraint
+    const fkColsSql = `
+      SELECT COLUMN_NAME
+      FROM information_schema.KEY_COLUMN_USAGE
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+        AND CONSTRAINT_NAME = ?
+      ORDER BY ORDINAL_POSITION
+    `;
+
+    const [fkCols] = await connection.query(fkColsSql, [
+      databaseName,
+      tableName,
+      constraintName
+    ]);
+
+    const fkColumnNames = fkCols.map(r => r.COLUMN_NAME);
+
+    // 3️⃣ Drop the foreign key constraint
+    await connection.query(`
+      ALTER TABLE \`${tableName}\`
+      DROP FOREIGN KEY \`${constraintName}\`
+    `);
+
+    // 4️⃣ Find candidate indexes that exactly match FK columns
+    const indexSql = `
+      SELECT
+        INDEX_NAME,
+        COLUMN_NAME,
+        SEQ_IN_INDEX
+      FROM information_schema.STATISTICS
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+        AND COLUMN_NAME IN (?)
+      ORDER BY INDEX_NAME, SEQ_IN_INDEX
+    `;
+
+    const [indexRows] = await connection.query(indexSql, [
+      databaseName,
+      tableName,
+      fkColumnNames
+    ]);
+
+    // Group index columns
+    const indexMap = new Map();
+
+    for (const row of indexRows) {
+      if (!indexMap.has(row.INDEX_NAME)) {
+        indexMap.set(row.INDEX_NAME, []);
       }
-      if (input.startsWith("CREATE TABLE IF NOT EXISTS") && words.length > 5) {
-        return [words[5]];
-      } else {
-        return [words[2], words[5]];
+      indexMap.get(row.INDEX_NAME).push(row.COLUMN_NAME);
+    }
+
+    // 5️⃣ Drop index only if it exactly matches FK columns
+    for (const [indexName, cols] of indexMap.entries()) {
+      if (
+        cols.length === fkColumnNames.length &&
+        cols.every((c, i) => c === fkColumnNames[i])
+      ) {
+        await connection.query(`
+          ALTER TABLE \`${tableName}\`
+          DROP INDEX \`${indexName}\`
+        `);
+        break; // only one index per FK
       }
     }
 
-    let table_name = getTableName(queryText);
-    if (table_name.length > 1) {
-      return {
-        success: true,
-        message: `${table_name[1]} column of ${table_name[0]} table created or modified successfully.`,
-        querytext: queryText,
-      };
-    } else {
-      return {
-        success: true,
-        message: `${table_name[0]} table created or modified successfully.`,
-        querytext: queryText,
-      };
+    return true;
+
+  } catch (err) {
+    console.error("Drop FK error:", err.message);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function removeForeignKeyConstraintFromColumn(config, databaseName, tableName, columnName) {
+  let connection;
+  let removed = false;
+
+  try {
+    connection = await mysql.createConnection({
+      ...config,
+      database: databaseName
+    });
+
+    /* 1️⃣ Remove FOREIGN KEY if exists */
+    const [fkRows] = await connection.execute(`
+            SELECT CONSTRAINT_NAME
+            FROM information_schema.KEY_COLUMN_USAGE
+            WHERE TABLE_SCHEMA = ?
+              AND TABLE_NAME = ?
+              AND COLUMN_NAME = ?
+              AND REFERENCED_TABLE_NAME IS NOT NULL
+        `, [databaseName, tableName, columnName]);
+
+    for (const row of fkRows) {
+      await connection.execute(`
+                ALTER TABLE \`${tableName}\`
+                DROP FOREIGN KEY \`${row.CONSTRAINT_NAME}\`
+            `);
+      removed = true;
+    }
+
+    /* 2️⃣ Remove INDEX / UNIQUE KEY (excluding PRIMARY) */
+    const [indexRows] = await connection.execute(`
+            SELECT DISTINCT INDEX_NAME
+            FROM information_schema.STATISTICS
+            WHERE TABLE_SCHEMA = ?
+              AND TABLE_NAME = ?
+              AND COLUMN_NAME = ?
+              AND INDEX_NAME <> 'PRIMARY'
+        `, [databaseName, tableName, columnName]);
+
+    for (const row of indexRows) {
+      await connection.execute(`
+                ALTER TABLE \`${tableName}\`
+                DROP INDEX \`${row.INDEX_NAME}\`
+            `);
+      removed = true;
     }
+
+    return removed;
+
+  } catch (err) {
+    console.error(err.message);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function columnExists(config, databaseName, tableName, columnName) {
+  let connection;
+  try {
+    connection = await mysql.createConnection(config);
+
+    const [rows] = await connection.execute(
+      `
+            SELECT 1
+            FROM INFORMATION_SCHEMA.COLUMNS
+            WHERE TABLE_SCHEMA = ?
+              AND TABLE_NAME = ?
+              AND COLUMN_NAME = ?
+            LIMIT 1
+            `,
+      [databaseName, tableName, columnName]
+    );
+
+    return rows.length > 0;
+  } catch (err) {
+    console.error("columnExists error:", err.message);
+    return null;
+  } finally {
+    if (connection) await connection.end();
+  }
+}
+async function runQuery(config, databaseName, queryText) {
+  let connection;
+  try {
+    if (!queryText || typeof queryText !== "string") return null;
+
+    connection = await mysql.createConnection({
+      ...config,
+      database: databaseName
+    });
+
+    await connection.execute(queryText);
+    return true;
   } catch (err) {
-    return { success: false, message: err.message };
+    const errms = err.message;
+    console.error(errms);
+    return null;
+  } finally {
+    if (connection) await connection.end();
   }
 }
 
 
+
+
 module.exports = {
+  isNumber,
+  getDateTime,
+  removefromarray,
+  getMySQLVersion,
+  isMySQL578OrAbove,
+  isValidMySQLConfig,
   isMySQLDatabase,
+  getCharsetAndCollations,
+  isCharsetCollationValid,
+  getMySQLEngines,
   checkDatabaseExists,
-  createDatabase,
   getAllDatabaseNames,
+  isValidMySQLIdentifier,
   isValidDatabaseName,
   isValidTableName,
   isValidColumnName,
-  parseColumnWithOptionalLoopStrict,
-  getDateTime,
+  createloopname,
+  perseTableNameWithLoop,
+  perseDatabaseNameWithLoop,
+  getloop,
+  reverseLoopName,
+  stringifyAny,
   isJsonString,
   isJsonObject,
   isJsonSame,
+  JoinJsonObjects,
   getTableNames,
   getColumnNames,
+  getDatabaseCharsetAndCollation,
   getColumnDetails,
+  columnHasKey,
   getForeignKeyDetails,
+  getAllForeignKeyDetails,
+  addForeignKeyWithIndex,
+  removeForeignKeyFromColumn,
+  removeForeignKeyConstraintFromColumn,
+  columnExists,
+  dropDatabase,
+  dropTable,
+  dropColumn,
+  writeJsFile,
+  runQuery,
 }