Maximizing Coding Speed with Copilot Chat: Senior Developer Guide That Tripled My Velocity

/chat

I need to implement a real-time notification system for our e-commerce platform. 
Current architecture: React frontend, Node.js/Express backend, PostgreSQL database, Redis cache.

Requirements:
- Real-time notifications for order updates, inventory changes, and promotions
- Support for 50K concurrent users
- Mobile push notifications + web notifications
- Admin dashboard for managing notification campaigns
- A/B testing for notification content

Please suggest:
1. Architecture approach (WebSockets vs Server-Sent Events vs Push API)
2. Database schema design for notifications
3. Scalability considerations and potential bottlenecks
4. Security and privacy implications
5. Integration points with existing auth system
6. Testing strategy for real-time features

Let's discuss the tradeoffs before I start implementation.

I'll help you design a robust notification system. Let me analyze your requirements:

## Architecture Recommendation: Hybrid Approach

### 1. Real-Time Delivery Layer
**WebSocket + Server-Sent Events Hybrid:**
- WebSockets for interactive features (order tracking, live inventory)
- SSE for one-way updates (marketing notifications, system alerts)
- Fallback to polling for unreliable connections

### 2. Database Schema Design
```sql
-- Core notification tables
CREATE TABLE notification_templates (
    id UUID PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    type notification_type NOT NULL,
    title_template TEXT NOT NULL,
    body_template TEXT NOT NULL,
    metadata JSONB DEFAULT '{}',
    created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE user_notifications (
    id UUID PRIMARY KEY,
    user_id UUID REFERENCES users(id),
    template_id UUID REFERENCES notification_templates(id),
    title TEXT NOT NULL,
    body TEXT NOT NULL,
    data JSONB DEFAULT '{}',
    status notification_status DEFAULT 'pending',
    scheduled_for TIMESTAMP DEFAULT NOW(),
    sent_at TIMESTAMP,
    read_at TIMESTAMP,
    created_at TIMESTAMP DEFAULT NOW()
);

-- Delivery tracking
CREATE TABLE notification_deliveries (
    id UUID PRIMARY KEY,
    notification_id UUID REFERENCES user_notifications(id),
    channel delivery_channel NOT NULL,
    status delivery_status DEFAULT 'pending',
    external_id VARCHAR(255),
    error_message TEXT,
    attempted_at TIMESTAMP DEFAULT NOW()
);

// Generated by Copilot Chat with full business context

import { Injectable, Logger } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { EventEmitter2 } from '@nestjs/event-emitter';
import { InjectRedis } from '@liaoliaots/nestjs-redis';
import Redis from 'ioredis';

// Domain entities and DTOs
interface NotificationChannel {
  type: 'push' | 'email' | 'sms' | 'in_app';
  priority: number;
  retryAttempts: number;
  backoffMultiplier: number;
}

interface NotificationContext {
  userId: string;
  templateId: string;
  data: Record<string, any>;
  channels: NotificationChannel[];
  scheduledFor?: Date;
  abTestGroup?: string;
}

interface DeliveryResult {
  channel: string;
  success: boolean;
  externalId?: string;
  error?: string;
  deliveredAt: Date;
}

@Injectable()
export class NotificationService {
  private readonly logger = new Logger(NotificationService.name);
  
  constructor(
    @InjectRepository(UserNotification)
    private notificationRepo: Repository<UserNotification>,
    
    @InjectRepository(NotificationTemplate)
    private templateRepo: Repository<NotificationTemplate>,
    
    @InjectRepository(NotificationDelivery)
    private deliveryRepo: Repository<NotificationDelivery>,
    
    @InjectRedis() private redis: Redis,
    private eventEmitter: EventEmitter2,
    private templateRenderer: TemplateRenderer,
    private rateLimiter: RateLimiter,
    private pushNotificationProvider: PushNotificationProvider,
    private emailProvider: EmailProvider,
    private smsProvider: SMSProvider
  ) {}
  
  /**
   * Send notification through optimal channels based on user preferences
   * and A/B testing configuration
   */
  async sendNotification(context: NotificationContext): Promise<string> {
    const correlationId = generateCorrelationId();
    
    this.logger.info('Processing notification request', {
      correlationId,
      userId: context.userId,
      templateId: context.templateId,
      channels: context.channels.map(c => c.type)
    });
    
    try {
      // 1. Rate limiting check
      await this.enforceRateLimit(context.userId);
      
      // 2. Load and render template
      const renderedNotification = await this.renderNotification(context);
      
      // 3. Create notification record
      const notification = await this.createNotificationRecord(
        context, 
        renderedNotification, 
        correlationId
      );
      
      // 4. Schedule or send immediately
      if (context.scheduledFor && context.scheduledFor > new Date()) {
        await this.scheduleNotification(notification, context.scheduledFor);
      } else {
        // Send through channels in priority order
        this.processNotificationChannels(notification, context.channels);
      }
      
      this.logger.info('Notification processing initiated', {
        correlationId,
        notificationId: notification.id
      });
      
      return notification.id;
      
    } catch (error) {
      this.logger.error('Notification processing failed', {
        correlationId,
        userId: context.userId,
        error: error.message,
        stack: error.stack
      });
      
      // Emit failure event for monitoring
      this.eventEmitter.emit('notification.failed', {
        userId: context.userId,
        templateId: context.templateId,
        error: error.message,
        correlationId
      });
      
      throw new NotificationProcessingException(
        `Failed to process notification: ${error.message}`,
        correlationId
      );
    }
  }
  
  private async processNotificationChannels(
    notification: UserNotification,
    channels: NotificationChannel[]
  ): Promise<void> {
    // Sort channels by priority
    const sortedChannels = channels.sort((a, b) => b.priority - a.priority);
    
    // Process channels concurrently with proper error isolation
    const deliveryPromises = sortedChannels.map(async (channel) => {
      try {
        const result = await this.deliverThroughChannel(notification, channel);
        
        // Record successful delivery
        await this.recordDelivery(notification.id, channel.type, result);
        
        this.logger.debug('Channel delivery succeeded', {
          notificationId: notification.id,
          channel: channel.type,
          externalId: result.externalId
        });
        
        return result;
        
      } catch (error) {
        this.logger.warn('Channel delivery failed', {
          notificationId: notification.id,
          channel: channel.type,
          error: error.message
        });
        
        // Record failed delivery for retry processing
        await this.recordDelivery(notification.id, channel.type, {
          success: false,
          error: error.message,
          channel: channel.type,
          deliveredAt: new Date()
        });
        
        // Schedule retry if attempts remaining
        if (channel.retryAttempts > 0) {
          await this.scheduleRetry(notification, channel, error);
        }
        
        throw error;
      }
    });
    
    // Wait for all channels to complete (or fail)
    const results = await Promise.allSettled(deliveryPromises);
    
    // Emit completion event with results summary
    const successCount = results.filter(r => r.status === 'fulfilled').length;
    this.eventEmitter.emit('notification.processed', {
      notificationId: notification.id,
      channelCount: channels.length,
      successCount,
      failureCount: channels.length - successCount
    });
  }
  
  private async deliverThroughChannel(
    notification: UserNotification,
    channel: NotificationChannel
  ): Promise<DeliveryResult> {
    
    switch (channel.type) {
      case 'push':
        return await this.sendPushNotification(notification);
      case 'email':
        return await this.sendEmailNotification(notification);
      case 'sms':
        return await this.sendSMSNotification(notification);
      case 'in_app':
        return await this.sendInAppNotification(notification);
      default:
        throw new UnsupportedChannelException(`Unknown channel: ${channel.type}`);
    }
  }
  
  private async enforceRateLimit(userId: string): Promise<void> {
    const rateLimitKey = `notification_rate_limit:${userId}`;
    const currentHour = new Date().getHours();
    
    // Check hourly limit (e.g., 50 notifications per hour)
    const hourlyCount = await this.redis.get(`${rateLimitKey}:${currentHour}`);
    
    if (hourlyCount && parseInt(hourlyCount) >= 50) {
      throw new RateLimitExceededException(
        `User ${userId} exceeded hourly notification limit`
      );
    }
    
    // Increment counter with expiration
    await this.redis.multi()
      .incr(`${rateLimitKey}:${currentHour}`)
      .expire(`${rateLimitKey}:${currentHour}`, 3600)
      .exec();
  }
  
  // ... Additional methods for template rendering, delivery recording, etc.
}

// Comprehensive unit test structure generated by Copilot
describe('NotificationService', () => {
  let service: NotificationService;
  let mockNotificationRepo: MockRepository<UserNotification>;
  let mockRedis: jest.Mocked<Redis>;
  
  beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [
        NotificationService,
        { provide: getRepositoryToken(UserNotification), useClass: MockRepository },
        { provide: 'default_IORedisModuleConnectionToken', useValue: mockRedis },
        // ... other mocked dependencies
      ],
    }).compile();
    
    service = module.get<NotificationService>(NotificationService);
  });
  
  describe('sendNotification', () => {
    it('should process notification through multiple channels', async () => {
      const context: NotificationContext = {
        userId: 'user123',
        templateId: 'welcome_template',
        data: { userName: 'John Doe' },
        channels: [
          { type: 'push', priority: 10, retryAttempts: 3, backoffMultiplier: 2 },
          { type: 'email', priority: 5, retryAttempts: 2, backoffMultiplier: 1.5 }
        ]
      };
      
      const notificationId = await service.sendNotification(context);
      
      expect(notificationId).toBeDefined();
      expect(mockNotificationRepo.save).toHaveBeenCalledWith(
        expect.objectContaining({
          userId: 'user123',
          templateId: 'welcome_template'
        })
      );
    });
    
    it('should enforce rate limits', async () => {
      mockRedis.get.mockResolvedValue('50'); // At limit
      
      const context: NotificationContext = {
        userId: 'user123',
        templateId: 'test',
        data: {},
        channels: [{ type: 'push', priority: 10, retryAttempts: 0, backoffMultiplier: 1 }]
      };
      
      await expect(service.sendNotification(context))
        .rejects.toThrow(RateLimitExceededException);
    });
  });
});

/chat

Review this notification service code for:
1. Performance bottlenecks and optimization opportunities
2. Security vulnerabilities and best practices
3. Error handling completeness
4. Scalability concerns
5. Code maintainability improvements
6. Monitoring and observability gaps

Provide specific recommendations with code examples for each issue.