polylingo_chat 0.1.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6491b6c4c4efb8f3a036ca5b603cf6d383d7ffd60804cf080dcb3cde055360d
-  data.tar.gz: 9998d94782b87daf3a3546221f9f16be51bcd74a959f2eb4b2a823de97222fec
+  metadata.gz: 01ec0809c7463514bcbf9249500c51241cf10ed887a0cf3128ce5258922b8861
+  data.tar.gz: 90fdaebab28909605dab1da70779094b0283ec1a08c45f24cb597a317e084645
 SHA512:
-  metadata.gz: 24c88ccebf1bf762ae31ed874a1d88e1afc45f6f0866c62a5f7ac61ae3b759528bd81738f147f275e0e29d458adf6f34c984b1e94b48f8ebc0760c4131f592be
-  data.tar.gz: c361b6cfdca10f5952a848d57cc94f32775d0fb85594b0044c7ba277b180571c4bc8cad23bc77b0a012fbd132138716b14242a46673794f1ea8b03854db4d114
+  metadata.gz: a7546b1a0a4d4c75339a8a54edc3f487acb03d367ee18e4474926f804e432114a8b86a2f4a874d37c2ce5ad83bc63338f685c766f0251f0c4885206484804660
+  data.tar.gz: 4439ee11861544ec14a424be4887b3487b0f8258eae378e1f463ea2df5f0d41301dd793f1d3cece4977a8410dbfa80989f791f062cd5fb4cca3148154073707c

data/README.md

@@ -13,11 +13,12 @@ Perfect for marketplaces, SaaS apps, CRMs, support systems, or global communitie
 - 🌍 **Optional AI translation** - works with or without translation
 - ⚙️ **Multi-provider support** — OpenAI, Anthropic Claude, or Google Gemini
 - 🧩 **Rails Engine** — mounts directly inside your app
-- 👥 **Conversations, Participants & Messages** models included
+- 📱 **API-only mode** — works with Rails API applications (auto-detected)
+- 👥 **Polymorphic associations** — supports multiple participant types (User, Vendor, Customer, etc.)
 - 🔌 **Works with any ActiveJob backend** (Sidekiq, Solid Queue, Delayed Job, etc.)
 - 🔐 **Secure & scoped** ActionCable channels
 - 🧱 **Extendable architecture** (custom UI, custom providers, custom storage)
-- 💾 **Built-in caching** support for translations
+- 💾 **Database-backed translation caching** - translations stored and reused (zero API costs on retrieval)
 - 🧪 **RSpec testing** framework included
 - 🗄️ **No Redis required** — uses Solid Cable for WebSocket persistence
 
@@ -53,17 +54,24 @@ bin/rails db:migrate
 ```
 
 **The installer automatically:**
-- ✅ Creates migrations for Conversations, Participants, and Messages
-- ✅ Generates model files with associations
-- ✅ Sets up ActionCable channels (PolylinguoChatChannel)
-- ✅ Creates JavaScript files for real-time chat
-- ✅ Configures Solid Cable in `config/cable.yml`
-- ✅ Downloads ActionCable ESM module to `vendor/javascript`
-- ✅ Updates `config/routes.rb` with chat routes
-- ✅ Updates `config/importmap.rb` with required pins
-- ✅ Updates `app/javascript/application.js` with chat import
+- ✅ Creates migrations for prefixed tables (`polylingo_chat_conversations`, `polylingo_chat_participants`, `polylingo_chat_messages`, `polylingo_chat_message_translations`)
+- ✅ Generates namespaced models in `app/models/polylingo_chat/` directory
+- ✅ Generates namespaced controllers in `app/controllers/polylingo_chat/` directory
+- ✅ Sets up ActionCable channels (PolylinguoChatChannel) for full-stack apps
+- ✅ Creates JavaScript files for real-time chat (full-stack only)
+- ✅ Configures Solid Cable in `config/cable.yml` (full-stack only)
+- ✅ Downloads ActionCable ESM module to `vendor/javascript` (full-stack only)
+- ✅ Updates `config/routes.rb` with namespaced routes
+- ✅ Updates `config/importmap.rb` with required pins (full-stack only)
+- ✅ Updates `app/javascript/application.js` with chat import (full-stack only)
 - ✅ Creates `config/initializers/polylingo_chat.rb` for configuration
 
+**Note:** Everything is fully namespaced:
+- Models: `PolylingoChat::Conversation`, `PolylingoChat::Participant`, `PolylingoChat::Message`
+- Controllers: `PolylingoChat::ConversationsController`, `PolylingoChat::MessagesController`
+- Tables: `polylingo_chat_conversations`, `polylingo_chat_participants`, `polylingo_chat_messages`
+- Routes: `/polylingo_chat/conversations`, `/polylingo_chat/messages`
+
 ### 3. Configure ActiveJob
 ```ruby
 # config/application.rb or config/environments/production.rb
