fakeit-facet/dist/utils.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 _typeof3 = require("@babel/runtime-corejs3/helpers/typeof");

var _mapInstanceProperty2 = require("@babel/runtime-corejs3/core-js-stable/instance/map");

var _sliceInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/slice");

var _Array$from = require("@babel/runtime-corejs3/core-js-stable/array/from");

var _Symbol = require("@babel/runtime-corejs3/core-js-stable/symbol");

var _getIteratorMethod = require("@babel/runtime-corejs3/core-js/get-iterator-method");

var _Array$isArray2 = require("@babel/runtime-corejs3/core-js-stable/array/is-array");

var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");

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

var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");

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

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

exports.findFiles = findFiles;
exports.objectSearch = objectSearch;
exports.parsers = void 0;
exports.pool = pool;
exports.readFiles = readFiles;

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

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

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

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

var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));

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

var _promise = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/promise"));

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

var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));

var _parseInt2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/parse-int"));

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

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

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

var _globby = _interopRequireDefault(require("globby"));

var _asyncArrayMethods = require("async-array-methods");

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

var _admZip = _interopRequireDefault(require("adm-zip"));

var _es6Promisify = require("es6-promisify");

var _fsExtraPromisify = _interopRequireDefault(require("fs-extra-promisify"));

var _es6PromisePool = _interopRequireDefault(require("es6-promise-pool"));

var _yamljs = _interopRequireDefault(require("yamljs"));

var _cson = _interopRequireDefault(require("cson"));

var _csvParse = _interopRequireDefault(require("csv-parse"));

var _csvStringify = _interopRequireDefault(require("csv-stringify"));

