OpenParable
Skip to content
← Back to skills

Action Cable Patterns

Development
action-cable-patterns

Action Cable Patterns is an Agent Skill for development published in the ThibautBaissac/rails_ai_agents repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Implements real-time features with Action Cable and WebSockets. Use when adding live updates, chat features, notifications, real-time dashboards, or when user mentions Action Cable, WebSockets, channels, or real-time. WHEN NOT: Simple HTTP request/response flows, REST APIs, static content, or features that don't need real-time updates.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/ThibautBaissac/rails_ai_agents/blob/HEAD/.claude/skills/action-cable-patterns/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/action-cable-patterns, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Action Cable Patterns for Rails 8

Overview

Action Cable integrates WebSockets with Rails:

  • Real-time updates without polling
  • Server-to-client push notifications
  • Chat and messaging features
  • Live dashboards and feeds
  • Collaborative editing

Quick Start

Action Cable is included in Rails by default. Configure it:

# config/cable.yml
development:
  adapter: async

test:
  adapter: test

production:
  adapter: solid_cable  # Rails 8 default
  # OR
  adapter: redis
  url: <%= ENV.fetch("REDIS_URL") %>

Project Structure

app/
├── channels/
│   ├── application_cable/
│   │   ├── connection.rb      # Authentication
│   │   └── channel.rb         # Base channel
│   ├── notifications_channel.rb
│   ├── events_channel.rb
│   └── chat_channel.rb
├── javascript/
│   └── channels/
│       ├── consumer.js
│       ├── notifications_channel.js
│       └── events_channel.js
spec/channels/
├── notifications_channel_spec.rb
└── events_channel_spec.rb

Connection Authentication

# app/channels/application_cable/connection.rb
module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = find_verified_user
    end

    private

    def find_verified_user
      # Using Rails 8 authentication
      if session_token = cookies.signed[:session_token]
        if session = Session.find_by(token: session_token)
          session.user
        else
          reject_unauthorized_connection
        end
      else
        reject_unauthorized_connection
      end
    end
  end
end

Channel Patterns

Four core patterns are available. See channel-patterns.md for full Ruby and JavaScript implementations:

  • Pattern 1: Notifications Channel — streams per-user notifications via stream_for current_user
  • Pattern 2: Resource Updates Channel — streams updates for a specific resource with authorization via reject
  • Pattern 3: Chat Channel — bidirectional messaging with speak and typing actions, presence tracking
  • Pattern 4: Dashboard Live Updates — broadcasts stats and activity feed to all account members

Each pattern follows the same structure:

  1. subscribed — find the resource, check authorization, call stream_for
  2. Class-level broadcast_* methods — render partials via ApplicationController.renderer
  3. A matching JavaScript subscription handler with a received(data) switch

Broadcasting

Broadcasting can be triggered from services, models, or callbacks. See broadcasting-and-stimulus.md for:

  • From a service object — call EventsChannel.broadcast_update(event) after persistence
  • From model callbacks — use after_create_commit to trigger channel broadcasts
  • Turbo Streams integration — use broadcast_append_to / broadcast_remove_to helpers directly on models
  • Stimulus controller — wrap the Action Cable subscription lifecycle inside a Stimulus controller for clean connect/disconnect management
  • Performance patterns — connection limits, selective broadcasting, debounced broadcasts

Testing Channels

See testing.md for full specs. Key conventions:

# Stub connection identity
stub_connection(current_user: user)

# Assert subscription confirmed and streaming
subscribe(event_id: event.id)
expect(subscription).to be_confirmed
expect(subscription).to have_stream_for(event)

# Assert rejection for unauthorized access
expect(subscription).to be_rejected

# Assert broadcast payload
expect {
  described_class.notify(user, notification)
}.to have_broadcasted_to(user).with(hash_including(type: "notification"))

Checklist

  • Connection authentication configured
  • Channel authorization implemented
  • Client-side subscription set up
  • Broadcasting from services/models
  • Channel specs written
  • Error handling in place
  • Reconnection logic on client
  • Performance limits configured

References

  • channel-patterns.md — Full implementations of Notifications, Resource Updates, Chat, and Dashboard channels (Ruby + JavaScript)
  • broadcasting-and-stimulus.md — Broadcasting from services/models, Turbo Streams integration, Stimulus controller, performance tips
  • testing.md — RSpec channel specs, authorization specs, and system tests