deep-package-manager/lib.compiled/Property/Migration.js

DEEP Package Manager

/**
 * Created by AlexanderC on 6/5/15.
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Migration = undefined;

var _FileWalker = require('../Helpers/FileWalker');

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _InvalidMigrationException = require('./Exception/InvalidMigrationException');

var _deepCore = require('deep-core');

var _deepCore2 = _interopRequireDefault(_deepCore);

var _AwsRequestSyncStack = require('../Helpers/AwsRequestSyncStack');

var _WaitFor = require('../Helpers/WaitFor');

var _Hash = require('../Helpers/Hash');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class Migration {
  /**
   * @param {String} name
   * @param {String} migrationPath
   * @param {String|null} versionPrefix
   */
  constructor(name, migrationPath, versionPrefix = null) {
    this._name = name;
    this._migrationPath = migrationPath;
    this._migration = null;
    this._versionPrefix = versionPrefix;

    this._registry = {
      ensure: (version, onMissingDb) => {
        onMissingDb();
        return true;
      },
      remove: version => {}
    };
  }

  /**
   * @returns {String}
   */
  get versionPrefix() {
    return this._versionPrefix;
  }

  /**
   * @returns {MigrationsRegistry|*}
   */
  get registry() {
    return this._registry;
  }

  /**
   * @param {MigrationsRegistry|*} registry
   */
  set registry(registry) {
    this._registry = registry;
  }

  /**
   * @param {Array} directories
   * @returns {Model[]}
   */
  static create(...directories) {
    let walker = new _FileWalker.FileWalker(_FileWalker.FileWalker.RECURSIVE);
    let filter = _FileWalker.FileWalker.matchExtensionsFilter(_FileWalker.FileWalker.skipDotsFilter(), Migration.EXTENSION);

    let validationSchemas = [];

    for (let i in directories) {
      if (!directories.hasOwnProperty(i)) {
        continue;
      }

      let dir = directories[i];

      if (_fs2.default.existsSync(dir)) {
        let versionPrefix = _Hash.Hash.md5(dir);
        let files = walker.walk(dir, filter);

        for (let j in files) {
          if (!files.hasOwnProperty(j)) {
            continue;
          }

          let migrationFile = files[j];
          let name = _path2.default.basename(migrationFile, `.${Migration.EXTENSION}`);

          validationSchemas.push(new Migration(name, migrationFile, versionPrefix));
        }
      }
    }

    return validationSchemas;
  }

  /**
   * @returns {String}
   */
  get name() {
    return this._name;
  }

  /**
   * @returns {String}
   */
  get migrationPath() {
    return this._migrationPath;
  }

  /**
   * @param {*} args
   * @returns {Migration}
   */
  up(...args) {
    return this._exec('up', ...args);
  }

  /**
   * @param {*} args
   * @returns {Migration}
   */
  down(...args) {
    return this._exec('down', ...args);
  }

  /**
   * @param {String} type
   * @param {Property|*} property
   * @param {Function} cb
   * @returns {Migration}
   * @private
   */
  _exec(type, property, cb) {
    let version = this.version;

    let wrappedCb = error => {
      console[error ? 'error' : 'log'](`Migration #${version} ${error ? 'FAILED' : 'SUCCEED'}`);

      cb(error);
    };

    try {
      let migration = this.migration;

      new _deepCore2.default.Runtime.Sandbox(() => {
        let ensureResult = this._registry.ensure(version, () => {
          console.debug(`Running migration #${version}`);

          migration[type].bind({
            awsAsync: _AwsRequestSyncStack.AwsRequestSyncStack,
            waitFor: _WaitFor.WaitFor
          })(property.provisioning.db, error => {
            if (error) {
              this._registry.remove(version);
            }

            wrappedCb(error);
          });
        });

        if (!ensureResult) {
          console.debug(`Skipping migration #${version}`);
          cb(null);
        }
      }).fail(wrappedCb).run();
    } catch (e) {
      wrappedCb(e);
    }

    return this;
  }

  /**
   * @returns {String|null}
   */
  get version() {
    let tsVersion = this._name.replace(/^version(\d+)$/i, '$1') || null;

    if (!tsVersion) {
      return null;
    }

    return this._versionPrefix ? `${this._versionPrefix}_${tsVersion}` : tsVersion;
  }

  /**
   * @returns {Object}
   */
  get migration() {
    if (!this._migration) {
      let migration = require(this._migrationPath);
      let version = this.version;

      if (!version) {
        throw new _InvalidMigrationException.InvalidMigrationException(this, 'Migration file name should match /^version(\\d+)$/i');
      } else if (typeof migration !== 'object') {
        throw new _InvalidMigrationException.InvalidMigrationException(this, 'Migration object expected');
      } else if (!migration.hasOwnProperty('up') || typeof migration.up !== 'function') {
        throw new _InvalidMigrationException.InvalidMigrationException(this, 'Migration.up() should be a function');
      }

      if (!migration.hasOwnProperty('down')) {
        Object.defineProperty(migration, 'down', {
          value: cb => {
            cb(null);
          }
        });
      }

      this._migration = migration;
    }

    return this._migration;
  }

  /**
   * @returns {String}
   */
  static get EXTENSION() {
    return 'js';
  }
}
exports.Migration = Migration;