10 Easy Steps to Effortlessly Build RESTful API CRUD Operations in Ruby on Rails

Building a RESTful API with CRUD (Create, Read, Update, Delete) operations using Ruby on Rails (RoR) can seem daunting at first. However, Rails’ conventions and powerful features make it a smooth and efficient process. In this guide, we’ll walk you through the steps of setting up a RESTful API with CRUD operations using Ruby on Rails, from setting up the environment to deploying the application.

Table of Contents

1. Introduction
2. Setting Up the Environment
3. Creating a New Rails Application
4. Generating a Scaffold
5. Configuring Routes
6. Understanding the Controller Actions
7. Testing the API Endpoints
8. Handling Errors and Validations
9. Securing the API
10. Deploying the Application
11. Conclusion

1. Introduction

RESTful APIs follow a set of principles that allow clients to interact with server-side resources via HTTP requests. CRUD operations represent the four basic functions of persistent storage: Create, Read, Update, and Delete. Ruby on Rails, with its elegant syntax and rich library of features, is an excellent framework for building such APIs.

2. Setting Up the Environment

Before we start, ensure you have the following installed on your machine:

• Ruby (version 2.7.0 or higher)
• Rails (version 6.0 or higher)
• PostgreSQL (or another preferred database)

3. Creating a New Rails Application

Create a new Rails application by running:

rails new blog_api --api -d postgresql
cd blog_api

The --api flag generates a slimmed-down version of Rails specifically for API-only applications. The -d postgresql flag sets PostgreSQL as the database.

4. Generating a Scaffold

Rails scaffolding quickly generates a set of CRUD operations for a resource. Let’s create a scaffold for a Post resource with title and body attributes:

rails generate scaffold Post title:string body:text

This command generates:

• Model (post.rb)
• Database migration (db/migrate)
• Controller (posts_controller.rb)
• Routes
• JSON views

Run the migration to create the posts table in your database:

rails db:create
rails db:migrate

5. Configuring Routes

Rails automatically adds routes for the Post resource. Open config/routes.rb to confirm:

Rails.application.routes.draw do
  resources :posts
end

This sets up RESTful routes for the Post resource.

6. Understanding the Controller Actions

The generated PostsController includes actions for CRUD operations:

• index: Retrieves all posts
• show: Retrieves a single post by ID
• create: Creates a new post
• update: Updates an existing post by ID
• destroy: Deletes a post by ID

Each action corresponds to a specific HTTP method and endpoint:

• GET /posts
• GET /posts/:id
• POST /posts
• PUT/PATCH /posts/:id
• DELETE /posts/:id

7. Testing the API Endpoints

Start the Rails server:

rails server

You can use tools like Postman or curl to test the API endpoints. Here’s how you can test each action:

Create a post:

curl -X POST http://localhost:3000/posts -d "post[title]=First Post&post[body]=This is the body of the first post."

Retrieve all posts:

curl http://localhost:3000/posts

Retrieve a single post:

curl http://localhost:3000/posts/1

Update a post:

curl -X PATCH http://localhost:3000/posts/1 -d "post[title]=Updated Title"

Delete a post:

curl -X DELETE http://localhost:3000/posts/1

8. Handling Errors and Validations

Add validations to the Post model to ensure data integrity. Open app/models/post.rb and add:

class Post < ApplicationRecord
  validates :title, presence: true, length: { minimum: 5 }
  validates :body, presence: true
end

Modify the create and update actions in PostsController to handle invalid data:

def create
  @post = Post.new(post_params)

  if @post.save
    render json: @post, status: :created, location: @post
  else
    render json: @post.errors, status: :unprocessable_entity
  end
end

def update
  if @post.update(post_params)
    render json: @post
  else
    render json: @post.errors, status: :unprocessable_entity
  end
end

9. Securing the API

To secure the API, you can implement authentication. One simple way is to use devise for user authentication and devise-jwt for token-based authentication.

Install the necessary gems:

gem 'devise'
gem 'devise-jwt'

Set up devise:

rails generate devise:install
rails generate devise User
rails db:migrate

Configure devise-jwt in the User model:

class User < ApplicationRecord
  devise :database_authenticatable, :registerable,
         :jwt_authenticatable, jwt_revocation_strategy: JwtDenylist
end

Create the JWT denylist model:

rails generate model JwtDenylist

10. Deploying the Application

To deploy your application, you can use platforms like Heroku. First, ensure your app is ready for production by adding the necessary gems and configurations. Then, deploy to Heroku with the following commands:

heroku create
git push heroku master
heroku run rails db:migrate

11. Conclusion

You’ve now built a RESTful CRUD API with Ruby on Rails. This guide covered setting up a Rails API, generating a scaffold, configuring routes, handling errors and validations, securing the API, and deploying it. With Rails’ powerful tools and conventions, building and maintaining robust APIs becomes an effortless task.

Feel free to extend this application by adding more features, improving security, or integrating it with a frontend framework like React or Vue.js. Happy coding!

The post 10 Easy Steps to Effortlessly Build RESTful API CRUD Operations in Ruby on Rails appeared first on CodeLila.