dbtasker 3.1.2 → 3.1.3

package/README.md

@@ -26,10 +26,10 @@ npm install dbtasker
 btasker requires a configuration object to manage connection credentials and safety behaviors.
 Property | Description
 | :--- | :--- |
-| **host** | MySQL Host (e.g., `localhost`) |
-| **user** | Database Username |
-| **password** | Database Password |
-| **port** | Connection Port (e.g., `3306`) |
+| **host** | MySQL Host (e.g., `localhost`) `(required)`|
+| **user** | Database Username `(required)` |
+| **password** | Database Password `(required)` |
+| **port** | Connection Port (e.g., `3306`) `(required)` |
 | **drop database** | `Boolean`: If true, allows dropping databases. |
 | **drop table** | `Boolean`: If true, allows dropping tables. |
 | **drop column** | `Boolean`: If true, allows dropping columns. |
@@ -49,6 +49,8 @@ const config = {
   droptable: true,
   dropcol: false,
   donttouch: ["production_db", "analytics_db"],
+  forceupdatecolumn: true,
+  forcedeletecolumn: true,
   sep: "_" 
 };
 ```
@@ -82,10 +84,30 @@ const schema = {
         defaults: "CURRENT_TIMESTAMP"
       }
     }
+  },
+  "(year)web_db": {
+    "tableName(month)": {
+      id: {
+        type: "int",
+        primarykey: true,
+        autoincrement: true
+      }
+    }
   }
 };
 ```
 
+### The Amazing and powerful one
+When you use years, months or days as parameter when declering database name or in table name the system will generate date as extension of the name with a seperator. Such as:
+
+```js
+const sep = "_"
+if(name == "(year)name" || "name(year)") generated == "name_2026_";
+if(name == "(month)name" || "name(month)") generated == "name_2026_12_";
+if(name == "(day)name" || "name(day)") generated == "name_2026_12_26_";
+```
+
+Now if the schema have any of this kind of name then you must run the function after that particular periode. So that funciton can create that database or table each time for your particular need.
 
 
 ## 🔗 Foreign Keys
