@coderzz/mocker-data-generator 3.0.5

package/build/main/tests/mocker.spec.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var ava_1 = require("ava");
+var __1 = require("..");
+(0, ava_1.default)('Should return an new instance of mocker', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    return tslib_1.__generator(this, function (_a) {
+        t.deepEqual((0, __1.default)(), new __1.Mocker());
+        return [2 /*return*/];
+    });
+}); });
+(0, ava_1.default)('Should iterate root level too with fields in models', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var length, expectedResult, user, db;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                length = 1;
+                expectedResult = { user: ['firstName'] };
+                user = { static: 'firstName' };
+                return [4 /*yield*/, (0, __1.default)().schema('user', user, length).build()];
+            case 1:
+                db = _a.sent();
+                t.deepEqual(db, expectedResult);
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Virtuals should be eliminated in the final object and can be accesible during generation', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var model, expectedResult, db;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                model = {
+                    exampleVirtual: {
+                        incrementalId: 0,
+                        virtual: true
+                    },
+                    id: {
+                        function: function () {
+                            return this.object.exampleVirtual;
+                        }
+                    },
+                    deep: {
+                        more: {
+                            field: {
+                                static: 'im here',
+                                virtual: true
+                            }
+                        }
+                    },
+                    deep2: {
+                        more: {
+                            field: {
+                                static: 'im here'
+                            }
+                        }
+                    }
+                };
+                expectedResult = {
+                    id: 0,
+                    deep2: {
+                        more: {
+                            field: 'im here'
+                        }
+                    }
+                };
+                return [4 /*yield*/, (0, __1.default)().schema('situation', model, 1).build()];
+            case 1:
+                db = _a.sent();
+                t.deepEqual(db.situation[0], expectedResult);
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Should iterate over more complex levels (deeper & function used...)', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var model, expectedResult, db;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                model = {
+                    name: {
+                        firstName: {
+                            static: 'firstName'
+                        },
+                        lastName: {
+                            static: 'lastName'
+                        },
+                        much: {
+                            deeper: {
+                                function: function () {
+                                    return (this.object.name.firstName +
+                                        ' ' +
+                                        this.object.name.lastName);
+                                }
+                            },
+                            more: {
+                                deeper: {
+                                    function: function () {
+                                        return (this.object.name.firstName +
+                                            ' ' +
+                                            this.object.name.lastName);
+                                    }
+                                },
+                                level: {
+                                    deeper: {
+                                        function: function () {
+                                            return (this.object.name.firstName +
+                                                ' ' +
+                                                this.object.name.lastName);
+                                        }
+                                    },
+                                    awesome: {
+                                        deeper: {
+                                            function: function () {
+                                                return (this.object.name.firstName +
+                                                    ' ' +
+                                                    this.object.name.lastName);
+                                            }
+                                        },
+                                        deeper2: {
+                                            function: function () {
+                                                return (this.object.name.firstName +
+                                                    ' ' +
+                                                    this.object.name.lastName);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+                expectedResult = {
+                    name: {
+                        firstName: 'firstName',
+                        lastName: 'lastName',
+                        much: {
+                            deeper: 'firstName lastName',
+                            more: {
+                                deeper: 'firstName lastName',
+                                level: {
+                                    deeper: 'firstName lastName',
+                                    awesome: {
+                                        deeper: 'firstName lastName',
+                                        deeper2: 'firstName lastName'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+                return [4 /*yield*/, (0, __1.default)().schema('situation', model, 1).build()];
+            case 1:
+                db = _a.sent();
+                t.deepEqual(db.situation[0], expectedResult);
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Should work with conditional keys', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var conditional, expectedResult, db;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                conditional = {
+                    condition: {
+                        static: 'a'
+                    },
+                    'object.condition==="a",a': {
+                        static: 'conditionLinkedToA'
+                    },
+                    'object.condition==="b",b': {
+                        static: 'conditionLinkedToB'
+                    }
+                };
+                expectedResult = {
+                    condition: 'a',
+                    a: 'conditionLinkedToA'
+                };
+                return [4 /*yield*/, (0, __1.default)().schema('situation', conditional, 1).build()];
+            case 1:
+                db = _a.sent();
+                t.deepEqual(db.situation[0], expectedResult);
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Should work with conditional keys II', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var conditional, user, email, db;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                conditional = {
+                    condition: {
+                        values: ['email', 'user']
+                    },
+                    'object.condition==="email",show': {
+                        static: 'email'
+                    },
+                    'object.condition==="user",show': {
+                        static: 'user'
+                    },
+                    'object.condition==="email",email': {
+                        hasOne: 'emails'
+                    },
+                    'object.condition==="user",user': {
+                        hasOne: 'users'
+                    }
+                };
+                user = { static: 'name.findName' };
+                email = { static: 'internet.email' };
+                return [4 /*yield*/, (0, __1.default)()
+                        .schema('users', user, 2)
+                        .schema('emails', email, 2)
+                        .schema('situation', conditional, 3)
+                        .build()];
+            case 1:
+                db = _a.sent();
+                t.true(true);
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Should not affect init values to next entity', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var length, request, request2, db;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                length = 10;
+                request = {
+                    type: {
+                        values: ['kitty', 'pitxi', 'txuri']
+                    }
+                };
+                request2 = {
+                    type: {
+                        static: 'staticValue'
+                    }
+                };
+                return [4 /*yield*/, (0, __1.default)()
+                        .schema('request', request, { uniqueField: 'type' })
+                        .schema('request2', request2, 10)
+                        .build()];
+            case 1:
+                db = _a.sent();
+                t.notDeepEqual(db.request, db.request2);
+                db.request2.forEach(function (r2) {
+                    db.request.forEach(function (r) {
+                        t.notDeepEqual(r2, r);
+                    });
+                });
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Should generate more entities', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var length, model1, model2, data;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                length = 10;
+                model1 = {
+                    request: {
+                        id: {
+                            static: 0
+                        },
+                        title: {
+                            static: 'hello im a cat'
+                        },
+                        number: {
+                            static: 0
+                        }
+                    }
+                };
+                model2 = {
+                    request: {
+                        id: {
+                            static: 0
+                        },
+                        title: {
+                            static: 'hello im a cat'
+                        },
+                        number: {
+                            static: 0
+                        }
+                    }
+                };
+                return [4 /*yield*/, (0, __1.default)()
+                        .schema('act', model1, length)
+                        .schema('act2', model2, length)
+                        .build()];
+            case 1:
+                data = _a.sent();
+                t.true(Object.keys(data).length === 2);
+                t.deepEqual(Object.keys(data), Array('act', 'act2'));
+                t.true(data.act.length === length);
+                t.true(data.act2.length === length);
+                data.act.forEach(function (d) {
+                    t.true(Object.keys(d).length === Object.keys(model1).length);
+                    t.deepEqual(Object.keys(d), Object.keys(model1));
+                    t.deepEqual(Object.keys(d.request), Object.keys(model1.request));
+                });
+                data.act2.forEach(function (d) {
+                    t.true(Object.keys(d).length === Object.keys(model2).length);
+                    t.deepEqual(Object.keys(d), Object.keys(model2));
+                    t.deepEqual(Object.keys(d.request), Object.keys(model2.request));
+                });
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Should uniqueField works', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var cat, cat2, result, data;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                cat = {
+                    name: ['txuri', 'pitxi', 'kitty']
+                };
+                cat2 = {
+                    name: ['txuri', 'pitxi', 'kitty']
+                };
+                result = [{ name: 'txuri' }, { name: 'pitxi' }, { name: 'kitty' }];
+                return [4 /*yield*/, (0, __1.default)()
+                        .schema('cat', cat, { uniqueField: 'name' })
+                        .schema('cat2', cat2, { uniqueField: 'name' })
+                        .build()];
+            case 1:
+                data = _a.sent();
+                t.deepEqual(data.cat, data.cat2);
+                t.deepEqual(data.cat, result);
+                t.deepEqual(data.cat2, result);
+                return [2 /*return*/];
+        }
+    });
+}); });
+(0, ava_1.default)('Should max works', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var cat, data;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                cat = {
+                    name: { values: ['txuri', 'pitxi', 'kitty'] }
+                };
+                return [4 /*yield*/, (0, __1.default)()
+                        .schema('cat', cat, { max: 10 })
+                        .schema('cat2', cat, { max: 40 })
+                        .build()];
+            case 1:
+                data = _a.sent();
+                t.true(data.cat.length <= 10);
+                t.true(data.cat2.length <= 40);
+                return [2 /*return*/];
+        }
+    });
+}); });
+/*
+test('Should max and min works', async t => {
+    let cat = {
+        name: ['txuri', 'pitxi', 'kitty']
+    }
+
+    let data = await mocker()
+        .schema('cat', cat, { min: 5, max: 10 })
+        .schema('cat2', cat, { min: 10, max: 40 })
+        .build()
+
+    t.true(data.cat.length <= 10)
+    t.true(data.cat.length >= 5)
+    t.true(data.cat2.length <= 40)
+    t.true(data.cat2.length >= 10)
+})
+
+test('Should generate correctly with 2 ways of uniqueField', function(done) {
+            var cat = {
+                name: ['txuri', 'pitxi', 'kitty']
+            };
+            var cat2 = {
+                name: {
+                    values: ['txuri', 'pitxi', 'kitty']
+                }
+            };
+            var result = [ { name: 'txuri' }, { name: 'pitxi' }, { name: 'kitty' } ]
+            var m = mocker()
+                .schema('cat', cat, {uniqueField: 'name'})
+                .schema('cat2', cat2, {uniqueField: 'name'})
+                .build(function(data){
+                    try {
+                        expect(data.cat)
+                            .to.deep.equal(data.cat2)
+                            .to.deep.equal(result)
+                            .to.not.be.undefined
+                            .to.not.be.null
+                        done()
+                    } catch (x) {
+                        done(x)
+                    }
+                })
+        })*/
+(0, ava_1.default)('Should be awesome', function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    return tslib_1.__generator(this, function (_a) {
+        t.true(true);
+        return [2 /*return*/];
+    });
+}); });

