@coderzz/mocker-data-generator 3.0.5

package/build/module/lib/Schema.js

@@ -0,0 +1,207 @@
+import { __assign, __extends, __spreadArray } from "tslib";
+import { Generator } from './Generator';
+import { evalWithContextData, fieldArrayCalcLength, iamLastParent, isArray, isConditional, isObject } from './utils';
+var iterate = function (obj, res, currentPath) {
+    var _this = this;
+    if (!currentPath) {
+        currentPath = [];
+    }
+    Object.keys(obj).map(function (k) {
+        var value = obj[k];
+        var path = currentPath.slice(0);
+        path.push(k);
+        if (iamLastParent(value)) {
+            if (path) {
+                if (isArray(value)) {
+                    if (value[0] && value[0].virtual) {
+                        _this.virtualPaths.push(path.toString());
+                    }
+                }
+                else {
+                    if (value.virtual) {
+                        _this.virtualPaths.push(path.toString());
+                    }
+                }
+            }
+            var key = '';
+            if (!isConditional(k)) {
+                key = k;
+            }
+            else {
+                var keykey = k.split(',');
+                if (evalWithContextData(keykey[0], _this.object, _this.DB, _this.generators)) {
+                    key = keykey[1];
+                }
+            }
+            if (key !== '') {
+                res[key] = _this.proccessLeaf(value, key);
+            }
+        }
+        else {
+            res[k] = {};
+            iterate.call(_this, value, res[k], path);
+        }
+    });
+};
+var Schema = /** @class */ (function (_super) {
+    __extends(Schema, _super);
+    function Schema(name, cfg, options, generators) {
+        if (generators === void 0) { generators = {}; }
+        var _this = _super.call(this) || this;
+        _this.schema = cfg;
+        _this.name = name;
+        _this.options = options;
+        _this.generators = generators;
+        // Temp fields
+        _this.DB = {};
+        _this.object = {};
+        _this.virtualPaths = [];
+        return _this;
+    }
+    Schema.prototype.proccessLeaf = function (field, fieldName) {
+        var _this = this;
+        if (isArray(field)) {
+            var fieldConfig_1 = field[0];
+            if (field.length > 1) {
+                fieldConfig_1 = { values: field };
+            }
+            var na = Array();
+            if (fieldConfig_1.concat) {
+                na = evalWithContextData(fieldConfig_1.concat, this.object, this.DB, this.generators);
+                // Strict Mode
+                na = fieldConfig_1.concatStrict
+                    ? __spreadArray([], Array.from(new Set(na)), true) : na;
+            }
+            var length_1 = fieldArrayCalcLength(field.length > 1 ? fieldConfig_1.values : fieldConfig_1, na.length, this);
+            var array = Array.from(new Array(length_1)).reduce(function (acc, el, index) {
+                var self = acc.slice(0);
+                acc.push(_this.generateField(fieldName, fieldConfig_1, index, length_1, self));
+                return acc;
+            }, []);
+            return array.concat(na);
+        }
+        else {
+            return this.generateField(fieldName, field);
+        }
+    };
+    Schema.prototype.generateField = function (fieldName, cfg) {
+        var _a, _b;
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        var result = {};
+        var customGenerators = Object.keys(this.generators);
+        var ownedByMocker = [
+            'self',
+            'db',
+            'hasOne',
+            'hasMany',
+            'static',
+            'function',
+            'values',
+            'incrementalId'
+        ];
+        var generators = __spreadArray(__spreadArray([], ownedByMocker, true), customGenerators, true);
+        var keys = Object.keys(cfg);
+        var key = keys.reduce(function (acc, val) {
+            if (generators.includes(val)) {
+                acc = val;
+            }
+            return acc;
+        }, 'noKey');
+        if (key === 'noKey' && !keys.includes('eval')) {
+            throw "Error: Invalid or missing generator".concat(fieldName !== 'root' ? " on field ".concat(fieldName) : '', ". Please use one of this generators [").concat(generators.join(','), "], note that if your generator doesnt appear in the list maybe you forgot to add it.");
+        }
+        if (keys.includes('eval') && keys.length === 1) {
+            key = 'eval';
+        }
+        try {
+            result = customGenerators.includes(key)
+                ? this.custom({
+                    generator: (_a = this.generators[key]) === null || _a === void 0 ? void 0 : _a.library,
+                    run: (_b = this.generators[key]) === null || _b === void 0 ? void 0 : _b.run,
+                    input: cfg[key],
+                    eval: cfg.eval
+                })
+                : this[key].apply(this, __spreadArray([__assign(__assign({}, cfg), { generators: this.generators })], args, false));
+        }
+        catch (e) {
+            throw 'Error: "' + key + '" ' + e;
+        }
+        return result;
+    };
+    Schema.prototype.buildSingle = function (schema) {
+        if (iamLastParent(schema)) {
+            this.object = this.proccessLeaf(schema, 'root');
+        }
+        else {
+            iterate.call(this, schema, this.object);
+        }
+    };
+    Schema.prototype.build = function (generators, db) {
+        var _this = this;
+        if (generators === void 0) { generators = {}; }
+        if (db === void 0) { db = {}; }
+        this.generators = generators;
+        this.object = {};
+        this.DB = db ? db : {};
+        this.DB[this.name] = this.DB[this.name] ? this.DB[this.name] : [];
+        if (Number.isInteger(this.options)) {
+            Array.from(new Array(this.options)).map(function () {
+                _this.buildSingle(_this.schema);
+                _this.DB[_this.name].push(_this.object);
+                _this.object = {};
+            });
+        }
+        else if (isObject(this.options) && this.options.max) {
+            var max = this.options.max;
+            var min = this.options.min ? this.options.min : 0;
+            var length = Math.floor(Math.random() * (max - min + 1) + min);
+            Array.from(new Array(length)).map(function () {
+                _this.buildSingle(_this.schema);
+                _this.DB[_this.name].push(_this.object);
+                _this.object = {};
+            });
+        }
+        else if (isObject(this.options) && this.options.uniqueField) {
+            var f_1 = this.options.uniqueField;
+            var entityConfig_1 = this.schema;
+            var possibleValues = void 0;
+            if (f_1 === '.') {
+                possibleValues = this.schema.values;
+            }
+            else {
+                if (this.schema[f_1]) {
+                    if (isArray(this.schema[f_1].values)) {
+                        possibleValues = this.schema[f_1].values;
+                    }
+                    else {
+                        possibleValues = this.schema[f_1];
+                    }
+                }
+                else {
+                    throw "The field \"".concat(f_1, "\" not exists.");
+                }
+            }
+            if (!isArray(possibleValues)) {
+                throw "The posible values value is not an Array";
+            }
+            possibleValues.map(function (value) {
+                if (f_1 === '.') {
+                    return;
+                }
+                entityConfig_1[f_1] = { static: value };
+                _this.buildSingle(entityConfig_1);
+                _this.DB[_this.name].push(_this.object);
+                _this.object = {};
+            });
+        }
+        else {
+            throw "An string \"".concat(this.options, "\" is not recognized as a parameter.");
+        }
+        return this.DB[this.name];
+    };
+    return Schema;
+}(Generator));
+export { Schema };

