shyft-storage-connector/lib/migration.js

Storage connector for Shyft

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.migrateI18nIndices = exports.fillMigrationsTable = exports.revertMigration = exports.runMigration = exports.generateMigration = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _lodash = _interopRequireDefault(require("lodash"));

var _path = _interopRequireDefault(require("path"));

var _CommandUtils = require("typeorm/commands/CommandUtils");

var _MigrationExecutor = require("typeorm/migration/MigrationExecutor");

var _prettierEslint = _interopRequireDefault(require("prettier-eslint"));

var _generator = require("../lib/generator");

var _util = require("./util");

var defaultTemplate = function defaultTemplate(migrationName, timestamp, upSqls, downSqls) {
  return "\nexport class ".concat(_lodash["default"].camelCase(migrationName)).concat(timestamp, " {\n  async up(queryRunner) {\n").concat(upSqls.join('\n'), "\n  }\n\n  async down(queryRunner) {\n").concat(downSqls.join('\n'), "\n  }\n}\n");
};

var upgradeMigrationQuery = function upgradeMigrationQuery(_query) {
  var isUpMigration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  var sqls = [];

  var query = _query.query.replace(new RegExp('`', 'g'), '\\`');

  var parameters = _query.parameters ? JSON.stringify(_query.parameters) : '';
  var match = query.match(/ALTER TABLE "(\w+)" ADD "(\w+)" (.+) NOT NULL/);

  if (match) {
    var _match = (0, _slicedToArray2["default"])(match, 4),
        table = _match[1],
        attribute = _match[2],
        _type = _match[3];

    var type = _type.toLowerCase();

    var defaultValue; // user tracking

    if (['created_by', 'updated_by'].includes(attribute)) {
      defaultValue = 'get_machine_user()';
    } // time tracking
    else if (['created_at', 'updated_at'].includes(attribute)) {
        defaultValue = 'NOW()';
      } // general type based default values
      else if (type.includes('timestamp')) {
          defaultValue = 'NOW()';
        } else if (type.includes('time')) {
          defaultValue = 'NOW()';
        } else if (type.includes('date')) {
          defaultValue = 'NOW()';
        } else if (type.includes('bigint')) {
          defaultValue = '0';
        } else if (type.includes('integer')) {
          defaultValue = '0';
        } else if (type.includes('numeric')) {
          defaultValue = '0.0';
        } else if (type.includes('boolean')) {
          defaultValue = false;
        } else if (type.includes('json') || type.includes('jsonb')) {
          defaultValue = "\\'{}\\'";
        } else if (type.includes('text')) {
          defaultValue = "\\'\\'";
        } else {
          throw new Error("Cannot handle column addition default for: ".concat(query));
        }

    var addColumnQuery = "    await queryRunner.query('".concat(query, " DEFAULT ").concat(defaultValue, "');");
    var dropDefaultQuery = "    await queryRunner.query('ALTER TABLE \"".concat(table, "\" ALTER COLUMN \"").concat(attribute, "\" DROP DEFAULT');");

    if (isUpMigration) {
      sqls.push(addColumnQuery);
      sqls.push(dropDefaultQuery);
    } else {
      sqls.push(dropDefaultQuery);
      sqls.push(addColumnQuery);
    }
  } else {
    var reformatted = query.replace(new RegExp('`', 'g'), '\\`').replace(new RegExp("'", 'g'), "\\'");
    sqls.push("    await queryRunner.query(`".concat(reformatted, "`, ").concat(parameters, ");"));
  }

  return sqls;
};

var getMigrationsFullPath = function getMigrationsFullPath(connectionConfig) {
  if (connectionConfig.migrations && connectionConfig.migrations[0]) {
    return _path["default"].dirname(connectionConfig.migrations[0].indexOf('/') === 0 ? connectionConfig.migrations[0] : _path["default"].join(process.cwd(), connectionConfig.migrations[0]));
  }

  return _path["default"].join(process.cwd(), 'migrations');
};