package/build/module/array-includes.js

@@ -0,0 +1,45 @@
+if (!Array.prototype.includes) {
+    Object.defineProperty(Array.prototype, 'includes', {
+        value: function (searchElement, fromIndex) {
+            // 1. Let O be ? ToObject(this value).
+            if (this == null) {
+                throw new TypeError('"this" is null or not defined');
+            }
+            var o = Object(this);
+            // 2. Let len be ? ToLength(? Get(O, "length")).
+            var len = o.length >>> 0;
+            // 3. If len is 0, return false.
+            if (len === 0) {
+                return false;
+            }
+            // 4. Let n be ? ToInteger(fromIndex).
+            //    (If fromIndex is undefined, this step produces the value 0.)
+            var n = fromIndex | 0;
+            // 5. If n ≥ 0, then
+            //  a. Let k be n.
+            // 6. Else n < 0,
+            //  a. Let k be len + n.
+            //  b. If k < 0, let k be 0.
+            var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+            function sameValueZero(x, y) {
+                return (x === y ||
+                    (typeof x === 'number' &&
+                        typeof y === 'number' &&
+                        isNaN(x) &&
+                        isNaN(y)));
+            }
+            // 7. Repeat, while k < len
+            while (k < len) {
+                // a. Let elementK be the result of ? Get(O, ! ToString(k)).
+                // b. If SameValueZero(searchElement, elementK) is true, return true.
+                // c. Increase k by 1.
+                if (sameValueZero(o[k], searchElement)) {
+                    return true;
+                }
+                k++;
+            }
+            // 8. Return false
+            return false;
+        }
+    });
+}