package/build/module/lib/types.js

@@ -0,0 +1 @@
+export {};

package/build/module/lib/utils.js

@@ -0,0 +1,209 @@
+import { __generator, __spreadArray, __values } from "tslib";
+export var isArray = function (arg) {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+};
+export var isObject = function (arg) {
+    return Object.prototype.toString.call(arg) === '[object Object]';
+};
+export var evalWithContextData = function (key, object, db, generators) {
+    // In this (way, we can pass object and use inside the eval string
+    return eval(key);
+};
+export var fieldArrayCalcLength = function (config, fixedArrayLength, schema) {
+    var length;
+    if (typeof config.length === 'function') {
+        length = config.length.call(schema);
+    }
+    else if (config.fixedLength) {
+        length = config.length - fixedArrayLength;
+    }
+    else {
+        length = Math.floor(Math.random() * config.length + 1);
+    }
+    return length;
+};
+export var iamLastChild = function (parent, k) {
+    if (isArray(parent[k])) {
+        var last = false;
+        if (parent[k].length === 0) {
+            return true;
+        }
+        for (var i = 0; i < parent[k].length; i++) {
+            var el = parent[k][i];
+            last = !isObject(el);
+            if (last) {
+                break;
+            }
+        }
+        return last;
+    }
+    else {
+        return !isObject(parent[k]);
+    }
+};
+export var iamLastParent = function (obj) {
+    var last = false;
+    if (isObject(obj)) {
+        var ks = Object.keys(obj);
+        for (var i = 0; i < ks.length; i++) {
+            var k = ks[i];
+            last = iamLastChild(obj, k);
+            if (!last) {
+                break;
+            }
+        }
+    }
+    else {
+        last = true;
+    }
+    return last;
+};
+export var isConditional = function (str) {
+    var arr = str.split(',');
+    return arr.length > 1;
+};
+export var cleanVirtuals = function (paths, object, options) {
+    // clean specific paths
+    var objectCleaner = function (path, obj, options) {
+        var lvls, dest, i, field;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    lvls = path.split(options.symbol);
+                    dest = obj;
+                    if (!lvls || lvls.length === 0) {
+                        return [2 /*return*/];
+                    }
+                    if (!obj) {
+                        return [2 /*return*/];
+                    }
+                    for (i = 0; i < lvls.length; i++) {
+                        field = lvls[i];
+                        if (i === lvls.length - 1 && dest[field]) {
+                            if (Object.getOwnPropertyNames(dest[field]).length < 1) {
+                                delete dest[field];
+                                break;
+                            }
+                        }
+                        else {
+                            dest = dest[field];
+                        }
+                    }
+                    lvls.pop();
+                    if (!(lvls.length > 0)) return [3 /*break*/, 2];
+                    return [5 /*yield**/, __values(objectCleaner(lvls.join(options.symbol), obj, options))];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2: return [2 /*return*/];
+                case 3: return [2 /*return*/];
+            }
+        });
+    };
+    var forEachPath = function (path, object, options) {
+        var lvls, dest, i, field;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    lvls = path.split(options.symbol);
+                    dest = object;
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < lvls.length)) return [3 /*break*/, 5];
+                    field = lvls[i];
+                    if (!(i === lvls.length - 1)) return [3 /*break*/, 3];
+                    // delete specific path
+                    delete dest[field];
+                    // clean specific path
+                    return [5 /*yield**/, __values(objectCleaner(path, object, options))];
+                case 2:
+                    // clean specific path
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    dest = dest[field];
+                    _a.label = 4;
+                case 4:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 5: return [2 /*return*/];
+            }
+        });
+    };
+    var forPaths = function (paths, object, options) {
+        var i, path;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < paths.length)) return [3 /*break*/, 4];
+                    path = paths[i];
+                    return [5 /*yield**/, __values(Array.from(forEachPath(path, object, options)))];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    };
+    for (var _i = 0, _a = Array.from(forPaths(paths, object, options)); _i < _a.length; _i++) {
+        var res = _a[_i];
+    }
+    return object;
+};
+export var stringToPathOrCall = function (name, fn, cfg) {
+    var _a = cfg.split('('), body = _a[0], args = _a[1];
+    body = body.split('.');
+    var func = body.reduce(function (acc, val) {
+        if (!acc[val]) {
+            throw "This ".concat(name, " method doesnt exists '").concat(cfg, "'.");
+        }
+        return acc[val];
+    }, fn);
+    if (!args) {
+        if (typeof func === 'function') {
+            return func.call(this);
+        }
+        else {
+            return func;
+        }
+    }
+    var _b = args.split(')'), args2 = _b[0], mods = _b[1];
+    args = args2
+        ? args2[0] === '{'
+            ? [JSON.parse(args2)]
+            : args2
+                .split(',')
+                .map(function (e) { return (/^\d+$/.test(e) ? Number.parseInt(e) : e); })
+        : [];
+    var result = func.call.apply(func, __spreadArray([this], args, false));
+    if (!mods || mods === '') {
+        return result;
+    }
+    mods = mods
+        .split('[')
+        .filter(function (i) { return i !== ''; })
+        .map(function (i) { return i.slice(0, -1); })
+        .map(function (i) { return (i[0] === '"' ? i.slice(1, -1) : parseInt(i, 10)); });
+    return mods.reduce(function (acc, val) {
+        if (!acc[val]) {
+            throw "'".concat(acc, "' doesnt have key '").concat(val, "'.");
+        }
+        return acc[val];
+    }, result);
+};
+export var loopInside = function (object, path) {
+    var p = path.split('.');
+    return p.reduce(function (acc, val) {
+        if (acc[val] === null) {
+            throw "'".concat(acc, "' doesnt have key '").concat(val, "'.");
+        }
+        return acc[val];
+    }, object);
+};

