muffin-cli/dist/lib/tasks/insert.js

The command line utility for building sites using muffin

'use strict';

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

var _mongonaut = require('mongonaut');

var _mongonaut2 = _interopRequireDefault(_mongonaut);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _utils = require('../utils');

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

class Inserter {
  constructor(files, callback) {
    this.files = files;
    this.cb = callback;

    // Don't load this at the beginning of the file. If you do so, the session...
    // ...will start immediately when the user runs a command that loads this task
    this.rope = require('../db').default;

    this.rope.on('open', function () {
      this.rope.db.listCollections().toArray(this.checkInput.bind(this));
    }.bind(this));
  }

  checkInput(err, names) {
    if (err) {
      return (0, _utils.log)(err);
    }

    let files = [],
        walkers = [];

    this.collections = names.map(details => {
      return details.name;
    });

    for (let thing of this.files) {
      let fullPath = _path2.default.resolve(thing),
          details = _path2.default.parse(fullPath);

      if (!(0, _utils.exists)(_path2.default.format(details))) {
        (0, _utils.log)(`The file or directory "${ details.base }" doesn\'t exist`);
        this.rope.close(() => process.exit(1));
      }

      if (details.ext) {
        files.push(fullPath);
        continue;
      }

      let prom = new Promise((resolve, reject) => {
        let walker = _fsExtra2.default.walk(fullPath),
            subFiles = [];

        walker.on('data', item => {
          let info = _path2.default.parse(item.path);

          if (info.ext) {
            subFiles.push(item.path);
          }
        });

        walker.on('end', () => resolve(subFiles));
        walker.on('error', reject);
      });

      walkers.push(prom);
    }

    this.rope.close();

    if (walkers.length === 0) {
      return this.tryImport(files);
    }

    Promise.all(walkers).then(function (items) {
      files = files.concat(items[0]);
      this.tryImport(files);
    }.bind(this)).catch((err, item) => {
      throw err;
    });
  }

  tryImport(files) {
    let imports = [];

    for (let file of files) {
      let info = _path2.default.parse(file);

      if (this.collections.indexOf(info.name) === -1) {
        (0, _utils.log)(`Collection "${ info.name }" doesn\'t exist`);
        this.rope.close(() => process.exit(1));
      }

      imports.push(this.importFile(info));
    }

    Promise.all(imports).then(function (data) {
      (0, _utils.log)(_chalk2.default.green('Successfully imported data!'));
      this.cb(data);
    }.bind(this), reason => {
      (0, _utils.log)('Not able to insert data! Make sure that your DB is running.');
    });
  }

  importFile(file) {
    let mongonaut = new _mongonaut2.default({
      user: process.env.DB_USER || '',
      pwd: process.env.DB_PASSWORD || '',
      db: process.env.DB_NAME || 'muffin'
    });

    mongonaut.set('collection', file.name);
    return mongonaut.import(_path2.default.format(file));
  }
}

exports.default = Inserter;