@coderzz/mocker-data-generator 3.0.5

package/build/main/lib/Generator.d.ts

@@ -0,0 +1,61 @@
+import { CustomGeneratorRun } from './types';
+export declare class Generator<T> {
+    name: string;
+    DB: {};
+    object: T;
+    schema: {
+        values: string[];
+    };
+    options: {
+        uniqueField: string;
+        max: number;
+        min: number;
+    };
+    virtualPaths: string[];
+    generators: {};
+    self(cfg: {
+        self: any;
+        eval?: boolean;
+    }): any;
+    db(cfg: {
+        eval?: boolean;
+        db: any;
+    }): any;
+    custom(cfg: {
+        generator: any;
+        input: string | RegExp;
+        run?: CustomGeneratorRun;
+        adapter?: (generator: any, input: string | RegExp) => any;
+        eval?: boolean;
+    }): any;
+    eval(cfg: {
+        eval: string;
+    }): any;
+    values(cfg: {
+        values: any[];
+    }): any;
+    function(cfg: {
+        function: any;
+    }, ...args: any[]): any;
+    static(cfg: {
+        static: any;
+    }): any;
+    incrementalId(cfg: {
+        incrementalId: number | true | string;
+    }): number;
+    hasOne(cfg: {
+        hasOne: string;
+        get?: string;
+        eval?: boolean;
+        uniqueDB?: any[];
+    }): null;
+    hasMany(cfg: {
+        min?: number;
+        max?: number;
+        hasMany: string;
+        amount?: number;
+        get?: string;
+        eval?: boolean;
+        unique?: boolean;
+    }): any;
+}

package/build/main/lib/Generator.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generator = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("./utils");
+var Generator = /** @class */ (function () {
+    function Generator() {
+    }
+    Generator.prototype.self = function (cfg) {
+        var object = this.object;
+        return cfg.eval
+            ? eval('object.' + cfg.self)
+            : (0, utils_1.loopInside)(this.object, cfg.self);
+    };
+    Generator.prototype.db = function (cfg) {
+        var db = this.DB;
+        if (cfg.eval) {
+            return eval('db.' + cfg.db);
+        }
+        else {
+            return (0, utils_1.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 utils_1.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, tslib_1.__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)
+                        : (0, utils_1.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)
+                    : (0, utils_1.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 tslib_1.__spreadArray(tslib_1.__spreadArray([], acc, true), [
+                _this.hasOne(tslib_1.__assign(tslib_1.__assign({}, newCfg), { uniqueDB: acc }))
+            ], false); }, [])
+            : Array.from(new Array(amount)).map(function () { return _this.hasOne(newCfg); });
+    };
+    return Generator;
+}());
+exports.Generator = Generator;

package/build/main/lib/Mocker.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from './Schema';
+import { CustomGeneratorRun, Generators } from './types';
+export type PromiseCb = Promise<any> | void;
+export type IDB = {
+    [key: string]: any[];
+};
+export declare class Mocker {
+    schemas: Schema[];
+    DB: IDB;
+    options: {};
+    generators: Generators;
+    constructor(options?: {});
+    seed(name: string, data: any[]): Mocker;
+    addGenerator(name: string, library: any, run?: CustomGeneratorRun): Mocker;
+    schema(name: string, schema: {}, options?: {}): Mocker;
+    reset(): Mocker;
+    restart(): Mocker;
+    private _buildSync;
+    buildSync(): IDB;
+    build(cb?: (error: Error | null, _?: any) => void): Promise<any>;
+    build(cb?: (error: Error | null, _?: any) => void): void;
+}

package/build/main/lib/Mocker.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mocker = void 0;
+var Schema_1 = require("./Schema");
+var utils_1 = require("./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_1.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 (0, utils_1.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;
+}());
+exports.Mocker = Mocker;

package/build/main/lib/Schema.d.ts

@@ -0,0 +1,9 @@
+import { Generator } from './Generator';
+import { Generators } from './types';
+export declare class Schema extends Generator<any> {
+    constructor(name: string, cfg: any, options: any, generators?: Generators);
+    proccessLeaf(field: any, fieldName?: any): any;
+    generateField(fieldName: any, cfg: any, ...args: any[]): {};
+    buildSingle(schema: any): void;
+    build(generators?: Generators, db?: {}): any;
+}

package/build/main/lib/Schema.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+var tslib_1 = require("tslib");
+var Generator_1 = require("./Generator");
+var utils_1 = require("./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 ((0, utils_1.iamLastParent)(value)) {
+            if (path) {
+                if ((0, utils_1.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 (!(0, utils_1.isConditional)(k)) {
+                key = k;
+            }
+            else {
+                var keykey = k.split(',');
+                if ((0, utils_1.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) {
+    tslib_1.__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 ((0, utils_1.isArray)(field)) {
+            var fieldConfig_1 = field[0];
+            if (field.length > 1) {
+                fieldConfig_1 = { values: field };
+            }
+            var na = Array();
+            if (fieldConfig_1.concat) {
+                na = (0, utils_1.evalWithContextData)(fieldConfig_1.concat, this.object, this.DB, this.generators);
+                // Strict Mode
+                na = fieldConfig_1.concatStrict
+                    ? tslib_1.__spreadArray([], Array.from(new Set(na)), true) : na;
+            }
+            var length_1 = (0, utils_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 = tslib_1.__spreadArray(tslib_1.__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, tslib_1.__spreadArray([tslib_1.__assign(tslib_1.__assign({}, cfg), { generators: this.generators })], args, false));
+        }
+        catch (e) {
+            throw 'Error: "' + key + '" ' + e;
+        }
+        return result;
+    };
+    Schema.prototype.buildSingle = function (schema) {
+        if ((0, utils_1.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 ((0, utils_1.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 ((0, utils_1.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 ((0, utils_1.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 (!(0, utils_1.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_1.Generator));
+exports.Schema = Schema;

package/build/main/lib/types.d.ts

@@ -0,0 +1,8 @@
+export type CustomGeneratorRun = (generator: any, input: any) => any;
+export type CustomGenerator = {
+    library: any;
+    run: CustomGeneratorRun | undefined;
+};
+export type Generators = {
+    [key: string]: CustomGenerator;
+};

package/build/main/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/main/lib/utils.d.ts

@@ -0,0 +1,10 @@
+export declare const isArray: (arg: any) => boolean;
+export declare const isObject: (arg: any) => boolean;
+export declare const evalWithContextData: (key: string, object: {}, db: {}, generators: {}) => any;
+export declare const fieldArrayCalcLength: (config: any, fixedArrayLength: any, schema: any) => any;
+export declare const iamLastChild: (parent: any, k: any) => boolean;
+export declare const iamLastParent: (obj: any) => boolean;
+export declare const isConditional: (str: any) => boolean;
+export declare const cleanVirtuals: (paths: any, object: any, options: any) => any;
+export declare const stringToPathOrCall: (name: any, fn: any, cfg: any) => any;
+export declare const loopInside: (object: any, path: string) => any;