Backend Architecture

This section documents the reactive architecture patterns used in the Sidechain VST Plugin. The plugin follows a modern C++26 reactive architecture with unidirectional data flow, eliminating callback hell and providing automatic UI updates.

Architecture Guide:

• Complete Architecture Guide
• Quick Start (5 Minutes)
  • Your First Store Integration
• Core Principles
• Architecture Layers
• The 9 Core Stores
• Observable Collections
• Data Flow Patterns
  • Feed Loading Flow
  • Optimistic Update Flow
• Threading Model
  • Audio Thread (Real-Time, Lock-Free)
  • Message Thread (UI Thread, JUCE)
  • Background Threads (Network, File I/O)
  • Async Pattern
• Component Patterns
  • Container/Presentation Pattern
• Testing Strategies
  • Unit Testing Stores
• Common Best Practices
  • Immutable Updates
  • Error Handling
  • Subscription Cleanup
• Troubleshooting
  • Component Not Updating When Store Changes
  • State Changes But Nobody Notified
  • Memory Leaks from Store Subscriptions
• See Also
• Store Pattern
  • Core Concepts
  • Store Architecture
  • Entity Stores
  • Domain Stores
  • Store Base Class
  • Subscription Lifecycle
  • Best Practices
  • Thread Safety
  • See Also
• Observable Pattern
  • Core Observable Types
  • Reactive Composition
  • Performance Characteristics
  • Best Practices
  • Common Patterns
  • See Also
• Reactive Components
  • Overview
  • Basic Usage
  • Binding Methods
  • Lifecycle & Thread Safety
  • Real-World Examples
  • Performance Considerations
  • Best Practices
  • Migration Guide
  • See Also
• Data Flow Patterns
  • Unidirectional Data Flow
  • Complete Flow Examples
  • Performance Patterns
  • Testing Patterns
  • See Also
• Threading Model
  • Thread Types
  • Thread Safety Rules
  • Common Patterns
  • Observable Thread Safety
  • Debugging Thread Issues
  • Performance Profiling
  • Best Practices Summary
  • See Also
• Service Layer
  • Architecture Pattern
  • Current State
  • Planned Services
  • Migration Pattern
  • Benefits of Service Layer
  • Service Implementation Patterns
  • Testing Services
  • Best Practices
  • Migration Timeline
  • See Also

Overview

The Sidechain plugin architecture is built on three core concepts:

1. Store Pattern - Centralized state management with reactive subscriptions

2. Observable Pattern - Reactive data bindings with automatic updates

3. Unidirectional Data Flow - Predictable state changes and UI updates

Key Benefits

• Single Source of Truth: All state lives in stores (PostsStore, ChatStore, UserStore)

• Automatic UI Updates: Components automatically repaint when store state changes

• Type Safety: Full C++26 type checking with templates

• Thread Safety: Proper message thread marshalling with JUCE integration

• Testability: Pure functions and dependency injection enable comprehensive testing

Architecture Diagram

┌─────────────────────────────────────────────────────────────┐
│                     User Interface Layer                     │
│  (PostsFeed, MessageThread, ProfileView - ReactiveBoundComponent) │
└────────────────────┬────────────────────────────────────────┘
                     │ subscribe()
                     ▼
┌─────────────────────────────────────────────────────────────┐
│                      Store Layer                             │
│     (PostsStore, ChatStore, UserStore - Store<TState>)       │
└────────────────────┬────────────────────────────────────────┘
                     │ dispatch()
                     ▼
┌─────────────────────────────────────────────────────────────┐
│                    Service Layer                             │
│    (FeedService, AudioService, AuthService)                  │
└────────────────────┬────────────────────────────────────────┘
                     │ API calls
                     ▼
┌─────────────────────────────────────────────────────────────┐
│                   Network Layer                              │
│   (NetworkClient, WebSocketClient, StreamChatClient)         │
└─────────────────────────────────────────────────────────────┘

Modern C++ Features Used

• C++26 Standard: Full use of modern C++ features

• Smart Pointers: std::unique_ptr, std::shared_ptr for RAII

• Templates: ObservableProperty<T>, Store<TState>

• Lambda Expressions: Reactive subscriptions and callbacks

• std::function: Type-safe function objects

• std::atomic: Lock-free audio thread communication

• Move Semantics: Efficient resource transfer

See Also

• Store Pattern - Centralized state management

• Observable Pattern - Reactive property bindings

• Reactive Components - UI component integration

• Data Flow Patterns - Data flow patterns and examples

• Threading Model - Threading model and safety

• Service Layer - Business logic layer

Backend Integration

For information about backend support and requirements:

• Backend Investigation Notes - Assessment of backend support for real-time collaboration (OT, error tracking, rate limiting)

Known Issues:

• Operational Transform: Not implemented on backend (required for Task 4.20)

• Error Tracking API: Not implemented (required for Task 4.19)

• Rate Limiting: Implemented with minor header bug in Retry-After header