product iamge

Designing Web APIs with Strapi: Get started with the Strapi headless CMS by building a complete learning management system API

This document was uploaded by one of our users. The uploader already confirmed that they had the permission to publish it. If you are author/publisher or own the copyright of this documents, please report to us by using this DMCA report form.

Download
Search on Amazon

Simply click on the Download Book button.

Yes, Book downloads on Ebookily are 100% Free.

Sometimes the book is free on Amazon As well, so go ahead and hit "Search on Amazon"

Leverage the power of Strapi to build self-hosted, customizable, and performant content APIs

Key Features

  • Discover how Strapi can help you build APIs quickly and focus on your products and features
  • Learn how to put Strapi into practice by implementing it in real-world scenarios
  • Understand how to use Strapi's powerful features to customize your APIs

Book Description

Strapi is a Node.js-based, flexible, open-source headless CMS with an integrated admin panel that anyone can use and helps save API development time. APIs built with Strapi can be consumed using REST or GraphQL from any client. With this book, you'll take a hands-on approach to exploring the capabilities of the Strapi platform and creating a custom API from scratch.

This book will help JavaScript developers to put their knowledge to work by guiding them through building powerful backend APIs. You'll see how to effortlessly create content structures that can be customized according to your needs, and gain insights into how to write, edit, and manage your content seamlessly with Strapi. As you progress through the chapters, you'll discover a wide range of Strapi features, as well as understand how to add complex features to the API such as user authentication, data sorting, and pagination. You'll not only learn how to find and use existing plugins from the open-source community but also build your own plugins with custom functionality with the Strapi plugin API and add them to the admin panel. Finally, you'll learn how to deploy the API to Heroku and AWS.

By the end of this book, you'll be able to build powerful, scalable, and secure APIs using Strapi.

What you will learn

  • Explore Strapi and understand how it works
  • Define content types to build APIs quickly and efficiently
  • Understand authentication and authorization in Strapi
  • Create production-ready APIs with Strapi
  • Deploy the Strapi API to various environments, including Heroku and AWS
  • Use best practices to run the Strapi API in production
  • Sync permissions to access the API between multiple environments
  • Write basic tests for API utilities as well as the endpoint

Who this book is for

This book is for backend and frontend JavaScript developers. Experienced API developers will learn a new, fast, and flexible way of building APIs, while frontend developers will be able to take a step toward becoming full-stack developers by learning how to leverage Strapi for building APIs quickly. Basic knowledge of JavaScript and REST API concepts is assumed.

Table of Contents

  1. An Introduction to Strapi
  2. Building Our First API
  3. Strapi Content-Types
  4. An Overview of the Strapi Admin Panel
  5. Customizing Our API
  6. Dealing with Content
  7. Authentication and Authorization in Strapi
  8. Using and Building Plugins
  9. Production-Ready Applications
  10. Deploying Strapi
  11. Testing the Strapi API
  12. Appendix: Connecting a React App to Strapi

Author(s): Khalid Elshafie, Mozafar Haider
Publisher: Packt Publishing
Year: 2022