@@ -143,8 +151,198 @@ bundle exec sidekiq  # or bin/rails solid_queue:start, or bin/rails jobs:work
 
 ---
 
+## 🛠️ Advanced Installation
+
+### API-Only Mode
+
+PolylingoChat automatically detects Rails API applications and skips ActionCable/frontend setup. You can also explicitly enable API-only mode:
+
+```bash
+bin/rails generate polylingo_chat:install --api-only
+bin/rails db:migrate
+```
+
+**API-only installation:**
+- ✅ Creates migrations and models
+- ✅ Creates API controllers (`Api::ConversationsController`, `Api::MessagesController`)
+- ✅ Adds API routes under `/api` namespace
+- ❌ Skips ActionCable channels
+- ❌ Skips JavaScript files
+- ❌ Skips Solid Cable setup
+
+### Using Polymorphic Associations
+
+PolylingoChat supports multiple participant types out of the box. Instead of limiting conversations to just Users, you can have Vendors, Customers, Admins, or any other model as participants.
+
+#### Example: Multi-Model Participants
+
+```ruby
+# Create a conversation
+conversation = PolylingoChat::Conversation.create!(title: "Support Ticket #123")
+
+# Add different types of participants
+user = User.find(1)
+vendor = Vendor.find(5)
+admin = Admin.find(2)
+
+conversation.add_participant(user, role: 'customer')
+conversation.add_participant(vendor, role: 'vendor')
+conversation.add_participant(admin, role: 'support')
+
+# Get all participants regardless of type
+conversation.participantables
+# => [#<User id: 1>, #<Vendor id: 5>, #<Admin id: 2>]
+
+# Get participants of a specific type
+conversation.participantables_of_type(Vendor)
+# => [#<Vendor id: 5>]
+
+# Backward compatibility - still works with User model
+conversation.users  # Returns all User participants
+```
+
+#### Sending Messages with Polymorphic Senders
+
+```ruby
+# Any model can send a message
+vendor = Vendor.find(5)
+PolylingoChat::Message.create!(
+  conversation: conversation,
+  sender: vendor,  # Polymorphic - can be User, Vendor, Customer, etc.
+  body: "We've shipped your order!"
+)
+
+# Message model automatically handles sender_name
+message.sender_name  # Tries: name, full_name, email, or "Unknown"
+```
+
+---
+
 ## 🎯 Usage
 
