<%= simple_format @article.body %>
<%# Partial untuk komentar %>
<%= render @comments %>
```
Alur tipikal: permintaan tiba di Router, yang meneruskannya ke Controller yang sesuai. Controller berinteraksi dengan Model untuk mengambil atau memodifikasi data, lalu meneruskan data tersebut ke View untuk render HTML.
### Pertanyaan 2: Apa itu Active Record dan bagaimana ORM Rails bekerja?
Active Record adalah ORM (Object-Relational Mapping) Rails yang mengimplementasikan pola Active Record. Setiap kelas Model mewakili sebuah tabel basis data, dan setiap instance mewakili satu baris.
```ruby
# app/models/user.rb
# Active Record memetakan kolom ke atribut secara otomatis
class User < ApplicationRecord
# Tabel 'users' diasosiasikan secara otomatis
# Kolom: id, email, name, created_at, updated_at
has_secure_password # BCrypt untuk kata sandi
has_many :articles, foreign_key: :author_id
has_one :profile, dependent: :destroy
has_and_belongs_to_many :roles
# Validasi
validates :email, presence: true,
uniqueness: { case_sensitive: false },
format: { with: URI::MailTo::EMAIL_REGEXP }
# Callback
before_save :normalize_email
# Metode kelas untuk query
def self.admins
joins(:roles).where(roles: { name: 'admin' })
end
private
def normalize_email
self.email = email.downcase.strip
end
end
```
```ruby
# Contoh query Active Record
# Konsol Rails atau di dalam service
# Pembuatan
user = User.create!(email: 'dev@example.com', name: 'Alice', password: 'secret123')
# Pembacaan dengan kondisi
active_users = User.where(active: true).order(:name)
user = User.find_by(email: 'dev@example.com')
# Query berantai (lazy evaluation)
recent_admins = User.admins
.where('created_at > ?', 1.month.ago)
.includes(:profile)
.limit(10)
# Pencegahan N+1 dengan eager loading
articles = Article.includes(:author, :comments).published
# Pembaruan
user.update!(name: 'Alice Martin')
# Transaksi
User.transaction do
user.debit_balance!(100)
recipient.credit_balance!(100)
Payment.create!(from: user, to: recipient, amount: 100)
end
```
Active Record mengubah metode Ruby menjadi query SQL yang dioptimalkan. Metode seperti `where`, `joins`, dan `includes` bersifat lazy: query baru dieksekusi saat iterasi atau saat memanggil `to_a`.
### Pertanyaan 3: Jelaskan sistem migrasi Rails
Migrasi memungkinkan versi skema basis data dengan Ruby. Migrasi bersifat reversible dan memungkinkan evolusi struktur data yang terkendali.
```ruby
# db/migrate/20260203100000_create_products.rb
# Migrasi untuk membuat tabel
class CreateProducts < ActiveRecord::Migration[7.1]
def change
create_table :products do |t|
t.string :name, null: false
t.text :description
t.decimal :price, precision: 10, scale: 2, null: false
t.integer :stock_quantity, default: 0
t.references :category, null: false, foreign_key: true
t.boolean :active, default: true
t.timestamps # created_at dan updated_at otomatis
end
# Indeks untuk performa
add_index :products, :name
add_index :products, [:category_id, :active]
end
end
```
```ruby
# db/migrate/20260203110000_add_slug_to_products.rb
# Migrasi untuk memodifikasi tabel yang sudah ada
class AddSlugToProducts < ActiveRecord::Migration[7.1]
def change
add_column :products, :slug, :string
add_index :products, :slug, unique: true
# Mengisi slug yang sudah ada
reversible do |dir|
dir.up do
Product.find_each do |product|
product.update_column(:slug, product.name.parameterize)
end
end
end
# Menjadikan NOT NULL setelah pengisian
change_column_null :products, :slug, false
end
end
```
```bash
# Perintah migrasi penting
rails db:migrate # Menjalankan migrasi yang tertunda
rails db:rollback # Membatalkan migrasi terakhir
rails db:rollback STEP=3 # Membatalkan 3 migrasi terakhir
rails db:migrate:status # Melihat status migrasi
rails db:seed # Menjalankan db/seeds.rb
rails db:reset # Drop, create, migrate, seed
```
Migrasi harus reversible. Metode `change` cerdas dan dapat membalik operasi umum secara otomatis. Untuk kasus kompleks, gunakan `up` dan `down` secara terpisah.
## Active Record tingkat lanjut
### Pertanyaan 4: Bagaimana mengoptimalkan query N+1 di Rails?
Masalah N+1 muncul ketika query awal diikuti oleh N query tambahan untuk memuat asosiasi. Rails menyediakan beberapa metode eager loading untuk mengatasi masalah ini.
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def index
# ❌ MASALAH N+1: 1 query + N query per pesanan
# @orders = Order.all
# Di view: order.user.name menghasilkan satu query per pesanan
# ✅ SOLUSI dengan includes (eager loading)
@orders = Order.includes(:user, :items)
.where(status: 'completed')
.order(created_at: :desc)
# Hanya menghasilkan 3 query secara total
end
def show
# includes: memuat asosiasi terpisah (2-3 query)
@order = Order.includes(items: :product).find(params[:id])
# preload: memaksa pemuatan terpisah
@order = Order.preload(:items, :user).find(params[:id])
# eager_load: memaksa LEFT OUTER JOIN (1 query)
@order = Order.eager_load(:items).find(params[:id])
end
end
```
```ruby
# app/models/order.rb
class Order < ApplicationRecord
belongs_to :user
has_many :items, class_name: 'OrderItem'
has_many :products, through: :items
# Scope dengan includes default
scope :with_details, -> { includes(:user, items: :product) }
# Counter cache untuk menghindari query COUNT
# Memerlukan: add_column :users, :orders_count, :integer, default: 0
belongs_to :user, counter_cache: true
end
```
```ruby
# Deteksi N+1 dengan gem Bullet (development)
# config/environments/development.rb
config.after_initialize do
Bullet.enable = true
Bullet.alert = true
Bullet.bullet_logger = true
Bullet.rails_logger = true
end
# Bullet akan menampilkan peringatan ketika:
# - Query N+1 terdeteksi
# - Eager loading tidak diperlukan
# - Counter cache seharusnya digunakan
```
Aturannya: gunakan `includes` secara default (Rails memilih strategi optimal), `preload` saat ingin memaksa query terpisah, `eager_load` saat memfilter berdasarkan asosiasi.
### Pertanyaan 5: Jelaskan Scope dan Query Object di Rails
Scope mengenkapsulasi kondisi query yang dapat digunakan ulang. Untuk query kompleks, Query Object menawarkan organisasi dan keterujian yang lebih baik.
```ruby
# app/models/product.rb
class Product < ApplicationRecord
# Scope sederhana
scope :active, -> { where(active: true) }
scope :in_stock, -> { where('stock_quantity > 0') }
scope :featured, -> { where(featured: true) }
# Scope dengan parameter
scope :cheaper_than, ->(price) { where('price < ?', price) }
scope :in_category, ->(category) { where(category: category) }
# Scope berantai
scope :available, -> { active.in_stock }
# Scope dengan joins
scope :with_recent_orders, -> {
joins(:order_items)
.where('order_items.created_at > ?', 30.days.ago)
.distinct
}
# Scope dengan subquery
scope :bestsellers, -> {
where(id: OrderItem.group(:product_id)
.order('COUNT(*) DESC')
.limit(10)
.select(:product_id))
}
end
```
```ruby
# app/queries/products_search_query.rb
# Query Object untuk pencarian kompleks
class ProductsSearchQuery
def initialize(relation = Product.all)
@relation = relation
end
def call(params)
@relation = filter_by_category(params[:category])
@relation = filter_by_price_range(params[:min_price], params[:max_price])
@relation = filter_by_search(params[:q])
@relation = apply_sorting(params[:sort])
@relation
end
private
def filter_by_category(category)
return @relation if category.blank?
@relation.where(category_id: category)
end
def filter_by_price_range(min, max)
@relation = @relation.where('price >= ?', min) if min.present?
@relation = @relation.where('price <= ?', max) if max.present?
@relation
end
def filter_by_search(query)
return @relation if query.blank?
@relation.where('name ILIKE ? OR description ILIKE ?',
"%#{query}%", "%#{query}%")
end
def apply_sorting(sort)
case sort
when 'price_asc' then @relation.order(price: :asc)
when 'price_desc' then @relation.order(price: :desc)
when 'newest' then @relation.order(created_at: :desc)
else @relation.order(:name)
end
end
end
# Penggunaan di controller
@products = ProductsSearchQuery.new(Product.active).call(params)
```
Scope sangat cocok untuk kondisi sederhana dan dapat digunakan ulang. Query Object cocok untuk pencarian kompleks dengan banyak filter opsional dan logika komposisi.
## Routing dan Controller
### Pertanyaan 6: Bagaimana cara kerja routing RESTful di Rails?
Rails mendorong rute RESTful yang memetakan kata kerja HTTP ke aksi CRUD. Router menerjemahkan URL menjadi panggilan controller spesifik.
```ruby
# config/routes.rb
Rails.application.routes.draw do
# Rute RESTful standar (7 aksi)
resources :articles do
# Rute bersarang
resources :comments, only: [:create, :destroy]
# Rute member (bertindak pada satu instance)
member do
post :publish
delete :archive
end
# Rute collection (bertindak pada koleksi)
collection do
get :drafts
get :search
end
end
# Rute API dengan namespace
namespace :api do
namespace :v1 do
resources :products, only: [:index, :show, :create, :update] do
resources :reviews, shallow: true
end
end
end
# Rute kustom
get 'dashboard', to: 'dashboard#index'
# Pembatasan rute
constraints(SubdomainConstraint.new) do
resources :admin_settings
end
# Rute root
root 'home#index'
end
```
```bash
# rails routes - Menampilkan semua rute yang dihasilkan
#
# Verb URI Pattern Controller#Action
# GET /articles articles#index
# POST /articles articles#create
# GET /articles/new articles#new
# GET /articles/:id/edit articles#edit
# GET /articles/:id articles#show
# PATCH /articles/:id articles#update
# DELETE /articles/:id articles#destroy
# POST /articles/:id/publish articles#publish
# GET /articles/drafts articles#drafts
```
Helper rute yang dihasilkan (`article_path(@article)`, `new_article_path`) memungkinkan referensi URL secara dinamis dan mudah dipelihara.
### Pertanyaan 7: Jelaskan callback dan filter di controller
Callback (before_action, after_action, around_action) memungkinkan eksekusi kode sebelum, sesudah, atau di sekitar aksi controller.
```ruby
# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
# Perlindungan CSRF aktif secara default
protect_from_forgery with: :exception
# Callback global untuk autentikasi
before_action :authenticate_user!
# Penanganan error global
rescue_from ActiveRecord::RecordNotFound, with: :not_found
rescue_from ActionController::ParameterMissing, with: :bad_request
private
def not_found
render json: { error: 'Sumber daya tidak ditemukan' }, status: :not_found
end
def bad_request(exception)
render json: { error: exception.message }, status: :bad_request
end
end
```
```ruby
# app/controllers/admin/products_controller.rb
class Admin::ProductsController < ApplicationController
# Callback dengan opsi
before_action :require_admin
before_action :set_product, only: [:show, :edit, :update, :destroy]
after_action :log_activity, only: [:create, :update, :destroy]
# Callback bersyarat
before_action :check_stock, only: [:update], if: :stock_changed?
def create
@product = Product.new(product_params)
if @product.save
redirect_to [:admin, @product], notice: 'Produk dibuat.'
else
render :new, status: :unprocessable_entity
end
end
def update
if @product.update(product_params)
redirect_to [:admin, @product], notice: 'Produk diperbarui.'
else
render :edit, status: :unprocessable_entity
end
end
private
def require_admin
redirect_to root_path unless current_user&.admin?
end
def set_product
@product = Product.find(params[:id])
end
def stock_changed?
params[:product][:stock_quantity].present?
end
def log_activity
ActivityLog.create!(
user: current_user,
action: action_name,
resource: @product
)
end
def product_params
params.require(:product).permit(:name, :price, :description, :stock_quantity)
end
end
```
Callback dieksekusi sesuai urutan deklarasi. Gunakan `skip_before_action` di subclass untuk menonaktifkan callback yang diwariskan. Hindari callback dengan terlalu banyak logika bisnis: lebih baik gunakan Service Object.
## Service dan arsitektur
### Pertanyaan 8: Bagaimana mengimplementasikan Service Object di Rails?
Service Object mengenkapsulasi logika bisnis kompleks yang bukan milik Model maupun Controller. Service Object meningkatkan keterujian dan mengikuti prinsip single responsibility.
```ruby
# app/services/order_processor.rb
# Service Object dengan antarmuka standar
class OrderProcessor
def initialize(order, payment_method:)
@order = order
@payment_method = payment_method
end
def call
return failure('Pesanan sudah diproses') if @order.processed?
ActiveRecord::Base.transaction do
validate_stock!
process_payment!
update_inventory!
send_confirmation!
@order.update!(status: 'completed', processed_at: Time.current)
end
success(@order)
rescue PaymentError => e
failure("Pembayaran gagal: #{e.message}")
rescue InsufficientStockError => e
failure("Stok tidak cukup: #{e.message}")
end
private
def validate_stock!
@order.items.each do |item|
unless item.product.stock_quantity >= item.quantity
raise InsufficientStockError, item.product.name
end
end
end
def process_payment!
result = PaymentGateway.charge(
amount: @order.total,
method: @payment_method,
description: "Pesanan ##{@order.id}"
)
raise PaymentError, result.error unless result.success?
@order.update!(payment_reference: result.transaction_id)
end
def update_inventory!
@order.items.each do |item|
item.product.decrement!(:stock_quantity, item.quantity)
end
end
def send_confirmation!
OrderMailer.confirmation(@order).deliver_later
end
def success(data)
Result.new(success: true, data: data)
end
def failure(error)
Result.new(success: false, error: error)
end
Result = Struct.new(:success, :data, :error, keyword_init: true) do
def success? = success
def failure? = !success
end
end
```
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def create
@order = current_user.orders.build(order_params)
if @order.save
result = OrderProcessor.new(@order, payment_method: params[:payment_method]).call
if result.success?
redirect_to @order, notice: 'Pesanan dikonfirmasi!'
else
@order.update!(status: 'payment_failed')
flash.now[:alert] = result.error
render :new, status: :unprocessable_entity
end
else
render :new, status: :unprocessable_entity
end
end
end
```
Pola Service Object mengikuti konvensi sederhana: satu kelas, satu tanggung jawab, satu metode publik `call`. Mengembalikan objek Result memungkinkan penanganan keberhasilan dan kegagalan yang rapi.
### Pertanyaan 9: Jelaskan Concerns di Rails
Concerns memungkinkan ekstraksi dan berbagi kode antara Model atau Controller. Concerns menggunakan `ActiveSupport::Concern` untuk sintaks include yang bersih.
```ruby
# app/models/concerns/sluggable.rb
# Concern yang dapat digunakan ulang untuk menghasilkan slug
module Sluggable
extend ActiveSupport::Concern
included do
# Kode yang dijalankan saat di-include
before_validation :generate_slug, if: :should_generate_slug?
validates :slug, presence: true, uniqueness: true
end
# Metode kelas
class_methods do
def find_by_slug!(slug)
find_by!(slug: slug)
end
def sluggable_source(column = :title)
@sluggable_source = column
end
def sluggable_source_column
@sluggable_source || :title
end
end
# Metode instance
def to_param
slug
end
private
def should_generate_slug?
slug.blank? || send("#{self.class.sluggable_source_column}_changed?")
end
def generate_slug
source = send(self.class.sluggable_source_column)
return if source.blank?
base_slug = source.parameterize
self.slug = unique_slug(base_slug)
end
def unique_slug(base)
slug = base
counter = 1
while self.class.where(slug: slug).where.not(id: id).exists?
slug = "#{base}-#{counter}"
counter += 1
end
slug
end
end
```
```ruby
# app/models/article.rb
class Article < ApplicationRecord
include Sluggable
sluggable_source :title # Opsional, default :title
end
# app/models/product.rb
class Product < ApplicationRecord
include Sluggable
sluggable_source :name
end
```
```ruby
# app/controllers/concerns/pagination.rb
# Concern untuk controller
module Pagination
extend ActiveSupport::Concern
included do
helper_method :page_param, :per_page_param
end
private
def paginate(relation)
relation.page(page_param).per(per_page_param)
end
def page_param
params[:page]&.to_i || 1
end
def per_page_param
[params[:per_page]&.to_i || 25, 100].min
end
end
```
Concerns berguna untuk kode yang benar-benar dibagikan. Hindari membuat Concern hanya untuk "memperpendek" sebuah Model: itu menyembunyikan kompleksitas tanpa menguranginya.
## Pengujian dengan RSpec
### Pertanyaan 10: Bagaimana menyusun tes RSpec di Rails?
RSpec adalah framework testing standar untuk Rails. Struktur tes yang baik mencakup Model spec, Controller spec, Service spec, dan tes integrasi.
```ruby
# spec/models/user_spec.rb
require 'rails_helper'
RSpec.describe User, type: :model do
# Factory dengan FactoryBot
let(:user) { build(:user) }
let(:admin) { build(:user, :admin) }
describe 'validations' do
it { is_expected.to validate_presence_of(:email) }
it { is_expected.to validate_uniqueness_of(:email).case_insensitive }
it 'memvalidasi format email' do
user.email = 'invalid'
expect(user).not_to be_valid
expect(user.errors[:email]).to include('is invalid')
end
end
describe 'associations' do
it { is_expected.to have_many(:articles).dependent(:destroy) }
it { is_expected.to have_one(:profile) }
it { is_expected.to belong_to(:organization).optional }
end
describe '#full_name' do
it 'mengembalikan nama depan dan belakang yang digabung' do
user = build(:user, first_name: 'John', last_name: 'Doe')
expect(user.full_name).to eq('John Doe')
end
it 'menangani nama belakang yang kosong' do
user = build(:user, first_name: 'John', last_name: nil)
expect(user.full_name).to eq('John')
end
end
describe '.active' do
it 'mengembalikan hanya pengguna aktif' do
active = create(:user, active: true)
inactive = create(:user, active: false)
expect(User.active).to include(active)
expect(User.active).not_to include(inactive)
end
end
end
```
```ruby
# spec/services/order_processor_spec.rb
require 'rails_helper'
RSpec.describe OrderProcessor do
let(:user) { create(:user) }
let(:product) { create(:product, stock_quantity: 10, price: 100) }
let(:order) { create(:order, user: user, items: [build(:order_item, product: product, quantity: 2)]) }
subject { described_class.new(order, payment_method: 'card') }
describe '#call' do
context 'ketika pesanan valid' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: true, transaction_id: 'txn_123')
)
end
it 'memproses pesanan dengan sukses' do
result = subject.call
expect(result).to be_success
expect(order.reload.status).to eq('completed')
end
it 'mengurangi stok produk' do
expect { subject.call }.to change { product.reload.stock_quantity }.by(-2)
end
it 'mengirim email konfirmasi' do
expect { subject.call }
.to have_enqueued_mail(OrderMailer, :confirmation)
.with(order)
end
end
context 'ketika pembayaran gagal' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: false, error: 'Card declined')
)
end
it 'mengembalikan hasil kegagalan' do
result = subject.call
expect(result).to be_failure
expect(result.error).to include('Card declined')
end
it 'tidak memperbarui status pesanan' do
expect { subject.call }.not_to change { order.reload.status }
end
end
end
end
```
```ruby
# spec/requests/api/v1/products_spec.rb
require 'rails_helper'
RSpec.describe 'API V1 Products', type: :request do
let(:user) { create(:user) }
let(:headers) { { 'Authorization' => "Bearer #{user.api_token}" } }
describe 'GET /api/v1/products' do
let!(:products) { create_list(:product, 3, :active) }
it 'mengembalikan daftar produk' do
get '/api/v1/products', headers: headers
expect(response).to have_http_status(:ok)
expect(json_response['data'].size).to eq(3)
end
it 'memfilter berdasarkan kategori' do
category = create(:category)
categorized = create(:product, category: category)
get '/api/v1/products', params: { category_id: category.id }, headers: headers
expect(json_response['data'].map { |p| p['id'] }).to eq([categorized.id])
end
end
describe 'POST /api/v1/products' do
let(:valid_params) do
{ product: { name: 'Produk Baru', price: 99.99, category_id: create(:category).id } }
end
it 'membuat produk baru' do
expect {
post '/api/v1/products', params: valid_params, headers: headers
}.to change(Product, :count).by(1)
expect(response).to have_http_status(:created)
end
end
end
```
Praktik terbaik: gunakan `let` untuk data, `describe` untuk metode/konteks, `context` untuk kondisi, dan `it` untuk asersi spesifik. Satu tes harus menguji satu hal.
### Pertanyaan 11: Bagaimana menggunakan factory dengan FactoryBot?
FactoryBot memungkinkan pembuatan data uji secara deklaratif dan mudah dipelihara. Factory menggantikan fixture statis.
```ruby
# spec/factories/users.rb
FactoryBot.define do
factory :user do
# Sequence untuk memastikan keunikan
sequence(:email) { |n| "user#{n}@example.com" }
first_name { Faker::Name.first_name }
last_name { Faker::Name.last_name }
password { 'password123' }
confirmed_at { Time.current }
# Trait untuk variasi
trait :admin do
role { 'admin' }
after(:create) do |user|
user.permissions.create!(name: 'admin_access')
end
end
trait :unconfirmed do
confirmed_at { nil }
end
trait :with_profile do
after(:create) do |user|
create(:profile, user: user)
end
end
trait :with_articles do
transient do
articles_count { 3 }
end
after(:create) do |user, evaluator|
create_list(:article, evaluator.articles_count, author: user)
end
end
# Factory turunan
factory :admin_user do
admin
with_profile
end
end
end
```
```ruby
# spec/factories/orders.rb
FactoryBot.define do
factory :order do
user
status { 'pending' }
trait :with_items do
transient do
items_count { 2 }
end
after(:create) do |order, evaluator|
create_list(:order_item, evaluator.items_count, order: order)
order.recalculate_total!
end
end
trait :completed do
status { 'completed' }
processed_at { Time.current }
with_items
end
trait :high_value do
after(:create) do |order|
create(:order_item, order: order, quantity: 10, unit_price: 500)
order.recalculate_total!
end
end
end
end
```
```ruby
# Penggunaan dalam tes
RSpec.describe OrderProcessor do
# build: instance tidak persisten
let(:user) { build(:user) }
# create: persisten ke DB
let(:order) { create(:order, :with_items, user: user) }
# create_list: beberapa instance
let(:products) { create_list(:product, 5) }
# Menggabungkan trait
let(:admin) { create(:user, :admin, :with_profile) }
# Mengganti atribut
let(:expensive_order) { create(:order, :with_items, items_count: 10) }
# build_stubbed: lebih cepat, untuk unit test
let(:stubbed_user) { build_stubbed(:user) }
end
```
Lebih baik menggunakan `build` atau `build_stubbed` daripada `create` ketika persistensi tidak diperlukan: ini mempercepat tes secara signifikan.
## Background Job
### Pertanyaan 12: Bagaimana menggunakan Active Job dan Sidekiq di Rails?
Active Job menyediakan antarmuka terpadu untuk pekerjaan latar belakang, terlepas dari backend (Sidekiq, Resque, dll.). Sidekiq adalah pilihan populer karena performanya dengan Redis.
```ruby
# app/jobs/process_order_job.rb
class ProcessOrderJob < ApplicationJob
queue_as :default
# Konfigurasi retry
retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10
discard_on ActiveJob::DeserializationError
# Opsi Sidekiq (jika backend Sidekiq)
sidekiq_options retry: 5, backtrace: true
def perform(order_id)
order = Order.find(order_id)
OrderProcessor.new(order).call
rescue ActiveRecord::RecordNotFound
# Pesanan dihapus antara antrean dan eksekusi
Rails.logger.warn("Order #{order_id} not found, skipping job")
end
end
```
```ruby
# app/jobs/batch_email_job.rb
class BatchEmailJob < ApplicationJob
queue_as :mailers
# Pembatasan laju dengan Sidekiq Enterprise atau gem throttle
sidekiq_options throttle: { threshold: 100, period: 1.minute }
def perform(user_ids, template_id)
template = EmailTemplate.find(template_id)
User.where(id: user_ids).find_each do |user|
UserMailer.custom_email(user, template).deliver_later
end
end
end
```
```ruby
# Mengantrekan pekerjaan
# Segera
ProcessOrderJob.perform_later(order.id)
# Tertunda
ProcessOrderJob.set(wait: 5.minutes).perform_later(order.id)
# Pada waktu spesifik
ProcessOrderJob.set(wait_until: Date.tomorrow.noon).perform_later(order.id)
# Antrean spesifik
ProcessOrderJob.set(queue: :critical).perform_later(order.id)
# Sinkron (untuk tes atau debugging)
ProcessOrderJob.perform_now(order.id)
```
```ruby
# config/sidekiq.yml
:concurrency: 10
:queues:
- [critical, 3] # Prioritas tinggi, bobot 3
- [default, 2] # Prioritas sedang, bobot 2
- [mailers, 1] # Prioritas rendah, bobot 1
- [low, 1]
:schedule:
cleanup_job:
cron: '0 3 * * *' # Setiap hari pukul 3 pagi
class: CleanupJob
```
Active Job mengabstraksi backend, tetapi mengakses fitur spesifik (batch, rate limiting) sering memerlukan keterikatan dengan backend yang dipilih.
## Pengembangan API
### Pertanyaan 13: Bagaimana membangun RESTful API dengan Rails?
Rails memudahkan pembangunan API JSON dengan controller API-only dan serializer. API yang baik memiliki versi, terdokumentasi, dan aman.
```ruby
# app/controllers/api/v1/base_controller.rb
module Api
module V1
class BaseController < ActionController::API
include ActionController::HttpAuthentication::Token::ControllerMethods
before_action :authenticate_token!
rescue_from ActiveRecord::RecordNotFound, with: :not_found
rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity
rescue_from ActionController::ParameterMissing, with: :bad_request
private
def authenticate_token!
authenticate_or_request_with_http_token do |token, options|
@current_user = User.find_by(api_token: token)
end
end
def current_user
@current_user
end
def not_found(exception)
render json: { error: 'Sumber daya tidak ditemukan', details: exception.message },
status: :not_found
end
def unprocessable_entity(exception)
render json: { error: 'Validasi gagal', details: exception.record.errors },
status: :unprocessable_entity
end
def bad_request(exception)
render json: { error: 'Permintaan tidak valid', details: exception.message },
status: :bad_request
end
end
end
end
```
```ruby
# app/controllers/api/v1/products_controller.rb
module Api
module V1
class ProductsController < BaseController
before_action :set_product, only: [:show, :update, :destroy]
def index
@products = Product.active
.includes(:category)
.page(params[:page])
.per(params[:per_page] || 20)
render json: {
data: ProductSerializer.new(@products).serializable_hash,
meta: pagination_meta(@products)
}
end
def show
render json: ProductSerializer.new(@product, include: [:category, :reviews])
end
def create
@product = Product.new(product_params)
@product.save!
render json: ProductSerializer.new(@product), status: :created
end
def update
@product.update!(product_params)
render json: ProductSerializer.new(@product)
end
def destroy
@product.destroy!
head :no_content
end
private
def set_product
@product = Product.find(params[:id])
end
def product_params
params.require(:product).permit(:name, :description, :price, :category_id)
end
def pagination_meta(collection)
{
current_page: collection.current_page,
total_pages: collection.total_pages,
total_count: collection.total_count
}
end
end
end
end
```
```ruby
# app/serializers/product_serializer.rb
# Dengan gem jsonapi-serializer
class ProductSerializer
include JSONAPI::Serializer
attributes :id, :name, :description, :price, :created_at
attribute :formatted_price do |product|
"$#{product.price.to_f.round(2)}"
end
belongs_to :category
has_many :reviews
link :self do |product|
Rails.application.routes.url_helpers.api_v1_product_url(product)
end
end
```
Praktik terbaik API: lakukan versi dengan namespace, gunakan kode HTTP yang sesuai, paginasi koleksi, dan berikan pesan kesalahan yang jelas.
### Pertanyaan 14: Bagaimana mengimplementasikan autentikasi JWT di Rails?
JWT (JSON Web Tokens) adalah metode autentikasi stateless yang populer untuk API. Token mengkodekan identitas dan validitas pengguna.
```ruby
# app/services/jwt_service.rb
class JwtService
SECRET_KEY = Rails.application.credentials.secret_key_base
ALGORITHM = 'HS256'.freeze
class << self
def encode(payload, exp = 24.hours.from_now)
payload[:exp] = exp.to_i
payload[:iat] = Time.current.to_i
JWT.encode(payload, SECRET_KEY, ALGORITHM)
end
def decode(token)
decoded = JWT.decode(token, SECRET_KEY, true, algorithm: ALGORITHM)
HashWithIndifferentAccess.new(decoded.first)
rescue JWT::ExpiredSignature
raise AuthenticationError, 'Token kedaluwarsa'
rescue JWT::DecodeError
raise AuthenticationError, 'Token tidak valid'
end
end
end
```
```ruby
# app/controllers/api/v1/auth_controller.rb
module Api
module V1
class AuthController < ActionController::API
def login
user = User.find_by(email: params[:email])
if user&.authenticate(params[:password])
token = JwtService.encode(user_id: user.id)
render json: {
token: token,
user: UserSerializer.new(user),
expires_at: 24.hours.from_now
}
else
render json: { error: 'Kredensial tidak valid' }, status: :unauthorized
end
end
def refresh
token = JwtService.encode(user_id: current_user.id)
render json: { token: token, expires_at: 24.hours.from_now }
end
end
end
end
```
```ruby
# app/controllers/concerns/jwt_authenticatable.rb
module JwtAuthenticatable
extend ActiveSupport::Concern
included do
before_action :authenticate_jwt!
end
private
def authenticate_jwt!
header = request.headers['Authorization']
token = header&.split(' ')&.last
raise AuthenticationError, 'Token tidak ada' unless token
decoded = JwtService.decode(token)
@current_user = User.find(decoded[:user_id])
rescue AuthenticationError => e
render json: { error: e.message }, status: :unauthorized
rescue ActiveRecord::RecordNotFound
render json: { error: 'Pengguna tidak ditemukan' }, status: :unauthorized
end
def current_user
@current_user
end
end
```
Untuk produksi, pertimbangkan: refresh token, blacklist token saat logout, dan waktu kedaluwarsa singkat. Gem seperti `devise-jwt` mempermudah implementasi.
## Caching dan performa
### Pertanyaan 15: Bagaimana mengimplementasikan caching di Rails?
Rails menawarkan beberapa tingkat caching: fragment caching, Russian Doll caching, low-level caching. Pilihannya bergantung pada kasus penggunaan.
```ruby
# config/environments/production.rb
config.action_controller.perform_caching = true
config.cache_store = :redis_cache_store, {
url: ENV['REDIS_URL'],
namespace: 'myapp:cache',
expires_in: 1.day,
race_condition_ttl: 10.seconds
}
```
```erb
<%# app/views/products/index.html.erb %>
<%# Fragment caching dengan kunci cache otomatis %>
<% @products.each do |product| %>
<%# Cache berdasarkan updated_at produk %>
<% cache product do %>
<%= render product %>
<% end %>
<% end %>
<%# Russian Doll caching - cache bersarang %>
<% cache ['v1', @category] do %>