Language: English
Pages: 310
Tags: API, Strapi

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Section 1: Understanding Strapi
Chapter 1: An Introduction to Strapi
What is Strapi?
Why use Strapi? (The benefits of Strapi)
Open source Node.js
Database-agnostic
Customizable (extendable)
RESTful and GraphQL
Users and permissions
Preparing the development environment
Installing Node.js
Installing Visual Studio Code (optional)
Installing Yarn
Installing Docker (optional)
Installing Postman
Creating a Strapi application
Overview of the admin panel
Understanding server scripts
The develop script
The start script
The build script
The Strapi script
Summary
Chapter 2: Building Our First API
Exploring the project structure of a Strapi application
The commands to run Strapi
The project structure
Under the hood – the components that make up Strapi
Defining the API requirements
Creating our first content-type – a classroom
Using the Strapi CLI instead of the admin panel
Clarifying Strapi terminology
Content-types, resources, object types, and models
Interacting with the Strapi API
Setting permissions
What did we just create?
Understanding the makeup of a Strapi API
Routes, controllers, services, and models
Content-types in code
Summary
Chapter 3: Strapi Content-Types
What is the Content-Type Builder plugin?
Creating and managing content-types
Creating a title field
Creating a slug field
Creating a type field
Creating url and contents fields
Understanding relations in Strapi
One-way
One-to-one
One-to-many
Many-to-one
Many-to-many
Many-way
Creating a Tutorial and Classroom relation
Creating a tutorial from the admin panel
Interacting with the API endpoints from Postman
Differences between SINGLE TYPES and COMPONENTS
Creating components
Summary
Chapter 4: An Overview of the Strapi Admin Panel
Navigating around the admin panel
Content Manager
PLUGINS
GENERAL
Marketplace
Plugins
Settings
Managing admin users
The difference between Users and admin users
Creating new admin panel users
Managing admin panel roles
Managing content effectively
Searching and filtering to query our data
Customizing the table view
Customizing the details view
Using the Media Library
Media types in API responses
Summary
Section 2: Diving Deeper into Strapi
Chapter 5: Customizing Our API
The routes – where it all starts
The default routes
Disabling a core route
Adding a new route
Handling routes with controllers
Adding a new controller handler for our endpoint
Controllers – it's all about context
Reusing logic with Strapi services
Communicating with the database using the Entity Service API
Returning a unified response
Populating relationships
Sanitizing data – hiding passwords
Overriding the default CRUD APIs
Tweaking database queries and responses with life cycle hooks
Using hooks
DRYing the hook's logic with services
Summary
Chapter 6: Dealing with Content
Creating sample data
Cleaning up
Sorting API content
What about sorting on multiple fields?
Filtering API content
Paginating API content
Under the hood – how it works
Summary
Chapter 7: Authentication and Authorization in Strapi
Understanding the difference between admin users and API users
API login and sign-up
What if I want to change the JWT expiration time?
What if I want to change the JWT secret?
Securing API routes
Under the hood – how it works
Using Strapi roles and permissions
Creating the Student role
Creating the Teacher role
Creating the Admin role
What if I want to change the default role for a new user?
Working with policies
Creating a policy
Honorable mention – OAuth providers
Summary
Chapter 8: Using and Building Plugins
Exploring the Strapi plugin ecosystem
What is a plugin in Strapi?
Installing and using plugins from the Marketplace
Installing the API Documentation plugin from the CLI
Finding more plugins
Use case – Enabling GraphQL for our API
Use case – Sending an email from Strapi
Sending an email using the Email plugin
Plugins and providers
Hooking our API to send an email
Creating our own plugins
Plugin development – frontend versus development
Building our plugin
Updating the model
Building the Enrollments component
Creating an API token
Displaying enrollments in the plugin
Using Strapi Design System
Summary
Section 3: Running Strapi in Production
Chapter 9: Production-Ready Applications
Seeding the database
Keeping permissions in sync
Serving media from an S3 bucket
Using PostgreSQL
Testing PostgreSQL locally
Summary
Chapter 10: Deploying Strapi
Deploying to Heroku
Deploying to AWS Fargate
Step 1 – Creating a Docker image for our API
Step 2 – Creating a Docker repository on AWS ECR
Step 3 – Creating an AWS Fargate cluster
Troubleshooting
Cleaning up
Summary
Chapter 11: Testing the Strapi API
An overview of software testing
Configuring test tools
Setting up the test environment
Preparing the database configuration
Preparing the Strapi instance
Writing and running tests
Testing a public endpoint
Testing a secure endpoint
Summary
Appendix:Connecting a React App to Strapi
About the React app
Understanding the React app folder structure
Running the app
Index
About PACKT
Other Books You May Enjoy