mysqlsyncr 1.1.10 → 1.2.1

package/src/cli.js

@@ -1,35 +1,62 @@
-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')
-        .command('ui', 'Open the UI')
-        .option('uiPort', { alias: 'U', describe: 'UI port', default: 3600 })
-        .option('openUI', { alias: 'O', describe: 'Open UI', default: true })
-        .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', default: '' })
-        .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 };
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { setVerbose } from './loggers.js';
+import { promptForOptions, promptForPassword, DATABASE_COMMANDS } from './prompt.js';
+
+const COMMANDS = ['dump', 'compare', 'update', 'ui', 'rebuild'];
+
+/**
+ * Parse the command line. With no command, asks for the command and its options
+ * in a terminal, or prints the help otherwise. command is null when there's nothing to run.
+ */
+export const cli = async () => {
+    const parser = 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')
+        .command('ui', 'Open the UI')
+        .command('rebuild', "Rebuild the dump's JSON from each table's CREATE TABLE and list what changes (dry run unless --write)")
+        .option('uiPort', { alias: 'U', describe: 'UI port', default: 3600 })
+        .option('openUI', { alias: 'O', describe: 'Open UI', default: true })
+        .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' })
+        // No default, so a missing password can be asked for; -p with no value means none
+        .option('password', { alias: 'p', describe: 'Database password (asked for in a terminal when not given)', type: 'string' })
+        .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('write', { describe: 'With rebuild, write the rebuilt files', type: 'boolean', default: false })
+        .option('verbose', { alias: 'v', describe: 'Enable verbose logging', type: 'boolean', default: false })
+        // .demandCommand(1)
+        .help();
+    const argv = parser.argv;
+
+    let command = argv._[0];
+    if (command === undefined) {
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+            command = await promptForOptions(argv);
+        } else {
+            parser.showHelp();
+            command = null;
+        }
+    } else if (!COMMANDS.includes(command)) {
+        console.error(`Unknown command: ${command}. Use one of: ${COMMANDS.join(', ')}`);
+        command = null;
+    }
+
+    const interactive = process.stdin.isTTY && process.stdout.isTTY;
+    if (DATABASE_COMMANDS.includes(command) && argv.password === undefined) {
+        argv.password = interactive ? await promptForPassword(argv) : '';
+    }
+
+    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

