# How to Build Real-Time Chat Applications with Supabase

This blog post is a comprehensive guide on building real-time chat applications using Supabase, covering database schema design, real-time subscriptions, user presence, and production considerations.

## Key Topics Covered:

### 1. Why Choose Supabase for Real-Time Chat
- Native PostgreSQL real-time subscriptions
- Row-level security for message privacy
- Integrated authentication with social providers
- Automatic scaling without infrastructure management
- Full TypeScript support with generated types

### 2. Database Schema Design
- Chat rooms/channels table structure
- Messages table with support for different message types
- User presence tracking
- Room membership and permissions
- Proper foreign key relationships and constraints

### 3. Row-Level Security Implementation
- Enabling RLS on all tables
- Policies for message access control
- User can only access rooms they're members of
- Secure message insertion and reading policies

### 4. Real-Time Subscriptions Setup
- Supabase client configuration for real-time
- WebSocket subscriptions for new messages
- Handling real-time updates in React components
- Message synchronization and state management

### 5. User Presence Implementation
- Real-time presence tracking
- Online/offline status monitoring
- Join/leave event handling
- Presence state synchronization

### 6. Message Broadcasting and Handling
- Sending different message types (text, images, files)
- File upload integration with Supabase Storage
- Message broadcasting to all room members
- Error handling and validation

### 7. Performance Optimization
- Message pagination strategies
- Database indexing for performance
- Message compression techniques
- Automatic cleanup of old data
- Caching strategies for user profiles

### 8. Production Considerations
- Rate limiting to prevent spam
- Content moderation and reporting
- Automated database backups
- Real-time connection monitoring
- Horizontal scaling planning

## Technical Implementation Details:

### Database Schema
```sql
-- Chat rooms table
CREATE TABLE chat_rooms (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  name TEXT NOT NULL,
  description TEXT,
  created_by UUID REFERENCES auth.users(id),
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Messages table
CREATE TABLE messages (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  room_id UUID REFERENCES chat_rooms(id) ON DELETE CASCADE,
  user_id UUID REFERENCES auth.users(id),
  content TEXT NOT NULL,
  message_type TEXT DEFAULT 'text' CHECK (message_type IN ('text', 'image', 'file')),
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- User presence table
CREATE TABLE user_presence (
  user_id UUID REFERENCES auth.users(id) PRIMARY KEY,
  last_seen TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  is_online BOOLEAN DEFAULT false,
  status TEXT DEFAULT 'offline'
);

-- Room members table
CREATE TABLE room_members (
  room_id UUID REFERENCES chat_rooms(id) ON DELETE CASCADE,
  user_id UUID REFERENCES auth.users(id),
  role TEXT DEFAULT 'member' CHECK (role IN ('owner', 'admin', 'member')),
  joined_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  PRIMARY KEY (room_id, user_id)
);
```

### Real-Time Client Setup

// Subscribe to new messages
const subscription = supabase
  .channel(`room:${roomId}`)
  .on(
    'postgres_changes',
    {
      event: 'INSERT',
      schema: 'public',
      table: 'messages',
      filter: `room_id=eq.${roomId}`
    },
    (payload) => {
      setMessages(prev => [...prev, payload.new])
    }
  )
  .subscribe()
```

### Row-Level Security Policies
```sql
-- Enable RLS
ALTER TABLE messages ENABLE ROW LEVEL SECURITY;

-- Users can read messages from rooms they're members of
CREATE POLICY "Users can read messages from rooms they're members of" 
ON messages 
FOR SELECT 
USING (
  room_id IN (
    SELECT room_id FROM room_members 
    WHERE user_id = auth.uid()
  )
);

-- Users can insert messages to rooms they're members of
CREATE POLICY "Users can insert messages to rooms they're members of" 
ON messages 
FOR INSERT 
WITH CHECK (
  user_id = auth.uid() AND
  room_id IN (
    SELECT room_id FROM room_members 
    WHERE user_id = auth.uid()
  )
);
```

## Target Audience:
- Developers building real-time applications
- Teams looking to implement chat functionality
- Supabase users wanting to leverage real-time features
- Full-stack developers interested in modern chat solutions

## Technologies Covered:
- Supabase (Database, Real-time, Storage, Auth)
- PostgreSQL
- TypeScript/JavaScript
- React (for client examples)
- Row-Level Security (RLS)
- WebSocket subscriptions

This guide provides a complete foundation for building production-ready chat applications using Supabase's powerful real-time capabilities, with proper security, performance optimization, and scalability considerations.