@codai/cbd/dist/features/realtime-sync.d.ts

Codai Better Database - High-Performance Vector Memory System with HPKV-inspired architecture and MCP server

/**
 * Real-time Data Synchronization and Streaming
 * WebSocket streaming, live updates, conflict resolution, multi-instance sync
 */
import { EventEmitter } from 'events';
interface SyncConfig {
    enableWebSocket: boolean;
    enableSocketIO: boolean;
    enableSSE: boolean;
    port: number;
    maxConnections: number;
    heartbeatInterval: number;
    conflictResolution: 'last-write-wins' | 'timestamp-based' | 'vector-clock' | 'custom';
    replicationStrategy: 'master-slave' | 'master-master' | 'peer-to-peer';
}
interface RealtimeSubscription {
    id: string;
    clientId: string;
    collection: string;
    query?: any;
    filters?: any[];
    transformations?: string[];
    active: boolean;
    createdAt: Date;
    lastActivity: Date;
}
interface SyncEvent {
    id: string;
    type: 'insert' | 'update' | 'delete' | 'batch';
    collection: string;
    documentId?: string;
    data?: any;
    timestamp: number;
    sourceInstance: string;
    vectorClock?: Map<string, number>;
    checksum?: string;
}
interface ConflictResolution {
    strategy: string;
    conflictedFields: string[];
    resolution: 'accepted' | 'rejected' | 'merged';
    resolvedValue: any;
    timestamp: number;
}
declare class RealtimeDataSynchronization extends EventEmitter {
    private config;
    private wsServer;
    private socketIOServer;
    private activeConnections;
    private subscriptions;
    private syncEventQueue;
    private instanceId;
    private vectorClock;
    private conflictResolver;
    private replicationManager;
    private performanceMetrics;
    constructor(config: SyncConfig);
    private initializeRealtimeSync;
    /**
     * WebSocket Server Setup and Management
     */
    private setupWebSocketServer;
    /**
     * Real-time Data Streaming
     */
    createLiveSubscription(clientId: string, collection: string, query?: any, options?: {
        filters?: any[];
        transformations?: string[];
        initialData?: boolean;
    }): Promise<RealtimeSubscription>;
    /**
     * Broadcast Data Changes
     */
    broadcastDataChange(collection: string, changeType: 'insert' | 'update' | 'delete', documentId: string, data?: any, options?: {
        excludeClient?: string;
        includeOnly?: string[];
        applyFilters?: boolean;
    }): Promise<{
        messagesSent: number;
        failedDeliveries: number;
        processingTime: number;
    }>;
    /**
     * Conflict Resolution
     */
    resolveConflict(conflictingEvents: SyncEvent[]): Promise<{
        resolution: ConflictResolution;
        resolvedEvent: SyncEvent;
        discardedEvents: SyncEvent[];
    }>;
    /**
     * Multi-Instance Synchronization
     */
    synchronizeWithInstances(targetInstances: string[]): Promise<{
        synchronizedInstances: string[];
        failedInstances: string[];
        syncedEvents: number;
        totalTime: number;
    }>;
    /**
     * Live Query Subscriptions
     */
    createLiveQuery(clientId: string, collection: string, query: any, options?: {
        aggregations?: any[];
        sorting?: any;
        pagination?: {
            limit: number;
            offset: number;
        };
        debounceMs?: number;
    }): Promise<string>;
    private generateClientId;
    private handleClientMessage;
    private handleClientDisconnect;
    private sendToClient;
    private sendInitialData;
    private processDataForClient;
    private applyFilters;
    private applyTransformations;
    private generateChecksum;
    private setupSocketIOServer;
    private setupServerSentEvents;
    private setupHeartbeat;
    private setupCleanup;
    private setupPerformanceMonitoring;
    private setupLiveQueryProcessing;
    private removeSubscription;
}
export { RealtimeDataSynchronization, SyncConfig, RealtimeSubscription, SyncEvent, ConflictResolution };
//# sourceMappingURL=realtime-sync.d.ts.map