generate-custom
Generate fake data using custom patterns like regex, enums, formats, and ranges for testing, seeding, and development purposes.
Instructions
Generates fake data following custom patterns, including regex patterns, enums, formats, and ranges
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | Number of records to generate | |
| patterns | Yes | Map of field names to pattern definitions | |
| locale | No | Locale for generated data (affects format-based patterns) | en |
| seed | No | Optional seed for reproducible generation |
Implementation Reference
- src/tools/generate-custom.ts:99-160 (handler)The main handler function for the 'generate-custom' tool. It parses and validates input parameters using the Zod schema, validates patterns, instantiates a CustomGenerator, generates the requested number of records following the specified patterns, and returns an MCP response containing the generated data as a JSON resource with metadata.export function handleGenerateCustom(args: unknown): Promise<{ content: unknown[] }> { const startTime = Date.now(); try { // Validate and parse arguments const params = GenerateCustomSchema.parse(args); // Validate patterns validatePatterns(params.patterns); // Create generator const generator = new CustomGenerator({ seed: params.seed, locale: params.locale, }); // Generate data const data = params.count === 1 ? [generator.generate({ patterns: params.patterns })] : generator.generateMany(params.count, { patterns: params.patterns }); const generationTimeMs = Date.now() - startTime; // Build response const metadata = { count: data.length, patternCount: Object.keys(params.patterns).length, seed: generator.getSeed(), locale: generator.getLocale(), generationTimeMs, }; const responseText = params.seed ? `Generated ${data.length} custom record${data.length > 1 ? 's' : ''} with seed ${params.seed}` : `Generated ${data.length} custom record${data.length > 1 ? 's' : ''}`; return Promise.resolve({ content: [ { type: 'text', text: responseText, }, { type: 'resource', resource: { uri: 'faker://custom/generated', mimeType: 'application/json', text: JSON.stringify({ data, metadata }, null, 2), }, }, ], }); } catch (error) { if (error instanceof z.ZodError) { throw new Error( `Invalid parameters: ${error.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}` ); } throw error; } }
- src/tools/generate-custom.ts:38-51 (schema)Zod validation schema defining the input parameters for the 'generate-custom' tool, including count, patterns (record of field to pattern type/value), locale, and optional seed. Used for validation and JSON Schema generation.export const GenerateCustomSchema = z.object({ count: z.number().min(1).max(10000).default(1).describe('Number of records to generate'), patterns: z .record(z.string(), CustomPatternSchema) .refine((patterns) => Object.keys(patterns).length > 0, { message: 'At least one pattern must be defined', }) .describe('Map of field names to pattern definitions'), locale: z .nativeEnum(SupportedLocale) .default(SupportedLocale.EN) .describe('Locale for generated data (affects format-based patterns)'), seed: z.number().optional().describe('Optional seed for reproducible generation'), });
- src/tools/generate-custom.ts:70-75 (registration)Tool definition object for 'generate-custom' containing the name, description, and inputSchema derived from the Zod schema using zodToJsonSchema. This is passed to the server registration.export const generateCustomTool: Tool = { name: 'generate-custom', description: 'Generates fake data following custom patterns, including regex patterns, enums, formats, and ranges', inputSchema: zodToJsonSchema(GenerateCustomSchema) as Tool['inputSchema'], };
- src/index.ts:31-31 (registration)Server registration of the 'generate-custom' tool, associating the tool definition with its handler function.server.registerTool(generateCustomTool, handleGenerateCustom);
- src/tools/generate-custom.ts:176-201 (helper)Helper function to validate all custom patterns in the input, dispatching to type-specific validators for regex, enum, format, and range patterns. Called by the handler before generation.function validatePatterns( patterns: Record<string, { type: PatternType; value: string | string[] | RangePattern }> ): void { for (const [fieldName, pattern] of Object.entries(patterns)) { try { switch (pattern.type) { case PatternType.REGEX: validateRegexPattern(pattern.value as string); break; case PatternType.ENUM: validateEnumPattern(pattern.value as string[]); break; case PatternType.FORMAT: validateFormatPattern(pattern.value as string); break; case PatternType.RANGE: validateRangePattern(pattern.value as RangePattern); break; default: throw new Error(`Unsupported pattern type`); } } catch (error) { throw new Error(`Invalid pattern for field '${fieldName}': ${(error as Error).message}`); } } }