agentleFS
ThibautBaissacThibautBaissac/rails_ai_agents/.claude/skills/action-cable-patterns/SKILL.md

action-cable-patterns

Skill665 starsChanged 6 months agoMITView on GitHub

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.

The file

Files
SKILL.md

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

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.