+### Using the API Endpoints
+
+PolylingoChat provides JSON API endpoints that work for both API-only and full-stack Rails applications:
+
+#### Create a Conversation
+
+```bash
+POST /polylingo_chat/conversations
+Content-Type: application/json
+
+{
+  "conversation": {
+    "title": "Project Discussion"
+  },
+  "participant_ids": [
+    { "type": "User", "id": 1, "role": "owner" },
+    { "type": "Vendor", "id": 5, "role": "participant" }
+  ]
+}
+```
+
+#### Send a Message
+
+```bash
+POST /polylingo_chat/conversations/:conversation_id/messages
+Content-Type: application/json
+
+{
+  "message": {
+    "body": "Hello! How are you?",
+    "language": "en"
+  },
+  "sender_type": "User",
+  "sender_id": 1
+}
+```
+
+#### Get Conversation with Messages
+
+```bash
+# Get conversation without specific language
+GET /polylingo_chat/conversations/:id.json
+
+# Get conversation with Spanish translations
+GET /polylingo_chat/conversations/:id.json?lang=es
+
+Response:
+{
+  "id": 1,
+  "title": "Project Discussion",
+  "participants": [
+    {
+      "id": 1,
+      "type": "User",
+      "participant_id": 1,
+      "role": "owner",
+      "name": "John Doe"
+    },
+    {
+      "id": 2,
+      "type": "Vendor",
+      "participant_id": 5,
+      "role": "participant",
+      "name": "ACME Corp"
+    }
+  ],
+  "messages": [
+    {
+      "id": 1,
+      "body": "Hello! How are you?",
+      "language": "en",
+      "translated": true,
+      "translation": "¡Hola! ¿Cómo estás?",
+      "translation_language": "es",
+      "available_translations": [
+        {"language": "es", "text": "¡Hola! ¿Cómo estás?"},
+        {"language": "fr", "text": "Bonjour! Comment allez-vous?"}
+      ],
+      "sender_type": "User",
+      "sender_id": 1,
+      "sender_name": "John Doe",
+      "created_at": "2025-01-15T10:30:00Z"
+    }
+  ]
+}
+```
+
+**New in v0.4.0:** The `?lang=` parameter returns cached translations from the database with zero API calls. The `available_translations` array shows all cached translations for each message.
+
+#### List All Messages in a Conversation
+
+```bash
+# Get messages without specific language
+GET /polylingo_chat/conversations/:conversation_id/messages.json
+
+# Get messages with French translations (from cache)
+GET /polylingo_chat/conversations/:conversation_id/messages.json?lang=fr
+
+Response:
+[
+  {
+    "id": 1,
+    "body": "Hello! How are you?",
+    "language": "en",
+    "translated": true,
+    "translation": "Bonjour! Comment allez-vous?",
+    "translation_language": "fr",
+    "available_translations": [
+      {"language": "es", "text": "¡Hola! ¿Cómo estás?"},
+      {"language": "fr", "text": "Bonjour! Comment allez-vous?"}
+    ],
+    "sender_type": "User",
+    "sender_id": 1,
+    "sender_name": "John Doe",
+    "conversation_id": 1,
+    "created_at": "2025-01-15T10:30:00Z",
+    "updated_at": "2025-01-15T10:30:05Z"
+  }
+]
+```
+
+### Full-Stack Usage (with ActionCable)
+
 ### 1. Set up your view
 
 First, expose the conversation and user IDs to JavaScript in your chat view:
@@ -165,14 +363,14 @@ First, expose the conversation and user IDs to JavaScript in your chat view:
 
 ```ruby
 # Create a conversation
-conversation = Conversation.create!(title: "Project Discussion")
+conversation = PolylingoChat::Conversation.create!(title: "Project Discussion")
 
 # Add participants
-Participant.create!(conversation: conversation, user: user1)
-Participant.create!(conversation: conversation, user: user2)
+conversation.add_participant(user1, role: 'member')
+conversation.add_participant(user2, role: 'member')
 
 # Send a message
-Message.create!(
+PolylingoChat::Message.create!(
   conversation: conversation,
   sender: user1,
   body: "Hello! How are you?"
@@ -280,25 +478,128 @@ Get key: https://ai.google.dev/
 
 ---
 
+## 💾 Translation Caching (New in v0.4.0)
+
+PolylingoChat now includes **database-backed translation caching** that dramatically reduces AI API costs and improves performance.
+
+### How Translation Caching Works
+
+1. **First Time Translation:**
+   - User sends a message → AI translates it for each participant's language
+   - Translations are saved to `polylingo_chat_message_translations` table
+   - One translation per language per message
+
+2. **Subsequent Retrievals:**
+   - Page reloads, API calls → translations loaded from database
+   - **Zero AI API calls** for cached translations
+   - Instant response times
+
+### Benefits
+
+- ✅ **Massive cost savings** - Translate once, retrieve unlimited times
+- ✅ **Lightning fast** - Database queries vs AI API calls
+- ✅ **Works offline** - No dependency on AI service availability for viewing
+- ✅ **Perfect for mobile** - Mobile apps get instant cached translations
+- ✅ **Scales effortlessly** - Database caching scales with your infrastructure
+
+### API Usage Example
+
+```bash
+# First time - translates and caches
+curl -X POST http://localhost:3000/polylingo_chat/conversations/1/messages.json \
+  -H "Content-Type: application/json" \
+  -d '{"message":{"body":"Hello!"},"sender_type":"User","sender_id":1}'
+
+# Response includes available_translations
+{
+  "id": 15,
+  "body": "Hello!",
+  "language": "en",
+  "available_translations": [
+    {"language": "es", "text": "¡Hola!"},
+    {"language": "fr", "text": "Bonjour!"}
+  ]
+}
+
+# Later retrievals - instant, no AI API calls
+curl http://localhost:3000/polylingo_chat/conversations/1/messages.json?lang=es
+
+# Returns cached Spanish translation immediately
+{
+  "translation": "¡Hola!",
+  "translation_language": "es",
+  "available_translations": [...]
+}
+```
+
+### Database Schema
+
+The `polylingo_chat_message_translations` table stores all cached translations:
+
+```ruby
+# Schema
+create_table :polylingo_chat_message_translations do |t|
+  t.references :message, null: false
+  t.string :language, null: false     # ISO 639-1 code (e.g., 'es', 'fr')
+  t.text :translated_text, null: false
+  t.timestamps
+
+  t.index [:message_id, :language], unique: true
+end
+```
+
+---
+
 ## 🏗️ How It Works
 
 ### Message Flow
 
 1. User sends a message → saved to database
-2. `Message#after_create_commit` enqueues job
+2. `Message#after_create_commit` enqueues translation job
 3. Job runs in background via your ActiveJob adapter
