REST API with Ruby on Rails: The Complete Guide

Get familiar with the concept of postman application and why it's so useful for API developers.

In this video we'll go through the main interface and will create a first request to get a data of article's collection. It's a first real communication with the application serwer we'll write later in the course.

In this video we'll learn how to create resources using Postman requests and we'll do it by creating the most important one: a user's registration!

Learn one of the most useful tricks for API developers that can give you a huge productivity boost in all of your projects - an automatic documentation from Postman.

In this lesson we're going into more advanced stuff possible with Postman application. In the video I present how to use the access token to authorize requests against our API so it's possible to create and update articles or add article's comments.

Postman allows your productivity to be boosted like crazy and in this lesson we'll cover a first tip how to achieve that. I'll show you how to use environment variables and dynamic content in your requests definition. After that You'll be able to switch between production and development environments with no time!

Summary of what we learned and a presentation of the complete course endpoints collection and API documentation for application we'll build.

In this document you'll find all information you need make most of the Postman Application, together with the whole documentation for this course's API.

In this single video, I'm going through the installation of most of the software used across the class using Mac OS as the operating system.

- Ruby V2.7.2

- Ruby on Rails V6.0.2

- Postgres Server and client

- Postman App

In this lesson, you will learn how to set up a scaffold for an API application and add basic gems that will help us through the whole course.

This lesson is a short introduction for API in general and what is our goal in the next few lessons. After you go through it You'll be more familiar with the API concept and possible types of communication between client and server. You also will understand better all future coding lessons, so I strongly encourage you to check it out.

After watching this video you'll be able to create an article model using the model generator with all necessary attributes. Also, you are going to learn how to add new articles and destroy existing ones.

This lesson is a short introduction to the main functionalities of the RSpec gem, which will take a big part across the whole course.

Here I cover the FactoryBot main features, as we'll use it's features in almost every test example, so it's nice to have the basics covered.

In this video, I show you how to write validation tests for Active Record models.

Here you'll learn how to make our app checking if the articles are valid or not.

Here I show how to test routes in the application which may be useful for bigger apps, with multiple versions support leading to the same controllers.

In this lesson you'll learn how to implement rounting to your list of articles by adding routes, creating controllers and using CRUD actions to pass the routing test (which you are also going to learn how to make during this lecture).

In this lesson, you'll learn how to test your requests in details, with end-to-end expectations, ensuring your application works well  in all cases.

API already returns expected data, but there are returned in the wrong format. Here we'll cover how to make the controller listing articles in a an expected format and which gems could help us with that.

A short note about deprecated serialization gems used in the latter part of the course.

In this lesson you are going to learn how to make the code much shorter, cleaner and overall nicer. We refactor the code to save a lot of time later.

In this episode you'll learn how to make articles being listed in a correct order automatically (from newest to oldest) to simulate the news feed.

Testing if the resources paginate well is a nice skill to have, wherever the performance of the app is important.

After completing this lecture you’ll know how to implement an important performance feature for our API - pagination.

In this video I'll share a way to handle errors in  Rails API applications in the really DRY way.

A short information about the upcoming update of the following episodes.

Here you’ll learn the basics of Oauth flow concept. It’s going to allow you to make a viable authorization method for your application’s users.

This short lesson is a quick guide about creating the Github Oauth application which'll be necessary for our authorization system.

Here you’ll learn how to integrate the authorization engine with your application using a gem “Octokit”  created by the community. Also there’s a lot of useful information about it, so keep an open mind!

In this episode we'll create a fully functional user object that'll be used in our authentication system, articles and comments later on. 

Here you’ll learn about basics of the final authentication service. We handled here the case when user is not authorized. Here also you'll going to improve your TDD skills a lot.

In this lesson we continue with authorization service by covering successed case. To do it we'll “mock” the gem's methods to behave the way we expected. It's a pretty important, so stay tuned!

Here you’ll learn how to implement a feature responsible for completing user’s logging in and registration by reusing the existing users. The lesson’s title kind of speaks for itself.

In this lesson we prepare the token to finish our authentication system using TDD and allowing frontend to send the authorized requests.

Now it's time to add endpoints for the purpose of managing sessions to finally authenticate our users and implement routing. Note: Routing won't be fully operational yet, so it’s going to need some improvements, which will be covered in the next lesson.

In this lesson we add controller tests for unauthorized requests. Before we handle the success request, it's essentional to take care of all inappropriate requests user can sent to us.

Refactoring time! To keep our management and productivity being the best as possible, we'll take care of moving some of the duplicated code into more manageable snippets, that we can reuse in the future. This lesson'll save a lot of time for us in the future.

After completing this lesson you’ll be able to correctly finish the registration and logging in processes by using TDD and fix some glitches that come with it. Also there’s a handy example of “mocking” the gem included that will help you fully understand it.

In this lesson we'll start implementing a very important feature - logging out. This time, again we start from unauthorized requests, and from this we'll cover the success ones next.

As we introduced the authorization, some of our already written tests started to fail. Here are solutions to errors from the previous lesson that make the code a lot more viable.

This is the last lesson about authorization and authentication. We’ll do the rest of the major work with logging out feature and add finishing touches to our code now. All of that in Test Driven Development of course!

The first part of implementing the endpoint to create new articles. We'll cover here unauthorized requests together with testing them here.

In this lesson you’ll mainly learn how to handle validation errors from your API endpoints. So there won't be any invalid articles saved in our database.

Here we’ll cover the final parts of article creation when everything is authorized and valid. Also, you're going to improve your skills in TDD with other examples.

Name speaks for itself. In this short lesson you're going to see my approach for the exercise I gave you before. I cover here the complete functionality for updating articles in our database. There are some improvements yet to be done which are covered in the next episode.

In this lecture you’ll learn how to prevent users from changing or even deleting other users’ articles to prevent griefing and make our application private.

In this lecture I show you how to make a possibility of destroying (deleting) articles by your users. Of course - users'll be able to delete only their articles and that's because of what we’ve done in our previous lesson.

I strongly suggest you to see this episode AFTER you try to implement this feature on your own.

In this lesson we starts comments system for our application. We choose different approach this time, using rails' built in "scaffold" generators.

In this first part we need to do some cleanup and refactoring to make all automatically generated tests related to listing articles being nice and green. It's quite a lot of work to do, but I'm sure you’ll succeed! 

Here improve the code related to the comment's creation to make all test passing. We clean up a lot, but there're still a lot of things to improve in the next lessons.

In this lesson you are going to learn how to finish implementing comment listing, fix some errors that come with automatic scaffold generators and make it overall nice and clean.

Here are final improvements and fixes for problems in comment creating feature. After finishing this lecture you’ll complete the first version of your application, ready for release, so congratulations for doing so well!