@mongodb-js/mock-data-generator 0.0.0-init → 1.2.0

package/dist/script-generation-utils.js

@@ -0,0 +1,586 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScript = generateScript;
+exports.getDefaultFakerMethod = getDefaultFakerMethod;
+exports.formatFakerArgs = formatFakerArgs;
+exports.generateDocument = generateDocument;
+const standalone_1 = __importDefault(require("prettier/standalone"));
+const parser_babel_1 = __importDefault(require("prettier/parser-babel"));
+const en_1 = require("@faker-js/faker/locale/en");
+const types_1 = require("./types");
+const DEFAULT_ARRAY_LENGTH = 3;
+/**
+ * Entry point method: Generate the final script
+ */
+function generateScript(schema, options) {
+    try {
+        const structure = buildDocumentStructure(schema);
+        const documentCode = renderDocumentCode(structure, options.arrayLengthMap || {});
+        // Generate unformatted script
+        const unformattedScript = `// Mock Data Generator Script
+// Document count: ${options.documentCount}
+
+const { faker } = require('@faker-js/faker');
+
+// Database and collection configuration - edit these to target a different location
+const DB_NAME = ${toStringLiteral(options.databaseName)};
+const COLL_NAME = ${toStringLiteral(options.collectionName)};
+
+// Connect to database
+use(DB_NAME);
+
+// Document generation function
+function generateDocument() {
+  return ${documentCode};
+}
+
+const BATCH_SIZE = 1000; // Number of documents to insert per batch
+const TOTAL_DOCUMENTS = ${options.documentCount};
+const numBatches = Math.ceil(TOTAL_DOCUMENTS / BATCH_SIZE);
+
+console.log(\`Starting mock data generation for \${DB_NAME}.\${COLL_NAME}\`);
+console.log(\`Total documents to generate: \${TOTAL_DOCUMENTS} documents\`);
+console.log(\`Batch size: \${BATCH_SIZE} documents per batch\`);
+
+const startTime = new Date();
+
+for (let batchStart = 0; batchStart < TOTAL_DOCUMENTS; batchStart += BATCH_SIZE) {
+  const batchEnd = Math.min(batchStart + BATCH_SIZE, TOTAL_DOCUMENTS);
+  const batchSize = batchEnd - batchStart;
+
+  console.log(\`Generating batch \${Math.floor(batchStart / BATCH_SIZE) + 1} of \${numBatches} (\${batchSize} documents)...\`);
+
+  // Generate documents for this batch
+  const batchDocuments = [];
+  for (let i = 0; i < batchSize; i++) {
+    batchDocuments.push(generateDocument());
+  }
+
+  // Insert the batch
+  db.getCollection(COLL_NAME).insertMany(batchDocuments);
+
+  console.log(\`Batch inserted successfully.\`);
+}
+
+const endTime = new Date();
+const duration = ((endTime - startTime) / 1000).toFixed(2);
+
+console.log(\`\\n=== Mock Data Generation Complete ===\`);
+console.log(\`Total time: \${duration} seconds\`);
+console.log(\`Collection: \${DB_NAME}.\${COLL_NAME}\`);`;
+        // Format the script using prettier
+        const script = standalone_1.default.format(unformattedScript, {
+            plugins: [parser_babel_1.default],
+            parser: 'babel',
+            printWidth: 50,
+            trailingComma: 'none',
+        });
+        return {
+            script,
+            success: true,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Parse a field path into simple parts
+ *
+ * Examples:
+ * "name" → ["name"]
+ * "user.email" → ["user", "email"]
+ * "tags[]" → ["tags", "[]"]
+ * "users[].name" → ["users", "[]", "name"]
+ * "matrix[][]" → ["matrix", "[]", "[]"]
+ */
+function parseFieldPath(fieldPath) {
+    const parts = [];
+    let current = '';
+    for (let i = 0; i < fieldPath.length; i++) {
+        const char = fieldPath[i];
+        if (char === '.') {
+            if (current) {
+                parts.push(current);
+                current = '';
+            }
+            else if (parts.length > 0 && parts[parts.length - 1] === '[]') {
+                // This is valid: "users[].name" - dot after array notation
+                // Continue parsing
+            }
+            else {
+                throw new Error(`Invalid field path "${fieldPath}": empty field name before dot`);
+            }
+        }
+        else if (char === '[' && fieldPath[i + 1] === ']') {
+            // Only treat [] as array notation if it's at the end, followed by a dot, or followed by another [
+            const isAtEnd = i + 2 >= fieldPath.length;
+            const isFollowedByDot = i + 2 < fieldPath.length && fieldPath[i + 2] === '.';
+            const isFollowedByBracket = i + 2 < fieldPath.length && fieldPath[i + 2] === '[';
+            if (isAtEnd || isFollowedByDot || isFollowedByBracket) {
+                // This is array notation
+                if (current) {
+                    parts.push(current);
+                    current = '';
+                }
+                parts.push('[]');
+                i++; // Skip the ]
+            }
+            else {
+                // This is just part of the field name
+                current += char;
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        parts.push(current);
+    }
+    if (parts.length === 0) {
+        throw new Error(`Invalid field path "${fieldPath}": no valid field names found`);
+    }
+    return parts;
+}
+/**
+ * Build the document structure from all field paths
+ */
+function buildDocumentStructure(schema) {
+    const result = {};
+    // Process each field path
+    for (const [fieldPath, mapping] of Object.entries(schema)) {
+        const pathParts = parseFieldPath(fieldPath);
+        insertIntoStructure(result, pathParts, mapping);
+    }
+    return result;
+}
+/**
+ * Insert a field mapping into the structure at the given path
+ */
+function insertIntoStructure(structure, pathParts, mapping) {
+    if (pathParts.length === 0) {
+        throw new Error('Cannot insert field mapping: empty path parts array');
+    }
+    // Base case: insert root-level field mapping
+    if (pathParts.length === 1) {
+        const part = pathParts[0];
+        if (part === '[]') {
+            throw new Error('Invalid field path: array notation "[]" cannot be used without a field name');
+        }
+        structure[part] = mapping;
+        return;
+    }
+    // Recursive case
+    const [firstPart, secondPart, ...remainingParts] = pathParts;
+    if (secondPart === '[]') {
+        // This is an array field
+        // Initialize array structure if it doesn't exist yet
+        if (!structure[firstPart] ||
+            typeof structure[firstPart] !== 'object' ||
+            !('type' in structure[firstPart]) ||
+            structure[firstPart].type !== 'array') {
+            structure[firstPart] = {
+                type: 'array',
+                elementType: {},
+            };
+        }
+        const arrayStructure = structure[firstPart];
+        if (remainingParts.length === 0) {
+            // Terminal case: Array of primitives (e.g., "tags[]")
+            // Directly assign the field mapping as the element type
+            arrayStructure.elementType = mapping;
+        }
+        else if (remainingParts[0] === '[]') {
+            // Nested array case: Multi-dimensional arrays (e.g., "matrix[][]")
+            // Build nested array structure
+            let currentArray = arrayStructure;
+            let i = 0;
+            // Process consecutive [] markers to build nested array structure
+            // Each iteration creates one array dimension (eg. matrix[][] = 2 iterations)
+            while (i < remainingParts.length && remainingParts[i] === '[]') {
+                // Create the next array dimension
+                currentArray.elementType = {
+                    type: 'array',
+                    elementType: {},
+                };
+                // Move to the next nesting level
+                currentArray = currentArray.elementType;
+                i++;
+            }
+            if (i < remainingParts.length) {
+                // This is an multi-dimensional array of documents (e.g., "matrix[][].name")
+                // Ensure we have a document structure for the remaining fields
+                if (typeof currentArray.elementType !== 'object' ||
+                    'mongoType' in currentArray.elementType ||
+                    'type' in currentArray.elementType) {
+                    currentArray.elementType = {};
+                }
+                // Recursively build the document
+                insertIntoStructure(currentArray.elementType, remainingParts.slice(i), mapping);
+            }
+            else {
+                // Pure multi-dimensional array - assign the mapping
+                currentArray.elementType = mapping;
+            }
+        }
+        else {
+            // Object case: Array of documents with fields (e.g., "users[].name", "users[].profile.email")
+            // Only initialize if elementType isn't already a proper object structure
+            if (typeof arrayStructure.elementType !== 'object' ||
+                'mongoType' in arrayStructure.elementType ||
+                'type' in arrayStructure.elementType) {
+                arrayStructure.elementType = {};
+            }
+            // Recursively build the object structure for array elements
+            insertIntoStructure(arrayStructure.elementType, remainingParts, mapping);
+        }
+    }
+    else {
+        // This is a regular object field
+        // Only initialize if it doesn't exist or isn't a plain object
+        if (!structure[firstPart] ||
+            typeof structure[firstPart] !== 'object' ||
+            'type' in structure[firstPart] ||
+            'mongoType' in structure[firstPart]) {
+            structure[firstPart] = {};
+        }
+        insertIntoStructure(structure[firstPart], [secondPart, ...remainingParts], mapping);
+    }
+}
+/**
+ * Generate JavaScript object code from document structure
+ */
+function renderDocumentCode(structure, arrayLengthMap = {}, currentPath = '') {
+    // For each field in structure:
+    //   - If FakerFieldMapping: generate faker call
+    //   - If DocumentStructure: generate nested object
+    //   - If ArrayStructure: generate array
+    const documentFields = [];
+    for (const [fieldName, value] of Object.entries(structure)) {
+        if ('mongoType' in value) {
+            // It's a field mapping
+            const mapping = value;
+            const fakerCall = generateFakerCall(mapping);
+            // Default to 1.0 for invalid probability values
+            let probability = 1.0;
+            if (mapping.probability !== undefined &&
+                typeof mapping.probability === 'number' &&
+                mapping.probability >= 0 &&
+                mapping.probability <= 1) {
+                probability = mapping.probability;
+            }
+            if (probability < 1.0) {
+                // Use Math.random for conditional field inclusion
+                documentFields.push(`...(Math.random() < ${probability} ? { ${formatFieldName(fieldName)}: ${fakerCall} } : {})`);
+            }
+            else {
+                // Normal field inclusion
+                documentFields.push(`${formatFieldName(fieldName)}: ${fakerCall}`);
+            }
+        }
+        else if ('type' in value && value.type === 'array') {
+            // It's an array
+            const fieldPath = currentPath
+                ? `${currentPath}.${fieldName}[]`
+                : `${fieldName}[]`;
+            const arrayCode = renderArrayCode(value, fieldName, arrayLengthMap, fieldPath);
+            documentFields.push(`${formatFieldName(fieldName)}: ${arrayCode}`);
+        }
+        else {
+            // It's a nested object: recursive call
+            const nestedPath = currentPath
+                ? `${currentPath}.${fieldName}`
+                : fieldName;
+            const nestedCode = renderDocumentCode(value, arrayLengthMap, nestedPath);
+            documentFields.push(`${formatFieldName(fieldName)}: ${nestedCode}`);
+        }
+    }
+    // Handle empty objects
+    if (documentFields.length === 0) {
+        return '{}';
+    }
+    return `{${documentFields.join(',')}}`;
+}
+/**
+ * Serializes a value into a JS literal that is safe to embed in generated code.
+ * JSON.stringify alone leaves characters that can break out of some contexts.
+ */
+function toStringLiteral(value) {
+    return JSON.stringify(value).replace(/[<>/\u2028\u2029]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
+/**
+ * Formats a field name for use in JavaScript object literal syntax.
+ * Only quotes field names that need it.
+ */
+function formatFieldName(fieldName) {
+    // If it's a valid JavaScript identifier, don't quote it
+    const isValidIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(fieldName);
+    if (isValidIdentifier) {
+        return fieldName;
+    }
+    else {
+        return toStringLiteral(fieldName);
+    }
+}
+/**
+ * Generate array code
+ */
+function renderArrayCode(arrayStructure, fieldName = '', arrayLengthMap = {}, currentFieldPath = '') {
+    const elementType = arrayStructure.elementType;
+    // Get array length for this dimension
+    let arrayLength = DEFAULT_ARRAY_LENGTH;
+    if (currentFieldPath && arrayLengthMap[currentFieldPath] !== undefined) {
+        arrayLength = arrayLengthMap[currentFieldPath];
+    }
+    if ('mongoType' in elementType) {
+        // Array of primitives
+        const fakerCall = generateFakerCall(elementType);
+        return `Array.from({length: ${arrayLength}}, () => ${fakerCall})`;
+    }
+    else if ('type' in elementType && elementType.type === 'array') {
+        // Nested array (e.g., matrix[][]) - append another [] to the path
+        const fieldPath = currentFieldPath + '[]';
+        const nestedArrayCode = renderArrayCode(elementType, fieldName, arrayLengthMap, fieldPath);
+        return `Array.from({length: ${arrayLength}}, () => ${nestedArrayCode})`;
+    }
+    else {
+        const objectCode = renderDocumentCode(elementType, arrayLengthMap, currentFieldPath);
+        return `Array.from({length: ${arrayLength}}, () => (${objectCode}))`;
+    }
+}
+/**
+ * Generate faker.js call from field mapping
+ */
+function generateFakerCall(mapping) {
+    const method = mapping.fakerMethod === types_1.UNRECOGNIZED_FAKER_METHOD
+        ? getDefaultFakerMethod(mapping.mongoType)
+        : mapping.fakerMethod;
+    // Use direct ObjectId generation for MongoDB ObjectIds
+    if (method === 'database.mongodbObjectId') {
+        return 'new ObjectId()';
+    }
+    const args = formatFakerArgs(mapping.fakerArgs);
+    return `faker.${method}(${args})`;
+}
+/**
+ * Gets default faker method for unrecognized fields based on MongoDB type
+ */
+function getDefaultFakerMethod(mongoType) {
+    switch (mongoType) {
+        // String types
+        case 'String':
+            return 'lorem.word';
+        // Numeric types
+        case 'Number':
+        case 'Int32':
+        case 'Long':
+            return 'number.int';
+        case 'Decimal128':
+            return 'number.float';
+        // Date and time types
+        case 'Date':
+        case 'Timestamp':
+            return 'date.recent';
+        // Object identifier
+        case 'ObjectId':
+            return 'database.mongodbObjectId';
+        // Boolean
+        case 'Boolean':
+            return 'datatype.boolean';
+        // Binary
+        case 'Binary':
+            return 'string.hexadecimal';
+        // Regular expression
+        case 'RegExp':
+            return 'lorem.word';
+        // JavaScript code
+        case 'Code':
+            return 'lorem.sentence';
+        // MinKey and MaxKey
+        case 'MinKey':
+            return 'number.int';
+        case 'MaxKey':
+            return 'number.int';
+        // Symbol (deprecated)
+        case 'Symbol':
+            return 'lorem.word';
+        // DBRef
+        case 'DBRef':
+            return 'database.mongodbObjectId';
+        // Default fallback
+        default:
+            return 'lorem.word';
+    }
+}
+/**
+ * Converts array of faker arguments to comma separated string for function calls.
+ *
+ * Serializes various argument types into valid JavaScript syntax:
+ * - Strings: Uses JSON.stringify() to handle quotes, newlines, and special characters
+ * - Numbers: Validates finite numbers and converts to string representation
+ * - Booleans: Converts to 'true' or 'false' literals
+ * - Objects with 'json' property: Parses and re-stringifies JSON for validation
+ *
+ * @param fakerArgs - Array of arguments to convert to JavaScript code
+ * @returns Comma-separated string of JavaScript arguments, or empty string if no args
+ * @throws Error if arguments contain invalid values (non-finite numbers, malformed JSON)
+ *
+ * @example
+ * formatFakerArgs(['male', 25, true]) // Returns: '"male", 25, true'
+ * formatFakerArgs([{json: '{"min": 1}'}]) // Returns: '{"min": 1}'
+ */
+function formatFakerArgs(fakerArgs) {
+    const stringifiedArgs = [];
+    for (let i = 0; i < fakerArgs.length; i++) {
+        const arg = fakerArgs[i];
+        if (typeof arg === 'string') {
+            stringifiedArgs.push(toStringLiteral(arg));
+        }
+        else if (typeof arg === 'number') {
+            if (!Number.isFinite(arg)) {
+                throw new Error(`Invalid number argument at index ${i}: must be a finite number`);
+            }
+            stringifiedArgs.push(`${arg}`);
+        }
+        else if (typeof arg === 'boolean') {
+            stringifiedArgs.push(`${arg}`);
+        }
+        else if (typeof arg === 'object' && arg !== null && 'json' in arg) {
+            // Re-serialize so only a JSON value, never arbitrary code, is emitted
+            stringifiedArgs.push(toStringLiteral(JSON.parse(arg.json)));
+        }
+        else {
+            throw new Error(`Invalid argument type at index ${i}: expected string, number, boolean, or {json: string}`);
+        }
+    }
+    return stringifiedArgs.join(', ');
+}
+/**
+ * Generates documents for the PreviewScreen component.
+ * Executes faker methods to create actual document objects.
+ */
+function generateDocument(fakerSchema, arrayLengthMap = {}) {
+    const structure = buildDocumentStructure(fakerSchema);
+    return constructDocumentValues(structure, arrayLengthMap);
+}
+function computeValue(elementType, arrayLengthMap, currentPath) {
+    try {
+        if ('mongoType' in elementType) {
+            // It's a field mapping
+            const mapping = elementType;
+            // Default to 1.0 for invalid probability values
+            let probability = 1.0;
+            if (typeof mapping.probability === 'number' &&
+                mapping.probability >= 0 &&
+                mapping.probability <= 1) {
+                probability = mapping.probability;
+            }
+            const shouldIncludeField = probability >= 1.0 || Math.random() < probability;
+            if (shouldIncludeField) {
+                return generateFakerValue(mapping);
+            }
+        }
+        else if ('type' in elementType && elementType.type === 'array') {
+            return constructArrayValues(elementType, arrayLengthMap, `${currentPath}[]`);
+        }
+        else {
+            return constructDocumentValues(elementType, arrayLengthMap, currentPath);
+        }
+    }
+    catch {
+        // Skip invalid faker methods
+    }
+}
+/**
+ * Construct actual document values from document structure.
+ * Mirrors renderDocumentCode but executes faker calls instead of generating code.
+ */
+function constructDocumentValues(structure, arrayLengthMap = {}, currentPath = '') {
+    const result = {};
+    for (const [fieldName, value] of Object.entries(structure)) {
+        const newPath = currentPath ? `${currentPath}.${fieldName}` : fieldName;
+        const val = computeValue(value, arrayLengthMap, newPath);
+        if (val !== undefined) {
+            result[fieldName] = val;
+        }
+    }
+    return result;
+}
+/**
+ * Construct array values from array structure.
+ * Mirrors renderArrayCode but executes faker calls instead of generating code.
+ */
+function constructArrayValues(arrayStructure, arrayLengthMap, currentPath) {
+    const elementType = arrayStructure.elementType;
+    // Get array length for this dimension
+    let arrayLength = DEFAULT_ARRAY_LENGTH;
+    if (arrayLengthMap[currentPath] !== undefined) {
+        arrayLength = arrayLengthMap[currentPath];
+    }
+    const result = [];
+    for (let i = 0; i < arrayLength; i++) {
+        result.push(computeValue(elementType, arrayLengthMap, currentPath));
+    }
+    return result;
+}
+/**
+ * Prepare faker arguments for execution.
+ * Converts FakerArg[] to actual values that can be passed to faker methods.
+ */
+function prepareFakerArgs(fakerArgs) {
+    const preparedArgs = [];
+    for (const arg of fakerArgs) {
+        if (typeof arg === 'string' ||
+            typeof arg === 'number' ||
+            typeof arg === 'boolean') {
+            preparedArgs.push(arg);
+        }
+        else if (typeof arg === 'object' && arg !== null && 'json' in arg) {
+            // Parse JSON objects
+            try {
+                const jsonArg = arg;
+                preparedArgs.push(JSON.parse(jsonArg.json));
+            }
+            catch {
+                // Skip invalid JSON
+                continue;
+            }
+        }
+    }
+    return preparedArgs;
+}
+/**
+ * Execute faker method to generate actual values.
+ * Mirrors generateFakerCall but executes the call instead of generating code.
+ */
+function generateFakerValue(mapping) {
+    const method = mapping.fakerMethod === types_1.UNRECOGNIZED_FAKER_METHOD
+        ? getDefaultFakerMethod(mapping.mongoType)
+        : mapping.fakerMethod;
+    try {
+        // Navigate to the faker method
+        const methodParts = method.split('.');
+        let fakerMethod = en_1.faker;
+        for (const part of methodParts) {
+            fakerMethod = fakerMethod[part];
+            if (!fakerMethod) {
+                throw new Error(`Faker method not found: ${method}`);
+            }
+        }
+        // Prepare arguments
+        const args = prepareFakerArgs(mapping.fakerArgs);
+        // Call the faker method
+        const result = fakerMethod.apply(en_1.faker, args);
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import type { PrimitiveSchemaType } from '@mongodb-js/mongodb-schema';
+/** A MongoDB primitive type name, as reported by schema analysis. */
+export type MongoDBFieldType = PrimitiveSchemaType['name'];
+/** Sentinel used when the LLM does not map a field to a known faker method. */
+export declare const UNRECOGNIZED_FAKER_METHOD = "Unrecognized";
+export type FakerArg = string | number | boolean | {
+    json: string;
+} | FakerArg[];
+export type ArrayLengthMap = Record<string, number>;
+export interface ScriptOptions {
+    documentCount: number;
+    databaseName: string;
+    collectionName: string;
+    arrayLengthMap?: ArrayLengthMap;
+}
+export interface FakerFieldMapping {
+    mongoType: MongoDBFieldType;
+    fakerMethod: string;
+    fakerArgs: FakerArg[];
+    probability?: number;
+}
+export type FakerSchema = Record<string, FakerFieldMapping>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,qEAAqE;AACrE,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAC;AAE3D,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB,iBAAiB,CAAC;AAExD,MAAM,MAAM,QAAQ,GAClB,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,QAAQ,EAAE,CAAC;AAM5D,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,gBAAgB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNRECOGNIZED_FAKER_METHOD = void 0;
+/** Sentinel used when the LLM does not map a field to a known faker method. */
+exports.UNRECOGNIZED_FAKER_METHOD = 'Unrecognized';