-4. **If API key present:** Message translated for each participant
+4. **If API key present:**
+   - Message translated for each participant's language
+   - Translations saved to `message_translations` table (cached)
+   - Future retrievals use cached translations (zero API calls)
 5. **If no API key:** Original message used for all participants
 6. Messages broadcast via ActionCable (using Solid Cable)
 7. Recipients see messages in real-time
 
 ### Models
 
-**Conversation** - Chat conversation with many participants and messages
-
-**Participant** - Join table linking Users to Conversations
-
-**Message** - Individual chat message with translation tracking
+All models are namespaced under `PolylingoChat::` and use the `polylingo_chat_` table prefix to prevent conflicts:
+
+**PolylingoChat::Conversation** - Chat conversation with many participants and messages
+- Table: `polylingo_chat_conversations`
+- Location: `app/models/polylingo_chat/conversation.rb`
+- `participantables` - Returns all participant records (polymorphic)
+- `participantables_of_type(klass)` - Returns participants of a specific type
+- `users` - Returns User participants (backward compatibility)
+- `add_participant(record, role: nil)` - Adds any model as a participant
+- `includes_participant?(record)` - Checks if a record is a participant
+
+**PolylingoChat::Participant** - Join table with polymorphic associations
+- Table: `polylingo_chat_participants`
+- Location: `app/models/polylingo_chat/participant.rb`
+- `participantable` - The actual participant (User, Vendor, Customer, etc.)
+- Supports multiple model types via polymorphic association
+- `user` alias for backward compatibility
+
+**PolylingoChat::Message** - Individual chat message with translation tracking
+- Table: `polylingo_chat_messages`
+- Location: `app/models/polylingo_chat/message.rb`
+- `sender` - Polymorphic association (User, Vendor, Customer, etc.)
+- `sender_name` - Helper method that works with any sender type
+- `translations` - Has many MessageTranslation records (cached translations)
+- `translation_for(language)` - Returns cached translation or original body
+- Automatic translation via background job if API key present
+
+**PolylingoChat::MessageTranslation** - Cached translations (New in v0.4.0)
+- Table: `polylingo_chat_message_translations`
+- Location: `app/models/polylingo_chat/message_translation.rb`
+- Stores one translation per language per message
+- Unique index on `[message_id, language]`
+- Dramatically reduces AI API costs by caching translations
 
 ### Solid Cable (Database-Backed WebSockets)
 
@@ -395,6 +696,66 @@ Perfect for:
 - Multi-language support systems
 - Cross-border collaboration
 