@@ -154,9 +176,10 @@ ColumnTwo: {
 const dbtasker = require("dbtasker");
 
 const config = { 
-  host: "localhost", 
+  host: "localhost",
+  port: 3306, 
   user: "root", 
-  password: "password" 
+  password: "password"
 };
 
 const schema = {

package/addcolumn.js

@@ -30,39 +30,31 @@ async function addForeignKeyWithIndexQuery(config, databaseName, tableName, colu
 async function addColumnQuery(columndata, columnName, tableName, databaseName, config) {
     try {
         if (!columndata || !columndata.columntype) {
-            throw new Error("columntype is required to add a column. Table: " + tableName + " Column name: " + columnName);
+            throw new Error(`columntype is required to add a column. Table: ${tableName} Column name: ${columnName}`);
         }
 
-        // Simple identifier escaping for MySQL identifiers
+        // Helper to escape backticks in names
         const escId = (s) => `\`${String(s).replace(/`/g, '``')}\``;
 
-        let queryText = `ALTER TABLE ${escId(tableName)} ADD COLUMN ${escId(columnName)}`;
+        // 1. Base query to add the column
+        let queryText = `ALTER TABLE ${escId(tableName)} ADD COLUMN ${escId(columnName)} ${columndata.columntype}`;
 
-        // column type
-        queryText += ` ${columndata.columntype}`;
-
-        // length / enum / set
+        // 2. Handle length / enum / set
         if (columndata.hasOwnProperty("length_value")) {
             const lengthval = columndata.length_value;
-
             if (typeof lengthval === "number") {
                 queryText += `(${lengthval})`;
-            } else if (
-                Array.isArray(lengthval) &&
-                lengthval.length === 2 &&
-                lengthval.every(v => typeof v === "number")
-            ) {
+            } else if (Array.isArray(lengthval) && lengthval.length === 2 && lengthval.every(v => typeof v === "number")) {
                 queryText += `(${lengthval[0]},${lengthval[1]})`;
-            } else if (
-                Array.isArray(lengthval) &&
-                lengthval.every(v => typeof v === "string")
-            ) {
+            } else if (Array.isArray(lengthval) && lengthval.every(v => typeof v === "string")) {
                 const escaped = lengthval.map(v => `'${v.replace(/'/g, "''")}'`);
                 queryText += `(${escaped.join(",")})`;
             }
         }
+
         queryText += " ";
 
+        // 3. Handle attributes
         if (columndata.unsigned === true) queryText += "UNSIGNED ";
         if (columndata.zerofill === true) queryText += "ZEROFILL ";
 
@@ -74,96 +66,66 @@ async function addColumnQuery(columndata, columnName, tableName, databaseName, c
             else queryText += `DEFAULT '${String(d).replace(/'/g, "''")}' `;
         }
 
-        if (columndata.autoincrement === true) {
-            queryText += "AUTO_INCREMENT ";
-        }
-
+        if (columndata.autoincrement === true) queryText += "AUTO_INCREMENT ";
         if (columndata._charset_) queryText += `CHARACTER SET ${columndata._charset_} `;
         if (columndata._collate_) queryText += `COLLATE ${columndata._collate_} `;
 
         if (columndata.hasOwnProperty("nulls")) {
             queryText += columndata.nulls ? "NULL " : "NOT NULL ";
         }
+
         if (columndata.comment) {
             queryText += `COMMENT '${String(columndata.comment).replace(/'/g, "''")}' `;
         }
 
-        // If no index specified, return the column add SQL
-        if (!columndata.hasOwnProperty("index") || columndata.index === undefined || columndata.index === null || columndata.index === '') {
-            return queryText.trim();
-        }
-
-        // index is provided — interpret it as a string describing index type
-        let rawIndex = columndata.index;
-        if (typeof rawIndex !== 'string') {
-            // defensively convert to string if possible
-            rawIndex = String(rawIndex);
-        }
-        const idxToken = rawIndex.trim().toUpperCase();
-
-        // Optional explicit index name
-        const idxNameRaw = columndata.index_name || columndata.indexName || null;
-        const idxName = idxNameRaw ? escId(idxNameRaw) : null;
-
-        // Optional prefix length for index (integer)
-        let idxLength = null;
-        if (Number.isInteger(columndata.index_length) && columndata.index_length > 0) {
-            idxLength = columndata.index_length;
-        } else if (Number.isInteger(columndata.indexLength) && columndata.indexLength > 0) {
-            idxLength = columndata.indexLength;
-        }
-
-        const colRef = idxLength ? `${escId(columnName)}(${idxLength})` : escId(columnName);
-
-        // normalize common variants to canonical type
-        let idxType = 'INDEX';
-        if (idxToken === 'PRIMARY' || idxToken === 'PRIMARY KEY') idxType = 'PRIMARY';
-        else if (idxToken === 'UNIQUE' || idxToken === 'UNIQUE KEY' || idxToken === 'UNIQUE INDEX') idxType = 'UNIQUE';
-        else if (idxToken === 'FULLTEXT' || idxToken === 'FULLTEXT KEY' || idxToken === 'FULLTEXT INDEX') idxType = 'FULLTEXT';
-        else if (idxToken === 'SPATIAL' || idxToken === 'SPATIAL KEY' || idxToken === 'SPATIAL INDEX') idxType = 'SPATIAL';
-        else idxType = 'INDEX'; // covers INDEX, KEY and others
-
-        // Build index clause. Prepend with comma because we already used ALTER TABLE ... ADD COLUMN ...
-        let indexClause = '';
-        switch (idxType) {
-            case 'PRIMARY':
-                // primary key doesn't accept a name
-                indexClause = `, ADD PRIMARY KEY (${colRef})`;
-                break;
-            case 'UNIQUE':
-                {
-                    const name = idxName || escId(`uniq_${String(tableName).replace(/\W+/g, '_')}_${String(columnName).replace(/\W+/g, '_')}`);
-                    indexClause = `, ADD UNIQUE KEY ${name} (${colRef})`;
-                }
-                break;
-            case 'FULLTEXT':
-                {
-                    const name = idxName || escId(`ft_${String(tableName).replace(/\W+/g, '_')}_${String(columnName).replace(/\W+/g, '_')}`);
-                    indexClause = `, ADD FULLTEXT KEY ${name} (${colRef})`;
-                }
-                break;
-            case 'SPATIAL':
-                {
-                    const name = idxName || escId(`sp_${String(tableName).replace(/\W+/g, '_')}_${String(columnName).replace(/\W+/g, '_')}`);
-                    indexClause = `, ADD SPATIAL KEY ${name} (${colRef})`;
-                }
-                break;
-            case 'INDEX':
-            default:
-                {
-                    const name = idxName || escId(`idx_${String(tableName).replace(/\W+/g, '_')}_${String(columnName).replace(/\W+/g, '_')}`);
-                    indexClause = `, ADD INDEX ${name} (${colRef})`;
-                }
-                break;
+        // 4. Handle Index (Optional)
+        const hasIndex = columndata.hasOwnProperty("index") && columndata.index !== undefined && columndata.index !== null && columndata.index !== '';
+
+        if (hasIndex) {
+            let rawIndex = String(columndata.index).trim().toUpperCase();
+            const idxNameRaw = columndata.index_name || columndata.indexName || null;
+            const idxName = idxNameRaw ? escId(idxNameRaw) : null;
+
+            let idxLength = null;
+            if (Number.isInteger(columndata.index_length) && columndata.index_length > 0) idxLength = columndata.index_length;
+            else if (Number.isInteger(columndata.indexLength) && columndata.indexLength > 0) idxLength = columndata.indexLength;
+
+            const colRef = idxLength ? `${escId(columnName)}(${idxLength})` : escId(columnName);
+
+            let idxType = 'INDEX';
+            if (rawIndex === 'PRIMARY' || rawIndex === 'PRIMARY KEY') idxType = 'PRIMARY';
+            else if (rawIndex.includes('UNIQUE')) idxType = 'UNIQUE';
+            else if (rawIndex.includes('FULLTEXT')) idxType = 'FULLTEXT';
+            else if (rawIndex.includes('SPATIAL')) idxType = 'SPATIAL';
+
+            switch (idxType) {
+                case 'PRIMARY':
+                    queryText += `, ADD PRIMARY KEY (${colRef})`;
+                    break;
+                case 'UNIQUE':
+                    queryText += `, ADD UNIQUE KEY ${idxName || escId(`uniq_${tableName}_${columnName}`)} (${colRef})`;
+                    break;
+                case 'FULLTEXT':
+                    queryText += `, ADD FULLTEXT KEY ${idxName || escId(`ft_${tableName}_${columnName}`)} (${colRef})`;
+                    break;
+                case 'SPATIAL':
+                    queryText += `, ADD SPATIAL KEY ${idxName || escId(`sp_${tableName}_${columnName}`)} (${colRef})`;
+                    break;
+                default:
+                    queryText += `, ADD INDEX ${idxName || escId(`idx_${tableName}_${columnName}`)} (${colRef})`;
+                    break;
+            }
         }
 
-        queryText += indexClause + ' ';
-
+        // 5. Final Execution (Happens every time)
         queryText = queryText.trim();
         const runquery = await fncs.runQuery(config, databaseName, queryText);
+
+        console.log(`Success: Added column ${columnName} to ${tableName}`);
         return runquery;
+
     } catch (err) {
-        console.error(err && err.message ? err.message : String(err));
+        console.error("Error in addColumnQuery:", err && err.message ? err.message : String(err));
         return null;
     }
 }
@@ -252,7 +214,7 @@ async function addColumnIfNeeded(config, jsondata, separator) {
                 }
             }
         }