@@ -1,93 +1,107 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { getDatabases, getDatabaseStructure } from './getters.js';
-import { findDifferences } from './differences.js';
-import { logDifferences, logger } 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
-    let expectedDatabases = await fs.readdir(inputDir);
-    //filter out diffs.json
-    expectedDatabases = expectedDatabases.filter(file => file !== 'diffs.json');
-    //filter out dumpInfo.json
-    expectedDatabases = expectedDatabases.filter(file => file !== 'dumpInfo.json');
-    logger('Expected databases from input directory:', expectedDatabases);
-
-    // Check existing databases
-    const existingDatabases = await getDatabases(connection);
-    // console.log('Existing databases:', existingDatabases);
-    const allDifferences = {};
-    const missingDatabases = [];
-    logger('All differences:', allDifferences);
-
-    // Note missing databases and prepare to create them
-    for (const database of expectedDatabases) {
-        if(options && options.database && options.database !== database){
-            continue;
-        }
-
-        if (!existingDatabases.includes(database)) {
-            allDifferences[database] = [{
-                database: database,
-                type: 'missing_database',
-                message: 'Database not found'
-            }];
-            missingDatabases.push(database);
-        }
-    }
-
-    // Create missing databases at the beginning
-    if (missingDatabases.length > 0 && update) {
-        logger('Creating missing databases:');
-        for (const database of missingDatabases) {
-            logger(`Creating database ${database}...`);
-            await connection.query(`CREATE DATABASE \`${database}\`;`);
-            logger(`Database ${database} created.`);
-        }
-    }else if (missingDatabases.length > 0 && !update){
-        logger('Missing databases found but update is not enabled. Please enable update to create missing databases.');
-        logger('Please run the command again with the --update flag to create missing databases.'); 
-        logger('Missing databases:');
-        logger(missingDatabases);
-    } else {
-        logger('All expected databases exist.');
-    }
-
-    for (const database of expectedDatabases) {
-        if(options && options.database && options.database !== database){
-            continue;
-        }
-        if(missingDatabases.includes(database)){
-            logger('Skipping database', database, 'because it is missing');
-            continue;
-        }
-        const filePath = path.join(inputDir, database, `${database}.json`);
-
-        try {
-            const fileContent = await fs.readFile(filePath, 'utf-8');
-            const expectedStructure = JSON.parse(fileContent);
-            logger('Getting database structure for', database);
-            const currentStructure = await getDatabaseStructure(connection, database, command, options);
-            logger('Database structure for', database, 'obtained');
-            const differences = findDifferences(expectedStructure, currentStructure);
-            logger('Differences for', database, 'obtained');
-            if (!update) {
-                logger('Logging differences for', database);
-                logDifferences(differences, database, true);
-            } else {
-                logger('Logging differences for', database);
-                logDifferences(differences, database, false);
-                logger('Applying differences for', database);
-                await applyDifferences(connection, database, differences);
-            }
-            allDifferences[database] = differences;
-        } catch (err) {
-            logger(`Error processing database ${database}:`, err.message);
-        }
-    }
-    return allDifferences;
+import fs from 'fs/promises';
+import path from 'path';
+import { getDatabases, getDatabaseStructure } from './getters.js';
+import { findDifferences } from './differences.js';
+import { logDifferences, logger } from './loggers.js';
+import { applyDifferences, describeFailures } from './apply.js';
+import { loadSyncOptions, getTableOptions, applyDefinerOption } from './options.js';
+import { findMissingRows } from './rows.js';
+
+export const compareAllDatabases = async (connection, inputDir, update = false, command, options) => {
+    if (connection.state === 'disconnected') {
+        await connection.reconnect(); // Ensure the connection is open
+    }
+    // Each expected database is a folder in the input directory; files like diffs.json,
+    // dumpInfo.json and syncOptions.json sit alongside them
+    const entries = await fs.readdir(inputDir, { withFileTypes: true });
+    const expectedDatabases = entries.filter(entry => entry.isDirectory()).map(entry => entry.name);
+    const syncOptions = await loadSyncOptions(inputDir);
+    logger('Expected databases from input directory:', expectedDatabases);
+
+    // Check existing databases
+    const existingDatabases = await getDatabases(connection);
+    // console.log('Existing databases:', existingDatabases);
+    const allDifferences = {};
+    const missingDatabases = [];
+    logger('All differences:', allDifferences);
+
+    // Note missing databases and prepare to create them
+    for (const database of expectedDatabases) {
+        if(options && options.database && options.database !== database){
+            continue;
+        }
+
+        if (!existingDatabases.includes(database)) {
+            allDifferences[database] = [{
+                database: database,
+                type: 'missing_database',
+                message: 'Database not found'
+            }];
+            missingDatabases.push(database);
+        }
+    }
+
+    // Create missing databases at the beginning
+    if (missingDatabases.length > 0 && update) {
+        logger('Creating missing databases:');
+        for (const database of missingDatabases) {
+            logger(`Creating database ${database}...`);
+            await connection.query(`CREATE DATABASE \`${database}\`;`);
+            logger(`Database ${database} created.`);
+        }
+    }else if (missingDatabases.length > 0 && !update){
+        logger('Missing databases found but update is not enabled. Please enable update to create missing databases.');
+        logger('Please run the command again with the --update flag to create missing databases.'); 
+        logger('Missing databases:');
+        logger(missingDatabases);
+    } else {
+        logger('All expected databases exist.');
+    }
+
+    for (const database of expectedDatabases) {
+        if(options && options.database && options.database !== database){
+            continue;
+        }
+        if(missingDatabases.includes(database)){
+            logger('Skipping database', database, 'because it is missing');
+            continue;
+        }
+        const filePath = path.join(inputDir, database, `${database}.json`);
+
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const expectedStructure = applyDefinerOption(JSON.parse(fileContent), syncOptions.definer);
+            logger('Getting database structure for', database);
+            const currentStructure = await getDatabaseStructure(connection, database, command, options);
+            logger('Database structure for', database, 'obtained');
+            const differences = findDifferences(expectedStructure, currentStructure, (tableName) => getTableOptions(syncOptions, database, tableName));
+            // A seed-row problem shouldn't hide this database's structure differences
+            try {
+                differences.push(...await findMissingRows(connection, database, expectedStructure, currentStructure, syncOptions));
+            } catch (err) {
+                console.error(`Could not check seed rows for ${database}: ${err.message}`);
+            }
+            logger('Differences for', database, 'obtained');
+            if (!update) {
+                logger('Logging differences for', database);
+                logDifferences(differences, database, true);
+            } else {
+                logger('Logging differences for', database);
+                logDifferences(differences, database, false);
+                logger('Applying differences for', database);
+                try {
+                    const result = await applyDifferences(connection, database, differences);
+                    if (result.failures.length > 0) {
+                        console.error(`Error applying differences for ${database}: ${describeFailures(result)}`);
+                    }
+                } catch (err) {
+                    console.error(`Error applying differences for ${database}: ${err.message}`);
+                }
+            }
+            allDifferences[database] = differences;
+        } catch (err) {
+            console.error(`Error processing database ${database}: ${err.message}`);
+        }
+    }
+    return allDifferences;
 }