mysqlsyncr 1.0.82 → 1.0.86

package/dist/index.js

@@ -6,7 +6,6 @@ import path, { normalize, resolve, dirname, basename, extname, relative, join }
 import yargs from 'yargs';
 import { notStrictEqual, strictEqual } from 'assert';
 import { fileURLToPath } from 'url';
-import 'module';
 import fs, { readdir, mkdir } from 'fs/promises';
 import express from 'express';
 import http from 'http';
@@ -3188,7 +3187,14 @@ var findDifferences = function findDifferences(expected, current) {
       _tableName = _Object$entries$_i[0],
       contents = _Object$entries$_i[1];
     //check if craete table matches from json, if so, we dont need to compare indexes, triggers, or fields
-
+    var columns = contents.columns,
+      indexes = contents.indexes,
+      triggers = contents.triggers;
+      contents.createSQL;
+      contents.name;
+      contents.engine;
+      contents.charset;
+      contents.collate;
     if (!current.tables[_tableName]) {
       console.log('missing_table', contents);
       differences.push({
@@ -3198,70 +3204,73 @@ var findDifferences = function findDifferences(expected, current) {
       });
       continue;
     }
-
-    //verify triggers
-    logger('Verifying triggers for table', _tableName);
-    var _iterator = _createForOfIteratorHelper(triggers),
-      _step;
     try {
-      var _loop = function _loop() {
-        var trigger = _step.value;
-        var currentTrigger = current.tables[_tableName].triggers.find(function (t) {
-          return t.Name === trigger.Name;
-        });
-        if (!currentTrigger) {
-          logger('Missing trigger', trigger);
-          differences.push({
-            type: 'missing_trigger',
-            tableName: _tableName,
-            trigger: trigger
+      //verify triggers
+      logger('Verifying triggers for table', _tableName);
+      var _iterator = _createForOfIteratorHelper(triggers),
+        _step;
+      try {
+        var _loop = function _loop() {
+          var trigger = _step.value;
+          var currentTrigger = current.tables[_tableName].triggers.find(function (t) {
+            return t.Name === trigger.Name;
           });
-        } else {
-          // Compare additional properties if needed
-          if (currentTrigger.Event !== trigger.Event || currentTrigger.Statement !== trigger.Statement) {
-            logger('Mismatched trigger', {
-              expected: trigger,
-              current: currentTrigger
-            });
+          if (!currentTrigger) {
+            logger('Missing trigger', trigger);
             differences.push({
-              type: 'mismatched_trigger',
+              type: 'missing_trigger',
               tableName: _tableName,
               trigger: trigger
             });
+          } else {
+            // Compare additional properties if needed
+            if (currentTrigger.Event !== trigger.Event || currentTrigger.Statement !== trigger.Statement) {
+              logger('Mismatched trigger', {
+                expected: trigger,
+                current: currentTrigger
+              });
+              differences.push({
+                type: 'mismatched_trigger',
+                tableName: _tableName,
+                trigger: trigger
+              });
+            }
           }
+        };
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          _loop();
         }
-      };
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        _loop();
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-    var _iterator2 = _createForOfIteratorHelper(current.tables[_tableName].triggers),
-      _step2;
-    try {
-      var _loop2 = function _loop2() {
-        var trigger = _step2.value;
-        if (!triggers.some(function (t) {
-          return t.Name === trigger.Name;
-        })) {
-          logger('Extra trigger', trigger);
-          differences.push({
-            type: 'extra_trigger',
-            tableName: _tableName,
-            trigger: trigger
-          });
+      var _iterator2 = _createForOfIteratorHelper(current.tables[_tableName].triggers),
+        _step2;
+      try {
+        var _loop2 = function _loop2() {
+          var trigger = _step2.value;
+          if (!triggers.some(function (t) {
+            return t.Name === trigger.Name;
+          })) {
+            logger('Extra trigger', trigger);
+            differences.push({
+              type: 'extra_trigger',
+              tableName: _tableName,
+              trigger: trigger
+            });
+          }
+        };
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          _loop2();
         }
-      };
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        _loop2();
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
+    } catch (e) {
+      console.error("Error verifying triggers for table ".concat(_tableName), e);
     }
     var createTableSql = current.tables[_tableName].createSQL;
     if (createTableSql === contents.createSQL) {
@@ -3272,14 +3281,6 @@ var findDifferences = function findDifferences(expected, current) {
       logger(createTableSql);
       logger(contents.createSQL);
     }
-    var columns = contents.columns,
-      indexes = contents.indexes,
-      triggers = contents.triggers;
-      contents.createSQL;
-      contents.name;
-      contents.engine;
-      contents.charset;
-      contents.collate;
     current.tables[_tableName].columns.map(function (f) {
       return f.Field;
     });
@@ -3563,7 +3564,7 @@ var findDifferences = function findDifferences(expected, current) {
   return differences;
 };
 
-var applyDifferences = /*#__PURE__*/function () {
+var applyDifferences$1 = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(connection, database, differences) {
     var _iterator, _step, _loop, _ret;
     return _regeneratorRuntime().wrap(function _callee$(_context2) {
@@ -4058,12 +4059,12 @@ var compareAllDatabases = /*#__PURE__*/function () {
           expectedDatabases = expectedDatabases.filter(function (file) {
             return file !== 'dumpInfo.json';
           });
-          // console.log('Expected databases from input directory:', expectedDatabases);
+          console.log('Expected databases from input directory:', expectedDatabases);
 
           // Check existing databases
-          _context.next = 13;
+          _context.next = 14;
           return getDatabases(connection);
-        case 13:
+        case 14:
           existingDatabases = _context.sent;
           // console.log('Existing databases:', existingDatabases);
           allDifferences = {};
@@ -4072,20 +4073,20 @@ var compareAllDatabases = /*#__PURE__*/function () {
 
           // Note missing databases and prepare to create them
           _iterator = _createForOfIteratorHelper(expectedDatabases);
-          _context.prev = 18;
+          _context.prev = 19;
           _iterator.s();
-        case 20:
+        case 21:
           if ((_step = _iterator.n()).done) {
-            _context.next = 27;
+            _context.next = 28;
             break;
           }
           _database = _step.value;
           if (!(options && options.database && options.database !== _database)) {
-            _context.next = 24;
+            _context.next = 25;
             break;
           }
-          return _context.abrupt("continue", 25);
-        case 24:
+          return _context.abrupt("continue", 26);
+        case 25:
           if (!existingDatabases.includes(_database)) {
             allDifferences[_database] = [{
               database: _database,
@@ -4094,58 +4095,58 @@ var compareAllDatabases = /*#__PURE__*/function () {
             }];
             missingDatabases.push(_database);
           }
-        case 25:
-          _context.next = 20;
+        case 26:
+          _context.next = 21;
           break;
-        case 27:
-          _context.next = 32;
+        case 28:
+          _context.next = 33;
           break;
-        case 29:
-          _context.prev = 29;
-          _context.t0 = _context["catch"](18);
+        case 30:
+          _context.prev = 30;
+          _context.t0 = _context["catch"](19);
           _iterator.e(_context.t0);
-        case 32:
-          _context.prev = 32;
+        case 33:
+          _context.prev = 33;
           _iterator.f();
-          return _context.finish(32);
-        case 35:
+          return _context.finish(33);
+        case 36:
           if (!(missingDatabases.length > 0 && update)) {
-            _context.next = 58;
+            _context.next = 59;
             break;
           }
           console.log('Creating missing databases:');
           _iterator2 = _createForOfIteratorHelper(missingDatabases);
-          _context.prev = 38;
+          _context.prev = 39;
           _iterator2.s();
-        case 40:
+        case 41:
           if ((_step2 = _iterator2.n()).done) {
-            _context.next = 48;
+            _context.next = 49;
             break;
           }
           database = _step2.value;
           console.log("Creating database ".concat(database, "..."));
-          _context.next = 45;
+          _context.next = 46;
           return connection.query("CREATE DATABASE `".concat(database, "`;"));
-        case 45:
-          console.log("Database ".concat(database, " created."));
         case 46:
-          _context.next = 40;
+          console.log("Database ".concat(database, " created."));
+        case 47:
+          _context.next = 41;
           break;
-        case 48:
-          _context.next = 53;
+        case 49:
+          _context.next = 54;
           break;
-        case 50:
-          _context.prev = 50;
-          _context.t1 = _context["catch"](38);
+        case 51:
+          _context.prev = 51;
+          _context.t1 = _context["catch"](39);
           _iterator2.e(_context.t1);
-        case 53:
-          _context.prev = 53;
+        case 54:
+          _context.prev = 54;
           _iterator2.f();
-          return _context.finish(53);
-        case 56:
-          _context.next = 59;
+          return _context.finish(54);
+        case 57:
+          _context.next = 60;
           break;
-        case 58:
+        case 59:
           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.');
@@ -4154,87 +4155,87 @@ var compareAllDatabases = /*#__PURE__*/function () {
           } else {
             console.log('All expected databases exist.');
           }
-        case 59:
+        case 60:
           _iterator3 = _createForOfIteratorHelper(expectedDatabases);
-          _context.prev = 60;
+          _context.prev = 61;
           _iterator3.s();
-        case 62:
+        case 63:
           if ((_step3 = _iterator3.n()).done) {
-            _context.next = 100;
+            _context.next = 101;
             break;
           }
           _database2 = _step3.value;
           if (!(options && options.database && options.database !== _database2)) {
-            _context.next = 66;
+            _context.next = 67;
             break;
           }
-          return _context.abrupt("continue", 98);
-        case 66:
+          return _context.abrupt("continue", 99);
+        case 67:
           if (!missingDatabases.includes(_database2)) {
-            _context.next = 69;
+            _context.next = 70;
             break;
           }
           console.log('Skipping database', _database2, 'because it is missing');
-          return _context.abrupt("continue", 98);
-        case 69:
+          return _context.abrupt("continue", 99);
+        case 70:
           filePath = path.join(inputDir, _database2, "".concat(_database2, ".json"));
-          _context.prev = 70;
-          _context.next = 73;
+          _context.prev = 71;
+          _context.next = 74;
           return fs.readFile(filePath, 'utf-8');
-        case 73:
+        case 74:
           fileContent = _context.sent;
           expectedStructure = JSON.parse(fileContent);
           console.log('Getting database structure for', _database2);
-          _context.next = 78;
+          _context.next = 79;
           return getDatabaseStructure(connection, _database2, command, options);
-        case 78:
+        case 79:
           currentStructure = _context.sent;
           console.log('Database structure for', _database2, 'obtained');
           differences = findDifferences(expectedStructure, currentStructure);
           console.log('Differences for', _database2, 'obtained');
           if (update) {
-            _context.next = 87;
+            _context.next = 88;
             break;
           }
           console.log('Logging differences for', _database2);
           logDifferences(differences, _database2, true);
-          _context.next = 92;
+          _context.next = 93;
           break;
-        case 87:
+        case 88:
           console.log('Logging differences for', _database2);
           logDifferences(differences, _database2, false);
           console.log('Applying differences for', _database2);
-          _context.next = 92;
-          return applyDifferences(connection, _database2, differences);
-        case 92:
+          _context.next = 93;
+          return applyDifferences$1(connection, _database2, differences);
+        case 93:
           allDifferences[_database2] = differences;
-          _context.next = 98;
+          _context.next = 99;
           break;
-        case 95:
-          _context.prev = 95;
-          _context.t2 = _context["catch"](70);
+        case 96:
+          _context.prev = 96;
+          _context.t2 = _context["catch"](71);
           console.error("Error processing database ".concat(_database2, ":"), _context.t2.message);
-        case 98:
-          _context.next = 62;
+        case 99:
+          _context.next = 63;
           break;
-        case 100:
-          _context.next = 105;
+        case 101:
+          _context.next = 106;
           break;
-        case 102:
-          _context.prev = 102;
-          _context.t3 = _context["catch"](60);
+        case 103:
+          _context.prev = 103;
+          _context.t3 = _context["catch"](61);
           _iterator3.e(_context.t3);
-        case 105:
-          _context.prev = 105;
+        case 106:
+          _context.prev = 106;
           _iterator3.f();
-          return _context.finish(105);
-        case 108:
-          return _context.abrupt("return", allDifferences);
+          return _context.finish(106);
         case 109:
+          return _context.abrupt("return", allDifferences);
+        case 110:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[18, 29, 32, 35], [38, 50, 53, 56], [60, 102, 105, 108], [70, 95]]);
+    }, _callee, null, [[19, 30, 33, 36], [39, 51, 54, 57], [61, 103, 106, 109], [71, 96]]);
   }));
   return function compareAllDatabases(_x, _x2) {
     return _ref.apply(this, arguments);
@@ -4476,7 +4477,7 @@ var startApiServer = function startApiServer(port, argv) {
                     _context6.prev = 4;
                     console.log('Applying the database structure based on JSON dumps');
                     _context6.next = 8;
-                    return applyDifferences(checker.connection, database, diffs);
+                    return applyDifferences$1(checker.connection, database, diffs);
                   case 8:
                     res.json({
                       message: 'Apply completed successfully'
@@ -5204,43 +5205,146 @@ var DBStructureChecker = /*#__PURE__*/function () {
   }]);
 }();
 var compare = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(config, output) {
-    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-      while (1) switch (_context4.prev = _context4.next) {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(config, output) {
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          return _context5.abrupt("return", new Promise(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(resolve, reject) {
+              var _checker;
+              return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                while (1) switch (_context4.prev = _context4.next) {
+                  case 0:
+                    _context4.prev = 0;
+                    _checker = new DBStructureChecker(config);
+                    _checker.connection.on('connect', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+                      var diffs;
+                      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                        while (1) switch (_context3.prev = _context3.next) {
+                          case 0:
+                            _context3.next = 2;
+                            return compareAllDatabases(_checker.connection, output, false, 'compare', {
+                              output: output
+                            });
+                          case 2:
+                            diffs = _context3.sent;
+                            resolve({
+                              type: 'success',
+                              diffs: diffs
+                            });
+                          case 4:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }, _callee3);
+                    })));
+                    _context4.next = 8;
+                    break;
+                  case 5:
+                    _context4.prev = 5;
+                    _context4.t0 = _context4["catch"](0);
+                    reject({
+                      type: 'error',
+                      error: _context4.t0.message
+                    });
+                  case 8:
+                    _context4.prev = 8;
+                    _context4.next = 11;
+                    return checker.closeConnection();
+                  case 11:
+                    return _context4.finish(8);
+                  case 12:
+                  case "end":
+                    return _context4.stop();
+                }
+              }, _callee4, null, [[0, 5, 8, 12]]);
+            }));
+            return function (_x3, _x4) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 1:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return function compare(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var apply = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(config, database, diffs) {
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
         case 0:
-          return _context4.abrupt("return", new Promise(function (resolve, reject) {
+          return _context7.abrupt("return", new Promise(function (resolve, reject) {
             try {
-              var checker = new DBStructureChecker(config);
-              checker.connection.on('connect', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-                var diffs;
-                return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-                  while (1) switch (_context3.prev = _context3.next) {
+              var _checker2 = new DBStructureChecker(config, database);
+              _checker2.connection.on('error', function (err) {
+                console.error('Database connection error in route apply:', err);
+                reject({
+                  type: 'error',
+                  error: err.message
+                });
+              });
+              _checker2.connection.on('connect', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+                return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+                  while (1) switch (_context6.prev = _context6.next) {
                     case 0:
-                      _context3.next = 2;
-                      return compareAllDatabases(checker.connection, output, false, 'compare', {
-                        output: output
+                      console.log('Connected to the database');
+                      _checker2.targetDatabase = database;
+                      _checker2.command = 'apply';
+                      _checker2.options = {
+                        config: config,
+                        database: database,
+                        diffs: diffs
+                      };
+                      _context6.prev = 4;
+                      console.log('Applying the database structure based on JSON dumps');
+                      _context6.next = 8;
+                      return applyDifferences(_checker2.connection, database, diffs);
+                    case 8:
+                      resolve({
+                        type: 'success',
+                        message: 'Apply completed successfully'
                       });
-                    case 2:
-                      diffs = _context3.sent;
-                      resolve(diffs);
-                    case 4:
+                      _context6.next = 14;
+                      break;
+                    case 11:
+                      _context6.prev = 11;
+                      _context6.t0 = _context6["catch"](4);
+                      reject({
+                        type: 'error',
+                        error: _context6.t0.message
+                      });
+                    case 14:
+                      _context6.prev = 14;
+                      _context6.next = 17;
+                      return _checker2.closeConnection();
+                    case 17:
+                      return _context6.finish(14);
+                    case 18:
                     case "end":
-                      return _context3.stop();
+                      return _context6.stop();
                   }
-                }, _callee3);
+                }, _callee6, null, [[4, 11, 14, 18]]);
               })));
             } catch (e) {
-              reject(e);
+              reject({
+                type: 'error',
+                error: e.message
+              });
             }
           }));
         case 1:
         case "end":
-          return _context4.stop();
+          return _context7.stop();
       }
-    }, _callee4);
+    }, _callee7);
   }));
-  return function compare(_x, _x2) {
-    return _ref.apply(this, arguments);
+  return function apply(_x5, _x6, _x7) {
+    return _ref4.apply(this, arguments);
   };
 }();
 
@@ -5256,15 +5360,15 @@ var isMain = function () {
   }
 }();
 if (isMain) {
-  _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
-    var _cli, command, config, argv, PORT, checker;
-    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-      while (1) switch (_context6.prev = _context6.next) {
+  _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+    var _cli, command, config, argv, PORT, _checker3;
+    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
         case 0:
           _cli = cli(), command = _cli.command, config = _cli.config, argv = _cli.argv;
           console.log("MySQLsyncr started via command line");
           if (!(command === 'ui')) {
-            _context6.next = 12;
+            _context9.next = 12;
             break;
           }
           PORT = argv.uiPort;
@@ -5272,58 +5376,58 @@ if (isMain) {
           console.log('Server started on port', PORT);
           console.log('Open http://localhost:' + PORT + ' in your browser to use the UI');
           if (!(argv.openUI && argv.openUI === true || argv.openUI === 'true')) {
-            _context6.next = 10;
+            _context9.next = 10;
             break;
           }
-          _context6.next = 10;
+          _context9.next = 10;
           return open("http://localhost:".concat(PORT));
         case 10:
-          _context6.next = 14;
+          _context9.next = 14;
           break;
         case 12:
           // Handle other commands (dump, compare, update) as before
-          checker = new DBStructureChecker(config, argv.database);
-          checker.connection.on('connect', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+          _checker3 = new DBStructureChecker(config, argv.database);
+          _checker3.connection.on('connect', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
             var diffs, totalDiffs, _totalDiffs, previousDiffs, runCount, maxRuns, _diffs;
-            return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-              while (1) switch (_context5.prev = _context5.next) {
+            return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+              while (1) switch (_context8.prev = _context8.next) {
                 case 0:
                   console.log('Connected to the database');
-                  checker.targetDatabase = argv.database;
-                  checker.command = command;
-                  checker.options = argv;
-                  _context5.prev = 4;
+                  _checker3.targetDatabase = argv.database;
+                  _checker3.command = command;
+                  _checker3.options = argv;
+                  _context8.prev = 4;
                   if (!(command === 'dump')) {
-                    _context5.next = 11;
+                    _context8.next = 11;
                     break;
                   }
                   console.log('Dumping the database structure to files');
-                  _context5.next = 9;
-                  return dumpAllDatabases(checker.connection, command, argv);
+                  _context8.next = 9;
+                  return dumpAllDatabases(_checker3.connection, command, argv);
                 case 9:
-                  _context5.next = 42;
+                  _context8.next = 42;
                   break;
                 case 11:
                   if (!(command === 'compare')) {
-                    _context5.next = 21;
+                    _context8.next = 21;
                     break;
                   }
                   console.log('Comparing the database structure with JSON dumps (dry run)');
-                  _context5.next = 15;
-                  return compareAllDatabases(checker.connection, argv.output, false, command, argv);
+                  _context8.next = 15;
+                  return compareAllDatabases(_checker3.connection, argv.output, false, command, argv);
                 case 15:
-                  diffs = _context5.sent;
+                  diffs = _context8.sent;
                   // Dry run
                   totalDiffs = Object.values(diffs).reduce(function (acc, arr) {
                     return acc + arr.length;
                   }, 0);
                   console.log('Total differences count:', totalDiffs);
                   fs$3.writeFileSync(path.join(argv.output, 'diffs.json'), JSON.stringify(diffs, null, 4));
-                  _context5.next = 42;
+                  _context8.next = 42;
                   break;
                 case 21:
                   if (!(command === 'update')) {
-                    _context5.next = 42;
+                    _context8.next = 42;
                     break;
                   }
                   console.log('Updating the database structure based on JSON dumps');
@@ -5333,14 +5437,14 @@ if (isMain) {
                   maxRuns = 6;
                 case 27:
                   if (!(runCount < maxRuns && _totalDiffs > 0 && (_totalDiffs < previousDiffs || previousDiffs === Infinity))) {
-                    _context5.next = 42;
+                    _context8.next = 42;
                     break;
                   }
                   console.log('Running update command. Run count:', runCount);
-                  _context5.next = 31;
-                  return compareAllDatabases(checker.connection, argv.output, true, command, argv);
+                  _context8.next = 31;
+                  return compareAllDatabases(_checker3.connection, argv.output, true, command, argv);
                 case 31:
-                  _diffs = _context5.sent;
+                  _diffs = _context8.sent;
                   // Apply updates
                   previousDiffs = _totalDiffs; // Update previous differences
                   _totalDiffs = Object.values(_diffs).reduce(function (acc, arr) {
@@ -5349,42 +5453,42 @@ if (isMain) {
                   console.log('Total differences count:', _totalDiffs);
                   runCount++;
                   if (!(_totalDiffs > 0 && runCount < maxRuns)) {
-                    _context5.next = 40;
+                    _context8.next = 40;
                     break;
                   }
                   console.log('Total differences count is still greater than 0. Waiting 1 second before next run. Run count:', runCount);
-                  _context5.next = 40;
+                  _context8.next = 40;
                   return new Promise(function (resolve) {
                     return setTimeout(resolve, 1000);
                   });
                 case 40:
-                  _context5.next = 27;
+                  _context8.next = 27;
                   break;
                 case 42:
-                  _context5.next = 47;
+                  _context8.next = 47;
                   break;
                 case 44:
-                  _context5.prev = 44;
-                  _context5.t0 = _context5["catch"](4);
-                  console.error(_context5.t0.message);
+                  _context8.prev = 44;
+                  _context8.t0 = _context8["catch"](4);
+                  console.error(_context8.t0.message);
                 case 47:
-                  _context5.prev = 47;
-                  _context5.next = 50;
-                  return checker.closeConnection();
+                  _context8.prev = 47;
+                  _context8.next = 50;
+                  return _checker3.closeConnection();
                 case 50:
-                  return _context5.finish(47);
+                  return _context8.finish(47);
                 case 51:
                 case "end":
-                  return _context5.stop();
+                  return _context8.stop();
               }
-            }, _callee5, null, [[4, 44, 47, 51]]);
+            }, _callee8, null, [[4, 44, 47, 51]]);
           })));
         case 14:
         case "end":
-          return _context6.stop();
+          return _context9.stop();
       }
-    }, _callee6);
+    }, _callee9);
   }))();
 }
 
-export { DBStructureChecker, compare, dumpAllDatabases, startApiServer };
+export { DBStructureChecker, apply, compare, dumpAllDatabases, startApiServer };