+### API-Only Mode
+Perfect for:
+- Mobile app backends (iOS, Android, React Native)
+- SPA frontends (React, Vue, Angular)
+- Microservices architectures
+- Custom WebSocket implementations
+- Multi-platform applications
+
+### Polymorphic Participants
+Perfect for:
+- Marketplace chats (Buyers ↔ Sellers ↔ Support)
+- Multi-tenant systems (Users ↔ Vendors ↔ Admins)
+- B2B platforms (Companies ↔ Representatives)
+- Healthcare apps (Patients ↔ Doctors ↔ Nurses)
+
+---
+
+## 🌐 Frontend Integration
+
+PolylingoChat works seamlessly with frontend frameworks like **React**, **Next.js**, **Vue**, **Angular**, and more.
+
+For a comprehensive guide on integrating with frontend applications, including:
+- Complete API endpoint documentation
+- React component examples with TypeScript
+- Next.js integration patterns
+- Real-time update strategies (polling, WebSocket, third-party services)
+- Authentication patterns
+- Translation query parameters
+
+See the **[Frontend Integration Guide](FRONTEND_INTEGRATION.md)** for complete details.
+
+### Quick Example (React + TypeScript)
+
+```typescript
+// Fetch messages with translation
+const messages = await fetch(
+  `/polylingo_chat/conversations/1/messages?translate=true&target_language=es`,
+  {
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    }
+  }
+).then(r => r.json());
+
+// Send a message
+await fetch('/polylingo_chat/conversations/1/messages', {
+  method: 'POST',
+  headers: {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({
+    message: { body: "Hello!" },
+    sender_type: "User",
+    sender_id: 1
+  })
+});
+```
+
 ---
 
 ## 🤝 Contributing

data/lib/generators/polylingo_chat/install/README

@@ -0,0 +1,72 @@
+===============================================================================
+
+PolylingoChat has been installed successfully!
+
+Models, Controllers, Views, and Jobs are provided by the gem (like Devise).
+They are located in the gem's app/ directory and can be overridden by creating
+files with the same path in your application's app/ directory.
+
+Next steps:
+
+1. Run migrations:
+   rails db:migrate
+
+2. Ensure your User model has a `preferred_language` column (optional):
+   rails g migration AddPreferredLanguageToUsers preferred_language:string
+   rails db:migrate
+
+3. Configure your AI provider in config/initializers/polylingo_chat.rb:
+   - Set config.api_key with your API key
+   - Choose your provider (:openai, :anthropic, or :gemini)
+   - Or leave api_key as nil for chat-only mode (no translation)
+
+4. Set up Solid Cable for production:
+   - Already configured for development
+   - For production, ensure database is configured in config/cable.yml
+
+5. For ActionCable/real-time chat (full-stack apps):
+   # Already set up automatically during installation
+   # JavaScript files and channels are configured
+
+6. Add this to your User model:
+   # app/models/user.rb
+   class User < ApplicationRecord
+     # Optional: for chat functionality
+     has_many :polylingo_chat_participants,
+              class_name: "PolylingoChat::Participant",
+              as: :participantable,
+              dependent: :destroy
+     has_many :polylingo_chat_conversations,
+              through: :polylingo_chat_participants,
+              source: :conversation
+     has_many :polylingo_chat_messages,
+              class_name: "PolylingoChat::Message",
+              as: :sender,
+              dependent: :destroy
+   end
+
+7. To customize models, controllers, or views, create files in your app:
+   # app/models/polylingo_chat/conversation.rb
+   module PolylingoChat
+     class Conversation < ApplicationRecord
+       # Your custom code here - this will override the gem's version
+     end
+   end
+
+   # app/controllers/polylingo_chat/conversations_controller.rb
+   module PolylingoChat
+     class ConversationsController < ApplicationController
+       # Your custom code here - this will override the gem's version
+     end
+   end
+
+8. Visit your conversations:
+   - HTML: http://localhost:3000/polylingo_chat/conversations
+   - JSON API: http://localhost:3000/polylingo_chat/conversations.json
+
+For frontend integration (React, Next.js, Vue, Angular):
+   See: FRONTEND_INTEGRATION.md in the gem's directory
+
+For more information, visit: https://github.com/AdwareTechnologies/polylingo_chat
+
+===============================================================================

data/lib/generators/polylingo_chat/install/install_generator.rb

@@ -8,26 +8,30 @@ module PolylingoChat
 
       source_root File.expand_path('templates', __dir__)
 
+      class_option :api_only, type: :boolean, default: nil,
+                   desc: "Install for API-only Rails app (skip ActionCable/frontend)"
+
       desc "Installs PolylingoChat with real-time multilingual chat"
 
+      def initialize(*args)
+        super
+        @api_only = detect_api_only_mode
+      end
+
       def self.next_migration_number(dirname)
         next_migration_number = current_migration_number(dirname) + 1
         ActiveRecord::Migration.next_migration_number(next_migration_number)
       end
 
       def copy_migrations