-        if(count > 0){
+        if (count > 0) {
             console.log(cstyler.green.bold("Successfully added " + count + " columns."));
         } else {
             console.log("No column found to be added. All the column are added already.");

package/altercolumn.js

@@ -1,6 +1,7 @@
 const fncs = require("./function");
 const cstyler = require("cstyler");
 const crypto = require('crypto');
+const addcolumn = require("./addcolumn");
 
 
 
@@ -8,13 +9,13 @@ const crypto = require('crypto');
 
 function generateSafeIndexName(prefix, table, column) {
     const fullName = `${prefix}_${table}_${column}`;
-    
+
     // If it fits, just return it
     if (fullName.length <= 64) return fullName;
 
     // If too long, hash the full string and append it to a slice
     const hash = crypto.createHash('sha256').update(fullName).digest('hex').slice(0, 8);
-    
+
     // 55 chars + 1 underscore + 8 chars hash = 64 chars total
     return `${fullName.slice(0, 55)}_${hash}`;
 }
@@ -442,7 +443,13 @@ async function alterColumnIfNeeded(config, jsondata, forceupdatecolumn, separato
                     if (!fncs.isJsonObject(jsondata[jsondb][jsontable][jsoncolumn])) { continue; }
                     if (!allcols.includes(jsoncolumn)) {
                         // column does not exist, skip it
-                        console.error(cstyler.red(`Column ${jsoncolumn} does not exist in table ${tableName} of database ${databaseName}. Skipping...`));
+                        console.error(cstyler.red(`Column ${jsoncolumn} does not exist in table ${tableName} of database ${databaseName}. Adding the column...`));
+                        const addcol = await addcolumn.addColumnQuery(jsondata[jsondb][jsontable][jsoncolumn], jsoncolumn, tableName, databaseName, config);
+                        if (addcol === null) {
+                            console.error(cstyler.red(`Failed to add column ${jsoncolumn} to table ${tableName} in database ${databaseName}. Skipping...`));
+                        } else if (addcol === true) {
+                            console.log(cstyler.green(`Successfully added column ${jsoncolumn} to table ${tableName} in database ${databaseName}.`));
+                        }
                         continue;
                     }
                     // lets add the column

package/index.js

@@ -1,7 +1,6 @@
 const fncs = require("./function");
-const recordedjson = require("./tableop");
 const cstyler = require("cstyler");
-const checker = require("./validation");
+const checker = require("./mysqlvalidation");
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbtasker",
-  "version": "3.1.2",
+  "version": "3.1.3",
   "funding": {
     "type": "patreon",
     "url": "https://www.patreon.com/kormoi/gift"
@@ -45,7 +45,8 @@
     "cstyler": "^4.0.0",
     "fs": "^0.0.1-security",
     "mysql2": "^3.14.3",
-    "path": "^0.12.7"
+    "path": "^0.12.7",
+    "pg": "^8.16.3"
   },
   "repository": {
     "type": "git",

package/pgfunctions.js

@@ -0,0 +1,54 @@
+const { Client } = require('pg');
+
+
+
+
+const client = new Client({
+  user: 'postgres',
+  host: 'localhost',
+  database: 'postgres', // Connect to the default db first
+  password: 'your_password',
+  port: 5432,
+});
+
+async function test() {
+  await client.connect();
+  const res = await client.query('SELECT NOW()');
+  console.log("Postgres Time:", res.rows[0].now);
+  await client.end();
+}
+/**
+ * Connects to Postgres and returns the Locale and Encoding settings.
+ */
+async function getPostgresLocale(config) {
+  const client = new Client(config);
+  
+  try {
+    await client.connect();
+
+    // We query three specific system settings:
+    // 1. server_encoding: The character set (e.g., UTF8)
+    // 2. lc_collate: The alphabetical sorting rules
+    // 3. lc_ctype: The character classification (language)
+    const query = `
+      SELECT 
+        current_setting('server_encoding') as encoding,
+        current_setting('lc_collate') as collate,
+        current_setting('lc_ctype') as ctype
+    `;
+
+    const res = await client.query(query);
+    
+    return {
+      success: true,
+      data: res.rows[0]
+    };
+
+  } catch (error) {
+    console.error("Error fetching Postgres settings:", error.message);
+    return { success: false, error: error.message };
+  } finally {
+    // Always close the client!
+    await client.end();
+  }
+}