mysqlsyncr 1.0.0

package/README.md

@@ -0,0 +1,176 @@
+# MySQLSync
+
+MySQLSync is a command-line tool for managing and comparing MySQL database structures with JSON dumps. It allows users to dump the database structure, compare it with existing JSON files, and update the database based on those JSON definitions.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+  - [Global Installation](#global-installation)
+  - [Local Installation](#local-installation)
+- [Usage](#usage)
+  - [Commands](#commands)
+  - [Configuration Options](#configuration-options)
+- [Using MySQLSync as a Module](#using-mysqlsync-as-a-module)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Features
+
+- **Dump**: Export the database structure to JSON files.
+- **Compare**: Compare the current database structure with JSON dumps to identify differences.
+- **Update**: Update the database structure based on the provided JSON definitions.
+- **Verbose Logging**: Enable detailed logging for debugging purposes.
+
+## Installation
+
+### Global Installation
+
+To install MySQLSync globally, allowing you to use it from the command line, run the following command:
+
+```bash
+npm install -g mysqlsync
+```
+
+This will allow you to run the command as `mysqlsync` from anywhere in your terminal.
+
+### Local Installation
+
+If you prefer to use MySQLSync locally within a project, you can install it as a dependency:
+
+```bash
+npm install mysqlsync
+```
+
+This will add MySQLSync to your project's `node_modules` and allow you to use it within your project.
+
+## Usage
+
+You can run MySQLSync commands using the following syntax:
+
+```bash
+mysqlsync <command> [options]
+```
+
+### Commands
+
+- `dump`: Dumps the database structure to files.
+- `compare`: Compares the database structure with JSON dumps (dry run).
+- `update`: Updates the database structure based on JSON dumps.
+
+### Configuration Options
+
+You can configure the following options when running the commands:
+
+| Option      | Alias | Description                                                                 | Default Value                  |
+|-------------|-------|-----------------------------------------------------------------------------|--------------------------------|
+| `host`      | `-h`  | Database host                                                              | `localhost`                   |
+| `port`      | `-P`  | Database port                                                              | `3306`                         |
+| `user`      | `-u`  | Database user                                                              | `root`                         |
+| `password`  | `-p`  | Database password (required)                                              |                                |
+| `database`  | `-d`  | Target database                                                            | `null`                        |
+| `output`    | `-o`  | Output directory for dumping. Default is one level up from the current directory in a new folder called `db-dump` | `../db-dump`                  |
+| `verbose`   | `-v`  | Enable verbose logging (boolean)                                          | `false`                       |
+
+### Example Usage
+
+1. **Dump the database structure**:
+   ```bash
+   mysqlsync dump --host localhost --user root --password yourpassword
+   ```
+
+2. **Compare the database structure with JSON dumps**:
+   ```bash
+   mysqlsync compare --host localhost --user root --password yourpassword
+   ```
+
+3. **Update the database structure based on JSON dumps**:
+   ```bash
+   mysqlsync update --host localhost --user root --password yourpassword
+   ```
+
+## Using MySQLSync as a Module
+
+If you want to use MySQLSync as a module in your own Node.js application, you can require it in your code:
+
+```javascript
+import mysqlsync from 'mysqlsync';
+
+// Example usage
+const config = {
+    host: 'localhost',
+    user: 'root',
+    password: 'yourpassword',
+    database: 'yourdatabase'
+};
+```
+
+```javascript
+// app.js
+import mysqlsync from 'mysqlsync';
+import fs from 'fs';
+import path from 'path';
+
+// Database configuration
+const config = {
+    host: 'localhost',
+    user: 'root',
+    password: 'yourpassword',
+    database: 'yourdatabase'
+};
+
+// Function to dump the database structure
+async function dumpDatabase() {
+    try {
+        console.log('Dumping the database structure...');
+        await mysqlsync.dump(config);
+        console.log('Database structure dumped successfully.');
+    } catch (error) {
+        console.error('Error dumping database:', error.message);
+    }
+}
+
+// Function to compare the database structure with JSON dumps
+async function compareDatabase() {
+    try {
+        const inputDir = path.join(__dirname, 'db-dump'); // Directory where JSON dumps are stored
+        console.log('Comparing the database structure with JSON dumps...');
+        const differences = await mysqlsync.compare(config, inputDir);
+        
+        if (differences.length > 0) {
+            console.log('Differences found:');
+            console.log(differences);
+        } else {
+            console.log('No differences found. The database structure matches the JSON dumps.');
+        }
+    } catch (error) {
+        console.error('Error comparing database:', error.message);
+    }
+}
+
+// Main function to execute dump and compare
+(async () => {
+    await dumpDatabase();
+    await compareDatabase();
+})();
+```
+
+Make sure to check the source code for available functions and their usage.
+
+## Contributing
+
+Contributions are welcome! If you would like to contribute to MySQLSync, please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bug fix.
+3. Make your changes and commit them with clear messages.
+4. Push your changes to your forked repository.
+5. Open a pull request to the main repository.
+
+### Code of Conduct
+
+Please adhere to the [Code of Conduct](CODE_OF_CONDUCT.md) when contributing to this project.
+
+## License
+
+This project is licensed under the ISC License. See the [LICENSE](LICENSE) file for more details.

package/__tests__/parser.test.js

@@ -0,0 +1,166 @@
+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 \`AlarmRuleHistory\` (
+  \`idAlarmHistory\` int(11) NOT NULL AUTO_INCREMENT,
+  \`idAsset\` int(11) NOT NULL,
+  \`idCaseDX\` int(11) DEFAULT NULL,
+  \`idAlertRule\` int(11) DEFAULT NULL,
+  \`activeAlarmRule\` smallint(1) NOT NULL DEFAULT '0',
+  \`alarmRule_StartDate\` timestamp NULL DEFAULT NULL,
+  \`alarmRule_EndDate\` timestamp NULL DEFAULT NULL,
+  \`dateCreated\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  \`dateUpdated\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  \`lastModifiedBy\` varchar(32) NOT NULL DEFAULT 'System Generated',
+  PRIMARY KEY (\`idAlarmHistory\`),
+  KEY \`AlertRule_idx\` (\`idAlertRule\`),
+  KEY \`CaseDX_idx\` (\`idCaseDX\`),
+  KEY \`Asset_idx\` (\`idAsset\`),
+  CONSTRAINT \`AlertRule\` FOREIGN KEY (\`idAlertRule\`) REFERENCES \`AlertRules\` (\`idAlertRule\`) ON DELETE NO ACTION ON UPDATE NO ACTION,
+  CONSTRAINT \`Asset\` FOREIGN KEY (\`idAsset\`) REFERENCES \`Assets\` (\`idAsset\`) ON DELETE NO ACTION ON UPDATE NO ACTION,
+  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 =     {                                                                                                       
+            "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"
+                }
+            ],
+            "indexes": [
+                {
+                    "ColumnName": [
+                        "`idAlarmHistory`"
+                    ],
+                    "Primary": true
+                },
+                {
+                    "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": [
+                        "`idAsset`"
+                    ],
+                    "References": {
+                        "Table": "`Assets`",
+                        "Column": "`idAsset`"
+                    },
+                    "OnDelete": "NO ACTION",
+                    "OnUpdate": "NO ACTION"
+                },
+                {
+                    "Name": "AlertRule",
+                    "Type": "FOREIGN KEY",
+                    "ColumnName": [
+                        "`idCaseDX`"
+                    ],
+                    "References": {
+                        "Table": "`Case_DX`",
+                        "Column": "`idCaseDX`"
+                    },
+                    "OnDelete": "NO ACTION",
+                    "OnUpdate": "NO ACTION"
+                }
+            ],
+            "engine": "InnoDB",
+            "charset": "latin1",
+            "collate": null
+        }
+    
+        
+
+        const result = parseCreateTableSQL(input);
+        expect(result).toEqual(expectedOutput);
+    });
+
+
+}); 

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "mysqlsyncr",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "start": "node src/index.js"
+  },
+  "bin": {
+    "mysqlsync": "src/index.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "mysql2": "^3.12.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.26.0",
+    "babel-jest": "^29.7.0",
+    "jest": "^29.0.0"
+  },
+  "babel": {
+    "presets": ["@babel/preset-env"]
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.js$": "babel-jest"
+    },
+    "testEnvironment": "node"
+  }
+}

package/src/apply.js

@@ -0,0 +1,187 @@
+import { logger } from './loggers.js';
+
+export const applyDifferences = async (connection, database, differences) => {
+    await connection.query(`USE \`${database}\``);
+
+    for (const diff of differences) {
+        try {
+            if (diff.type === 'missing_table') {
+                const { tableName, createSQL } = diff;
+                logger(`Creating missing table ${tableName}`);
+                logger(`Executing: ${createSQL}`);
+                await connection.query(createSQL);
+
+            } else if (diff.type === 'extra_table') {
+                const { tableName } = diff;
+                logger(`Dropping extra table ${tableName}`);
+                const dropTableSQL = `DROP TABLE \`${tableName}\`;`;
+                logger(`Executing: ${dropTableSQL}`);
+                await connection.query(dropTableSQL);
+
+            } else if (diff.type === 'missing_field') {
+                const defaultValue =
+                    diff.field.Default === 'CURRENT_TIMESTAMP'
+                        ? 'DEFAULT CURRENT_TIMESTAMP'
+                        : diff.field.Default !== null
+                            ? `DEFAULT '${diff.field.Default}'`
+                            : '';
+                const addFieldSQL = `ALTER TABLE \`${diff.tableName}\` ADD \`${diff.field.Field}\` ${diff.field.Type} ${diff.field.Null === 'NO' ? 'NOT NULL' : ''
+                    } ${defaultValue} ${diff.field.Extra || ''};`;
+                logger(`Executing: ${addFieldSQL}`);
+                await connection.query(addFieldSQL);
+
+
+            } else if (diff.type === 'extra_field') {
+                const dropFieldSQL = `ALTER TABLE \`${diff.tableName}\` DROP COLUMN \`${diff.field.Field}\`;`;
+                logger(`Executing: ${dropFieldSQL}`);
+                await connection.query(dropFieldSQL);
+
+            } else if (diff.type === 'mismatched_field') {
+                const { tableName, field } = diff;
+                const dropFieldSQL = `ALTER TABLE \`${tableName}\` CHANGE \`${field.Field}\` \`${field.Field}\` ${field.Type} ${field.Null === 'NO' ? 'NOT NULL' : ''
+                    } ${field.Default === 'CURRENT_TIMESTAMP' ? 'DEFAULT CURRENT_TIMESTAMP' : field.Default !== null ? `DEFAULT '${field.Default}'` : ''};`;
+                logger(`Executing: ${dropFieldSQL}`);
+                await connection.query(dropFieldSQL);
+
+            } else if (diff.type === 'missing_index') {
+                const existingColumns = await connection.query(`SHOW COLUMNS FROM \`${diff.tableName}\``);
+                const columnNames = existingColumns.map(col => col.Field);
+
+                // Check if all columns for the index exist
+                const missingColumns = Array.isArray(diff.index.ColumnName) ? diff.index.ColumnName.filter(col => !columnNames.includes(col)) : [];
+
+                if (missingColumns.length > 0) {
+                    logger(`Cannot create index ${diff.index.Name} on ${diff.tableName}. Missing columns: ${missingColumns.join(', ')}`);
+                    continue; // Skip index creation if columns are missing
+                }
+
+                // Prepare the index columns with proper formatting
+                const indexColumns = diff.index.ColumnName.map(col => `\`${col}\``); // Format column names
+
+                // Handle PRIMARY index creation
+                if (diff.index.Name === 'PRIMARY') {
+                    if (indexColumns.length > 0) {
+                        const primaryKeySQL = `ALTER TABLE \`${diff.tableName}\` ADD PRIMARY KEY (${indexColumns.join(', ')});`;
+                        logger(`Executing: ${primaryKeySQL}`);
+                        await connection.query(primaryKeySQL);
+                    } else {
+                        logger(`Cannot create PRIMARY index on ${diff.tableName}. ColumnName is undefined or empty.`, diff.index);
+                    }
+                } else {
+                    // Create the new index with UNIQUE if applicable
+                    const uniqueSQL = diff.index.Unique ? 'UNIQUE ' : ''; // Check if the index is unique
+                    if (indexColumns.length > 0) {
+                        const addIndexSQL = `ALTER TABLE \`${diff.tableName}\` ADD ${uniqueSQL}INDEX \`${diff.index.Name}\` (${indexColumns.join(', ')});`;
+                        logger(`Executing: ${addIndexSQL}`);
+                        await connection.query(addIndexSQL);
+                    } else {
+                        logger(`Cannot create index ${diff.index.Name} on ${diff.tableName}. ColumnName is undefined or empty.`, diff.index);
+                    }
+                }
+
+            } else if (diff.type === 'extra_index') {
+                // Handle dropping of extra indexes
+                if (diff.index.Name === 'PRIMARY') {
+                    const dropPrimaryKeySQL = `ALTER TABLE \`${diff.tableName}\` DROP PRIMARY KEY;`;
+                    logger(`Executing: ${dropPrimaryKeySQL}`);
+                    await connection.query(dropPrimaryKeySQL);
+                } else {
+                    const dropIndexSQL = `DROP INDEX \`${diff.index.Name}\` ON \`${diff.tableName}\`;`;
+                    logger(`Executing: ${dropIndexSQL}`);
+                    await connection.query(dropIndexSQL);
+                }
+
+            } else if (diff.type === 'mismatched_index') {
+                const { tableName, index } = diff;
+                // Drop the existing index
+                if (index.Name === 'PRIMARY') {
+                    const dropPrimaryKeySQL = `ALTER TABLE \`${tableName}\` DROP PRIMARY KEY;`;
+                    logger(`Executing: ${dropPrimaryKeySQL}`);
+                    await connection.query(dropPrimaryKeySQL);
+                } else {
+                    const dropIndexSQL = `DROP INDEX \`${index.Name}\` ON \`${tableName}\`;`;
+                    logger(`Executing: ${dropIndexSQL}`);
+                    await connection.query(dropIndexSQL);
+                }
+                console.log('index', index)
+
+                // Create the new index
+                const uniqueSQL = index.Unique ? 'UNIQUE ' : ''; // Check if the index is unique
+                if (index.Name === 'PRIMARY') {
+                    const addPrimaryKeySQL = `ALTER TABLE \`${tableName}\` ADD PRIMARY KEY (${index.ColumnName.join(', ')});`;
+                    logger(`Executing: ${addPrimaryKeySQL}`);
+                    await connection.query(addPrimaryKeySQL);
+                } else {
+                    const addIndexSQL = `ALTER TABLE \`${tableName}\` ADD ${uniqueSQL}INDEX \`${index.Name}\` (${index.ColumnName.join(', ')});`; // Include UNIQUE if applicable
+                    logger(`Executing: ${addIndexSQL}`);
+                    await connection.query(addIndexSQL);
+                }
+
+            } else if (diff.type === 'missing_procedure' || diff.type === 'mismatched_procedure') {
+
+                // Drop the procedure if it exists
+                const dropCurrentProcSQL = `DROP PROCEDURE IF EXISTS \`${diff.Name}\`;`;
+                logger(`Executing: ${dropCurrentProcSQL}`);
+                await connection.query(dropCurrentProcSQL);
+
+                // Create the procedure
+                const createProcSQL = diff.Definition;
+                logger(`Executing: ${createProcSQL}`); // Log the SQL statement
+                await connection.query(createProcSQL);
+
+
+
+            } else if (diff.type === 'missing_view') {
+                const dropViewSQL = `DROP VIEW IF EXISTS \`${diff.viewName}\`;`;
+                logger(`Executing: ${dropViewSQL}`);
+                await connection.query(dropViewSQL);
+                const createViewSQL = diff.definition; // Use the expected definition to create the view
+                logger(`Executing: ${createViewSQL}`);
+                await connection.query(createViewSQL);
+
+
+            } else if (diff.type === 'mismatched_view') {
+                const dropViewSQL = `DROP VIEW IF EXISTS \`${diff.viewName}\`;`;
+                logger(`Executing: ${dropViewSQL}`);
+                await connection.query(dropViewSQL);
+                const createViewSQL = diff.definition; // Use the expected definition to create the view
+                logger(`Executing: ${createViewSQL}`);
+                await connection.query(createViewSQL);
+
+
+            } else if (diff.type === 'extra_view') {
+                const dropViewSQL = `DROP VIEW IF EXISTS \`${diff.viewName}\`;`;
+                logger(`Executing: ${dropViewSQL}`);
+                await connection.query(dropViewSQL);
+
+
+            } else if (diff.type === 'missing_trigger') {
+                const createTriggerSQL = `CREATE TRIGGER \`${diff.triggerName}\` ${diff.definition.Event} ON \`${diff.definition.Table}\` FOR EACH ROW ${diff.definition.Definition}`;
+                logger(`Executing: ${createTriggerSQL}`);
+                await connection.query(createTriggerSQL);
+
+
+            } else if (diff.type === 'mismatched_trigger') {
+                const dropTriggerSQL = `DROP TRIGGER IF EXISTS \`${diff.trigger.Name}\`;`;
+                logger(`Executing: ${dropTriggerSQL}`);
+                await connection.query(dropTriggerSQL);
+                const createTriggerSQL = `CREATE TRIGGER \`${diff.trigger.Name}\` ${diff.trigger.Event} ON \`${diff.trigger.Table}\` FOR EACH ROW ${diff.trigger.Definition}`;
+                logger(`Executing: ${createTriggerSQL}`);
+                await connection.query(createTriggerSQL);
+
+
+            } else if (diff.type === 'extra_trigger') {
+                const dropTriggerSQL = `DROP TRIGGER IF EXISTS \`${diff.trigger.Name}\`;`;
+                logger(`Executing: ${dropTriggerSQL}`);
+                await connection.query(dropTriggerSQL);
+
+
+
+            } else {
+                logger(`Error applying difference of type:${diff.type}`, diff)
+            }
+        } catch (e) {
+            logger(`Error applying difference of type:${diff.type}. Error: ${e.message}`, diff);
+        }
+    }
+}

package/src/cli.js

@@ -0,0 +1,32 @@
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { setVerbose } from './loggers.js';
+
+export const cli = () => {
+    const argv = yargs(hideBin(process.argv))
+        .command('dump', 'Dump the database structure to files')
+        .command('compare', 'Compare the database structure with JSON dumps (dry run)')
+        .command('update', 'Update the database structure based on JSON dumps')
+        .option('host', { alias: 'h', describe: 'Database host', default: 'localhost' })
+        .option('port', { alias: 'P', describe: 'Database port', default: 3306 })
+        .option('user', { alias: 'u', describe: 'Database user', default: 'root' })
+        .option('password', { alias: 'p', describe: 'Database password', demandOption: true })
+        .option('database', { alias: 'd', describe: 'Target database', default: null })
+        .option('output', { alias: 'o', describe: 'Output directory for dumping. default is one level up from the current directory in a new folder called db-dump', default: '../db-dump' })
+        .option('verbose', { alias: 'v', describe: 'Enable verbose logging', type: 'boolean', default: false })
+        .demandCommand(1)
+        .help()
+        .argv;
+
+    const command = argv._[0];
+    const config = {
+        host: argv.host,
+        port: argv.port,
+        user: argv.user,
+        password: argv.password,
+    };
+
+    setVerbose(argv.verbose);
+
+    return { command, config, argv };
+};

package/src/compare.js

@@ -0,0 +1,80 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getDatabases, getDatabaseStructure } from './getters.js';
+import { findDifferences } from './differences.js';
+import { logDifferences } from './loggers.js';
+import { applyDifferences } from './apply.js';
+
+export const compareAllDatabases = async (connection, inputDir, update = false, command, options) => {
+    if (connection.state === 'disconnected') {
+        await connection.reconnect(); // Ensure the connection is open
+    }
+    // Read the expected databases from the input directory
+    const expectedDatabases = await fs.readdir(inputDir);
+    // console.log('Expected databases from input directory:', expectedDatabases);
+
+    // Check existing databases
+    const existingDatabases = await getDatabases(connection);
+    // console.log('Existing databases:', existingDatabases);
+
+    const missingDatabases = [];
+
+    // Note missing databases and prepare to create them
+    for (const database of expectedDatabases) {
+        if(options.database && options.database !== database){
+            continue;
+        }
+        if (!existingDatabases.includes(database)) {
+            missingDatabases.push(database);
+        }
+    }
+
+    // Create missing databases at the beginning
+    if (missingDatabases.length > 0 && update) {
+        console.log('Creating missing databases:');
+        for (const database of missingDatabases) {
+            console.log(`Creating database ${database}...`);
+            await connection.query(`CREATE DATABASE \`${database}\`;`);
+            console.log(`Database ${database} created.`);
+        }
+    }else if (missingDatabases.length > 0 && !update){
+        console.error('Missing databases found but update is not enabled. Please enable update to create missing databases.');
+        console.error('Please run the command again with the --update flag to create missing databases.'); 
+        console.error('Missing databases:');
+        console.error(missingDatabases);
+        return;
+    } else {
+        console.log('All expected databases exist.');
+    }
+
+    const allDifferences = {};
+    for (const database of expectedDatabases) {
+        if(options.database && options.database !== database){
+            continue;
+        }
+        const filePath = path.join(inputDir, database, `${database}.json`);
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const expectedStructure = JSON.parse(fileContent);
+            console.log('Getting database structure for', database);
+            const currentStructure = await getDatabaseStructure(connection, database, command, options);
+            console.log('Database structure for', database, 'obtained');
+            const differences = findDifferences(expectedStructure, currentStructure);
+            console.log('Differences for', database, 'obtained');
+            if (!update) {
+                console.log('Logging differences for', database);
+                logDifferences(differences, database, true);
+            } else {
+                console.log('Logging differences for', database);
+                logDifferences(differences, database, false);
+                console.log('Applying differences for', database);
+                await applyDifferences(connection, database, differences);
+            }
+            allDifferences[database] = differences;
+        } catch (err) {
+            console.error(`Error processing database ${database}:`, err.message);
+        }
+    }
+
+    return allDifferences;
+}