vite-plugin-lessmock/dist/generateMock.js

A vite plugin that auto generate mock data with fake data for TypeScript interfaces.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GenerateMock = void 0;
const ts_json_schema_generator_1 = require("ts-json-schema-generator");
const faker_1 = require("@faker-js/faker");
const lodash_1 = __importDefault(require("lodash"));
class GenerateMock {
    constructor(tsFilepath) {
        this.USE_TYPE = 'TLessMock';
        this.filepath = tsFilepath;
        this.schema = this.getJsonSchema();
    }
    generate() {
        if (this.schema === null)
            return null;
        const data = this.schema.definitions[this.USE_TYPE];
        if (typeof data === 'object') {
            return this.parse(data);
        }
        return null;
    }
    getJsonSchema() {
        if (this.schema === null)
            return null;
        if (this.schema)
            return this.schema;
        const config = {
            path: this.filepath,
            type: this.USE_TYPE,
            skipTypeCheck: true
        };
        try {
            const d = (0, ts_json_schema_generator_1.createGenerator)(config).createSchema(config.type);
            return d;
        }
        catch (err) {
            return null;
        }
    }
    parseObjectType(schema) {
        const data = {};
        const required = schema.required || [];
        Object.entries(schema.properties || {}).forEach(([field, value]) => {
            if (required.includes(field) || faker_1.faker.datatype.boolean()) {
                data[field] = this.parse(value);
            }
        });
        return data;
    }
    parseArrayType(schema) {
        if (!lodash_1.default.isObject(schema.items))
            return null;
        return new Array(schema.maxItems || schema.maxLength || 1).fill(null).map(() => {
            return this.parse(schema.items);
        });
    }
    parseOtherType(schema) {
        const type = schema.type;
        if (schema.anyOf) {
            const d = faker_1.faker.random.arrayElement(schema.anyOf);
            return this.parse(d);
        }
        if (schema.const !== undefined) {
            return schema.const;
        }
        if (schema.enum) {
            return faker_1.faker.random.arrayElement(schema.enum);
        }
        if (schema.format) {
            // eslint-disable-next-line no-new-func
            return new Function('faker', `return ${schema.format}`)(faker_1.faker);
        }
        if (type === 'string') {
            const s = faker_1.faker.lorem.sentences(1);
            const len = schema.maxLength === undefined ? s.length : schema.maxLength;
            return s.slice(0, len);
        }
        if (type === 'number') {
            const { maximum, minimum } = schema;
            return faker_1.faker.datatype.number({ max: maximum, min: minimum });
        }
        if (type === 'boolean') {
            return faker_1.faker.datatype.boolean();
        }
        return null;
    }
    unref(schema) {
        if (lodash_1.default.isObject(schema) && schema.type === undefined && schema.$ref) {
            const key = schema.$ref.replace('#/definitions/', '');
            const rest = lodash_1.default.omit(schema, '$ref');
            const newSchema = this.schema.definitions[decodeURIComponent(key)];
            return Object.assign(rest, newSchema);
        }
        return schema;
    }
    parse(data) {
        let mock;
        data = this.unref(data);
        if (typeof data === 'object') {
            switch (data.type) {
                case 'object':
                    mock = this.parseObjectType(data);
                    break;
                case 'array':
                    mock = this.parseArrayType(data);
                    break;
                default:
                    mock = this.parseOtherType(data);
            }
        }
        return mock;
    }
}
exports.GenerateMock = GenerateMock;