fakeit-facet/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";

var _Reflect$construct = require("@babel/runtime-corejs3/core-js-stable/reflect/construct");

var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");

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

_Object$defineProperty(exports, "__esModule", {
  value: true
});

exports["default"] = void 0;

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

var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));

var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));

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

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/inherits"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/getPrototypeOf"));

var _toJs = _interopRequireDefault(require("to-js"));

var _lodash = require("lodash");

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

var _models = _interopRequireDefault(require("./models"));

var _index = _interopRequireDefault(require("./output/index"));

var _base = _interopRequireDefault(require("./base"));

var _documents = _interopRequireDefault(require("./documents"));

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

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

/// @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 = /*#__PURE__*/function (_Base) {
  (0, _inherits2["default"])(Fakeit, _Base);

  var _super = _createSuper(Fakeit);

  function Fakeit() {
    var _this;

    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    (0, _classCallCheck2["default"])(this, Fakeit);
    _this = _super.call(this, options);
    _this.documents = {};
    _this.globals = {};
    return _this;
  } // eslint-disable-next-line max-statements


  (0, _createClass2["default"])(Fakeit, [{
    key: "generate",
    value: function () {
      var _generate = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(models) {
        var _context;

        var output_options,
            label,
            model,
            output,
            total_dependants,
            documents,
            result,
            time,
            _context2,
            _context3,
            _context4,
            documentText,
            _args = arguments;

        return _regenerator["default"].wrap(function _callee$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                output_options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};

                if (_toJs["default"].type(models) === 'object') {
                  output_options = models;
                  models = models.models;
                }

                if (models) {
                  _context5.next = 4;
                  break;
                }

                return _context5.abrupt("return");

              case 4:
                label = (0, _lodash.uniqueId)('fakeit');
                this.time(label);
                model = new _models["default"](this.options);
                output = new _index["default"](this.options, output_options);
                output.prepare();
                _context5.next = 11;
                return model.registerModels(models);

              case 11:
                // calculate the total # of dependencies, if it is 0 and we're using Couchbase,
                // we can leverage streams to output the data.
                total_dependants = (0, _forEach["default"])(_context = model.models).call(_context, function (value) {
                  total_dependants += value.dependants.length;
                });
                _context5.next = 14;
                return output.preparing;

              case 14:
                // 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 _documentsStream["default"](this.options, this.globals, model.inputs, output);
                } else {
                  documents = new _documents["default"](this.options, this.documents, this.globals, model.inputs);
                  documents.on('data', function (data, modelDoc) {
                    var options = {
                      scope: modelDoc.scope || '',
                      collection: modelDoc.collection || ''
                    };
                    return output.output(data, options);
                  });
                }

                _context5.next = 17;
                return documents.build(model.models);

              case 17:
                result = _context5.sent;
                delete model.inputs;
                _context5.next = 21;
                return output.finalize();

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

                if (this.options.verbose) {
                  documentText = documents.total === 1 ? 'document' : 'documents';
                  console.log((0, _concat["default"])(_context2 = (0, _concat["default"])(_context3 = (0, _concat["default"])(_context4 = "".concat(_logSymbols.success, " Finished generating ")).call(_context4, documents.total, " ")).call(_context3, documentText, " in ")).call(_context2, time));
                }

                return _context5.abrupt("return", result);

              case 24:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee, this);
      }));

      function generate(_x) {
        return _generate.apply(this, arguments);
      }

      return generate;
    }()
  }]);
  return Fakeit;
}(_base["default"]);

exports["default"] = Fakeit;