Building APIs with Python, Flask, and GraphQL

Table of Contents

  1. Overview
  2. Prerequisites
  3. Installation and Setup
  4. Creating a Flask App
  5. Defining GraphQL Schema
  6. Implementing the Resolvers
  7. Testing the API
  8. Conclusion

Overview

In this tutorial, we will learn how to build APIs using Python, Flask, and GraphQL. APIs (Application Programming Interfaces) allow different software applications to communicate with each other and exchange data. Flask is a popular web framework in Python, which provides a lightweight and flexible approach to building web applications. GraphQL is a query language for APIs that offers efficient data fetching and powerful query capabilities.

By the end of this tutorial, you will have a solid understanding of how to set up a Flask app, define a GraphQL schema, implement resolvers, and test your API.

Prerequisites

Before we begin, make sure you have the following prerequisites:

  • Basic knowledge of Python programming language.
  • Familiarity with web development concepts.
  • Python 3.x installed on your machine.
  • Basic understanding of API concepts.

Installation and Setup

First, let’s set up a new project folder and virtual environment for our Flask app.

  1. Create a new directory for your project: mkdir flask-api
  2. Navigate to the project directory: cd flask-api
  3. Create a virtual environment: python3 -m venv venv
  4. Activate the virtual environment:
    • For macOS/Linux: source venv/bin/activate
    • For Windows: venv\Scripts\activate.bat

Now, let’s install Flask and the necessary extensions by running the following command in your project directory: pip install flask flask-graphql graphene-sqlalchemy With the environment set up, we can proceed to build our Flask app.

Creating a Flask App

  1. Create a new Python file called app.py.
  2. Import the necessary modules: 
     from flask import Flask
 from flask_graphql import GraphQLView
 from flask_sqlalchemy import SQLAlchemy
 import graphene
  3. Initialize the Flask app and configure the database: 
     app = Flask(__name__)
 app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db'
 db = SQLAlchemy(app)
  4. Define a database model for your API. For this tutorial, let’s create a simple User model: 
     class User(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(50))
     email = db.Column(db.String(100))
	
     def __repr__(self):
         return self.name
  5. Create a GraphQL schema using the graphene library: 
     class UserSchema(graphene.ObjectType):
     id = graphene.Int()
     name = graphene.String()
     email = graphene.String()
	
 schema = graphene.Schema(query=UserSchema)
  6. Register the GraphQL view in your Flask app: 
     app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
  7. Add a main function to run the app: 
     if __name__ == '__main__':
     app.run(debug=True)

    Defining GraphQL Schema

Now that we have set up the Flask app and defined our database model, let’s define the GraphQL schema.

  1. Open the UserSchema class in app.py and modify it as follows: 
     class UserSchema(graphene.ObjectType):
     id = graphene.Int()
     name = graphene.String()
     email = graphene.String()
	
 class Query(graphene.ObjectType):
     users = graphene.List(UserSchema)
	
     def resolve_users(self, info):
         return User.query.all()
	
 schema = graphene.Schema(query=Query)

    We added a Query class with a users field that returns a list of all users from the database. The resolve_users function retrieves the users from the database using the User.query.all() method.

Implementing the Resolvers

Next, we need to implement the resolvers for our GraphQL schema.

  1. Open the UserSchema class in app.py and modify it as follows: 
     class UserSchema(graphene.ObjectType):
     id = graphene.Int()
     name = graphene.String()
     email = graphene.String()
	
     def resolve_id(self, info):
         return self.id
	
     def resolve_name(self, info):
         return self.name
	
     def resolve_email(self, info):
         return self.email

    The resolve_x methods are responsible for resolving the values of the corresponding fields in the schema. In this case, we simply return the values of the id, name, and email attributes of the User object.

Testing the API

Now that our API is ready, let’s test it using a GraphQL client like GraphiQL or Insomnia.

  1. Start the Flask app by running python app.py in the terminal.
  2. Open a web browser and navigate to http://localhost:5000/graphql.
  3. You should see the GraphiQL interface, which allows you to interact with the API.

  4. Execute the following query in the left pane of GraphiQL:

    {
  users {
    id
    name
    email
  }
}
  5. Click the “Play” button or press Ctrl + Enter to send the query.
  6. You should receive a response with the list of users.

Congratulations! You have successfully built an API using Python, Flask, and GraphQL. You have also learned how to define a GraphQL schema, implement resolvers, and test your API.

Conclusion

In this tutorial, we covered the basics of building APIs with Python, Flask, and GraphQL. We started by setting up a Flask app, defining a GraphQL schema, and implementing resolvers. Finally, we tested the API using a GraphQL client.

Building APIs with Flask and GraphQL provides a flexible and efficient way to handle data fetching and querying in web applications. It enables developers to create APIs that meet the specific needs of their applications and clients.

Now that you have a good understanding of the fundamentals, feel free to explore more advanced features and concepts of Flask and GraphQL to enhance your API-building skills. Happy coding!

Tip: To learn more about Flask and GraphQL, refer to the official documentation and explore additional tutorials and examples available online.

Published:

Related Articles