-        migration_template "create_conversations.rb", "db/migrate/create_conversations.rb"
-        migration_template "create_participants.rb", "db/migrate/create_participants.rb"
-        migration_template "create_messages.rb", "db/migrate/create_messages.rb"
-      end
-
-      def create_models
-        template "models/conversation.rb", "app/models/conversation.rb"
-        template "models/participant.rb", "app/models/participant.rb"
-        template "models/message.rb", "app/models/message.rb"
+        migration_template "create_conversations.rb", "db/migrate/create_polylingo_chat_conversations.rb"
+        migration_template "create_participants.rb", "db/migrate/create_polylingo_chat_participants.rb"
+        migration_template "create_messages.rb", "db/migrate/create_polylingo_chat_messages.rb"
+        migration_template "create_message_translations.rb", "db/migrate/create_polylingo_chat_message_translations.rb"
       end
 
       def create_channels
+        return if @api_only
         empty_directory "app/channels/application_cable"
         template "channels/application_cable/channel.rb", "app/channels/application_cable/channel.rb"
         template "channels/application_cable/connection.rb", "app/channels/application_cable/connection.rb"
@@ -35,6 +39,7 @@ module PolylingoChat
       end
 
       def create_javascript_files
+        return if @api_only
         empty_directory "app/javascript/channels"
         template "javascript/chat.js", "app/javascript/chat.js"
         template "javascript/channels/consumer.js", "app/javascript/channels/consumer.js"
@@ -42,6 +47,7 @@ module PolylingoChat
       end
 
       def configure_cable
+        return if @api_only
         if File.exist?("config/cable.yml")
           gsub_file "config/cable.yml", /^development:\s*\n\s+adapter:\s+\w+.*$/m do |match|
             "development:\n  adapter: solid_cable\n  polling_interval: 0.1.seconds\n  message_retention: 1.day"
@@ -50,26 +56,28 @@ module PolylingoChat
       end
 
       def setup_solid_cable
+        return if @api_only
         say "Setting up Solid Cable...", :green
         rails_command "solid_cable:install", abort_on_failure: false
       end
 
       def download_actioncable
+        return if @api_only
         empty_directory "vendor/javascript"
         say "Downloading ActionCable ESM module...", :green
         run "curl -o vendor/javascript/@rails--actioncable.js https://ga.jspm.io/npm:@rails/actioncable@7.1.3/app/assets/javascripts/actioncable.esm.js"
       end
 
       def add_routes
-        route 'mount ActionCable.server => "/cable"'
-        route <<~RUBY
-          resources :conversations do
-            resources :messages, only: [:create]
-          end
-        RUBY
+        unless @api_only
+          route 'mount ActionCable.server => "/cable"'
+        end
+
+        route 'mount PolylingoChat::Engine => "/polylingo_chat"'
       end
 
       def update_importmap
+        return if @api_only
         if File.exist?("config/importmap.rb")
           append_to_file "config/importmap.rb" do
             <<~RUBY
@@ -84,6 +92,7 @@ module PolylingoChat
       end
 
       def update_application_js
+        return if @api_only
         if File.exist?("app/javascript/application.js")
           append_to_file "app/javascript/application.js" do
             <<~JS
@@ -102,6 +111,26 @@ module PolylingoChat
       def show_readme
         readme "README" if behavior == :invoke
       end
+
+      private
+
+      def detect_api_only_mode
+        # Use explicit option if provided
+        return options[:api_only] unless options[:api_only].nil?
+
+        # Auto-detect: Check if this is an API-only Rails app
+        # API-only apps typically don't have ActionView or have it explicitly disabled
+        api_only = !defined?(ActionView::Base) ||
+                   (defined?(Rails.application) && Rails.application.config.respond_to?(:api_only) && Rails.application.config.api_only)
+
+        if api_only
+          say "Detected API-only Rails application. Skipping ActionCable/frontend setup.", :yellow
+        else
+          say "Installing with full-stack support (ActionCable + frontend).", :green
+        end
+
+        api_only
+      end
     end
   end
 end

data/lib/generators/polylingo_chat/install/templates/channels/polylingo_chat_channel.rb

@@ -1,4 +1,4 @@
-class PolylinguoChatChannel < ApplicationCable::Channel
+class PolylingoChatChannel < ApplicationCable::Channel
   def subscribed
     conversation_id = params[:conversation_id]