mysqlsyncr 1.0.32 → 1.0.36

package/__tests__/parser.test.js

@@ -25,136 +25,137 @@ describe('Create Table Parser', () => {
   CONSTRAINT \`CaseDX\` FOREIGN KEY (\`idCaseDX\`) REFERENCES \`Case_DX\` (\`idCaseDX\`) ON DELETE NO ACTION ON UPDATE NO ACTION
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1 COMMENT='Keeps track of all active/inactive alarm rules used for the assets.\n';`;
 
-        const expectedOutput =     {                                                                                                       
+        const expectedOutput = {
             "name": "AlarmRuleHistory",
             "columns": [
-                {
-                    "Field": "idAlarmHistory",
-                    "Type": "int(11)",
-                    "NotNull": true,
-                    "AutoIncrement": true
-                },
-                {
-                    "Field": "idAsset",
-                    "Type": "int(11)",
-                    "NotNull": true
-                },
-                {
-                    "Field": "idCaseDX",
-                    "Type": "int(11)",
-                    "Default": "NULL"
-                },
-                {
-                    "Field": "idAlertRule",
-                    "Type": "int(11)",
-                    "Default": "NULL"
-                },
-                {
-                    "Field": "activeAlarmRule",
-                    "Type": "smallint(1)",
-                    "NotNull": true,
-                    "Default": "'0'"
-                },
-                {
-                    "Field": "alarmRule_StartDate",
-                    "Type": "timestamp",
-                    "Default": "NULL"
-                },
-                {
-                    "Field": "alarmRule_EndDate",
-                    "Type": "timestamp",
-                    "Default": "NULL"
-                },
-                {
-                    "Field": "dateCreated",
-                    "Type": "timestamp",
-                    "NotNull": true,
-                    "Default": "CURRENT_TIMESTAMP"
-                },
-                {
-                    "Field": "dateUpdated",
-                    "Type": "timestamp",
-                    "NotNull": true,
-                    "Default": "CURRENT_TIMESTAMP"
-                },
-                {
-                    "Field": "lastModifiedBy",
-                    "Type": "varchar(32)",
-                    "NotNull": true,
-                    "Default": "'System"
-                }
+              {
+                "Field": "idAlarmHistory",
+                "Type": "int(11)",
+                "NotNull": true,
+                "AutoIncrement": true
+              },
+              {
+                "Field": "idAsset",
+                "Type": "int(11)",
+                "NotNull": true
+              },
+              {
+                "Field": "idCaseDX",
+                "Type": "int(11)",
+                "Default": "NULL"
+              },
+              {
+                "Field": "idAlertRule",
+                "Type": "int(11)",
+                "Default": "NULL"
+              },
+              {
+                "Field": "activeAlarmRule",
+                "Type": "smallint(1)",
+                "NotNull": true,
+                "Default": "0"
+              },
+              {
+                "Field": "alarmRule_StartDate",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "alarmRule_EndDate",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "dateCreated",
+                "Type": "timestamp",
+                "NotNull": true,
+                "Default": "CURRENT_TIMESTAMP"
+              },
+              {
+                "Field": "dateUpdated",
+                "Type": "timestamp",
+                "NotNull": true,
+                "Default": "CURRENT_TIMESTAMP"
+              },
+              {
+                "Field": "lastModifiedBy",
+                "Type": "varchar(32)",
+                "NotNull": true,
+                "Default": "System"
+              }
             ],
             "indexes": [
-                {
-                    "ColumnName": [
-                        "`idAlarmHistory`"
-                    ],
-                    "Primary": true
-                },
-                {
-                    "ColumnName": [
-                        "`idAlertRule`"
-                    ],
-                    "Name": "AlertRule_idx"
-                },
-                {
-                    "ColumnName": [
-                        "`idCaseDX`"
-                    ],
-                    "Name": "CaseDX_idx"
-                },
-                {
-                    "ColumnName": [
-                        "`idAsset`"
-                    ],
-                    "Name": "Asset_idx"
-                }
+              {
+                "ColumnName": [
+                  "idAlarmHistory"
+                ],
+                "Primary": true,
+                "Name": "PRIMARY"
+              },
+              {
+                "ColumnName": [
+                  "idAlertRule"
+                ],
+                "Name": "AlertRule_idx"
+              },
+              {
+                "ColumnName": [
+                  "idCaseDX"
+                ],
+                "Name": "CaseDX_idx"
+              },
+              {
+                "ColumnName": [
+                  "idAsset"
+                ],
+                "Name": "Asset_idx"
+              }
             ],
             "constraints": [
-                {
-                    "Name": "AlertRule",
-                    "Type": "FOREIGN KEY",
-                    "ColumnName": [
-                        "`idAlertRule`"
-                    ],
-                    "References": {
-                        "Table": "`AlertRules`",
-                        "Column": "`idAlertRule`"
-                    },
-                    "OnDelete": "NO ACTION",
-                    "OnUpdate": "NO ACTION"
+              {
+                "Name": "AlertRule",
+                "Type": "FOREIGN KEY",
+                "ColumnName": [
+                  "idAlertRule"
+                ],
+                "References": {
+                  "Table": "AlertRules",
+                  "Column": "idAlertRule"
+                },
+                "OnDelete": "NO ACTION",
+                "OnUpdate": "NO ACTION"
+              },
+              {
+                "Name": "AlertRule",
+                "Type": "FOREIGN KEY",
+                "ColumnName": [
+                  "idAsset"
+                ],
+                "References": {
+                  "Table": "Assets",
+                  "Column": "idAsset"
                 },
-                {
-                    "Name": "AlertRule",
-                    "Type": "FOREIGN KEY",
-                    "ColumnName": [
-                        "`idAsset`"
-                    ],
-                    "References": {
-                        "Table": "`Assets`",
-                        "Column": "`idAsset`"
-                    },
-                    "OnDelete": "NO ACTION",
-                    "OnUpdate": "NO ACTION"
+                "OnDelete": "NO ACTION",
+                "OnUpdate": "NO ACTION"
+              },
+              {
+                "Name": "AlertRule",
+                "Type": "FOREIGN KEY",
+                "ColumnName": [
+                  "idCaseDX"
+                ],
+                "References": {
+                  "Table": "Case_DX",
+                  "Column": "idCaseDX"
                 },
-                {
-                    "Name": "AlertRule",
-                    "Type": "FOREIGN KEY",
-                    "ColumnName": [
-                        "`idCaseDX`"
-                    ],
-                    "References": {
-                        "Table": "`Case_DX`",
-                        "Column": "`idCaseDX`"
-                    },
-                    "OnDelete": "NO ACTION",
-                    "OnUpdate": "NO ACTION"
-                }
+                "OnDelete": "NO ACTION",
+                "OnUpdate": "NO ACTION"
+              }
             ],
             "engine": "InnoDB",
             "charset": "latin1",
             "collate": null
-        }
+          }
     
         
 

package/__tests__/parser2.test.js

@@ -0,0 +1,153 @@
+import { parseCreateTableSQL, parseDatabaseStructure } from '../src/parsers';
+
+
+
+describe('Create Table Parser', () => {
+
+    test('should correctly parse a valid create table statement. Check #1', () => {
+        const input = `CREATE TABLE \`Alarms\` (
+            \`alarmId\` int NOT NULL AUTO_INCREMENT,
+            \`alarmRuleId\` int NOT NULL,
+            \`alarmStatus\` int NOT NULL,
+            \`alarmStatus_Text\` varchar(50) NOT NULL,
+            \`alarmCreated_Date\` timestamp NULL DEFAULT NULL,
+            \`alarmConfirmed_Date\` timestamp NULL DEFAULT NULL,
+            \`alarmRecall_Date\` timestamp NULL DEFAULT NULL,
+            \`activeAlarm\` tinyint(1) NOT NULL DEFAULT '0',
+            \`emailSent\` tinyint(1) DEFAULT '0',
+            \`emailSent_AnswerPlus\` tinyint(1) DEFAULT '0',
+            \`ticketEmailSent\` tinyint(1) DEFAULT '0',
+            \`type\` varchar(45) DEFAULT NULL,
+            \`oorValue\` float(10,2) DEFAULT NULL,
+            \`thresholdValue\` float(10,2) DEFAULT NULL,
+            \`dateCreated\` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
+            \`dateUpdated\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+            PRIMARY KEY (\`alarmId\`),
+            UNIQUE KEY \`UniqueAlarmRules\` (\`alarmRuleId\`),
+            KEY \`idx_alarms_alarmruleid_alarmstatus\` (\`alarmRuleId\`, \`alarmStatus\`)
+          ) ENGINE=InnoDB AUTO_INCREMENT=117 DEFAULT CHARSET=latin1 COMMENT='Alarm table for alarms '`;
+          
+
+        const expectedOutput = {
+            "name": "Alarms",
+            "columns": [
+              {
+                "Field": "alarmId",
+                "Type": "int",
+                "NotNull": true,
+                "AutoIncrement": true
+              },
+              {
+                "Field": "alarmRuleId",
+                "Type": "int",
+                "NotNull": true
+              },
+              {
+                "Field": "alarmStatus",
+                "Type": "int",
+                "NotNull": true
+              },
+              {
+                "Field": "alarmStatus_Text",
+                "Type": "varchar(50)",
+                "NotNull": true
+              },
+              {
+                "Field": "alarmCreated_Date",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "alarmConfirmed_Date",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "alarmRecall_Date",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "activeAlarm",
+                "Type": "tinyint(1)",
+                "NotNull": true,
+                "Default": "0"
+              },
+              {
+                "Field": "emailSent",
+                "Type": "tinyint(1)",
+                "Default": "0"
+              },
+              {
+                "Field": "emailSent_AnswerPlus",
+                "Type": "tinyint(1)",
+                "Default": "0"
+              },
+              {
+                "Field": "ticketEmailSent",
+                "Type": "tinyint(1)",
+                "Default": "0"
+              },
+              {
+                "Field": "type",
+                "Type": "varchar(45)",
+                "Default": "NULL"
+              },
+              {
+                "Field": "oorValue",
+                "Type": "float(10,2)"
+              },
+              {
+                "Field": "thresholdValue",
+                "Type": "float(10,2)"
+              },
+              {
+                "Field": "dateCreated",
+                "Type": "timestamp",
+                "Default": "CURRENT_TIMESTAMP"
+              },
+              {
+                "Field": "dateUpdated",
+                "Type": "timestamp",
+                "NotNull": true,
+                "Default": "CURRENT_TIMESTAMP"
+              }
+            ],
+            "indexes": [
+              {
+                "ColumnName": [
+                  "alarmId"
+                ],
+                "Primary": true,
+                "Name": "PRIMARY"
+              },
+              {
+                "ColumnName": [
+                  "alarmRuleId"
+                ],
+                "Unique": true,
+                "Name": "UniqueAlarmRules"
+              },
+              {
+                "ColumnName": [
+                  "alarmRuleId",
+                  "alarmStatus"
+                ],
+                "Name": "idx_alarms_alarmruleid_alarmstatus"
+              }
+            ],
+            "constraints": [],
+            "engine": null,
+            "charset": null,
+            "collate": null
+          }
+    
+        
+
+        const result = parseCreateTableSQL(input);
+        console.log('Result:', JSON.stringify(result, null, 2))
+        expect(result).toEqual(expectedOutput);
+    });
+
+
+}); 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysqlsyncr",
-  "version": "1.0.32",
+  "version": "1.0.36",
   "description": "",
   "main": "src/index.js",
   "type": "module",

package/src/apply.js

@@ -65,6 +65,16 @@ export const applyDifferences = async (connection, database, differences) => {
                     console.log(`Executing: ${modifyFieldSQL}`);
                     await connection.query(modifyFieldSQL);
                 }
+                if(diff.field.Default){
+                    const defaultClause = diff.field.Default === 'CURRENT_TIMESTAMP' 
+                    ? 'DEFAULT CURRENT_TIMESTAMP'
+                    : diff.field.Default !== undefined && diff.field.Default !== null 
+                        ? `DEFAULT '${diff.field.Default}'` 
+                        : '';
+                    const modifyFieldSQL = `ALTER TABLE \`${diff.tableName}\` MODIFY \`${diff.field.Field}\` ${diff.field.Type} ${defaultClause};`;
+                    console.log(`Executing: ${modifyFieldSQL}`);
+                    await connection.query(modifyFieldSQL);
+                }
 
             } else if (diff.type === 'extra_field') {
                 const dropFieldSQL = `ALTER TABLE \`${diff.tableName}\` DROP COLUMN \`${diff.field.Field}\`;`;

package/src/differences.js

@@ -38,12 +38,12 @@ export const findDifferences = (expected, current) => {
         const expectedFieldNames = columns.map(f => f.Field);
 
         logger('Detecting missing fields for table', tableName);
-        // Detect missing fields
-        for (const field of columns) {
-            if (!currentFieldNames.includes(field.Field)) {
-                differences.push({ type: 'missing_field', tableName, field });
-            }
-        }
+        // // Detect missing fields
+        // for (const field of columns) {
+        //     if (!currentFieldNames.includes(field.Field)) {
+        //         differences.push({ type: 'missing_field', tableName, field });
+        //     }
+        // }
 
         logger('Detecting extra fields for table', tableName);
         // Detect extra fields

package/src/dump.js

@@ -1,7 +1,11 @@
+import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
 import { getDatabases, getDatabaseStructure } from './getters.js';
 
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
 export const dumpAllDatabases = async (connection, command, options) => {
     let response = {}
     const databases = await getDatabases(connection);
@@ -16,6 +20,8 @@ export const dumpAllDatabases = async (connection, command, options) => {
         await fs.writeFile(path.join(options.output , database, `${database}.json`), JSON.stringify(dbStructure, null, 4), 'utf-8');
         response[database] = dbStructure;
     }
+
+    await fs.writeFile(path.join(options.output, 'dumpInfo.json'), JSON.stringify({timestamp: new Date().toISOString(), version: version}, null, 4), 'utf-8');
     return response;
 }
 
@@ -33,7 +39,7 @@ export const getDatabasesFromExistingDumps = async (options) => {
     let response = {}
     const databases = await fs.readdir(path.join(options.output));
     for (const database of databases) {
-        if(database.includes('diffs')){
+        if(database.includes('diffs') || database.includes('dumpInfo')){
             console.log('Skipping diffs folder')
             continue
         }

package/src/index.js

@@ -14,17 +14,19 @@ class DBStructureChecker {
     constructor(config, targetDatabase = null) {
         this.config = config;
         this.targetDatabase = targetDatabase;
-        this.connection = mysql.createConnection(this.config);
+        this.connection = mysql.createConnection(this.config)
         this.dumpAllDatabases = dumpAllDatabases;
         this.compareAllDatabases = compareAllDatabases;
         this.getDatabases = () => {
 
             fs.readFileSync(path.join(__dirname, 'databases.json'), 'utf8');
         }
-        this.connection.on('error', (err) => {
-            console.error('Database connection error:', err);
-        });
+        // this.connection.on('error', (err) => {
+        //     this.emit('error', err);
+        //     console.error('Database connection error:', err);
+        // });
         this.connection.query = util.promisify(this.connection.query); // Promisify for async/await
+
     }
 
     async reconnect() {

package/src/parsers.js

@@ -1,4 +1,3 @@
-
 export const parseCreateTableSQL = (createTableSQL) => {
     if(!createTableSQL) return null;
     const name = createTableSQL.match(/CREATE TABLE\s+`([^`]+)`/)[1];
@@ -32,9 +31,10 @@ export const parseCreateTableSQL = (createTableSQL) => {
         const indexMatch = indexRegex.exec(line);
         const constraintMatch = parseConstraint(line);
         if (columnMatch && !indexMatch && !constraintMatch) {
+            const columnType = parseColumnType(line);
             const column = {
                 Field: columnMatch[1],
-                Type: columnMatch[2]
+                Type: columnType
             };
 
             // Set Null property based on NOT NULL presence
@@ -116,15 +116,30 @@ export const parseConstraint = (sql) => {
     }else{
         onUpdate = 'NO ACTION';
     }
+    let columnName = match[1] || ''
+    columnName = columnName.replace(/`/g, '')
+    let table = match[2] || ''
+    table = table.replace(/`/g, '')
+    let column = match[3] || ''
+    column = column.replace(/`/g, '')
     return {
         Name: "AlertRule", // Replace with actual constraint name if needed
         Type: "FOREIGN KEY",
-        ColumnName: [match[1]], // Column in the current table
+        ColumnName: [columnName], // Column in the current table
         References: {
-            Table: match[2], // Referenced table
-            Column: match[3], // Referenced column
+            Table: table, // Referenced table
+            Column: column, // Referenced column
         },
         OnDelete: onDelete, 
         OnUpdate: onUpdate, 
     };
-};
+};
+
+const parseColumnType = (line) => {
+    // Match type pattern including parameters, handling both single and double parameter types
+    const typeRegex = /`[^`]+`\s+([a-zA-Z]+(?:\([0-9]+(?:,[0-9]+)?\))?)/i;
+    const match = line.match(typeRegex);
+    
+    if (!match) return null;
+    return match[1]; // Returns the full type including parameters
+};