package/build/module/index.js

@@ -0,0 +1,7 @@
+import './array-includes';
+import { Mocker } from './lib/Mocker';
+export * from './lib/Mocker';
+export * from './lib/Schema';
+export * from './lib/Generator';
+export var mocker = function (opts) { return new Mocker(opts); };
+export default mocker;

package/build/module/lib/Generator.js

@@ -0,0 +1,131 @@
+import { __assign, __spreadArray } from "tslib";
+import { loopInside, stringToPathOrCall } from './utils';
+var Generator = /** @class */ (function () {
+    function Generator() {
+    }
+    Generator.prototype.self = function (cfg) {
+        var object = this.object;
+        return cfg.eval
+            ? eval('object.' + cfg.self)
+            : loopInside(this.object, cfg.self);
+    };
+    Generator.prototype.db = function (cfg) {
+        var db = this.DB;
+        if (cfg.eval) {
+            return eval('db.' + cfg.db);
+        }
+        else {
+            return loopInside(this.DB, cfg.db);
+        }
+    };
+    Generator.prototype.custom = function (cfg) {
+        var db = this.DB;
+        var object = this.object;
+        var re;
+        var matches;
+        var strFn;
+        var generator = cfg.generator;
+        if (cfg.run) {
+            return cfg.run(generator, cfg.input);
+        }
+        else if (cfg.eval) {
+            return eval('generator.' + cfg.input);
+        }
+        else {
+            return stringToPathOrCall.call(generator, 'generator', generator, cfg.input);
+        }
+    };
+    Generator.prototype.eval = function (cfg) {
+        var db = this.DB;
+        var object = this.object;
+        var generators = this.generators;
+        return eval(cfg.eval);
+    };
+    Generator.prototype.values = function (cfg) {
+        var i = Math.floor(cfg.values.length * Math.random());
+        return cfg.values[i];
+    };
+    Generator.prototype.function = function (cfg) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var object = this.object;
+        var db = this.DB;
+        var generators = this.generators;
+        return (_a = cfg.function).call.apply(_a, __spreadArray([{ object: object, db: db, generators: generators }], args, false));
+    };
+    Generator.prototype.static = function (cfg) {
+        return cfg.static;
+    };
+    Generator.prototype.incrementalId = function (cfg) {
+        var n = 0;
+        var db = this.DB;
+        if (db[this.name] && db[this.name].length) {
+            n = db[this.name].length;
+        }
+        if (cfg.incrementalId === true) {
+            cfg.incrementalId = '0';
+        }
+        return n + parseInt(cfg.incrementalId, 10);
+    };
+    Generator.prototype.hasOne = function (cfg) {
+        var db = this.DB;
+        var entity = null;
+        if (cfg.uniqueDB) {
+            var dbString = JSON.stringify(cfg.uniqueDB);
+            for (var i = 0; i < db[cfg.hasOne].length; i++) {
+                var element = db[cfg.hasOne][i];
+                element = cfg.get
+                    ? cfg.eval
+                        ? eval('element.' + cfg.get)
+                        : loopInside(element, cfg.get)
+                    : element;
+                if (cfg.uniqueDB.length === 0 ||
+                    dbString.indexOf(JSON.stringify(element)) < 0) {
+                    entity = element;
+                    break;
+                }
+            }
+            if (entity === null) {
+                throw "Can\u00B4t get unique data. Source \"".concat(cfg.hasOne, "\" has not enough data");
+            }
+        }
+        else {
+            var i = Math.floor(db[cfg.hasOne].length * Math.random());
+            entity = db[cfg.hasOne][i];
+            entity = cfg.get
+                ? cfg.eval
+                    ? eval('entity.' + cfg.get)
+                    : loopInside(entity, cfg.get)
+                : entity;
+        }
+        return entity;
+    };
+    Generator.prototype.hasMany = function (cfg) {
+        var _this = this;
+        var amount = 1;
+        var db = this.DB;
+        var min = cfg.min || cfg.min === 0 ? cfg.min : 1;
+        var max = cfg.max ? cfg.max : cfg.hasMany ? db[cfg.hasMany].length : 1;
+        if (cfg.amount) {
+            amount = cfg.amount;
+        }
+        else {
+            amount = Math.floor(Math.random() * (max - min + 1)) + min;
+        }
+        var newCfg = {
+            hasOne: cfg.hasMany,
+            get: cfg.get ? cfg.get : undefined,
+            eval: cfg.eval ? true : false
+        };
+        return cfg.unique
+            ? Array.from(new Array(amount)).reduce(function (acc, val) { return __spreadArray(__spreadArray([], acc, true), [
+                _this.hasOne(__assign(__assign({}, newCfg), { uniqueDB: acc }))
+            ], false); }, [])
+            : Array.from(new Array(amount)).map(function () { return _this.hasOne(newCfg); });
+    };
+    return Generator;
+}());
+export { Generator };