var generateMigration = /*#__PURE__*/function () {
  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(configuration, migrationName, customTemplate) {
    var includeI18n,
        enforce,
        connection,
        storageConfiguration,
        manager,
        connectionConfig,
        migrationsPath,
        timestamp,
        upSqls,
        downSqls,
        i18nMigrations,
        sqlInMemory,
        filename,
        template,
        fileContent,
        migrationPath,
        formatted,
        _args = arguments;
    return _regenerator["default"].wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            includeI18n = _args.length > 3 && _args[3] !== undefined ? _args[3] : false;
            enforce = _args.length > 4 && _args[4] !== undefined ? _args[4] : false;
            _context.next = 4;
            return (0, _generator.connectStorage)(configuration, false);

          case 4:
            connection = (0, _generator.getConnection)();
            storageConfiguration = configuration.getStorageConfiguration();
            manager = connection.manager;
            connectionConfig = storageConfiguration.getConnectionConfig();
            migrationsPath = getMigrationsFullPath(connectionConfig);
            timestamp = new Date().getTime();
            upSqls = [];
            downSqls = [];

            if (!includeI18n) {
              _context.next = 18;
              break;
            }

            _context.next = 15;
            return storageConfiguration.generateI18nIndicesMigration(configuration, manager);

          case 15:
            i18nMigrations = _context.sent;
            i18nMigrations.upQueries.forEach(function (query) {
              upgradeMigrationQuery({
                query: query
              }, true).map(function (sql) {
                return upSqls.push(sql);
              });
            });
            i18nMigrations.downQueries.forEach(function (query) {
              upgradeMigrationQuery({
                query: query
              }, false).map(function (sql) {
                return downSqls.push(sql);
              });
            });

          case 18:
            _context.next = 20;
            return connection.driver.createSchemaBuilder().log();

          case 20:
            sqlInMemory = _context.sent;
            sqlInMemory.upQueries.forEach(function (query) {
              upgradeMigrationQuery(query, true).map(function (sql) {
                return upSqls.push(sql);
              });
            });
            sqlInMemory.downQueries.forEach(function (query) {
              upgradeMigrationQuery(query, false).map(function (sql) {
                return downSqls.push(sql);
              });
            });

            if (!(upSqls.length || downSqls.length || enforce)) {
              _context.next = 36;
              break;
            }

            if (migrationName) {
              _context.next = 26;
              break;
            }

            throw new Error('Error: Please specify a migration name');

          case 26:
            filename = "".concat(timestamp, "-").concat(_lodash["default"].camelCase(migrationName), ".js");
            template = customTemplate || defaultTemplate;
            fileContent = template(migrationName, timestamp, upSqls, downSqls.reverse());
            migrationPath = _path["default"].join(migrationsPath, filename);
            formatted = (0, _prettierEslint["default"])({
              text: fileContent,
              filePath: migrationPath
            });
            _context.next = 33;
            return _CommandUtils.CommandUtils.createFile(migrationPath, formatted);

          case 33:
            console.log("Migration file '".concat(migrationPath, "' has been generated successfully."));
            _context.next = 37;
            break;

          case 36:
            console.log('No changes were found in database schema.');

          case 37:
            _context.next = 39;
            return (0, _generator.disconnectStorage)(configuration);

          case 39:
            return _context.abrupt("return", upSqls.length || downSqls.length || enforce ? timestamp : null);

          case 40:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function generateMigration(_x, _x2, _x3) {
    return _ref.apply(this, arguments);
  };
}();

exports.generateMigration = generateMigration;

var runMigration = /*#__PURE__*/function () {
  var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(configuration) {
    var connection;
    return _regenerator["default"].wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return (0, _generator.connectStorage)(configuration, false);

          case 2:
            connection = (0, _generator.getConnection)();
            _context2.prev = 3;
            _context2.next = 6;
            return connection.runMigrations({
              transaction: 'each'
            });

          case 6:
            _context2.next = 15;
            break;

          case 8:
            _context2.prev = 8;
            _context2.t0 = _context2["catch"](3);
            console.error('Migration failed');
            console.error(_context2.t0);
            _context2.next = 14;
            return (0, _generator.disconnectStorage)(configuration);

          case 14:
            process.exit(1);

          case 15:
            _context2.next = 17;
            return (0, _generator.disconnectStorage)(configuration);

          case 17:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, null, [[3, 8]]);
  }));

  return function runMigration(_x4) {
    return _ref2.apply(this, arguments);
  };
}();

exports.runMigration = runMigration;

