generate-custom

Instructions

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}`);
      }
    }
  }