Recipe Search and Steps

Welcome back! In the last lesson, you learned how to build basic endpoints to retrieve recipes from your database, including fetching a single recipe by its ID and listing recipes with pagination. These are the building blocks of any recipe API.

Now, let’s take things a step further. Imagine you open a cooking app and want to find recipes that use only the ingredients you have in your kitchen. Or maybe you want to see the steps of a recipe as a list so you can follow them one by one. These features make your app much more helpful and user-friendly.

In this lesson, you’ll learn how to:

• Search for recipes by a list of ingredients.
• Return recipe steps as an array, not just a long string.

These skills will help you build a smarter, more flexible recipe API.

Before we dive in, let’s quickly remind ourselves how our data is organized. This will help you understand how searching and filtering work.

• Recipe: Each recipe has an id, a name, a steps field (which is a string with all the steps), and a list of ingredients.
• Ingredient: Each ingredient has an id and a name. Ingredients are linked to recipes through a many-to-many relationship.
• Review: Each review is linked to a recipe and has a rating.

Here’s a simplified look at the models (from your models.py):

recipe_ingredient = db.Table('recipe_ingredient',
    db.Column('recipe_id', db.Integer, db.ForeignKey('recipe.id'), primary_key=True),
    db.Column('ingredient_id', db.Integer, db.ForeignKey('ingredient.id'), primary_key=True)
)

class Ingredient(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))
    recipes = db.relationship('Recipe', secondary=recipe_ingredient, back_populates='ingredients')

class Recipe(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    ingredients = db.relationship('Ingredient', secondary=recipe_ingredient, back_populates='recipes')
    steps = db.Column(db.Text)

• The recipe_ingredient table connects recipes and ingredients.
• Each recipe can have many ingredients, and each ingredient can be used in many recipes.

This structure is important for searching recipes by ingredients.

Many apps and websites want to show recipe steps one at a time, not as a single long string. To help with this, you can create an endpoint that returns the steps as a list.

First, get the recipe by its ID:

@routes.route('/api/recipes/<int:recipe_id>/steps', methods=['GET'])
def get_recipe_steps_array(recipe_id):
    recipe = Recipe.query.get_or_404(recipe_id)

• get_or_404 will return a 404 error if the recipe does not exist.

Assume the steps are stored as a string, with each step on a new line. You can split this string into a list:

steps = [step.strip() for step in recipe.steps.split('\n') if step.strip()]

• split('\n') breaks the string into lines.
• strip() removes any extra spaces.
• The list comprehension skips any empty lines.

In this step, we use the jsonify function to create a JSON response that includes the recipe’s ID, name, and the list of steps. The jsonify function takes a Python dictionary and converts it into a JSON object, which is the standard format for API responses.

Here’s how you do it:

return jsonify({
    'recipe_id': recipe.id,
    'name': recipe.name,
    'steps': steps
}), 200

Here’s what we return:

• recipe_id: The unique ID of the recipe.
• name: The name of the recipe.
• steps: The list of individual steps, split into an array.

Example output:

{
  "recipe_id": 2,
  "name": "Tomato Basil Soup",
  "steps": [
    "Chop tomatoes.",
    "Add basil.",
    "Simmer for 20 minutes."
  ]
}

This structure allows clients (like web or mobile apps) to easily loop through the steps and present them to users in a clear, step-by-step format.

Let’s say you want to find all recipes that use a specific set of ingredients, like "tomato" and "basil". You’ll need an endpoint that takes a list of ingredient names and returns only the recipes that use all of them.

First, you need to accept a list of ingredient names from the user. In Flask, you can do this by creating a POST endpoint that expects a JSON body.

@routes.route('/api/recipes/by-ingredients', methods=['POST'])
def get_recipes_by_ingredients():
    data = request.get_json()

    if not data or 'ingredients' not in data:
        return jsonify({'error': 'Missing "ingredients" in request'}), 400

    ingredient_names = [name.strip().lower() for name in data['ingredients']]
    if not ingredient_names:
        return jsonify({'error': 'Empty ingredients list'}), 400

• request.get_json() reads the JSON body from the request.
• We check if the "ingredients" key is present and not empty.
• We also convert all ingredient names to lowercase for case-insensitive matching.

Example input:

{
  "ingredients": ["Tomato", "Basil"]
}

Next, you need to find the IDs of the ingredients that match the names provided.

ingredient_ids = [i.id for i in Ingredient.query.filter(func.lower(Ingredient.name).in_(ingredient_names)).all()]
if not ingredient_ids:
    return jsonify([]), 200

• This code looks up all ingredients in the database whose names match the ones in the list.
• If no ingredients are found, we return an empty list.

Now, you want to find recipes that use all the specified ingredients. This is a bit more complex, but here’s how it works:

subquery = (
    db.session.query(
        recipe_ingredient.c.recipe_id,
        func.count(recipe_ingredient.c.ingredient_id).label('match_count')
    )
    .filter(recipe_ingredient.c.ingredient_id.in_(ingredient_ids))
    .group_by(recipe_ingredient.c.recipe_id)
    .subquery()
)

recipes = (
    db.session.query(Recipe)
    .join(subquery, Recipe.id == subquery.c.recipe_id)
    .filter(subquery.c.match_count == len(ingredient_ids))
    .all()
)

• The subquery counts how many of the requested ingredients each recipe uses.
• We then select only those recipes where the count matches the number of ingredients requested. This ensures the recipe uses all the ingredients.

Finally, you return the matching recipes as a JSON list.

result = [{
    'id': recipe.id,
    'name': recipe.name,
    'ingredients': [i.name for i in recipe.ingredients],
    'steps': recipe.steps
} for recipe in recipes]

return jsonify(result), 200

Example output:

[
  {
    "id": 2,
    "name": "Tomato Basil Soup",
    "ingredients": ["Tomato", "Basil", "Garlic"],
    "steps": "Chop tomatoes...\nAdd basil..."
  }
]

If no recipes match, you’ll get an empty list: [].

In this lesson, you learned how to:

• Return recipe steps as an array, making it easier for users to follow each step.
• Search for recipes by a list of ingredients, returning only those that use all the specified ingredients.

These features make your recipe API much more useful and user-friendly. Up next, you’ll get to practice building and testing these endpoints yourself. This hands-on practice will help you solidify your understanding and prepare you for even more advanced features. Good luck!