mysqlsyncr 1.0.50 → 1.0.54

package/__tests__/import.cjs

@@ -0,0 +1,23 @@
+const mysqlSyncr = require('../dist/index.cjs.cjs');
+const path = require('path');
+
+const dotenv = require('dotenv');
+dotenv.config({ path: path.resolve(__dirname, '../.env') });
+
+console.log(`DB_STRUCTURE_PATH: ${process.env.DB_STRUCTURE_PATH}`);
+console.log(`DB_PASSWORD: ${process.env.DB_PASSWORD}`);
+const config ={
+    host: "127.0.0.1",
+    user: 'root',
+    password: process.env.DB_PASSWORD,
+    port: 3306
+};
+const testDbConnection = async () => {
+        console.log(mysqlSyncr);
+        const diffs = await mysqlSyncr.compare(config, process.env.DB_STRUCTURE_PATH);
+    console.log(diffs);
+}
+
+testDbConnection();
+
+

package/dist/apply.js

@@ -0,0 +1,459 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyDifferences = void 0;
+var _loggers = require("./loggers.js");
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, ""); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, "_invoke", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: "normal", arg: t.call(e, r) }; } catch (t) { return { type: "throw", arg: t }; } } e.wrap = wrap; var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { ["next", "throw", "return"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if ("throw" !== c.type) { var u = c.arg, h = u.value; return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) { invoke("next", t, i, a); }, function (t) { invoke("throw", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke("throw", t, i, a); }); } a(c.arg); } var r; o(this, "_invoke", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw Error("Generator is already running"); if (o === s) { if ("throw" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else "return" === n.method && n.abrupt("return", n.arg); o = f; var p = tryCatch(e, r, n); if ("normal" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, "throw" === n && e.iterator["return"] && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y; var i = tryCatch(o, e.iterator, r.arg); if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = "normal", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: "root" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || "" === e) { var r = e[a]; if (r) return r.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + " is not iterable"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) { var e = "function" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () { return this; }), define(g, "toString", function () { return "[object Generator]"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if ("throw" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if ("root" === i.tryLoc) return handle("end"); if (i.tryLoc <= this.prev) { var c = n.call(i, "catchLoc"), u = n.call(i, "finallyLoc"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw Error("try statement without catch or finally"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { var i = o; break; } } i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if ("throw" === t.type) throw t.arg; return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, "catch": function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if ("throw" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw Error("illegal catch attempt"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, "next" === this.method && (this.arg = t), y; } }, e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+var applyDifferences = exports.applyDifferences = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(connection, database, differences) {
+    var _iterator, _step, _loop, _ret;
+    return _regeneratorRuntime().wrap(function _callee$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          differences.sort(function (a, b) {
+            //Sort to make sure we apply the differences in a logical order.
+            var typePriority = {
+              'missing_database': 1,
+              'missing_table': 2,
+              'extra_table': 2,
+              'missing_field': 3,
+              'extra_field': 3,
+              'mismatched_field': 3,
+              'missing_index': 4,
+              'extra_index': 4,
+              'mismatched_index': 4,
+              'missing_procedure': 5,
+              'mismatched_procedure': 5,
+              'missing_view': 6,
+              'mismatched_view': 6,
+              'extra_view': 6,
+              'missing_trigger': 7,
+              'mismatched_trigger': 7,
+              'extra_trigger': 7
+            };
+            return (typePriority[a.type] || 999) - (typePriority[b.type] || 999);
+          });
+          _iterator = _createForOfIteratorHelper(differences);
+          _context2.prev = 2;
+          _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+            var diff, createDatabaseSQL, tableName, createSQL, _tableName, dropTableSQL, addFieldSQL, modifyFieldSQL, defaultClause, _modifyFieldSQL, dropFieldSQL, _tableName2, field, _defaultClause, _dropFieldSQL, existingColumns, columnNames, missingColumns, indexColumns, primaryKeySQL, uniqueSQL, addIndexSQL, dropPrimaryKeySQL, dropIndexSQL, _tableName3, index, _dropPrimaryKeySQL, _dropIndexSQL, _uniqueSQL, addPrimaryKeySQL, _addIndexSQL, dropCurrentProcSQL, createProcSQL, dropViewSQL, createViewSQL, _dropViewSQL, _createViewSQL, _dropViewSQL2, createTriggerSQL, dropTriggerSQL, _createTriggerSQL, _dropTriggerSQL, _createDatabaseSQL;
+            return _regeneratorRuntime().wrap(function _loop$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  diff = _step.value;
+                  _context.prev = 1;
+                  if (!(diff.type == 'missing_database')) {
+                    _context.next = 8;
+                    break;
+                  }
+                  createDatabaseSQL = "CREATE DATABASE `".concat(differences[0].database, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(createDatabaseSQL));
+                  _context.next = 7;
+                  return connection.query(createDatabaseSQL);
+                case 7:
+                  return _context.abrupt("return", 0);
+                case 8:
+                  _context.next = 10;
+                  return connection.query("USE `".concat(database, "`"));
+                case 10:
+                  if (!(diff.type === 'missing_table')) {
+                    _context.next = 18;
+                    break;
+                  }
+                  tableName = diff.tableName, createSQL = diff.createSQL;
+                  (0, _loggers.logger)("Creating missing table ".concat(tableName));
+                  (0, _loggers.logger)("Executing: ".concat(createSQL));
+                  _context.next = 16;
+                  return connection.query(createSQL);
+                case 16:
+                  _context.next = 210;
+                  break;
+                case 18:
+                  if (!(diff.type === 'extra_table')) {
+                    _context.next = 27;
+                    break;
+                  }
+                  _tableName = diff.tableName;
+                  (0, _loggers.logger)("Dropping extra table ".concat(_tableName));
+                  dropTableSQL = "DROP TABLE `".concat(_tableName, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(dropTableSQL));
+                  _context.next = 25;
+                  return connection.query(dropTableSQL);
+                case 25:
+                  _context.next = 210;
+                  break;
+                case 27:
+                  if (!(diff.type === 'missing_field')) {
+                    _context.next = 45;
+                    break;
+                  }
+                  // Step 1: Add column with DEFAULT NULL to handle existing records
+                  addFieldSQL = "ALTER TABLE `".concat(diff.tableName, "` ADD `").concat(diff.field.Field, "` ").concat(diff.field.Type, " DEFAULT NULL;");
+                  console.log("Executing: ".concat(addFieldSQL));
+                  _context.next = 32;
+                  return connection.query(addFieldSQL);
+                case 32:
+                  if (!(diff.field.NotNull && !diff.field.Default)) {
+                    _context.next = 37;
+                    break;
+                  }
+                  modifyFieldSQL = "ALTER TABLE `".concat(diff.tableName, "` MODIFY `").concat(diff.field.Field, "` ").concat(diff.field.Type, " NOT NULL;");
+                  console.log("Executing: ".concat(modifyFieldSQL));
+                  _context.next = 37;
+                  return connection.query(modifyFieldSQL);
+                case 37:
+                  if (!diff.field.Default) {
+                    _context.next = 43;
+                    break;
+                  }
+                  defaultClause = diff.field.Default === 'CURRENT_TIMESTAMP' ? 'DEFAULT CURRENT_TIMESTAMP' : diff.field.Default !== undefined && diff.field.Default !== null ? "DEFAULT '".concat(diff.field.Default, "'") : '';
+                  _modifyFieldSQL = "ALTER TABLE `".concat(diff.tableName, "` MODIFY `").concat(diff.field.Field, "` ").concat(diff.field.Type, " ").concat(defaultClause, ";");
+                  console.log("Executing: ".concat(_modifyFieldSQL));
+                  _context.next = 43;
+                  return connection.query(_modifyFieldSQL);
+                case 43:
+                  _context.next = 210;
+                  break;
+                case 45:
+                  if (!(diff.type === 'extra_field')) {
+                    _context.next = 52;
+                    break;
+                  }
+                  dropFieldSQL = "ALTER TABLE `".concat(diff.tableName, "` DROP COLUMN `").concat(diff.field.Field, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(dropFieldSQL));
+                  _context.next = 50;
+                  return connection.query(dropFieldSQL);
+                case 50:
+                  _context.next = 210;
+                  break;
+                case 52:
+                  if (!(diff.type === 'mismatched_field')) {
+                    _context.next = 61;
+                    break;
+                  }
+                  _tableName2 = diff.tableName, field = diff.field;
+                  _defaultClause = field.Default === 'CURRENT_TIMESTAMP' ? 'DEFAULT CURRENT_TIMESTAMP' : field.Default !== undefined && field.Default !== null ? "DEFAULT '".concat(field.Default, "'") : '';
+                  _dropFieldSQL = "ALTER TABLE `".concat(_tableName2, "` CHANGE `").concat(field.Field, "` `").concat(field.Field, "` ").concat(field.Type, " ").concat(field.NotNull ? 'NOT NULL' : '', " ").concat(_defaultClause, ";");
+                  (0, _loggers.logger)("Executing: ".concat(_dropFieldSQL));
+                  _context.next = 59;
+                  return connection.query(_dropFieldSQL);
+                case 59:
+                  _context.next = 210;
+                  break;
+                case 61:
+                  if (!(diff.type === 'missing_index')) {
+                    _context.next = 93;
+                    break;
+                  }
+                  _context.next = 64;
+                  return connection.query("SHOW COLUMNS FROM `".concat(diff.tableName, "`"));
+                case 64:
+                  existingColumns = _context.sent;
+                  columnNames = existingColumns.map(function (col) {
+                    return col.Field;
+                  }); // Check if all columns for the index exist
+                  missingColumns = Array.isArray(diff.index.ColumnName) ? diff.index.ColumnName.filter(function (col) {
+                    return !columnNames.includes(col);
+                  }) : [];
+                  if (!(missingColumns.length > 0)) {
+                    _context.next = 70;
+                    break;
+                  }
+                  (0, _loggers.logger)("Cannot create index ".concat(diff.index.Name, " on ").concat(diff.tableName, ". Missing columns: ").concat(missingColumns.join(', ')));
+                  return _context.abrupt("return", 0);
+                case 70:
+                  // Prepare the index columns with proper formatting
+                  indexColumns = diff.index.ColumnName.map(function (col) {
+                    return "`".concat(col, "`");
+                  }); // Format column names
+                  // Handle PRIMARY index creation
+                  if (!(diff.index.Name === 'PRIMARY')) {
+                    _context.next = 82;
+                    break;
+                  }
+                  if (!(indexColumns.length > 0)) {
+                    _context.next = 79;
+                    break;
+                  }
+                  primaryKeySQL = "ALTER TABLE `".concat(diff.tableName, "` ADD PRIMARY KEY (").concat(indexColumns.join(', '), ");");
+                  (0, _loggers.logger)("Executing: ".concat(primaryKeySQL));
+                  _context.next = 77;
+                  return connection.query(primaryKeySQL);
+                case 77:
+                  _context.next = 80;
+                  break;
+                case 79:
+                  (0, _loggers.logger)("Cannot create PRIMARY index on ".concat(diff.tableName, ". ColumnName is undefined or empty."), diff.index);
+                case 80:
+                  _context.next = 91;
+                  break;
+                case 82:
+                  // Create the new index with UNIQUE if applicable
+                  uniqueSQL = diff.index.Unique ? 'UNIQUE ' : ''; // Check if the index is unique
+                  if (!(indexColumns.length > 0)) {
+                    _context.next = 90;
+                    break;
+                  }
+                  addIndexSQL = "ALTER TABLE `".concat(diff.tableName, "` ADD ").concat(uniqueSQL, "INDEX `").concat(diff.index.Name, "` (").concat(indexColumns.join(', '), ");");
+                  (0, _loggers.logger)("Executing: ".concat(addIndexSQL));
+                  _context.next = 88;
+                  return connection.query(addIndexSQL);
+                case 88:
+                  _context.next = 91;
+                  break;
+                case 90:
+                  (0, _loggers.logger)("Cannot create index ".concat(diff.index.Name, " on ").concat(diff.tableName, ". ColumnName is undefined or empty."), diff.index);
+                case 91:
+                  _context.next = 210;
+                  break;
+                case 93:
+                  if (!(diff.type === 'extra_index')) {
+                    _context.next = 107;
+                    break;
+                  }
+                  if (!(diff.index.Name === 'PRIMARY')) {
+                    _context.next = 101;
+                    break;
+                  }
+                  dropPrimaryKeySQL = "ALTER TABLE `".concat(diff.tableName, "` DROP PRIMARY KEY;");
+                  (0, _loggers.logger)("Executing: ".concat(dropPrimaryKeySQL));
+                  _context.next = 99;
+                  return connection.query(dropPrimaryKeySQL);
+                case 99:
+                  _context.next = 105;
+                  break;
+                case 101:
+                  dropIndexSQL = "DROP INDEX `".concat(diff.index.Name, "` ON `").concat(diff.tableName, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(dropIndexSQL));
+                  _context.next = 105;
+                  return connection.query(dropIndexSQL);
+                case 105:
+                  _context.next = 210;
+                  break;
+                case 107:
+                  if (!(diff.type === 'mismatched_index')) {
+                    _context.next = 135;
+                    break;
+                  }
+                  _tableName3 = diff.tableName, index = diff.index; // Drop the existing index
+                  if (!(index.Name === 'PRIMARY')) {
+                    _context.next = 116;
+                    break;
+                  }
+                  _dropPrimaryKeySQL = "ALTER TABLE `".concat(_tableName3, "` DROP PRIMARY KEY;");
+                  (0, _loggers.logger)("Executing: ".concat(_dropPrimaryKeySQL));
+                  _context.next = 114;
+                  return connection.query(_dropPrimaryKeySQL);
+                case 114:
+                  _context.next = 120;
+                  break;
+                case 116:
+                  _dropIndexSQL = "DROP INDEX `".concat(index.Name, "` ON `").concat(_tableName3, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(_dropIndexSQL));
+                  _context.next = 120;
+                  return connection.query(_dropIndexSQL);
+                case 120:
+                  console.log('index', index);
+
+                  // Create the new index
+                  _uniqueSQL = index.Unique ? 'UNIQUE ' : ''; // Check if the index is unique
+                  if (!(index.Name === 'PRIMARY')) {
+                    _context.next = 129;
+                    break;
+                  }
+                  addPrimaryKeySQL = "ALTER TABLE `".concat(_tableName3, "` ADD PRIMARY KEY (").concat(index.ColumnName.join(', '), ");");
+                  (0, _loggers.logger)("Executing: ".concat(addPrimaryKeySQL));
+                  _context.next = 127;
+                  return connection.query(addPrimaryKeySQL);
+                case 127:
+                  _context.next = 133;
+                  break;
+                case 129:
+                  _addIndexSQL = "ALTER TABLE `".concat(_tableName3, "` ADD ").concat(_uniqueSQL, "INDEX `").concat(index.Name, "` (").concat(index.ColumnName.join(', '), ");"); // Include UNIQUE if applicable
+                  (0, _loggers.logger)("Executing: ".concat(_addIndexSQL));
+                  _context.next = 133;
+                  return connection.query(_addIndexSQL);
+                case 133:
+                  _context.next = 210;
+                  break;
+                case 135:
+                  if (!(diff.type === 'missing_procedure' || diff.type === 'mismatched_procedure')) {
+                    _context.next = 146;
+                    break;
+                  }
+                  // Drop the procedure if it exists
+                  dropCurrentProcSQL = "DROP PROCEDURE IF EXISTS `".concat(diff.Name, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(dropCurrentProcSQL));
+                  _context.next = 140;
+                  return connection.query(dropCurrentProcSQL);
+                case 140:
+                  // Create the procedure
+                  createProcSQL = diff.Definition;
+                  (0, _loggers.logger)("Executing: ".concat(createProcSQL)); // Log the SQL statement
+                  _context.next = 144;
+                  return connection.query(createProcSQL);
+                case 144:
+                  _context.next = 210;
+                  break;
+                case 146:
+                  if (!(diff.type === 'missing_view')) {
+                    _context.next = 157;
+                    break;
+                  }
+                  dropViewSQL = "DROP VIEW IF EXISTS `".concat(diff.viewName, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(dropViewSQL));
+                  _context.next = 151;
+                  return connection.query(dropViewSQL);
+                case 151:
+                  createViewSQL = diff.definition; // Use the expected definition to create the view
+                  (0, _loggers.logger)("Executing: ".concat(createViewSQL));
+                  _context.next = 155;
+                  return connection.query(createViewSQL);
+                case 155:
+                  _context.next = 210;
+                  break;
+                case 157:
+                  if (!(diff.type === 'mismatched_view')) {
+                    _context.next = 168;
+                    break;
+                  }
+                  _dropViewSQL = "DROP VIEW IF EXISTS `".concat(diff.viewName, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(_dropViewSQL));
+                  _context.next = 162;
+                  return connection.query(_dropViewSQL);
+                case 162:
+                  _createViewSQL = diff.definition; // Use the expected definition to create the view
+                  (0, _loggers.logger)("Executing: ".concat(_createViewSQL));
+                  _context.next = 166;
+                  return connection.query(_createViewSQL);
+                case 166:
+                  _context.next = 210;
+                  break;
+                case 168:
+                  if (!(diff.type === 'extra_view')) {
+                    _context.next = 175;
+                    break;
+                  }
+                  _dropViewSQL2 = "DROP VIEW IF EXISTS `".concat(diff.viewName, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(_dropViewSQL2));
+                  _context.next = 173;
+                  return connection.query(_dropViewSQL2);
+                case 173:
+                  _context.next = 210;
+                  break;
+                case 175:
+                  if (!(diff.type === 'missing_trigger')) {
+                    _context.next = 183;
+                    break;
+                  }
+                  createTriggerSQL = diff.trigger.Definition;
+                  console.log('fixing trigger', diff.trigger.Name);
+                  console.log("Executing: ".concat(createTriggerSQL));
+                  _context.next = 181;
+                  return connection.query(createTriggerSQL);
+                case 181:
+                  _context.next = 210;
+                  break;
+                case 183:
+                  if (!(diff.type === 'mismatched_trigger')) {
+                    _context.next = 194;
+                    break;
+                  }
+                  dropTriggerSQL = "DROP TRIGGER IF EXISTS `".concat(diff.trigger.Name, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(dropTriggerSQL));
+                  _context.next = 188;
+                  return connection.query(dropTriggerSQL);
+                case 188:
+                  _createTriggerSQL = diff.trigger.Definition;
+                  console.log("Executing: ".concat(_createTriggerSQL));
+                  _context.next = 192;
+                  return connection.query(_createTriggerSQL);
+                case 192:
+                  _context.next = 210;
+                  break;
+                case 194:
+                  if (!(diff.type === 'extra_trigger')) {
+                    _context.next = 201;
+                    break;
+                  }
+                  _dropTriggerSQL = "DROP TRIGGER IF EXISTS `".concat(diff.trigger.Name, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(_dropTriggerSQL));
+                  _context.next = 199;
+                  return connection.query(_dropTriggerSQL);
+                case 199:
+                  _context.next = 210;
+                  break;
+                case 201:
+                  if (!(diff.type === 'missing_database')) {
+                    _context.next = 209;
+                    break;
+                  }
+                  console.log('fixing missing database', diff.database);
+                  _createDatabaseSQL = "CREATE DATABASE `".concat(diff.database, "`;");
+                  (0, _loggers.logger)("Executing: ".concat(_createDatabaseSQL));
+                  _context.next = 207;
+                  return connection.query(_createDatabaseSQL);
+                case 207:
+                  _context.next = 210;
+                  break;
+                case 209:
+                  (0, _loggers.logger)("Error applying difference of type:".concat(diff.type), diff);
+                case 210:
+                  _context.next = 215;
+                  break;
+                case 212:
+                  _context.prev = 212;
+                  _context.t0 = _context["catch"](1);
+                  (0, _loggers.logger)("Error applying difference of type:".concat(diff.type, ". Error: ").concat(_context.t0.message), diff);
+                case 215:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop, null, [[1, 212]]);
+          });
+          _iterator.s();
+        case 5:
+          if ((_step = _iterator.n()).done) {
+            _context2.next = 12;
+            break;
+          }
+          return _context2.delegateYield(_loop(), "t0", 7);
+        case 7:
+          _ret = _context2.t0;
+          if (!(_ret === 0)) {
+            _context2.next = 10;
+            break;
+          }
+          return _context2.abrupt("continue", 10);
+        case 10:
+          _context2.next = 5;
+          break;
+        case 12:
+          _context2.next = 17;
+          break;
+        case 14:
+          _context2.prev = 14;
+          _context2.t1 = _context2["catch"](2);
+          _iterator.e(_context2.t1);
+        case 17:
+          _context2.prev = 17;
+          _iterator.f();
+          return _context2.finish(17);
+        case 20:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee, null, [[2, 14, 17, 20]]);
+  }));
+  return function applyDifferences(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/cli.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cli = void 0;
+var _yargs = _interopRequireDefault(require("yargs"));
+var _helpers = require("yargs/helpers");
+var _loggers = require("./loggers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+var cli = exports.cli = function cli() {
+  var argv = (0, _yargs["default"])((0, _helpers.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;
+  var command = argv._[0];
+  var config = {
+    host: argv.host,
+    port: argv.port,
+    user: argv.user,
+    password: argv.password
+  };
+  (0, _loggers.setVerbose)(argv.verbose);
+  return {
+    command: command,
+    config: config,
+    argv: argv
+  };
+};