cs-element
Version:
Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support
319 lines • 9.91 kB
TypeScript
import { CSElementPlugin } from '../types/plugin-interfaces';
export interface PluginContext {
element: CSElement;
operation: string;
[key: string]: any;
}
export interface PluginResult {
success: boolean;
data?: any;
error?: string;
[key: string]: any;
}
import { CSElement } from '../core/CSElement';
export declare enum NetworkOperation {
SYNC = "sync",
UPLOAD = "upload",
DOWNLOAD = "download",
BROADCAST = "broadcast",
SUBSCRIBE = "subscribe",
UNSUBSCRIBE = "unsubscribe",
PING = "ping",
HEARTBEAT = "heartbeat"
}
export declare enum ConnectionType {
HTTP = "http",
WEBSOCKET = "websocket",
TCP = "tcp",
UDP = "udp",
GRPC = "grpc",
MQTT = "mqtt"
}
export declare enum SyncStrategy {
FULL_SYNC = "full_sync",
INCREMENTAL_SYNC = "incremental_sync",
CONFLICT_RESOLUTION = "conflict_resolution",
MERGE = "merge",
OVERWRITE = "overwrite"
}
export declare enum NetworkStatus {
CONNECTED = "connected",
DISCONNECTED = "disconnected",
CONNECTING = "connecting",
RECONNECTING = "reconnecting",
ERROR = "error"
}
export declare enum ConflictResolution {
LOCAL_WINS = "local_wins",
REMOTE_WINS = "remote_wins",
TIMESTAMP_WINS = "timestamp_wins",
MERGE_CHANGES = "merge_changes",
MANUAL_RESOLUTION = "manual_resolution"
}
export interface NetworkEndpoint {
id: string;
name: string;
url: string;
type: ConnectionType;
headers?: Record<string, string>;
authentication?: AuthenticationConfig;
timeout: number;
retryCount: number;
retryDelay: number;
isActive: boolean;
lastConnected?: Date;
lastError?: string;
metadata: Record<string, any>;
}
export interface AuthenticationConfig {
type: 'none' | 'basic' | 'bearer' | 'apikey' | 'oauth2' | 'custom';
credentials: Record<string, string>;
refreshToken?: string;
expiresAt?: Date;
}
export interface SyncConfiguration {
id: string;
name: string;
endpointId: string;
strategy: SyncStrategy;
conflictResolution: ConflictResolution;
syncInterval: number;
enabled: boolean;
bidirectional: boolean;
filterRules: SyncFilter[];
transformRules: SyncTransform[];
lastSync?: Date;
nextSync?: Date;
errorCount: number;
maxErrors: number;
}
export interface SyncFilter {
field: string;
operator: 'equals' | 'not_equals' | 'contains' | 'matches' | 'greater' | 'less';
value: any;
include: boolean;
}
export interface SyncTransform {
field: string;
operation: 'rename' | 'map_value' | 'calculate' | 'format' | 'custom';
parameters: Record<string, any>;
}
export interface NetworkRequest {
id: string;
operation: NetworkOperation;
endpointId: string;
method: string;
path: string;
headers: Record<string, string>;
body?: any;
timestamp: Date;
timeout: number;
retryCount: number;
priority: number;
metadata: Record<string, any>;
}
export interface NetworkResponse {
requestId: string;
status: number;
statusText: string;
headers: Record<string, string>;
body: any;
duration: number;
timestamp: Date;
error?: string;
}
export interface SyncResult {
id: string;
configId: string;
startTime: Date;
endTime: Date;
success: boolean;
strategy: SyncStrategy;
elementsProcessed: number;
elementsUpdated: number;
elementsCreated: number;
elementsDeleted: number;
conflicts: SyncConflict[];
errors: string[];
statistics: SyncStatistics;
}
export interface SyncConflict {
elementId: string;
field: string;
localValue: any;
remoteValue: any;
resolution: ConflictResolution;
resolvedValue: any;
timestamp: Date;
}
export interface SyncStatistics {
totalElements: number;
syncedElements: number;
skippedElements: number;
conflictedElements: number;
dataTransferred: number;
transferSpeed: number;
networkLatency: number;
}
export interface NetworkConnection {
id: string;
endpointId: string;
type: ConnectionType;
status: NetworkStatus;
connectedAt?: Date;
lastActivity?: Date;
messagesSent: number;
messagesReceived: number;
bytesTransferred: number;
latency: number;
errorCount: number;
socket?: any;
}
export interface NetworkMessage {
id: string;
connectionId: string;
type: 'request' | 'response' | 'event' | 'notification';
operation: NetworkOperation;
payload: any;
timestamp: Date;
priority: number;
requiresAck: boolean;
ackReceived?: boolean;
timeout?: number;
}
export interface NetworkEvent {
id: string;
type: 'connection_established' | 'connection_lost' | 'sync_completed' | 'conflict_detected' | 'error_occurred';
connectionId?: string;
data: Record<string, any>;
timestamp: Date;
}
export interface NetworkPluginConfig {
enabled?: boolean;
priority?: number;
enableAutoSync: boolean;
defaultSyncInterval: number;
maxConcurrentConnections: number;
connectionTimeout: number;
requestTimeout: number;
maxRetries: number;
retryDelay: number;
enableOfflineMode: boolean;
offlineQueueSize: number;
enableCompression: boolean;
enableEncryption: boolean;
heartbeatInterval: number;
reconnectDelay: number;
maxReconnectAttempts: number;
enableEventLogging: boolean;
logLevel: 'debug' | 'info' | 'warn' | 'error';
}
export interface NetworkStats {
totalConnections: number;
activeConnections: number;
failedConnections: number;
totalRequests: number;
successfulRequests: number;
failedRequests: number;
totalDataTransferred: number;
averageLatency: number;
averageResponseTime: number;
syncOperations: number;
successfulSyncs: number;
failedSyncs: number;
conflictsResolved: number;
offlineOperations: number;
lastSyncTime?: Date;
uptime: number;
errorRate: number;
}
export declare class NetworkPlugin implements CSElementPlugin {
readonly name = "NetworkPlugin";
readonly version = "1.0.0";
readonly description = "\u041F\u043B\u0430\u0433\u0438\u043D \u0434\u043B\u044F \u0441\u0435\u0442\u0435\u0432\u044B\u0445 \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0439 \u0438 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u0438 \u0434\u0430\u043D\u043D\u044B\u0445";
private config;
private endpoints;
private syncConfigs;
private connections;
private pendingRequests;
private requestQueue;
private offlineQueue;
private syncResults;
private events;
private stats;
private syncTimer?;
private heartbeatTimer?;
private isOnline;
constructor(config?: Partial<NetworkPluginConfig>);
install(_CSElementClass: typeof CSElement): void;
initialize(): Promise<void>;
destroy(): Promise<void>;
getConfig(): NetworkPluginConfig;
updateConfig(newConfig: Partial<NetworkPluginConfig>): void;
afterCreate(element: CSElement, _context: PluginContext): Promise<PluginResult>;
afterUpdate(element: CSElement, _context: PluginContext): Promise<PluginResult>;
afterDelete(element: CSElement, _context: PluginContext): Promise<PluginResult>;
addEndpoint(endpointData: Omit<NetworkEndpoint, 'id'>): string;
getEndpoint(id: string): NetworkEndpoint | undefined;
updateEndpoint(id: string, updates: Partial<NetworkEndpoint>): boolean;
deleteEndpoint(id: string): boolean;
createConnection(endpointId: string): Promise<string>;
closeConnection(connectionId: string): Promise<boolean>;
addSyncConfig(configData: Omit<SyncConfiguration, 'id' | 'lastSync' | 'nextSync' | 'errorCount'>): string;
getSyncConfig(id: string): SyncConfiguration | undefined;
updateSyncConfig(id: string, updates: Partial<SyncConfiguration>): boolean;
deleteSyncConfig(id: string): boolean;
syncData(configId: string): Promise<SyncResult>;
sendRequest(request: Omit<NetworkRequest, 'id' | 'timestamp'>): Promise<NetworkResponse>;
sendMessage(connectionId: string, message: Omit<NetworkMessage, 'id' | 'timestamp'>): Promise<boolean>;
private establishConnection;
private establishWebSocketConnection;
private establishTCPConnection;
private setupWebSocketHandlers;
private setupTCPHandlers;
private handleIncomingMessage;
private terminateConnection;
private closeConnectionsByEndpoint;
private queueElementSync;
private shouldSyncElement;
private getElementValue;
private evaluateFilter;
private executeRequest;
private addAuthentication;
private addAxiosAuthentication;
private queueOfflineRequest;
private getLocalData;
private getRemoteData;
private performFullSync;
private performIncrementalSync;
private performConflictResolution;
private transmitMessage;
private setupNetworkMonitoring;
private checkNetworkStatus;
private processOfflineQueue;
private startAutoSync;
private runScheduledSyncs;
private startHeartbeat;
private sendHeartbeats;
private startRequestProcessor;
private processRequestQueue;
private calculateNextSync;
private emitEvent;
private updateStats;
private log;
private shouldLog;
private generateId;
getStats(): NetworkStats;
getAllEndpoints(): NetworkEndpoint[];
getAllSyncConfigs(): SyncConfiguration[];
getActiveConnections(): NetworkConnection[];
getAllConnections(): NetworkConnection[];
getPendingRequests(): NetworkRequest[];
getRequestQueue(): NetworkRequest[];
getOfflineQueue(): NetworkRequest[];
getSyncResults(): SyncResult[];
getEvents(): NetworkEvent[];
isNetworkOnline(): boolean;
getConnectionStatus(connectionId: string): NetworkStatus | undefined;
}
//# sourceMappingURL=NetworkPlugin.d.ts.map