Context and Getting to Know the Project

This project is being developed within a full-stack bootcamp created by Onebitcode, which aims to develop both the backend and frontend (web and mobile) of an e-commerce platform for selling game licenses (keys). In this post, I will summarize the essential parts of my learning in the initial modules of the course, which focuses on the development of the API using Ruby on Rails. In these first modules, we built the backend for the business's administrative side. The entire structure is planned out with some excellent lessons explaining database planning, necessary endpoints, mockups, and many of the requirements that will be crucial for the development.

Entities

In a complex project like an e-commerce platform, it’s expected that there will be several entities that are linked together, forming important relationships between them to gather valuable information that will drive the e-commerce product. The main entities are:

• Categories (Game Categories)
• Users
• System Requirements
• Coupons
• Licenses
• Products
• Games

What will be used/installed in the project?

• Ruby 2.7.1
• Rails 6.0.3.3
• Email sending with Mailcatcher
• Authentication with Devise Token Auth, which uses a login technique that receives the username and password to return a token for the user. For every request the user sends, they will receive a response and a new token to use for the next request.
• RSpec as the testing tool. Although Rails comes with Minitest by default, RSpec has wide adoption and has become the industry standard, and this course focuses on using it.
  

Creating the Category Model

The Category model is very simple; it only has a "name" field, and it can be created in Rails with just one command:

rails g model Category name

When we run this command, it generates four files: a migration, the model factory, the model test, and the model itself. After creating the model, we need to run the migration to actually create it in the database.

rails db:migrate

Following the test-driven development (TDD) approach, we create tests for the Category model we just created.

require "rails_helper"

RSpec.describe Category, type: :model do
  it { is_expected.to validate_presence_of(:name) }
  it { is_expected.to validate_uniqueness_of(:name).case_insensitive }
end

In this test, we validate the presence of the "name" field and its uniqueness within the table. The model itself would look like this:

class Category < ApplicationRecord
  validates :name, presence: true, uniqueness: { case_sensitive: false }
end

Polymorphic Model

The Product entity will be polymorphic, meaning it will have a polymorphic association. Polymorphic association is an important concept in object-oriented programming that allows an object to be associated with other objects of different types, without depending on a specific class. In other words, an object can have multiple associations with other objects that implement a specific interface or abstract class. The main advantage of polymorphic association is that it allows for greater flexibility and modularity in software design.

We will create Product as polymorphic because, although we currently only have games, it could have different types in the future. This means that the product must be able to belong to more than one model. With this, we can focus the responsibility of the product on its own entity and allow for the addition of more types in the future, beyond just games. The polymorphic approach gives us more flexibility and scalability in our system, ensuring we can add new features without needing to modify the basic structure of our code.

rails g model Product name description:text "price:decimal{10,2}" productable:references{polymorphic}

With the model created, we write the validation tests for the model. The same validations for the presence of certain fields, uniqueness, and a numericality check for a price greater than zero are added. Additionally, a belong_to test is added to validate the associations made in the model.

RSpec.describe Product, type: :model do
  it { is_expected.to belong_to :productable }
  it { is_expected.to validate_presence_of(:name) }
  it { is_expected.to validate_uniqueness_of(:name).case_insensitive }
  it { is_expected.to validate_presence_of(:description) }
  it { is_expected.to validate_presence_of(:price) }
  it { is_expected.to validate_numericality_of(:price).is_greater_than(0) }
end

Once the tests are created and failing, we can add all these validations in the Product model and verify that all tests pass.

class Product < ApplicationRecord
  belongs_to :productable, polymorphic: true

  validates :name, presence: true, uniqueness: { case_sensitive: false }
  validates :description, presence: true
  validates :price, presence: true, numericality: { greater_than: 0 }
end

Associative Entity: ProductCategory

This model is an associative entity, specifically created to allow the association between two other models: Product and Category. In practice, an associative entity is a table (or class) that represents the relationship between two or more entities, being responsible for storing the identifiers (or references) of these entities. For example, consider an online sales system where we have two entities: "Customers" and "Products." To represent a product purchase by a customer, we could create an associative entity called "Purchases" that stores the customer identifier, the product identifier, and other relevant information, such as the purchase date and payment amount.

Associative entities are useful because they allow representing many-to-many (N x N) relationships between entities, which cannot be directly modeled without creating an intermediary entity. Additionally, they provide an efficient way to query related information between two or more entities.

In summary, associative entities are an important tool in programming and databases for modeling complex relationships between entities. They allow for N x N associations and provide an efficient way to query related information between entities.

Command to create this model:

rails g model ProductCategory product:references category:references

Test for ProductCategory:

RSpec.describe ProductCategory, type: :model do
  it { is_expected.to belong_to :product }
  it { is_expected.to belong_to :category }
end

Validations in the ProductCategory model:

class ProductCategory < ApplicationRecord
  belongs_to :product
  belongs_to :category
end