package/build/module/lib/Mocker.js

@@ -0,0 +1,73 @@
+import { Schema } from './Schema';
+import { cleanVirtuals } from './utils';
+var Mocker = /** @class */ (function () {
+    function Mocker(options) {
+        if (options === void 0) { options = {}; }
+        this.schemas = [];
+        this.DB = {};
+        this.options = {};
+        this.generators = {};
+        this.options = options;
+        this.DB = {};
+    }
+    Mocker.prototype.seed = function (name, data) {
+        this.DB[name] = data;
+        return this;
+    };
+    Mocker.prototype.addGenerator = function (name, library, run) {
+        this.generators[name] = { library: library, run: run };
+        return this;
+    };
+    Mocker.prototype.schema = function (name, schema, options) {
+        this.schemas.push(new Schema(name, schema, options));
+        return this;
+    };
+    Mocker.prototype.reset = function () {
+        this.DB = {};
+        return this;
+    };
+    Mocker.prototype.restart = function () {
+        this.DB = {};
+        this.schemas = [];
+        return this;
+    };
+    Mocker.prototype._buildSync = function () {
+        var _this = this;
+        this.schemas.reduce(function (acc, schema) {
+            var instances;
+            try {
+                instances = schema.build(_this.generators, acc);
+            }
+            catch (e) {
+                throw new Error('Schema: "' + schema.name + '" ' + e);
+            }
+            // Clean virtuals
+            if (schema.virtualPaths.length > 0) {
+                instances.forEach(function (x) {
+                    return cleanVirtuals(schema.virtualPaths, x, {
+                        strict: true,
+                        symbol: ','
+                    });
+                });
+            }
+            // Add to db
+            acc[schema.name] = instances;
+            return acc;
+        }, this.DB);
+    };
+    Mocker.prototype.buildSync = function () {
+        this._buildSync();
+        return this.DB;
+    };
+    Mocker.prototype.build = function (cb) {
+        try {
+            this._buildSync();
+        }
+        catch (e) {
+            return cb ? cb(e) : Promise.reject(e);
+        }
+        return cb ? cb(null, this.DB) : Promise.resolve(this.DB);
+    };
+    return Mocker;
+}());
+export { Mocker };