var revertMigration = /*#__PURE__*/function () {
  var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(configuration) {
    var connection;
    return _regenerator["default"].wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            _context3.next = 2;
            return (0, _generator.connectStorage)(configuration, false);

          case 2:
            connection = (0, _generator.getConnection)();
            _context3.prev = 3;
            _context3.next = 6;
            return connection.undoLastMigration({
              transaction: 'each'
            });

          case 6:
            _context3.next = 15;
            break;

          case 8:
            _context3.prev = 8;
            _context3.t0 = _context3["catch"](3);
            console.error('Migration reversion failed');
            console.error(_context3.t0);
            _context3.next = 14;
            return (0, _generator.disconnectStorage)(configuration);

          case 14:
            process.exit(1);

          case 15:
            _context3.next = 17;
            return (0, _generator.disconnectStorage)(configuration);

          case 17:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3, null, [[3, 8]]);
  }));

  return function revertMigration(_x5) {
    return _ref3.apply(this, arguments);
  };
}();

exports.revertMigration = revertMigration;

var fillMigrationsTable = /*#__PURE__*/function () {
  var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
    var connection, queryRunner, migrationExecutor, allMigrations;
    return _regenerator["default"].wrap(function _callee5$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            connection = (0, _generator.getConnection)();
            queryRunner = connection.createQueryRunner();
            migrationExecutor = new _MigrationExecutor.MigrationExecutor(connection);
            _context5.next = 5;
            return migrationExecutor.createMigrationsTableIfNotExist(queryRunner);

          case 5:
            allMigrations = migrationExecutor.getMigrations();
            _context5.next = 8;
            return (0, _util.asyncForEach)(allMigrations, /*#__PURE__*/function () {
              var _ref5 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(migration) {
                return _regenerator["default"].wrap(function _callee4$(_context4) {
                  while (1) {
                    switch (_context4.prev = _context4.next) {
                      case 0:
                        _context4.next = 2;
                        return migrationExecutor.insertExecutedMigration(queryRunner, migration);

                      case 2:
                      case "end":
                        return _context4.stop();
                    }
                  }
                }, _callee4);
              }));

              return function (_x6) {
                return _ref5.apply(this, arguments);
              };
            }());

          case 8:
          case "end":
            return _context5.stop();
        }
      }
    }, _callee5);
  }));

  return function fillMigrationsTable() {
    return _ref4.apply(this, arguments);
  };
}();

exports.fillMigrationsTable = fillMigrationsTable;

var migrateI18nIndices = /*#__PURE__*/function () {
  var _ref6 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(configuration) {
    var connection, storageConfiguration, manager, queryRunner, _yield$storageConfigu, upQueries;

    return _regenerator["default"].wrap(function _callee7$(_context7) {
      while (1) {
        switch (_context7.prev = _context7.next) {
          case 0:
            _context7.next = 2;
            return (0, _generator.connectStorage)(configuration, false);

          case 2:
            connection = (0, _generator.getConnection)();
            storageConfiguration = configuration.getStorageConfiguration();
            manager = connection.manager;
            queryRunner = connection.createQueryRunner();
            _context7.prev = 6;
            _context7.next = 9;
            return storageConfiguration.generateI18nIndicesMigration(configuration, manager);

          case 9:
            _yield$storageConfigu = _context7.sent;
            upQueries = _yield$storageConfigu.upQueries;

            if (!upQueries.length) {
              _context7.next = 18;
              break;
            }

            _context7.next = 14;
            return queryRunner.startTransaction();

          case 14:
            _context7.next = 16;
            return (0, _util.asyncForEach)(upQueries, /*#__PURE__*/function () {
              var _ref7 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(query) {
                return _regenerator["default"].wrap(function _callee6$(_context6) {
                  while (1) {
                    switch (_context6.prev = _context6.next) {
                      case 0:
                        _context6.next = 2;
                        return queryRunner.query(query);

                      case 2:
                        return _context6.abrupt("return", _context6.sent);

                      case 3:
                      case "end":
                        return _context6.stop();
                    }
                  }
                }, _callee6);
              }));

              return function (_x8) {
                return _ref7.apply(this, arguments);
              };
            }());

          case 16:
            _context7.next = 18;
            return queryRunner.commitTransaction();

          case 18:
            _context7.next = 27;
            break;

          case 20:
            _context7.prev = 20;
            _context7.t0 = _context7["catch"](6);
            console.error('I18n migration failed');
            console.error(_context7.t0);
            _context7.next = 26;
            return (0, _generator.disconnectStorage)(configuration);

          case 26:
            process.exit(1);

          case 27:
            _context7.next = 29;
            return (0, _generator.disconnectStorage)(configuration);

          case 29:
          case "end":
            return _context7.stop();
        }
      }
    }, _callee7, null, [[6, 20]]);
  }));

  return function migrateI18nIndices(_x7) {
    return _ref6.apply(this, arguments);
  };
}();

exports.migrateI18nIndices = migrateI18nIndices;