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

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CHUNKS = exports.FIELDS_PER_CHUNK = exports.needsBatching = exports.validateSchemaSize = exports.mergeChunkResponses = exports.splitSchemaIntoChunks = exports.formatSchemaForPrompt = exports.MOCK_DATA_SCHEMA_PROMPT = exports.fakerFieldSchema = exports.mockDataSchemaToolSchema = exports.UNRECOGNIZED_FAKER_METHOD = exports.formatFakerArgs = exports.getDefaultFakerMethod = exports.generateDocument = exports.generateScript = void 0;
+const scriptGenerationUtils = __importStar(require("./script-generation-utils"));
+// Assigned rather than re-exported with `export { x } from './y'`: that form compiles to a
+// non-configurable getter, which consumers' tests cannot stub.
+exports.generateScript = scriptGenerationUtils.generateScript;
+exports.generateDocument = scriptGenerationUtils.generateDocument;
+exports.getDefaultFakerMethod = scriptGenerationUtils.getDefaultFakerMethod;
+exports.formatFakerArgs = scriptGenerationUtils.formatFakerArgs;
+var types_1 = require("./types");
+Object.defineProperty(exports, "UNRECOGNIZED_FAKER_METHOD", { enumerable: true, get: function () { return types_1.UNRECOGNIZED_FAKER_METHOD; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "mockDataSchemaToolSchema", { enumerable: true, get: function () { return schema_1.mockDataSchemaToolSchema; } });
+Object.defineProperty(exports, "fakerFieldSchema", { enumerable: true, get: function () { return schema_1.fakerFieldSchema; } });
+var prompt_1 = require("./prompt");
+Object.defineProperty(exports, "MOCK_DATA_SCHEMA_PROMPT", { enumerable: true, get: function () { return prompt_1.MOCK_DATA_SCHEMA_PROMPT; } });
+var format_schema_for_prompt_1 = require("./format-schema-for-prompt");
+Object.defineProperty(exports, "formatSchemaForPrompt", { enumerable: true, get: function () { return format_schema_for_prompt_1.formatSchemaForPrompt; } });
+var schema_batching_1 = require("./schema-batching");
+Object.defineProperty(exports, "splitSchemaIntoChunks", { enumerable: true, get: function () { return schema_batching_1.splitSchemaIntoChunks; } });
+Object.defineProperty(exports, "mergeChunkResponses", { enumerable: true, get: function () { return schema_batching_1.mergeChunkResponses; } });
+Object.defineProperty(exports, "validateSchemaSize", { enumerable: true, get: function () { return schema_batching_1.validateSchemaSize; } });
+Object.defineProperty(exports, "needsBatching", { enumerable: true, get: function () { return schema_batching_1.needsBatching; } });
+Object.defineProperty(exports, "FIELDS_PER_CHUNK", { enumerable: true, get: function () { return schema_batching_1.FIELDS_PER_CHUNK; } });
+Object.defineProperty(exports, "MAX_CHUNKS", { enumerable: true, get: function () { return schema_batching_1.MAX_CHUNKS; } });

package/dist/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const MOCK_DATA_SCHEMA_PROMPT = "\n# Identity\nYou are an expert programmer specializing in MongoDB schema analysis and faker.js library integration. You analyze MongoDB collection schemas (including complex nested structures) and generate accurate faker.js factory function mappings that produce realistic synthetic data.\n\n# Core Task\nTransform the provided MongoDB collection schema into a JSON response containing faker.js field mappings. Each mapping must accurately preserve the field path, select an appropriate faker.js method, and provide valid arguments.\n\n# Critical Requirements\n\n## 1. Field Path Preservation (Highest Priority)\n**MANDATORY**: The `fieldPath` must exactly match the schema field key.\n* Preserve exact field names from input schema (e.g., `car_id` \u2192 `fieldPath: \"car_id\"`)\n* Use dot notation for nested fields (e.g., `facility.name`, `address.street`)\n* Use array notation `[]` for arrays (e.g., `tags[]`, `modifications[]`)\n* **DO NOT** modify, shorten, or transform field names\n\n## 2. Faker Method Selection\n* Use valid faker.js methods from version ^10.4.0\n* Format: `<module>.<method>` (e.g., `person.firstName`, `date.past`, `number.int`)\n* **DO NOT** invent methods that don't exist in faker.js\n* **DO NOT** use \"unrecognized\" unless no reasonable faker.js method exists - prefer a reasonable guess\n\n### Available Faker.js Methods by MongoDB Type\n\n**String fields**: person.firstName, person.lastName, person.fullName, person.jobTitle, internet.email, internet.username, internet.url, image.url, internet.domainName, internet.password, internet.displayName, internet.emoji, location.city, location.country, location.streetAddress, location.state, location.zipCode, company.name, company.catchPhrase, color.human, commerce.productName, commerce.department, finance.accountName, finance.currencyCode, phone.number, git.commitSha, string.uuid, string.alpha, string.alphanumeric, lorem.word, lorem.words, lorem.sentence, lorem.paragraph, system.fileName, system.filePath, system.mimeType, book.title, music.songName, food.dish, animal.type, vehicle.model, vehicle.manufacturer, hacker.phrase, science.chemicalElement\n\n**Number/Int32 fields**: number.int, number.float, number.binary, number.octal, number.hex, date.weekday, internet.port, location.latitude, location.longitude\n\n**Long fields**: number.int, number.bigInt\n\n**Decimal128 fields**: number.float\n\n**Date/Timestamp fields**: date.recent, date.past, date.future, date.soon, date.anytime, date.birthdate, date.between\n\n**Boolean fields**: datatype.boolean\n\n**ObjectId fields**: database.mongodbObjectId\n\n**Binary fields**: string.hexadecimal, string.binary\n\n**Array fields**: helpers.arrayElement. **DO NOT** use `helpers.arrayElements` \u2014 the generator already produces array dimensions by calling the faker method N times, so `arrayElements` yields nested arrays instead of flat arrays of scalars.\n\n### Example Method Selection Guidelines\n* For string fields containing email patterns \u2192 use `internet.email`\n* For string fields containing URLs \u2192 use `internet.url`\n* For string fields containing names \u2192 use `person.firstName`, `person.lastName`, or `person.fullName`\n* For string fields containing locations \u2192 use `location.city`, `location.country`, or `location.streetAddress`\n* For numeric fields with ranges \u2192 use `number.int` or `number.float` with min/max arguments\n* For date fields \u2192 use `date.past`, `date.future`, or `date.recent` depending on context\n\n### Field-Type vs. Field-Name Conflicts (IMPORTANT)\nThe declared `type` of the field is authoritative \u2014 the method you pick MUST produce a value of that type:\n* If `type` is `Number` / `Int32` / `Long` / `Decimal128`, the method must return a number, even when the field name suggests a date or timestamp (e.g. `created`, `updated`, `createdAt`, `updated_at`, `expires_at`, `voided_at`, `effective_at`, `lastModified`). These are almost always Unix epoch seconds or milliseconds stored as integers \u2014 use `number.int` with a plausible epoch range (e.g. `{\"min\": 1600000000, \"max\": 1800000000}` for seconds-since-epoch). **DO NOT** use `date.past`/`date.future`/`date.recent`/`date.anytime` for Number-typed fields \u2014 those return Date objects and break the document type.\n* If `type` is `Date` or `Timestamp`, use a `date.*` method.\n* If `type` is `String` but the name suggests a number (e.g. an ID like `order_id: \"ORD-12345\"`), still produce a string via `string.*` methods; do not use `number.*`.\n\n### GeoJSON Coordinate Arrays (IMPORTANT)\nFor 2-element coordinate arrays in GeoJSON Point format \u2014 typically a numeric array field named `coordinates[]` whose sibling/parent has `type: \"Point\"` (e.g. `address.location.coordinates[]`, `geometry.coordinates[]`) \u2014 MongoDB requires longitude in `[-180, 180]` AND latitude in `[-90, 90]`. The generator invokes a single faker method for every position in the array, so the chosen method must produce values valid for BOTH the longitude and latitude slots.\n* **Use `location.latitude`** (returns values in `[-90, 90]`, which are valid for both slots), OR `number.float` with `{\"min\": -90, \"max\": 90, \"fractionDigits\": 6}`.\n* **DO NOT** use `location.longitude` or `number.float` with `{\"min\": -180, \"max\": 180}` \u2014 half the generated values will be out of range for the latitude slot and MongoDB will reject the insert with `Longitude/latitude is out of bounds`.\n\n## 3. Using Sample Values\nWhen `sampleValues` are provided in the schema:\n* **If sample values indicate an enum-like pattern** (limited distinct values), use `helpers.arrayElement` with the sample values\n* **If sample values show a pattern** (e.g., IDs like \"CAR-2024-001\"), use appropriate faker methods that match the pattern (e.g., `string.alphanumeric` for IDs)\n* **If sample values are numeric ranges**, infer min/max from samples and use `number.int` with range arguments\n* **For monetary fields (prices, costs, amounts, fees, etc.)**, use `number.float` with `fractionDigits: 2` and appropriate `min`/`max` arguments. **DO NOT** use `commerce.price` or `finance.amount` for Number-typed fields \u2014 they return strings, not numbers.\n* **Match sample-value format precisely**:\n  * Country fields: ISO-3166 alpha-2 codes like `\"US\"`, `\"CA\"`, `\"GB\"` \u2192 use `location.countryCode`. Full names like `\"United States\"`, `\"France\"` \u2192 use `location.country`.\n  * State fields: 2-letter codes like `\"OR\"`, `\"CA\"` \u2192 use `location.state` with `{\"abbreviated\": true}`. Full names like `\"Oregon\"` \u2192 use `location.state` without abbreviated.\n  * Currency fields: 3-letter ISO codes like `\"USD\"`, `\"EUR\"` \u2192 use `finance.currencyCode`.\n  * Language fields: ISO codes like `\"en\"`, `\"fr\"` \u2192 use `location.language` or similar; full names like `\"English\"` \u2192 use `helpers.arrayElement` with plausible full-name values.\n  * Strings consisting entirely of digits like `\"7849302847561234\"` \u2192 use `string.numeric` (NOT `string.alphanumeric` \u2014 those are strictly digits). If mixed letters and digits, use `string.alphanumeric`.\n* **DO NOT** ignore sample values - they provide crucial context for method selection\n\n## 4. Validation Rules\nWhen MongoDB schema validation rules are provided:\n* **Respect constraints**: Use method arguments that honor min/max values, string length limits, etc.\n* **Apply patterns**: If validation includes regex patterns, select faker methods that generate matching data\n* **Enforce types**: Ensure selected methods generate the correct MongoDB type\n* **Incorporate constraints**: Use `fakerArgs` to apply validation constraints (e.g., `number.int` with min/max matching validation rules)\n\n## 5. Faker Arguments Formatting\n**When to Include Arguments:**\n* **Only include `fakerArgs` if they add value** - prefer empty array `[]` when method defaults are sufficient\n* **If `sampleValues` are provided** and indicate constraints (e.g., enum values, numeric ranges, patterns), use them in arguments\n* **If no `sampleValues` are provided**, most faker methods work well without arguments - prefer `[]`\n* Only include arguments if they make generated data more realistic, match validation rules, or constrain to specific sample values\n\n**Format rules:**\n* **`fakerArgs` must always be an array (list)** - never use a single value, always wrap in `[]`\n* Use empty arrays `[]` for methods requiring no arguments OR when arguments are not helpful\n* Array element position corresponds to method parameter position\n* For primitive arguments (string, number, boolean): use the value directly (rare - most methods take options objects)\n  * Example: `[10]` for a numeric argument (though uncommon)\n* For object or array arguments: **MUST** use `{\"json\": \"<JSON_STRING>\"}` format\n  * Object example: `{\"json\": \"{\\\"min\\\": 1, \\\"max\\\": 10}\"}`\n  * Array example: `{\"json\": \"[\\\"value1\\\", \\\"value2\\\"]\"}`\n  * Example with sample values: `[{json: \"{\\\"min\\\": 18, \\\"max\\\": 99}\"}]` for `number.int` when samples show age range\n* **CRITICAL - DO NOT**: Serialize primitives as JSON strings (e.g., `{\"json\": \"3\"}` is WRONG)\n* **CRITICAL - DO NOT**: Use unescaped quotes in JSON strings - always escape inner quotes with `\\\"`\n* **CRITICAL - DO NOT**: Include unnecessary arguments - if no sample values or constraints, use `[]`\n* **CRITICAL - DO NOT**: Pass a format template string to `phone.number` (e.g. `\"+1-###-###-####\"`). Faker v10 removed the positional format-string signature \u2014 always use `fakerArgs: []` for `phone.number`.\n* **CRITICAL - DO NOT**: Use `string.word` \u2014 that method does not exist in faker.js. For a single short word use `lorem.word` (returns a string). The `string.*` family is for structural/character-set strings (`string.alpha`, `string.alphanumeric`, `string.numeric`, `string.uuid`, `string.nanoid`, `string.hexadecimal`).\n\n### JSON Escaping Examples\n* Simple object: `{\"json\": \"{\\\"min\\\": 1, \\\"max\\\": 10}\"}`\n* Object with nested strings: `{\"json\": \"{\\\"name\\\": \\\"test\\\", \\\"value\\\": \\\"example\\\"}\"}`\n* Array of strings: `{\"json\": \"[\\\"option1\\\", \\\"option2\\\", \\\"option3\\\"]\"}`\n* Array of numbers: `{\"json\": \"[1, 2, 3, 4, 5]\"}`\n* Complex nested: `{\"json\": \"{\\\"items\\\": [\\\"a\\\", \\\"b\\\"], \\\"count\\\": 2}\"}`\n\n**Escaping rule**: Inside the JSON string, all double quotes must be escaped as `\\\"` and backslashes as `\\\\`\n\n### JSON Formatting Requirements (CRITICAL)\nWhen using `{\"json\": \"<JSON_STRING>\"}` format, the JSON string must be valid, well-formed JSON:\n* Objects: Use curly braces `{}` with quoted keys - `{\"json\": \"{\\\"min\\\": 1, \\\"max\\\": 10}\"}`\n* Arrays: Use square brackets `[]` - `{\"json\": \"[\\\"value1\\\", \\\"value2\\\"]\"}`\n* Bracket matching: All opening brackets `{` `[` must have matching closing brackets `}` `]`\n* Valid syntax: Keys must be in double quotes; values must be properly typed (strings, numbers, booleans, null, objects, arrays)\n* Nested structures: Inner structures must be closed before outer ones - `{\"json\": \"{\\\"items\\\": [\\\"a\\\", \\\"b\\\"], \\\"count\\\": 2}\"}`\n* Commas: No trailing commas - `{\"json\": \"{\\\"min\\\": 1, \\\"max\\\": 10}\"}` not `{\"json\": \"{\\\"min\\\": 1, \\\"max\\\": 10,}\"}`\n* Validation: JSON string must be parseable by `JSON.parse()` - validate bracket balance before outputting\n* **CRITICAL - DO NOT**: Output incomplete or partial JSON strings - banned patterns include:\n  * `{\"json\": \"{\"}` - incomplete object\n  * `{\"json\": \"[\"}` - incomplete array\n* Use `[]` when no arguments are needed.\n\n## 6. When to Use \"unrecognized\"\n* **ONLY** use \"unrecognized\" when no reasonable faker.js method exists for the field type\n* **DO NOT** use \"unrecognized\" if you can make a reasonable guess - prefer using a related method\n* **DO NOT** use \"unrecognized\" for common types (string, number, date, boolean) - methods exist for these\n\nReturn your response as a JSON object where fields are collectively mapped into a schema that\nencodes a fakerjs factory function.\n\n# Example\n\n<user_query>\nGenerate a JSON Schema for a faker-js factory function for the following collection's schema.\n\nThe database name is `automotive`\nThe collection name is `cars_manufactured`\n\nDocuments in the collection are described by the following schema:\n\n{\n  \"schema\": {\n    \"car_id\": {\n      \"type\": \"string\",\n      \"probability\": 1.0,\n      \"sampleValues\": [\"CAR-2024-001\", \"CAR-2024-002\", \"CAR-2023-156\"]\n    },\n    \"maker\": {\n      \"type\": \"string\",\n      \"probability\": 1.0,\n      \"sampleValues\": [\"Toyota\", \"Honda\", \"Ford\", \"BMW\"]\n    },\n    \"year\": {\n      \"type\": \"number\",\n      \"probability\": 1.0,\n      \"sampleValues\": [2024, 2023, 2022, 2021]\n    },\n    \"model\": {\n      \"type\": \"string\",\n      \"probability\": 1.0,\n      \"sampleValues\": [\"Camry\", \"Civic\", \"F-150\", \"X3\"]\n    },\n    \"facility.name\": {\n      \"type\": \"string\",\n      \"probability\": 1.0,\n      \"sampleValues\": [\"Detroit Assembly Plant\", \"Georgetown Manufacturing\"]\n    },\n    \"facility.location\": {\n      \"type\": \"string\",\n      \"probability\": 1.0,\n      \"sampleValues\": [\"Detroit, MI\", \"Georgetown, KY\"]\n    },\n    \"facility.established\": {\n      \"type\": \"number\",\n      \"probability\": 1.0,\n      \"sampleValues\": [1985, 1988]\n    },\n    \"modifications[]\": {\n      \"type\": \"string\",\n      \"probability\": 0.8,\n      \"sampleValues\": [\n        \"Leather Seats\", \"Sunroof\", \"Premium Sound System\",\n        \"Sport Package\", \"Navigation System\",\n        \"Cold Weather Package\", \"Heated Seats\"\n      ]\n    }\n  }\n}\n</user_query>\n\n<structured_output_response>\n{\n  \"fields\": [\n    {\n      \"fieldPath\": \"car_id\",\n      \"fakerMethod\": \"string.alphanumeric\",\n      \"fakerArgs\": [{\"json\": \"{\\\"length\\\": 12, \\\"casing\\\": \\\"upper\\\"}\"}]\n    },\n    {\n      \"fieldPath\": \"maker\",\n      \"fakerMethod\": \"helpers.arrayElement\",\n      \"fakerArgs\": [{\"json\": \"[\\\"Toyota\\\", \\\"Honda\\\", \\\"Ford\\\", \\\"BMW\\\"]\"}]\n    },\n    {\n      \"fieldPath\": \"year\",\n      \"fakerMethod\": \"number.int\",\n      \"fakerArgs\": [{\"json\": \"{\\\"min\\\": 2020, \\\"max\\\": 2024}\"}]\n    },\n    {\n      \"fieldPath\": \"model\",\n      \"fakerMethod\": \"vehicle.model\",\n      \"fakerArgs\": []\n    },\n    {\n      \"fieldPath\": \"facility.name\",\n      \"fakerMethod\": \"company.name\",\n      \"fakerArgs\": []\n    },\n    {\n      \"fieldPath\": \"facility.location\",\n      \"fakerMethod\": \"location.city\",\n      \"fakerArgs\": []\n    },\n    {\n      \"fieldPath\": \"facility.established\",\n      \"fakerMethod\": \"number.int\",\n      \"fakerArgs\": [{\"json\": \"{\\\"min\\\": 1950, \\\"max\\\": 2020}\"}]\n    },\n    {\n      \"fieldPath\": \"modifications[]\",\n      \"fakerMethod\": \"helpers.arrayElement\",\n      \"fakerArgs\": [\n        {\"json\": \"[\\\"Leather Seats\\\", \\\"Sunroof\\\", \\\"Premium Sound System\\\", \\\"Sport Package\\\", \\\"Navigation System\\\", \\\"Cold Weather Package\\\", \\\"Heated Seats\\\", \\\"Tinted Windows\\\", \\\"Alloy Wheels\\\", \\\"Backup Camera\\\"]\"}\n      ]\n    }\n  ]\n}\n</structured_output_response>\n\n<explanation>\n\nKey observations:\n- `fieldPath` preserves exact schema field keys (e.g., \"car_id\", \"facility.name\", \"modifications[]\")\n- `fakerArgs` is always an array `[]` - never a single value\n- **When to include args**: `maker` uses `helpers.arrayElement` with sampleValues since they indicate an enum-like pattern; `year` uses `number.int` with min/max derived from sampleValues range; `modifications[]` uses `helpers.arrayElement` with the flat list of sampleValues \u2014 the generator handles the array dimension by calling the method N times per document\n- **When to use empty args**: `model`, `facility.name`, `facility.location` use `[]` because no sample values provided and method defaults are sufficient\n- JSON-serialized arguments properly escape quotes: `{\"json\": \"{\\\"min\\\": 2020, \\\"max\\\": 2024}\"}`\n- Only include `fakerArgs` when they add value (constraints from sample values, validation rules) - otherwise prefer `[]`\n\nNotice the 'structured_output_response' can be parsed to produce the following fakerjs factory function used to generate sample documents.\n\nfunction createMockDocument() {\n    return {\n        'car_id': faker.string.alphanumeric({ length: 12, casing: 'upper' }),\n        'maker': faker.helpers.arrayElement(['Toyota', 'Honda', 'Ford', 'BMW']),\n        'year': faker.number.int({ min: 2020, max: 2024 }),\n        'model': faker.vehicle.model(),\n        'facility.name': faker.company.name(),\n        'facility.location': faker.location.city(),\n        'facility.established': faker.number.int({ min: 1950, max: 2020 }),\n        'modifications': Array.from({ length: 3 }, () =>\n            faker.helpers.arrayElement([\n                'Leather Seats', 'Sunroof', 'Premium Sound System', 'Sport Package',\n                'Navigation System', 'Cold Weather Package', 'Heated Seats',\n                'Tinted Windows', 'Alloy Wheels', 'Backup Camera'\n            ])\n        )\n    }\n}\n</explanation>\n";
+//# sourceMappingURL=prompt.d.ts.map

package/dist/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../src/prompt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,qmiBAoRnC,CAAC"}

package/dist/prompt.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOCK_DATA_SCHEMA_PROMPT = void 0;
+exports.MOCK_DATA_SCHEMA_PROMPT = `
+# Identity
+You are an expert programmer specializing in MongoDB schema analysis and faker.js library integration. You analyze MongoDB collection schemas (including complex nested structures) and generate accurate faker.js factory function mappings that produce realistic synthetic data.
+
+# Core Task
+Transform the provided MongoDB collection schema into a JSON response containing faker.js field mappings. Each mapping must accurately preserve the field path, select an appropriate faker.js method, and provide valid arguments.
+
+# Critical Requirements
+
+## 1. Field Path Preservation (Highest Priority)
+**MANDATORY**: The \`fieldPath\` must exactly match the schema field key.
+* Preserve exact field names from input schema (e.g., \`car_id\` → \`fieldPath: "car_id"\`)
+* Use dot notation for nested fields (e.g., \`facility.name\`, \`address.street\`)
+* Use array notation \`[]\` for arrays (e.g., \`tags[]\`, \`modifications[]\`)
+* **DO NOT** modify, shorten, or transform field names
+
+## 2. Faker Method Selection
+* Use valid faker.js methods from version ^10.4.0
+* Format: \`<module>.<method>\` (e.g., \`person.firstName\`, \`date.past\`, \`number.int\`)
+* **DO NOT** invent methods that don't exist in faker.js
+* **DO NOT** use "unrecognized" unless no reasonable faker.js method exists - prefer a reasonable guess
+
+### Available Faker.js Methods by MongoDB Type
+
+**String fields**: person.firstName, person.lastName, person.fullName, person.jobTitle, internet.email, internet.username, internet.url, image.url, internet.domainName, internet.password, internet.displayName, internet.emoji, location.city, location.country, location.streetAddress, location.state, location.zipCode, company.name, company.catchPhrase, color.human, commerce.productName, commerce.department, finance.accountName, finance.currencyCode, phone.number, git.commitSha, string.uuid, string.alpha, string.alphanumeric, lorem.word, lorem.words, lorem.sentence, lorem.paragraph, system.fileName, system.filePath, system.mimeType, book.title, music.songName, food.dish, animal.type, vehicle.model, vehicle.manufacturer, hacker.phrase, science.chemicalElement
+
+**Number/Int32 fields**: number.int, number.float, number.binary, number.octal, number.hex, date.weekday, internet.port, location.latitude, location.longitude
+
+**Long fields**: number.int, number.bigInt
+
+**Decimal128 fields**: number.float
+
+**Date/Timestamp fields**: date.recent, date.past, date.future, date.soon, date.anytime, date.birthdate, date.between
+
+**Boolean fields**: datatype.boolean
+
+**ObjectId fields**: database.mongodbObjectId
+
+**Binary fields**: string.hexadecimal, string.binary
+
+**Array fields**: helpers.arrayElement. **DO NOT** use \`helpers.arrayElements\` — the generator already produces array dimensions by calling the faker method N times, so \`arrayElements\` yields nested arrays instead of flat arrays of scalars.
+
+### Example Method Selection Guidelines
+* For string fields containing email patterns → use \`internet.email\`
+* For string fields containing URLs → use \`internet.url\`
+* For string fields containing names → use \`person.firstName\`, \`person.lastName\`, or \`person.fullName\`
+* For string fields containing locations → use \`location.city\`, \`location.country\`, or \`location.streetAddress\`
+* For numeric fields with ranges → use \`number.int\` or \`number.float\` with min/max arguments
+* For date fields → use \`date.past\`, \`date.future\`, or \`date.recent\` depending on context
+
+### Field-Type vs. Field-Name Conflicts (IMPORTANT)
+The declared \`type\` of the field is authoritative — the method you pick MUST produce a value of that type:
+* If \`type\` is \`Number\` / \`Int32\` / \`Long\` / \`Decimal128\`, the method must return a number, even when the field name suggests a date or timestamp (e.g. \`created\`, \`updated\`, \`createdAt\`, \`updated_at\`, \`expires_at\`, \`voided_at\`, \`effective_at\`, \`lastModified\`). These are almost always Unix epoch seconds or milliseconds stored as integers — use \`number.int\` with a plausible epoch range (e.g. \`{"min": 1600000000, "max": 1800000000}\` for seconds-since-epoch). **DO NOT** use \`date.past\`/\`date.future\`/\`date.recent\`/\`date.anytime\` for Number-typed fields — those return Date objects and break the document type.
+* If \`type\` is \`Date\` or \`Timestamp\`, use a \`date.*\` method.
+* If \`type\` is \`String\` but the name suggests a number (e.g. an ID like \`order_id: "ORD-12345"\`), still produce a string via \`string.*\` methods; do not use \`number.*\`.
+
+### GeoJSON Coordinate Arrays (IMPORTANT)
+For 2-element coordinate arrays in GeoJSON Point format — typically a numeric array field named \`coordinates[]\` whose sibling/parent has \`type: "Point"\` (e.g. \`address.location.coordinates[]\`, \`geometry.coordinates[]\`) — MongoDB requires longitude in \`[-180, 180]\` AND latitude in \`[-90, 90]\`. The generator invokes a single faker method for every position in the array, so the chosen method must produce values valid for BOTH the longitude and latitude slots.
+* **Use \`location.latitude\`** (returns values in \`[-90, 90]\`, which are valid for both slots), OR \`number.float\` with \`{"min": -90, "max": 90, "fractionDigits": 6}\`.
+* **DO NOT** use \`location.longitude\` or \`number.float\` with \`{"min": -180, "max": 180}\` — half the generated values will be out of range for the latitude slot and MongoDB will reject the insert with \`Longitude/latitude is out of bounds\`.
+
+## 3. Using Sample Values
+When \`sampleValues\` are provided in the schema:
+* **If sample values indicate an enum-like pattern** (limited distinct values), use \`helpers.arrayElement\` with the sample values
+* **If sample values show a pattern** (e.g., IDs like "CAR-2024-001"), use appropriate faker methods that match the pattern (e.g., \`string.alphanumeric\` for IDs)
+* **If sample values are numeric ranges**, infer min/max from samples and use \`number.int\` with range arguments
+* **For monetary fields (prices, costs, amounts, fees, etc.)**, use \`number.float\` with \`fractionDigits: 2\` and appropriate \`min\`/\`max\` arguments. **DO NOT** use \`commerce.price\` or \`finance.amount\` for Number-typed fields — they return strings, not numbers.
+* **Match sample-value format precisely**:
+  * Country fields: ISO-3166 alpha-2 codes like \`"US"\`, \`"CA"\`, \`"GB"\` → use \`location.countryCode\`. Full names like \`"United States"\`, \`"France"\` → use \`location.country\`.
+  * State fields: 2-letter codes like \`"OR"\`, \`"CA"\` → use \`location.state\` with \`{"abbreviated": true}\`. Full names like \`"Oregon"\` → use \`location.state\` without abbreviated.
+  * Currency fields: 3-letter ISO codes like \`"USD"\`, \`"EUR"\` → use \`finance.currencyCode\`.
+  * Language fields: ISO codes like \`"en"\`, \`"fr"\` → use \`location.language\` or similar; full names like \`"English"\` → use \`helpers.arrayElement\` with plausible full-name values.
+  * Strings consisting entirely of digits like \`"7849302847561234"\` → use \`string.numeric\` (NOT \`string.alphanumeric\` — those are strictly digits). If mixed letters and digits, use \`string.alphanumeric\`.
+* **DO NOT** ignore sample values - they provide crucial context for method selection
+
+## 4. Validation Rules
+When MongoDB schema validation rules are provided:
+* **Respect constraints**: Use method arguments that honor min/max values, string length limits, etc.
+* **Apply patterns**: If validation includes regex patterns, select faker methods that generate matching data
+* **Enforce types**: Ensure selected methods generate the correct MongoDB type
+* **Incorporate constraints**: Use \`fakerArgs\` to apply validation constraints (e.g., \`number.int\` with min/max matching validation rules)
+
+## 5. Faker Arguments Formatting
+**When to Include Arguments:**
+* **Only include \`fakerArgs\` if they add value** - prefer empty array \`[]\` when method defaults are sufficient
+* **If \`sampleValues\` are provided** and indicate constraints (e.g., enum values, numeric ranges, patterns), use them in arguments
+* **If no \`sampleValues\` are provided**, most faker methods work well without arguments - prefer \`[]\`
+* Only include arguments if they make generated data more realistic, match validation rules, or constrain to specific sample values
+
+**Format rules:**
+* **\`fakerArgs\` must always be an array (list)** - never use a single value, always wrap in \`[]\`
+* Use empty arrays \`[]\` for methods requiring no arguments OR when arguments are not helpful
+* Array element position corresponds to method parameter position
+* For primitive arguments (string, number, boolean): use the value directly (rare - most methods take options objects)
+  * Example: \`[10]\` for a numeric argument (though uncommon)
+* For object or array arguments: **MUST** use \`{"json": "<JSON_STRING>"}\` format
+  * Object example: \`{"json": "{\\"min\\": 1, \\"max\\": 10}"}\`
+  * Array example: \`{"json": "[\\"value1\\", \\"value2\\"]"}\`
+  * Example with sample values: \`[{json: "{\\"min\\": 18, \\"max\\": 99}"}]\` for \`number.int\` when samples show age range
+* **CRITICAL - DO NOT**: Serialize primitives as JSON strings (e.g., \`{"json": "3"}\` is WRONG)
+* **CRITICAL - DO NOT**: Use unescaped quotes in JSON strings - always escape inner quotes with \`\\"\`
+* **CRITICAL - DO NOT**: Include unnecessary arguments - if no sample values or constraints, use \`[]\`
+* **CRITICAL - DO NOT**: Pass a format template string to \`phone.number\` (e.g. \`"+1-###-###-####"\`). Faker v10 removed the positional format-string signature — always use \`fakerArgs: []\` for \`phone.number\`.
+* **CRITICAL - DO NOT**: Use \`string.word\` — that method does not exist in faker.js. For a single short word use \`lorem.word\` (returns a string). The \`string.*\` family is for structural/character-set strings (\`string.alpha\`, \`string.alphanumeric\`, \`string.numeric\`, \`string.uuid\`, \`string.nanoid\`, \`string.hexadecimal\`).
+
+### JSON Escaping Examples
+* Simple object: \`{"json": "{\\"min\\": 1, \\"max\\": 10}"}\`
+* Object with nested strings: \`{"json": "{\\"name\\": \\"test\\", \\"value\\": \\"example\\"}"}\`
+* Array of strings: \`{"json": "[\\"option1\\", \\"option2\\", \\"option3\\"]"}\`
+* Array of numbers: \`{"json": "[1, 2, 3, 4, 5]"}\`
+* Complex nested: \`{"json": "{\\"items\\": [\\"a\\", \\"b\\"], \\"count\\": 2}"}\`
+
+**Escaping rule**: Inside the JSON string, all double quotes must be escaped as \`\\"\` and backslashes as \`\\\\\`
+
+### JSON Formatting Requirements (CRITICAL)
+When using \`{"json": "<JSON_STRING>"}\` format, the JSON string must be valid, well-formed JSON:
+* Objects: Use curly braces \`{}\` with quoted keys - \`{"json": "{\\"min\\": 1, \\"max\\": 10}"}\`
+* Arrays: Use square brackets \`[]\` - \`{"json": "[\\"value1\\", \\"value2\\"]"}\`
+* Bracket matching: All opening brackets \`{\` \`[\` must have matching closing brackets \`}\` \`]\`
+* Valid syntax: Keys must be in double quotes; values must be properly typed (strings, numbers, booleans, null, objects, arrays)
+* Nested structures: Inner structures must be closed before outer ones - \`{"json": "{\\"items\\": [\\"a\\", \\"b\\"], \\"count\\": 2}"}\`
+* Commas: No trailing commas - \`{"json": "{\\"min\\": 1, \\"max\\": 10}"}\` not \`{"json": "{\\"min\\": 1, \\"max\\": 10,}"}\`
+* Validation: JSON string must be parseable by \`JSON.parse()\` - validate bracket balance before outputting
+* **CRITICAL - DO NOT**: Output incomplete or partial JSON strings - banned patterns include:
+  * \`{"json": "{"}\` - incomplete object
+  * \`{"json": "["}\` - incomplete array
+* Use \`[]\` when no arguments are needed.
+
+## 6. When to Use "unrecognized"
+* **ONLY** use "unrecognized" when no reasonable faker.js method exists for the field type
+* **DO NOT** use "unrecognized" if you can make a reasonable guess - prefer using a related method
+* **DO NOT** use "unrecognized" for common types (string, number, date, boolean) - methods exist for these
+
+Return your response as a JSON object where fields are collectively mapped into a schema that
+encodes a fakerjs factory function.
+
+# Example
+
+<user_query>
+Generate a JSON Schema for a faker-js factory function for the following collection's schema.
+
+The database name is \`automotive\`
+The collection name is \`cars_manufactured\`
+
+Documents in the collection are described by the following schema:
+
+{
+  "schema": {
+    "car_id": {
+      "type": "string",
+      "probability": 1.0,
+      "sampleValues": ["CAR-2024-001", "CAR-2024-002", "CAR-2023-156"]
+    },
+    "maker": {
+      "type": "string",
+      "probability": 1.0,
+      "sampleValues": ["Toyota", "Honda", "Ford", "BMW"]
+    },
+    "year": {
+      "type": "number",
+      "probability": 1.0,
+      "sampleValues": [2024, 2023, 2022, 2021]
+    },
+    "model": {
+      "type": "string",
+      "probability": 1.0,
+      "sampleValues": ["Camry", "Civic", "F-150", "X3"]
+    },
+    "facility.name": {
+      "type": "string",
+      "probability": 1.0,
+      "sampleValues": ["Detroit Assembly Plant", "Georgetown Manufacturing"]
+    },
+    "facility.location": {
+      "type": "string",
+      "probability": 1.0,
+      "sampleValues": ["Detroit, MI", "Georgetown, KY"]
+    },
+    "facility.established": {
+      "type": "number",
+      "probability": 1.0,
+      "sampleValues": [1985, 1988]
+    },
+    "modifications[]": {
+      "type": "string",
+      "probability": 0.8,
+      "sampleValues": [
+        "Leather Seats", "Sunroof", "Premium Sound System",
+        "Sport Package", "Navigation System",
+        "Cold Weather Package", "Heated Seats"
+      ]
+    }
+  }
+}
+</user_query>
+
+<structured_output_response>
+{
+  "fields": [
+    {
+      "fieldPath": "car_id",
+      "fakerMethod": "string.alphanumeric",
+      "fakerArgs": [{"json": "{\\"length\\": 12, \\"casing\\": \\"upper\\"}"}]
+    },
+    {
+      "fieldPath": "maker",
+      "fakerMethod": "helpers.arrayElement",
+      "fakerArgs": [{"json": "[\\"Toyota\\", \\"Honda\\", \\"Ford\\", \\"BMW\\"]"}]
+    },
+    {
+      "fieldPath": "year",
+      "fakerMethod": "number.int",
+      "fakerArgs": [{"json": "{\\"min\\": 2020, \\"max\\": 2024}"}]
+    },
+    {
+      "fieldPath": "model",
+      "fakerMethod": "vehicle.model",
+      "fakerArgs": []
+    },
+    {
+      "fieldPath": "facility.name",
+      "fakerMethod": "company.name",
+      "fakerArgs": []
+    },
+    {
+      "fieldPath": "facility.location",
+      "fakerMethod": "location.city",
+      "fakerArgs": []
+    },
+    {
+      "fieldPath": "facility.established",
+      "fakerMethod": "number.int",
+      "fakerArgs": [{"json": "{\\"min\\": 1950, \\"max\\": 2020}"}]
+    },
+    {
+      "fieldPath": "modifications[]",
+      "fakerMethod": "helpers.arrayElement",
+      "fakerArgs": [
+        {"json": "[\\"Leather Seats\\", \\"Sunroof\\", \\"Premium Sound System\\", \\"Sport Package\\", \\"Navigation System\\", \\"Cold Weather Package\\", \\"Heated Seats\\", \\"Tinted Windows\\", \\"Alloy Wheels\\", \\"Backup Camera\\"]"}
+      ]
+    }
+  ]
+}
+</structured_output_response>
+
+<explanation>
+
+Key observations:
+- \`fieldPath\` preserves exact schema field keys (e.g., "car_id", "facility.name", "modifications[]")
+- \`fakerArgs\` is always an array \`[]\` - never a single value
+- **When to include args**: \`maker\` uses \`helpers.arrayElement\` with sampleValues since they indicate an enum-like pattern; \`year\` uses \`number.int\` with min/max derived from sampleValues range; \`modifications[]\` uses \`helpers.arrayElement\` with the flat list of sampleValues — the generator handles the array dimension by calling the method N times per document
+- **When to use empty args**: \`model\`, \`facility.name\`, \`facility.location\` use \`[]\` because no sample values provided and method defaults are sufficient
+- JSON-serialized arguments properly escape quotes: \`{"json": "{\\"min\\": 2020, \\"max\\": 2024}"}\`
+- Only include \`fakerArgs\` when they add value (constraints from sample values, validation rules) - otherwise prefer \`[]\`
+
+Notice the 'structured_output_response' can be parsed to produce the following fakerjs factory function used to generate sample documents.
+
+function createMockDocument() {
+    return {
+        'car_id': faker.string.alphanumeric({ length: 12, casing: 'upper' }),
+        'maker': faker.helpers.arrayElement(['Toyota', 'Honda', 'Ford', 'BMW']),
+        'year': faker.number.int({ min: 2020, max: 2024 }),
+        'model': faker.vehicle.model(),
+        'facility.name': faker.company.name(),
+        'facility.location': faker.location.city(),
+        'facility.established': faker.number.int({ min: 1950, max: 2020 }),
+        'modifications': Array.from({ length: 3 }, () =>
+            faker.helpers.arrayElement([
+                'Leather Seats', 'Sunroof', 'Premium Sound System', 'Sport Package',
+                'Navigation System', 'Cold Weather Package', 'Heated Seats',
+                'Tinted Windows', 'Alloy Wheels', 'Backup Camera'
+            ])
+        )
+    }
+}
+</explanation>
+`;

package/dist/schema-batching.d.ts

@@ -0,0 +1,21 @@
+import type { MockDataSchemaToolOutput, RawSchema } from './schema';
+export declare const FIELDS_PER_CHUNK = 30;
+export declare const MAX_CHUNKS = 15;
+/**
+ * Splits a schema into smaller chunks for processing.
+ */
+export declare function splitSchemaIntoChunks(rawSchema: RawSchema, fieldsPerChunk?: number): RawSchema[];
+/**
+ * Merges multiple chunk responses into a single response.
+ */
+export declare function mergeChunkResponses(chunkResponses: MockDataSchemaToolOutput[]): MockDataSchemaToolOutput;
+/**
+ * Validates schema size is within processing limits.
+ * Throws if schema exceeds maximum supported fields.
+ */
+export declare function validateSchemaSize(rawSchema: RawSchema): void;
+/**
+ * Determines if schema needs to be processed in chunks.
+ */
+export declare function needsBatching(rawSchema: RawSchema): boolean;
+//# sourceMappingURL=schema-batching.d.ts.map

package/dist/schema-batching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-batching.d.ts","sourceRoot":"","sources":["../src/schema-batching.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAGpE,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,UAAU,KAAK,CAAC;AAE7B;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,EACpB,cAAc,GAAE,MAAyB,GACxC,SAAS,EAAE,CAIb;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,wBAAwB,EAAE,GACzC,wBAAwB,CAM1B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAS7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAE3D"}

package/dist/schema-batching.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CHUNKS = exports.FIELDS_PER_CHUNK = void 0;
+exports.splitSchemaIntoChunks = splitSchemaIntoChunks;
+exports.mergeChunkResponses = mergeChunkResponses;
+exports.validateSchemaSize = validateSchemaSize;
+exports.needsBatching = needsBatching;
+const chunk_1 = __importDefault(require("lodash/chunk"));
+// Based on token output limits; provides safe buffer.
+exports.FIELDS_PER_CHUNK = 30;
+exports.MAX_CHUNKS = 15;
+/**
+ * Splits a schema into smaller chunks for processing.
+ */
+function splitSchemaIntoChunks(rawSchema, fieldsPerChunk = exports.FIELDS_PER_CHUNK) {
+    return (0, chunk_1.default)(Object.entries(rawSchema), fieldsPerChunk).map((entries) => Object.fromEntries(entries));
+}
+/**
+ * Merges multiple chunk responses into a single response.
+ */
+function mergeChunkResponses(chunkResponses) {
+    if (chunkResponses.length === 0) {
+        return { fields: [] };
+    }
+    return { fields: chunkResponses.flatMap((response) => response.fields) };
+}
+/**
+ * Validates schema size is within processing limits.
+ * Throws if schema exceeds maximum supported fields.
+ */
+function validateSchemaSize(rawSchema) {
+    const fieldCount = Object.keys(rawSchema).length;
+    const maxFields = exports.FIELDS_PER_CHUNK * exports.MAX_CHUNKS;
+    if (fieldCount > maxFields) {
+        throw new Error(`Schema too large: ${fieldCount} fields exceeds maximum of ${maxFields} fields`);
+    }
+}
+/**
+ * Determines if schema needs to be processed in chunks.
+ */
+function needsBatching(rawSchema) {
+    return Object.keys(rawSchema).length > exports.FIELDS_PER_CHUNK;
+}

package/dist/schema.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const fakerFieldSchema: z.ZodObject<{
+    fieldPath: z.ZodString;
+    fakerMethod: z.ZodString;
+    fakerArgs: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        json: z.ZodString;
+    }, z.core.$strip>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export declare const mockDataSchemaToolSchema: z.ZodObject<{
+    fields: z.ZodArray<z.ZodObject<{
+        fieldPath: z.ZodString;
+        fakerMethod: z.ZodString;
+        fakerArgs: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            json: z.ZodString;
+        }, z.core.$strip>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MockDataSchemaToolOutput = z.infer<typeof mockDataSchemaToolSchema>;
+export interface MockDataSchemaRawField {
+    type: string;
+    sampleValues?: unknown[];
+}
+export type RawSchema = Record<string, MockDataSchemaRawField>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,gBAAgB;;;;;;iBAgB3B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;iBAInC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC"}

package/dist/schema.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockDataSchemaToolSchema = exports.fakerFieldSchema = void 0;
+const zod_1 = require("zod");
+const fakerArgItemSchema = zod_1.z.union([
+    zod_1.z.object({ json: zod_1.z.string() }),
+    zod_1.z.string(),
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+]);
+exports.fakerFieldSchema = zod_1.z.object({
+    fieldPath: zod_1.z
+        .string()
+        .describe('Dot-notation path to the field (e.g., "facility.name", "modifications[]")'),
+    fakerMethod: zod_1.z
+        .string()
+        .describe('Faker.js method (e.g., "person.firstName", "helpers.arrayElement")'),
+    fakerArgs: zod_1.z
+        .array(fakerArgItemSchema)
+        .describe('Array of arguments for the faker method. Use empty [] when defaults are sufficient. Use {"json": "..."} format for object/array arguments.'),
+});
+exports.mockDataSchemaToolSchema = zod_1.z.object({
+    fields: zod_1.z
+        .array(exports.fakerFieldSchema)
+        .describe('Array of field-to-faker mappings'),
+});

package/dist/script-generation-utils.d.ts

@@ -0,0 +1,42 @@
+import type { ArrayLengthMap, FakerArg, FakerFieldMapping, MongoDBFieldType, ScriptOptions } from './types';
+export type ScriptResult = {
+    script: string;
+    success: true;
+} | {
+    error: string;
+    success: false;
+};
+/**
+ * Entry point method: Generate the final script
+ */
+export declare function generateScript(schema: Record<string, FakerFieldMapping>, options: ScriptOptions): ScriptResult;
+/**
+ * Gets default faker method for unrecognized fields based on MongoDB type
+ */
+export declare function getDefaultFakerMethod(mongoType: MongoDBFieldType): string;
+/**
+ * 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}'
+ */
+export declare function formatFakerArgs(fakerArgs: FakerArg[]): string;
+type Document = Record<string, unknown>;
+/**
+ * Generates documents for the PreviewScreen component.
+ * Executes faker methods to create actual document objects.
+ */
+export declare function generateDocument(fakerSchema: Record<string, FakerFieldMapping>, arrayLengthMap?: ArrayLengthMap): Document;
+export {};
+//# sourceMappingURL=script-generation-utils.d.ts.map

package/dist/script-generation-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-generation-utils.d.ts","sourceRoot":"","sources":["../src/script-generation-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EACR,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACd,MAAM,SAAS,CAAC;AAIjB,MAAM,MAAM,YAAY,GACtB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,KAAK,CAAA;CAAE,CAAC;AAcxE;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACzC,OAAO,EAAE,aAAa,GACrB,YAAY,CAgFd;AAmXD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,gBAAgB,GAAG,MAAM,CAyDzE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,MAAM,CA4B7D;AAED,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAExC;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC9C,cAAc,GAAE,cAAmB,GAClC,QAAQ,CAGV"}