fakeit/dist/index.js

Command-line utility that generates fake data which can be output as JSON, YAML, CSON, or CSV formats based on models defined in YAML.

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _models = require('./models');

var _models2 = _interopRequireDefault(_models);

var _index = require('./output/index');

var _index2 = _interopRequireDefault(_index);

var _base = require('./base');

var _base2 = _interopRequireDefault(_base);

var _toJs = require('to-js');

var _toJs2 = _interopRequireDefault(_toJs);

var _lodash = require('lodash');

var _documents = require('./documents');

var _documents2 = _interopRequireDefault(_documents);

var _documentsStream = require('./documents-stream');

var _documentsStream2 = _interopRequireDefault(_documentsStream);

var _logSymbols = require('log-symbols');

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

/// @name Fakeit
/// @page api
/// @description
/// This class is used to generate fake data in `json`, `cson`, `csv`, `yml`, `yaml` formats.
/// You can have it output idividual files or you can connect to a data base and store the files there.
/// @arg {object} options [{}] Here are the defaults
/// ```
/// options = {
///   inputs: '', // @todo remove
///   exclude: '', // @todo remove
///   // a fixed number of documents to generate
///   count: null,
///   // Base options
///   root: process.cwd(),
///   seed: 0,
///   babel_config: '+(.babelrc|package.json)',
///   log: true,
///   verbose: false,
///   timestamp: true,
/// }
/// ```
/* istanbul ignore next: These are already tested in other files */
var Fakeit = function (_Base) {
  (0, _inherits3.default)(Fakeit, _Base);

  function Fakeit() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    (0, _classCallCheck3.default)(this, Fakeit);

    var _this = (0, _possibleConstructorReturn3.default)(this, (Fakeit.__proto__ || (0, _getPrototypeOf2.default)(Fakeit)).call(this, options));

    _this.documents = {};
    _this.globals = {};
    return _this;
  }

  (0, _createClass3.default)(Fakeit, [{
    key: 'generate',
    value: function () {
      var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(models) {
        var output_options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        var label, model, output, total_dependants, result, documents, time;
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                if (_toJs2.default.type(models) === 'object') {
                  output_options = models;
                  models = models.models;
                }

                if (models) {
                  _context.next = 3;
                  break;
                }

                return _context.abrupt('return');

              case 3:
                label = (0, _lodash.uniqueId)('fakeit');

                this.time(label);
                model = new _models2.default(this.options);
                output = new _index2.default(this.options, output_options);

                output.prepare();

                _context.next = 10;
                return model.registerModels(models);

              case 10:
                // calculate the total # of dependencies, if it is 0 and we're using Couchbase,
                // we can leverage streams to output the data.
                total_dependants = model.models.forEach(function (value) {
                  total_dependants += value.dependants.length;
                });
                _context.next = 13;
                return output.preparing;

              case 13:
                result = void 0, documents = void 0;
                // only use streams if outputting to couchbase, the user has asked for it and there aren't any dependants

                if (output_options.output === 'couchbase' && output_options.useStreams && !total_dependants) {
                  // we're outtputting to couchbase and there aren't any dependants use streams
                  documents = new _documentsStream2.default(this.options, this.globals, model.inputs, output);
                } else {
                  documents = new _documents2.default(this.options, this.documents, this.globals, model.inputs);
                  documents.on('data', function (data) {
                    return output.output(data);
                  });
                }
                _context.next = 17;
                return documents.build(model.models);

              case 17:
                result = _context.sent;

                delete model.inputs;
                _context.next = 21;
                return output.finalize();

              case 21:
                time = this.timeEnd(label);

                if (this.options.verbose) {
                  console.log(_logSymbols.success + ' Finished generating ' + documents.total + ' documents in ' + time);
                }
                return _context.abrupt('return', result);

              case 24:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function generate(_x2) {
        return _ref.apply(this, arguments);
      }

      return generate;
    }()
  }]);
  return Fakeit;
}(_base2.default);

exports.default = Fakeit;