package/package.json

@@ -0,0 +1,130 @@
+{
+    "name": "@coderzz/mocker-data-generator",
+    "version": "3.0.5",
+    "description": "A simplified way to generate mock data, builds using a simple schema and with the FakerJs",
+    "main": "build/main/index.js",
+    "typings": "build/main/index.d.ts",
+    "module": "build/module/index.js",
+    "repository": "https://github.com/anyideaz/mocker-data-generator",
+    "keywords": [
+        "mock",
+        "data",
+        "faker",
+        "fakerjs",
+        "chance",
+        "chancejs",
+        "casual",
+        "randexp",
+        "json",
+        "fake",
+        "mocks",
+        "massive",
+        "generator"
+    ],
+    "author": {
+        "name": "Daniel Biedma Ramos",
+        "email": "info@dbr.io",
+        "url": "https://dbr.io"
+    },
+    "files": [
+        "build/main/**/*",
+        "build/module/**/*",
+        "build/browser/**/*",
+        "package.json",
+        "README.md",
+        "CHANGELOG.md",
+        "LICENSE"
+    ],
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/anyideaz/mocker-data-generator/issues"
+    },
+    "scripts": {
+        "info": "npm-scripts-info",
+        "build": "trash build && tsc -p tsconfig.json && tsc -p config/tsconfig.module.json",
+        "build:tests": "trash test && node config/exports/build-tests.js",
+        "lint": "tslint src/**/*.ts",
+        "unit": "npm run build && nyc ava",
+        "check-coverage": "nyc check-coverage --lines 80 --functions 80 --branches 80",
+        "test": "npm run unit && npm run check-coverage",
+        "watch": "trash build && multiview [yarn watch:build] [yarn watch:unit]",
+        "watch:build": "tsc -p tsconfig.json -w",
+        "watch:unit": "tsc -p tsconfig.json && ava --watch --verbose",
+        "cov": "npm run unit && npm run html-coverage && opn coverage/index.html",
+        "html-coverage": "nyc report --reporter=html",
+        "send-coverage": "nyc report --reporter=lcov > coverage.lcov && codecov",
+        "docs": "typedoc src/index.ts --excludePrivate --mode file --theme minimal --out build/docs && opn build/docs/index.html",
+        "docs:json": "typedoc --mode file --json build/docs/typedoc.json src/index.ts",
+        "release": "standard-version",
+        "release:patch": "standard-version --release-as patch",
+        "release:minor": "standard-version --release-as minor",
+        "release:major": "standard-version --release-as major",
+        "release-github": "source .env.sh && conventional-github-releaser -p angular -r 1",
+        "prett": "prettier 'src/**/*.ts' --write",
+        "docs:dev": "cd _docs_website && next",
+        "docs:serve:dev": "npm run run docs:build && npm run docs:start",
+        "docs:build": "cd _docs_website && next build",
+        "docs:start": "cd _docs_website && next start",
+        "docs:examples": "node _docs_website/generateExamples.js",
+        "docs:export:dev": "trash _docs_website/.next && trash _docs_website/out && npm run docs:examples && cd _docs_website && NODE_ENV=development next build && NODE_ENV=development next export && npm run docs:serve:prod",
+        "docs:export": "trash _docs_website/.next && trash _docs_website/out && npm run docs:examples && cd _docs_website && NODE_ENV=production next build && NODE_ENV=production next export && touch out/.nojekyll",
+        "docs:serve:prod": "http-server _docs_website/out",
+        "docs:deploy:gh-pages": "gh-pages -d _docs_website/out -b gh-pages -t"
+    },
+    "scripts-info": {
+        "info": "Display information about the scripts",
+        "build": "(Trash and re)build the library",
+        "lint": "Lint all typescript source files",
+        "unit": "Run unit tests",
+        "test": "Lint and test the library",
+        "watch": "Watch source files, rebuild library on changes, rerun relevant tests",
+        "watch:build": "Watch source files, rebuild library on changes",
+        "watch:unit": "Watch the build, rerun relevant tests on changes",
+        "cov": "Run tests, generate the HTML coverage report, and open it in a browser",
+        "html-coverage": "Output HTML test coverage report",
+        "send-coverage": "Output lcov test coverage report and send it to codecov",
+        "docs": "Generate API documentation and open it in a browser",
+        "docs:json": "Generate API documentation in typedoc JSON format",
+        "release": "Bump package.json version, update CHANGELOG.md, tag a release"
+    },
+    "devDependencies": {
+        "@faker-js/faker": "^8.4.1",
+        "@types/node": "^18.15.13",
+        "ava": "^5.1.0",
+        "casual-browserify": "^1.5.19",
+        "chance": "^1.1.7",
+        "codecov": "^3.8.2",
+        "conventional-github-releaser": "^3.1.5",
+        "gh-pages": "^4.0.0",
+        "http-server": "^14.1.1",
+        "multiview": "^3.0.1",
+        "npm-scripts-info": "^0.3.9",
+        "nyc": "^15.1.0",
+        "opn-cli": "^5.0.0",
+        "prettier": "^2.8.1",
+        "randexp": "^0.5.3",
+        "standard-version": "^9.5.0",
+        "trash-cli": "^5.0.0",
+        "ts-node": "^10.9.1",
+        "tslib": "^2.4.1",
+        "tslint": "^6.1.3",
+        "tslint-config-standard": "^9.0.0",
+        "typedoc": "^0.23.23",
+        "typescript": "^4.9.4"
+    },
+    "nyc": {
+        "exclude": [
+            "**/*.spec.js",
+            "**/array-includes.js"
+        ]
+    },
+    "ava": {
+        "files": [
+            "build/main/**/*.spec.js",
+            "!**/array-includes.js"
+        ],
+        "source": [
+            "build/main/**/*"
+        ]
+    }
+}