Introduction:
In the world of Ruby on Rails, developers are often faced with the challenge of building robust and scalable APIs. One powerful tool that comes to the rescue is the Grape gem.
Grape provides a simple and efficient way to create APIs in Ruby, and in this blog, we will explore how to leverage Grape for handling the User Model in a Ruby on Rails application. Specifically, we will focus on creating an API endpoint for managing users at api/v1/users.

What is Grape?
Grape is a micro-framework for creating APIs in Ruby. It is designed to be lightweight, modular, and highly customisable. Grape integrates seamlessly with Ruby on Rails applications, making it an excellent choice for building APIs. With Grape, you can define endpoints, handle requests and responses, and even generate documentation effortlessly.

Setting up Grape in Ruby on Rails:
To begin, make sure you have a Ruby on Rails application set up. You can create a new Rails application by running the following command:

rails new my_app

Next, add the Grape gem to your application's Gemfile:

gem 'grape'

After adding the Grape gem, run bundle install to install the gem and its dependencies.

Creating the User Model:
In this example, we will assume that you already have a User model in your Rails application. If you don't, you can generate one using the following command:

rails generate model User name:string email:string

After generating the User model, run the migration using rails db:migrate to create the corresponding table in the database.

Implementing the User API Endpoint:
Now it's time to create the API endpoint for managing users. In your Rails application's app/api directory, create a new file named v1/users.rb. This file will contain the Grape endpoint definition for the users API.

module V1
  class Users < Grape::API
    version 'v1', using: :path
    format :json

    resource :users do
      desc 'Return a list of users'
      get do
        User.all
      end

      desc 'Return a specific user'
      params do
        requires :id, type: Integer, desc: 'User ID'
      end
      route_param :id do
        get do
          User.find(params[:id])
        end
      end

      desc 'Create a new user'
      params do
        requires :name, type: String, desc: 'User name'
        requires :email, type: String, desc: 'User email'
      end
      post do
        User.create(name: params[:name], email: params[:email])
      end

      desc 'Update an existing user'
      params do
        requires :id, type: Integer, desc: 'User ID'
        optional :name, type: String, desc: 'User name'
        optional :email, type: String, desc: 'User email'
      end
      put ':id' do
        user = User.find(params[:id])
        user.update(name: params[:name], email: params[:email])
        user
      end

      desc 'Delete a user'
      params do
        requires :id, type: Integer, desc: 'User ID'
      end
      delete ':id' do
        user = User.find(params[:id])
        user.destroy
      end
    end
  end
end

This code defines the /api/v1/users endpoint with various HTTP methods:

• GET /api/v1/users - Returns a list of all users.
• GET /api/v1/users/:id - Returns a specific user based on the provided :id.
• POST /api/v1/users - Creates a new user with the given parameters.
• PUT /api/v1/users/:id - Updates an existing user with the provided :id.
• DELETE /api/v1/users/:id - Deletes a user with the given :id.

Mounting the User API Endpoint:
To make the User API endpoint accessible, you need to mount it in your Rails application. Open the config/routes.rb file and add the following line:

mount V1::Users => '/api/v1/users'

This line instructs the Rails application to map the /api/v1/users URL path to the V1::Users Grape API endpoint.

Conclusion:
With the Grape gem, building powerful API endpoints in Ruby on Rails becomes a breeze. In this blog post, we explored how to handle the User model and create an API endpoint at api/v1/users. By following the steps outlined above, you can easily implement CRUD operations for managing users via the API. Grape's simplicity and flexibility make it an excellent choice for building robust APIs in Ruby on Rails.