Introduction to Routers in MVC Architecture with FastAPI

Welcome to the fourth lesson of our course on building an image generation service with FastAPI! So far, we've built several key components of our application: the PromptManager for formatting user inputs, the ImageManager for storing and processing images, and the ImageGeneratorService that connects to Google's Gemini API to generate images.

Now, we're ready to add another important layer to our application architecture: the router. In web applications, routers play a crucial role in the Model-View-Controller (MVC) pattern. They act as intermediaries between the service layer (which contains our business logic) and the presentation layer (which handles user interactions).

The router's primary responsibilities include:

• Receiving and validating input from the user interface
• Calling the appropriate service methods with validated inputs
• Handling errors that might occur during processing
• Formatting responses in a consistent way before sending them back to the user

In our image generation application, the router will receive text prompts from users, validate them, pass them to our ImageGeneratorService, and then format the responses (either successful image data or error messages) before sending them back.

By adding this router layer, we're further improving the separation of concerns in our application. The service layer can focus purely on business logic (generating images), while the router handles the specifics of HTTP requests and responses. This makes our code more maintainable, testable, and easier to extend in the future.

Let's start by creating our router class. We'll create a new file called image_generator_router.py in the app/routers directory. This router will depend on our ImageGeneratorService to perform the actual image generation.

Here's how we'll set up the basic structure of our router:

from services.image_generator_service import ImageGeneratorService

class ImageGeneratorRouter:
    def __init__(self):
        self.image_generator_service = ImageGeneratorService()

In this code, we're importing our ImageGeneratorService class that we created in the previous lesson.

The router's constructor initializes an instance of the ImageGeneratorService. This establishes the dependency between our router and service layers. By creating this dependency in the constructor, we're following the principle of dependency injection, which makes our code more modular and easier to test.

Our router will be responsible for two main operations:

1. Generating a new image based on user input
2. Retrieving all previously generated images

For each of these operations, we'll create a dedicated method in our router class. These methods will handle input validation, error handling, and response formatting, ensuring that our API provides a consistent interface to clients.

Now, let's implement the method for generating images. This method will receive user input, validate it, call the service to generate an image, and format the response:

def generate_image(self, user_input):
    if not user_input:
        return {'error': 'Missing input'}, 400
    try:
        base64_image = self.image_generator_service.generate_image(user_input)
        return {'image': base64_image}
    except Exception as e:
        return {'error': str(e)}, 500

Let's break down what's happening in this method:

First, we check if the user_input is empty or None. If it is, we return an error response with a 400 status code (Bad Request), indicating that the client provided invalid input. The response is a tuple containing a dictionary with an 'error' key, and the HTTP status code.

If the input is valid, we enter a try-except block. Within the try block, we call the generate_image method of our service, passing the user input. This method will format the prompt, call the Gemini API, and return the base64-encoded image data.

If the image generation is successful, we return a dictionary with an 'image' key containing the base64 string. This response will have a default status code of 200 (OK) when processed by FastAPI later.

If an exception occurs during image generation, we catch it in the except block and return an error response with a 500 status code (Internal Server Error).

Notice how we're using HTTP status codes to indicate the nature of the response. This is a standard practice in RESTful APIs:

• 200: Success
• 400: Client error (invalid input)
• 500: Server error (something went wrong on our end)

Next, let's implement the method for retrieving all previously generated images:

def get_images(self):
    images = self.image_generator_service.get_all_images()
    return {'images': images}

This method is simpler than the previous one because it doesn't require input validation. We simply call the get_all_images method of our service, which returns a list of all stored images.

We then return a dictionary with an 'images' key containing the list of image objects. Each image object includes an ID, the prompt used to generate it, and the base64-encoded image data.

Now that we've implemented our router, let's test it to make sure it works correctly. We'll update our app/main.py file to use the new router:

from routers.image_generator_router import ImageGeneratorRouter

router = ImageGeneratorRouter()

# Simulate image generation
try:
    response = router.generate_image("Luxury Tech Conference 2025")
    
    # Check if the response is a tuple indicating an error
    if isinstance(response, tuple):
        print(f"Error: {response[0]['error']}")
    else:
        print("Generated Image:")
        print(response['image'])
except Exception as e:
    print(f"Error generating image: {str(e)}")

# Retrieve all images through the router
all_images_response = router.get_images()
print("\nAll Images via Router:")
print(all_images_response)

In this test script, we're creating an instance of our ImageGeneratorRouter and testing both valid and invalid operations. We use isinstance(response, tuple) because our router explicitly returns (dictionary, status_code) for errors, while returning just a dictionary for success.

Let's also test the error handling by trying to generate an image with an empty prompt:

# Test error handling with empty input
empty_response = router.generate_image("")
print("\nEmpty Input Test:")
print(f"Status Code: {empty_response[1]}")
print(f"Response: {empty_response[0]}")

This would produce output like:

Empty Input Test:
Status Code: 400
Response: {'error': 'Missing input'}

This confirms that our router correctly validates input and returns appropriate error responses with status codes.

In this lesson, we've built the ImageGeneratorRouter, which serves as an intermediary between our service layer and the future FastAPI routes. This router handles input validation, error management, and response formatting, providing a clean, consistent interface for clients to interact with our image generation service.

Let's review what we've learned:

1. We understood the role of routers in the MVC architecture and how they fit into our application.
2. We created a router class that depends on our ImageGeneratorService.
3. We implemented methods for generating images and retrieving previously generated ones.
4. We added input validation and error handling to ensure robust operation.
5. We tested our router to verify that it works correctly.

In the next lesson, we'll integrate our router with FastAPI endpoints to create a complete web API for image generation. We'll define routes that clients can call to generate images and retrieve previously generated ones.