thibautbaissac/rails_ai_agents/state-records

bin/rails generate model Closure card:references:uuid user:references:uuid account:references:uuid
bin/rails db:migrate
bin/rails console                              # Test: Card.open.count
bin/rails test test/models/

# BAD
class Card < ApplicationRecord
  def close
    update!(closed: true, closed_at: Time.current)
  end
 
  scope :open, -> { where(closed: false) }
end

# GOOD
class Closure < ApplicationRecord
  # touch: true ensures the parent's updated_at changes when state changes,
  # which drives cache invalidation (Russian doll caching, ETags, etc.)
  belongs_to :card, touch: true
  belongs_to :user, optional: true
  belongs_to :account, default: -> { card.account }
 
  validates :card, uniqueness: true
end
 
class Card < ApplicationRecord
  has_one :closure, dependent: :destroy
 
  def close(user: Current.user)
    create_closure!(user: user)
  end
 
  def reopen
    closure&.destroy!
  end
 
  def closed?
    closure.present?
  end
 
  scope :open, -> { where.missing(:closure) }
  scope :closed, -> { joins(:closure) }
end

class Closure < ApplicationRecord
  belongs_to :account, default: -> { card.account }
  belongs_to :card, touch: true
  belongs_to :user, optional: true
 
  validates :card, uniqueness: true
 
  after_create_commit :notify_watchers
  after_destroy_commit :notify_watchers
 
  private
 
  def notify_watchers
    card.notify_watchers_later
  end
end

module Card::Closeable
  extend ActiveSupport::Concern
 
  included do
    has_one :closure, dependent: :destroy
 
    scope :open, -> { where.missing(:closure) }
    scope :closed, -> { joins(:closure) }
  end
 
  def close(user: Current.user)
    create_closure!(user: user)
    track_event "card_closed", user: user
  end
 
  def reopen
    closure&.destroy!
    track_event "card_reopened"
  end
 
  def closed?
    closure.present?
  end
 
  def open?
    !closed?
  end
 
  def closed_at
    closure&.created_at
  end
 
  def closed_by
    closure&.user
  end
end

class Board::Publication < ApplicationRecord
  belongs_to :account, default: -> { board.account }
  belongs_to :board, touch: true
 
  has_secure_token :key
 
  validates :board, uniqueness: true
 
  def public_url
    Rails.application.routes.url_helpers.public_board_url(key)
  end
end
 
module Board::Publishable
  extend ActiveSupport::Concern
 
  included do
    has_one :publication, dependent: :destroy
 
    scope :published, -> { joins(:publication) }
    scope :private, -> { where.missing(:publication) }
  end
 
  def publish(description: nil)
    create_publication!(description: description)
    track_event "board_published"
  end
 
  def unpublish
    publication&.destroy!
    track_event "board_unpublished"
  end
 
  def published?
    publication.present?
  end
 
  def public_url
    publication&.public_url
  end
end

# Finding by state: positive uses joins, negative uses where.missing
Card.open                    # where.missing(:closure)
Card.closed                  # joins(:closure)
Board.published              # joins(:publication)
Card.golden                  # joins(:goldness)
 
# Complex combinations
scope :actionable, -> {
  where.missing(:closure).where.missing(:not_now).where.missing(:archival)
}
 
# Sorting by state
scope :with_golden_first, -> {
  left_outer_joins(:goldness)
    .select("cards.*", "card_goldnesses.created_at as golden_at")
    .order(Arel.sql("golden_at IS NULL, golden_at DESC"))
}
 
# Filtering by actor
scope :closed_by, ->(user) { joins(:closure).where(closures: { user: user }) }

# config/routes.rb
resources :cards do
  resource :closure, only: [:create, :destroy], module: :cards
  resource :goldness, only: [:create, :destroy], module: :cards
  resource :not_now, only: [:create, :destroy], module: :cards
end
 
# app/controllers/cards/closures_controller.rb
class Cards::ClosuresController < ApplicationController
  include CardScoped
 
  def create
    @card.close(user: Current.user)
    render_card_replacement
  end
 
  def destroy
    @card.reopen
    render_card_replacement
  end
end

<%# Toggle button %>
<%= button_to card_goldness_path(card),
    method: card.golden? ? :delete : :post,
    data: { turbo_frame: dom_id(card) } do %>
  <%= card.golden? ? "Ungild" : "Gild" %>
<% end %>
 
<%# State badge %>
<% if card.closed? %>
  <span class="badge badge--closed">
    Closed <%= time_ago_in_words(card.closed_at) %> ago
    <% if card.closed_by %>by <%= card.closed_by.name %><% end %>
  </span>
<% end %>