function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof _Symbol !== "undefined" && _getIteratorMethod(o) || o["@@iterator"]; if (!it) { if (_Array$isArray2(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { var _context13; if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = _sliceInstanceProperty(_context13 = Object.prototype.toString.call(o)).call(_context13, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

/// @name objectSearch
/// @description Recursively looks through objects and finds the pattern provided
/// @arg {object, array} data - The data to search through
/// @arg {regex,string} pattern - The pattern used to match a path
/// @arg {string} current_path - The current part of the path. This is used as apart of the recursion and you shouldn't pass anyting to it manually.
/// @arg {array} paths - The paths that have been match. This is used as apart of the recursion and you shouldn't pass anyting to it manually.
/// @returns {array} - With the paths that have been matched
function objectSearch(data, pattern, current_path) {
  var paths = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];

  function appendPath(opath, index) {
    var _context;

    opath = opath ? (0, _concat["default"])(_context = "".concat(opath, ".")).call(_context, index) : "".concat(index);
    opath = opath.replace(/^\.|\.$|\.{2,}/, '');
    return opath;
  }

  if ((0, _isArray["default"])(data)) {
    for (var i = 0; i < data.length; i++) {
      var test_path = appendPath(current_path, i);

      if (test_path.match(pattern) && !(0, _includes["default"])(paths).call(paths, test_path)) {
        paths.push(test_path);
      }

      objectSearch(data[i], pattern, test_path, paths);
    }
  } else if ((0, _typeof2["default"])(data) === 'object' && data !== null) {
    for (var key in data) {
      if (data.hasOwnProperty(key)) {
        var _test_path = appendPath(current_path, key);

        if (_test_path.match(pattern) && !(0, _includes["default"])(paths).call(paths, _test_path)) {
          paths.push(_test_path);
        }

        objectSearch(data[key], pattern, _test_path, paths);
      }
    }
  }

  return paths;
} /// @name findFiles
/// @description
/// This is a very efficient way to to recursively read a directory and get all the files.
/// @arg {string, array} globs - The glob(s) or dir(s) you want to get all the files from
/// @returns {array} All the files in the paths(s) that were passed
/// @async


function findFiles(_x) {
  return _findFiles.apply(this, arguments);
} /// @name readFiles
/// @description
/// This will read all the files that have been passed to it and return them in an array of objects.
/// @arg {string, array} files - The files to read. This can be any file including `zip`.
/// @returns {array} An `array` of files where each object will have the following information
///
/// ```js
/// {
///   path: '', // the full path of the file
///   content: '', // the contents of the file as a string
///   // the rest of the keys are the same as what you would get from running `path.parse`
///   root: '',
///   dir: '',
///   base: '',
///   ext: '',
///   name: '',
/// }
/// ```
/// @async


function _findFiles() {
  _findFiles = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(globs) {
    var files, sort, find;
    return _regenerator["default"].wrap(function _callee5$(_context7) {
      while (1) {
        switch (_context7.prev = _context7.next) {
          case 0:
            // all the files after
            files = [];

            sort = function sort(list) {
              var to_search = [];
              list = _toJs["default"].flatten(list);

              var _iterator = _createForOfIteratorHelper(list),
                  _step;

              try {
                for (_iterator.s(); !(_step = _iterator.n()).done;) {
                  var item = _step.value;

                  if (_path["default"].extname(item)) {
                    files.push(item);
                  } else {
                    to_search.push(item);
                  }
                }
              } catch (err) {
                _iterator.e(err);
              } finally {
                _iterator.f();
              }

              return to_search;
            };

            find = /*#__PURE__*/function () {
              var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(items) {
                return _regenerator["default"].wrap(function _callee4$(_context6) {
                  while (1) {
                    switch (_context6.prev = _context6.next) {
                      case 0:
                        _context6.t0 = sort;
                        _context6.next = 3;
                        return (0, _mapInstanceProperty2(_asyncArrayMethods))(items, /*#__PURE__*/function () {
                          var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(item) {
                            return _regenerator["default"].wrap(function _callee3$(_context5) {
                              while (1) {
                                switch (_context5.prev = _context5.next) {
                                  case 0:
                                    if (!_globby["default"].hasMagic(item)) {
                                      _context5.next = 4;
                                      break;
                                    }

                                    _context5.next = 3;
                                    return (0, _globby["default"])(item);

                                  case 3:
                                    return _context5.abrupt("return", _context5.sent);

                                  case 4:
                                    if (!_path["default"].extname(item)) {
                                      _context5.next = 6;
                                      break;
                                    }

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

                                  case 6:
                                    _context5.next = 8;
                                    return (0, _globby["default"])(item);

                                  case 8:
                                    return _context5.abrupt("return", _context5.sent);

                                  case 9:
                                  case "end":
                                    return _context5.stop();
                                }
                              }
                            }, _callee3);
                          }));

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

                      case 3:
                        _context6.t1 = _context6.sent;
                        items = (0, _context6.t0)(_context6.t1);

                        if (!items.length) {
                          _context6.next = 7;
                          break;
                        }

                        return _context6.abrupt("return", find(items));

                      case 7:
                      case "end":
                        return _context6.stop();
                    }
                  }
                }, _callee4);
              }));

              return function find(_x5) {
                return _ref.apply(this, arguments);
              };
            }();

            _context7.next = 5;
            return find(_toJs["default"].array(globs));

          case 5:
            return _context7.abrupt("return", files);

          case 6:
          case "end":
            return _context7.stop();
        }
      }
    }, _callee5);
  }));
  return _findFiles.apply(this, arguments);
}

function readFiles(_x2) {
  return _readFiles.apply(this, arguments);
} /// @name pool
/// @description
/// This is very similar to the `Array.prototype.map` except that
/// it's used to limit the number of functions running at a time.
/// @arg {array} items - The array to loop over
/// @arg {function} fn - The function to run on each of the items. It has the same arguments the map function does
/// @arg {number} limit [100] - The number of promises that can run at any given item.
/// @returns {array} of the items that were returned by the fn.
/// @async


