typescript-scaffolder/dist/utils/mock-data-generator.js

 ### Unit Test Coverage: 97.53%

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateMockData = generateMockData;
exports.generatePrimitiveMock = generatePrimitiveMock;
exports.getFakerValueForKey = getFakerValueForKey;
exports.handleDefaultCase = handleDefaultCase;
const faker_1 = require("@faker-js/faker");
const logger_1 = require("./logger");
/**
 * Generates a mock data sample from a type-hinted json schema
 * @param count
 * @param schemaJson
 * @param arrayLength
 */
function generateMockData(count, schemaJson, arrayLength = 1) {
    const funcName = 'generateMockData';
    logger_1.Logger.debug(funcName, 'Starting mock data generation...');
    const results = [];
    const schema = JSON.parse(schemaJson);
    for (let i = 0; i < count; i++) {
        const autoFaked = {};
        logger_1.Logger.debug(funcName, `Identified the following keys: ${Object.keys(schema).join(', ')}`);
        for (const key of Object.keys(schema)) {
            const value = schema[key];
            // Handle array type hints like "string[]"
            if (typeof value === 'string' && value.endsWith('[]')) {
                const baseType = value.replace('[]', '');
                logger_1.Logger.debug(funcName, `Array type identified at key: ${String(key)} with base type ${baseType}`);
                autoFaked[key] = Array.from({ length: arrayLength }).map(() => generatePrimitiveMock(baseType));
                continue;
            }
            if (typeof value === 'string') {
                logger_1.Logger.debug(funcName, `Primitive type string detected at key: ${String(key)} with type hint: ${value}`);
                autoFaked[key] = getFakerValueForKey(String(key)) ?? generatePrimitiveMock(value);
            }
            else {
                autoFaked[key] = handleDefaultCase(value, String(key), arrayLength);
            }
        }
        results.push(autoFaked);
    }
    return results;
}
function generatePrimitiveMock(type) {
    switch (type.toLowerCase()) {
        case 'string':
            return faker_1.faker.lorem.word();
        case 'number':
            return faker_1.faker.number.int({ min: 0, max: 100 });
        case 'boolean':
            return faker_1.faker.datatype.boolean();
        case 'date':
            return faker_1.faker.date.recent().toISOString();
        default:
            return `UnhandledType<${type}>`; // easier to catch visually
    }
}
function getFakerValueForKey(key) {
    const funcName = 'getFakeValueForKey';
    logger_1.Logger.debug(funcName, `String identified at key: ${String(key)}`);
    const lowerKey = key.toLowerCase();
    if (lowerKey.includes('email'))
        return faker_1.faker.internet.email();
    if (lowerKey.includes('name'))
        return faker_1.faker.person.fullName();
    if (lowerKey.includes('url'))
        return faker_1.faker.internet.url();
    return null;
}
function handleDefaultCase(value, key, arrayLength) {
    const funcName = 'handleDefaultCase';
    if (Array.isArray(value) &&
        value.length > 0 &&
        typeof value[0] === 'object' &&
        value[0] !== null) {
        logger_1.Logger.debug(funcName, `Array of nested objects detected at key: ${key}`);
        return Array.from({ length: arrayLength }, () => generateMockData(1, JSON.stringify(value[0]), arrayLength)[0]);
    }
    if (Array.isArray(value) &&
        value.length > 0 &&
        typeof value[0] === 'string') {
        logger_1.Logger.debug(funcName, `Array of mixed primitive types detected at key: ${key}`);
        return value.map(type => generatePrimitiveMock(type));
    }
    if (typeof value === 'object' && value !== null) {
        logger_1.Logger.debug(funcName, `Nested object detected at key: ${key}`);
        return generateMockData(1, JSON.stringify(value), arrayLength)[0];
    }
    logger_1.Logger.warn(funcName, `Unknown type or unsupported structure at key: ${key}`);
    return `UnhandledType<${JSON.stringify(value)}>`;
}