Documentation
Overview
Architecture Overview

Architecture Overview

The Matrix Middleware Framework introduces a revolutionary dual-interpretation architecture that allows the same XAML to serve both as a UI prototype in WPF and as a runtime middleware configuration.

Key Concepts

1. Dual Interpretation

  • WPF Interpretation: XAML renders as interactive UI components for prototyping and monitoring
  • Runtime Interpretation: Same XAML deploys as middleware geometry with routing logic

2. Geometry System

The framework uses geometric abstractions to represent middleware relationships:

interface IGeometry {
    addNode(node: INode): void;
    removeNode(node: INode): void;
    routeEvent(event: MiddlewareEvent): Promise<void>;
}

class TreeGeometry implements IGeometry {
    private root: TreeNode;
    private routingStrategy: IRoutingStrategy;

    constructor(strategy: IRoutingStrategy) {
        this.routingStrategy = strategy;
    }

    // Implementation details...
}

3. Routing Strategies

Events flow through the geometry using configurable routing strategies:

interface IRoutingStrategy {
    routeEvent(event: MiddlewareEvent, node: INode): Promise<void>;
}

class TreeTunnelRoutingStrategy implements IRoutingStrategy {
    async routeEvent(event: MiddlewareEvent, node: TreeNode): Promise<void> {
        await node.handleEvent(event);
        if (!event.handled) {
            for (const child of node.children) {
                await this.routeEvent(event, child);
            }
        }
    }
}

XAML Integration

The framework extends WPF’s XAML to support middleware concepts:

<TreeGeometry xmlns="http://schemas.codeium.com/middleware/2023"
             xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
    
    <!-- WPF UI Representation -->
    <wpf:TreePanel x:Name="UITree" 
                   Background="LightGray"
                   Width="800" Height="600">
        
        <!-- Middleware Configuration -->
        <MQTTConnector Name="MQTTConnector" Path=":mqtt"
                      Host="{Binding MQTTHost}"
                      Port="{Binding MQTTPort}"
                      onConnect="handleConnect">
            
            <JWTAuthorizationComponent Name="JWTAuth" Path=":jwt"
                                     Secret="{Binding JWTSecret}"
                                     onAuthorize="handleAuth">
                
                <TerminalComponent Name="Terminal" Path=":terminal"
                                 BufferSize="1024"
                                 onCommand="handleCommand"/>
                
            </JWTAuthorizationComponent>
        </MQTTConnector>
    </wpf:TreePanel>
</TreeGeometry>

Runtime Deployment

During runtime deployment:

  1. XAML is parsed to extract middleware configuration
  2. WPF-specific elements are ignored
  3. Geometry and routing strategy are instantiated
  4. Components are connected according to the tree structure

Monitoring and Control

The WPF UI can:

  • Visualize the middleware tree structure
  • Monitor event flow and component state
  • Trigger test events and observe routing
  • Modify runtime configuration through data binding

Benefits

  1. Unified Development

    • Single source of truth in XAML
    • Visual prototyping with immediate feedback
    • Runtime deployment without reconfiguration

  2. Powerful Abstractions

    • Geometric representation of middleware relationships
    • Flexible routing strategies
    • Component-based architecture

  3. Developer Experience

    • Familiar WPF tooling and patterns
    • Visual debugging and monitoring
    • Declarative configuration