function _readFiles() {
  _readFiles = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(files) {
    var _context10;

    return _regenerator["default"].wrap(function _callee8$(_context11) {
      while (1) {
        switch (_context11.prev = _context11.next) {
          case 0:
            if (files) {
              _context11.next = 2;
              break;
            }

            return _context11.abrupt("return");

          case 2:
            files = _toJs["default"].array(files);
            _context11.next = 5;
            return (0, _mapInstanceProperty2(_asyncArrayMethods))(files, /*#__PURE__*/function () {
              var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(file) {
                var info, zip;
                return _regenerator["default"].wrap(function _callee7$(_context9) {
                  while (1) {
                    switch (_context9.prev = _context9.next) {
                      case 0:
                        file = _path["default"].resolve(file); // resolve the full path

                        // resolve the full path
                        info = _path["default"].parse(file); // parse the full path to get the name and extension

                        if (!(info.ext === '.zip')) {
                          _context9.next = 5;
                          break;
                        }

                        zip = new _admZip["default"](file);
                        return _context9.abrupt("return", (0, _mapInstanceProperty2(_asyncArrayMethods))(zip.getEntries(), /*#__PURE__*/function () {
                          var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(entry) {
                            var file_info;
                            return _regenerator["default"].wrap(function _callee6$(_context8) {
                              while (1) {
                                switch (_context8.prev = _context8.next) {
                                  case 0:
                                    if (!(!entry.isDirectory && !entry.entryName.match(/^(\.|__MACOSX)/))) {
                                      _context8.next = 7;
                                      break;
                                    }

                                    file_info = _path["default"].parse(entry.entryName); // eslint-disable-line

                                    // eslint-disable-line
                                    file_info.path = entry.entryName;
                                    _context8.next = 5;
                                    return zip.readAsText(entry.entryName);

                                  case 5:
                                    file_info.content = _context8.sent;
                                    return _context8.abrupt("return", file_info);

                                  case 7:
                                  case "end":
                                    return _context8.stop();
                                }
                              }
                            }, _callee6);
                          }));

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

                      case 5:
                        info.path = file;
                        _context9.t0 = _toJs["default"];
                        _context9.next = 9;
                        return _fsExtraPromisify["default"].readFile(file);

                      case 9:
                        _context9.t1 = _context9.sent;
                        info.content = _context9.t0.string.call(_context9.t0, _context9.t1);
                        return _context9.abrupt("return", info);

                      case 12:
                      case "end":
                        return _context9.stop();
                    }
                  }
                }, _callee7);
              }));

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

          case 5:
            files = _context11.sent;
            return _context11.abrupt("return", (0, _filter["default"])(_context10 = _toJs["default"].flatten(files)).call(_context10, Boolean));

          case 7:
          case "end":
            return _context11.stop();
        }
      }
    }, _callee8);
  }));
  return _readFiles.apply(this, arguments);
}

function pool(_x3, _x4) {
  return _pool.apply(this, arguments);
} /// @name parsers
/// @description
/// This holds all the parsers that this project uses and normalizes
/// them to all function the same way.
/// Each parser in this object has 2 functions `parse`, and `stringify`.
/// @type {object}


function _pool() {
  _pool = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(items, fn) {
    var limit,
        i,
        results,
        length,
        producer,
        runner,
        _args9 = arguments;
    return _regenerator["default"].wrap(function _callee9$(_context12) {
      while (1) {
        switch (_context12.prev = _context12.next) {
          case 0:
            limit = _args9.length > 2 && _args9[2] !== undefined ? _args9[2] : 100;
            i = 0;
            results = [];

            if (typeof items === 'number') {
              length = items;
              items = [];
            } else {
              length = items.length;
            }

            producer = function producer() {
              if (i < length) {
                var index = i;
                return fn(items[index] || i, i++, items).then(function (result) {
                  results[index] = result;
                });
              }

              return null;
            };

            runner = new _es6PromisePool["default"](producer, limit);
            _context12.next = 8;
            return runner.start();

          case 8:
            return _context12.abrupt("return", results);

          case 9:
          case "end":
            return _context12.stop();
        }
      }
    }, _callee9);
  }));
  return _pool.apply(this, arguments);
}

var parsers = {};
exports.parsers = parsers;
var csv = {
  parse: (0, _es6Promisify.promisify)(_csvParse["default"]),
  stringify: (0, _es6Promisify.promisify)(_csvStringify["default"])
}; /// # @name parsers.yaml
/// # @alias parsers.yml
/// # @type {object}

parsers.yaml = parsers.yml = {
  /// # @name parsers.yaml.parse
  /// # @alias parsers.yml.parse
  /// # @arg {string, object} obj
  /// # @returns {object} - The javascript object
  /// # @async
  parse: function parse(obj) {
    return _promise["default"].resolve(_yamljs["default"].parse(obj));
  },
  /// # @name parsers.yaml.stringify
  /// # @alias parsers.yml.stringify
  /// # @arg {object} obj
  /// # @arg {number} indent [2] The indent level
  /// # @returns {string} - The yaml string
  /// # @async
  stringify: function stringify(obj) {
    var _context2;

    var indent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
    return _promise["default"].resolve((0, _trim["default"])(_context2 = _yamljs["default"].stringify(obj, null, indent)).call(_context2));
  }
}; /// # @name parsers.json
/// # @type {object}

parsers.json = {
  /// # @name parsers.json.parse
  /// # @arg {string, object} obj
  /// # @returns {object} - The javascript object
  /// # @async
  parse: function parse(obj) {
    return _promise["default"].resolve(JSON.parse(obj));
  },
  /// # @name parsers.json.stringify
  /// # @arg {object} obj
  /// # @arg {number} indent [2] The indent level
  /// # @returns {string} - The yaml string
  /// # @async
  stringify: function stringify(obj) {
    var indent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
    return _promise["default"].resolve((0, _stringify["default"])(obj, null, !(0, _parseInt2["default"])(indent) ? null : indent));
  }
}; /// # @name parsers.cson
/// # @type {object}

parsers.cson = {
  /// # @name parsers.cson.parse
  /// # @arg {string, object} obj
  /// # @returns {object} - The javascript object
  /// # @async
  parse: function parse(obj) {
    return new _promise["default"](function (resolve, reject) {
      _cson["default"].parse(obj, {}, function (err, result) {
        /* istanbul ignore next */
        if (err) {
          return reject(err);
        }

        resolve(result);
      });
    });
  },
  /// # @name parsers.cson.stringify
  /// # @arg {object} obj
  /// # @arg {number} indent [2] The indent level
  /// # @returns {string} - The yaml string
  /// # @async
  stringify: function stringify(obj) {
    var indent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
    return _promise["default"].resolve(_cson["default"].stringify(obj, null, indent));
  }
}; /// # @name parsers.csv
/// # @type {object}

parsers.csv = {
  /// # @name parsers.csv.parse
  /// # @arg {string, object}
  /// # @returns {array} - The javascript object
  /// # @async
  parse: function parse(obj) {
    return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
      var result, fix;
      return _regenerator["default"].wrap(function _callee$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              fix = function _fix(a, b) {
                /* istanbul ignore if : too hard to create a test case for it */
                if (!a || !b) {
                  return a;
                }

                for (var k in b) {
                  // eslint-disable-line
                  if (b.hasOwnProperty(k)) {
                    /* istanbul ignore if : too hard to create a test case for it */
                    if (_toJs.is.plainObject(b[k])) {
                      a[k] = _toJs.is.plainObject(a[k]) ? fix(a[k], b[k]) : b[k];
                    } else if (_toJs.is.string(b[k]) && /^[0-9]+$/.test(b[k])) {
                      // convert string into a number
                      a[k] = _toJs["default"].number(b[k]);
                    } else if (_toJs.is.string(b[k]) && b[k][0] === '{') {
                      // convert string into an object
                      a[k] = fix({}, _toJs["default"].object(b[k]));
                    } else {
                      a[k] = b[k];
                    }
                  }
                }

                return a;
              };

              _context3.next = 3;
              return csv.parse(obj, {
                columns: true
              });

            case 3:
              result = _context3.sent;
              return _context3.abrupt("return", (0, _map["default"])(result).call(result, function (item) {
                return fix({}, item);
              }));

            case 5:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee);
    }))();
  },
  /// # @name parsers.csv.stringify
  /// # @arg {object} obj
  /// # @arg {object} options [{ header: true, quotedString: true }] The csv options
  /// # @returns {string} - The yaml string
  /// # @async
  stringify: function stringify(obj, options) {
    return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
      var result;
      return _regenerator["default"].wrap(function _callee2$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              if ((0, _typeof2["default"])(options) !== 'object') {
                options = {};
              }

              options = _toJs["default"].extend({
                header: true,
                quotedString: true
              }, options);
              _context4.next = 4;
              return csv.stringify(_toJs["default"].array(obj), options);

            case 4:
              result = _context4.sent;
              return _context4.abrupt("return", (0, _trim["default"])(result).call(result));

            case 6:
            case "end":
              return _context4.stop();
          }
        }
      }, _callee2);
    }))();
  }
};