cs-element/dist/plugins/types/transaction-interfaces.d.ts

Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support

/**
 * Интерфейсы для системы транзакций CSElement
 * Поддержка ACID свойств и rollback операций
 */
/**
 * Статус транзакции
 */
export declare enum TransactionStatus {
    PENDING = "pending",
    ACTIVE = "active",
    COMMITTING = "committing",
    COMMITTED = "committed",
    ROLLING_BACK = "rolling_back",
    ROLLED_BACK = "rolled_back",
    FAILED = "failed"
}
/**
 * Тип операции в транзакции
 */
export declare enum TransactionOperationType {
    CREATE_ELEMENT = "create_element",
    UPDATE_ELEMENT = "update_element",
    DELETE_ELEMENT = "delete_element",
    ADD_CHILD = "add_child",
    REMOVE_CHILD = "remove_child",
    SET_DATA = "set_data",
    DELETE_DATA = "delete_data",
    CUSTOM = "custom"
}
/**
 * Уровень изоляции транзакции
 */
export declare enum IsolationLevel {
    READ_UNCOMMITTED = "read_uncommitted",
    READ_COMMITTED = "read_committed",
    REPEATABLE_READ = "repeatable_read",
    SERIALIZABLE = "serializable"
}
/**
 * Базовая операция в транзакции
 */
export interface TransactionOperation {
    id: string;
    type: TransactionOperationType;
    elementId: string;
    timestamp: number;
    execute: () => Promise<any>;
    rollback: () => Promise<any>;
    data?: any;
    metadata?: Record<string, any>;
}
/**
 * Снимок состояния элемента для отката
 */
export interface ElementSnapshot {
    elementId: string;
    timestamp: number;
    state: {
        name: string;
        index: number;
        data: Record<string, any>;
        children: string[];
        owners: string[];
    };
    metadata?: Record<string, any>;
}
/**
 * Конфигурация транзакции
 */
export interface TransactionConfig {
    isolationLevel?: IsolationLevel;
    timeout?: number;
    maxOperations?: number;
    autoCommit?: boolean;
    savepoints?: boolean;
    lockTimeout?: number;
}
/**
 * Результат операции транзакции
 */
export interface TransactionResult<T = any> {
    success: boolean;
    data?: T;
    error?: string;
    operationId?: string;
    timestamp?: number;
}
/**
 * Информация о транзакции
 */
export interface TransactionInfo {
    id: string;
    status: TransactionStatus;
    startTime: number;
    endTime?: number;
    duration?: number;
    operationsCount: number;
    config: TransactionConfig;
    operations: {
        total: number;
        committed: number;
        rolledBack: number;
        failed: number;
    };
    locks: string[];
    errors: string[];
}
/**
 * Точка сохранения (savepoint)
 */
export interface Savepoint {
    id: string;
    name: string;
    transactionId: string;
    timestamp: number;
    operationIndex: number;
    snapshots: ElementSnapshot[];
}
/**
 * Интерфейс транзакции
 */
export interface Transaction {
    readonly id: string;
    readonly status: TransactionStatus;
    readonly startTime: number;
    readonly config: TransactionConfig;
    /**
     * Добавление операции в транзакцию
     */
    addOperation(operation: TransactionOperation): Promise<TransactionResult>;
    /**
     * Создание точки сохранения
     */
    createSavepoint(name: string): Promise<Savepoint>;
    /**
     * Откат к точке сохранения
     */
    rollbackToSavepoint(savepointId: string): Promise<TransactionResult>;
    /**
     * Удаление точки сохранения
     */
    releaseSavepoint(savepointId: string): Promise<TransactionResult>;
    /**
     * Подтверждение транзакции
     */
    commit(): Promise<TransactionResult>;
    /**
     * Откат транзакции
     */
    rollback(): Promise<TransactionResult>;
    /**
     * Получение информации о транзакции
     */
    getInfo(): TransactionInfo;
    /**
     * Получение списка операций
     */
    getOperations(): TransactionOperation[];
    /**
     * Получение списка точек сохранения
     */
    getSavepoints(): Savepoint[];
}
/**
 * Интерфейс менеджера транзакций
 */
export interface TransactionManager {
    /**
     * Начало новой транзакции
     */
    begin(config?: TransactionConfig): Promise<Transaction>;
    /**
     * Получение активной транзакции
     */
    getCurrentTransaction(): Transaction | null;
    /**
     * Получение транзакции по ID
     */
    getTransaction(id: string): Transaction | null;
    /**
     * Получение всех активных транзакций
     */
    getActiveTransactions(): Transaction[];
    /**
     * Выполнение операций в транзакции
     */
    withTransaction<T>(callback: (transaction: Transaction) => Promise<T>, config?: TransactionConfig): Promise<T>;
    /**
     * Принудительное завершение транзакции
     */
    forceComplete(transactionId: string, commit: boolean): Promise<TransactionResult>;
    /**
     * Очистка завершенных транзакций
     */
    cleanup(olderThan?: number): Promise<number>;
    /**
     * Получение статистики транзакций
     */
    getStats(): {
        active: number;
        committed: number;
        rolledBack: number;
        failed: number;
        totalOperations: number;
        averageDuration: number;
    };
}
/**
 * Интерфейс для блокировки ресурсов
 */
export interface LockManager {
    /**
     * Получение блокировки на элемент
     */
    acquireLock(elementId: string, transactionId: string, lockType: 'read' | 'write'): Promise<boolean>;
    /**
     * Освобождение блокировки
     */
    releaseLock(elementId: string, transactionId: string): Promise<boolean>;
    /**
     * Освобождение всех блокировок транзакции
     */
    releaseAllLocks(transactionId: string): Promise<number>;
    /**
     * Проверка блокировки элемента
     */
    isLocked(elementId: string): boolean;
    /**
     * Получение информации о блокировках
     */
    getLockInfo(elementId: string): {
        locked: boolean;
        transactionId?: string;
        lockType?: 'read' | 'write';
        timestamp?: number;
    };
    /**
     * Обнаружение взаимоблокировок
     */
    detectDeadlocks(): string[][];
    /**
     * Принудительное снятие блокировок
     */
    forceReleaseLocks(elementIds: string[]): Promise<number>;
}
/**
 * События транзакционной системы
 */
export declare enum TransactionEventType {
    TRANSACTION_STARTED = "transaction:started",
    TRANSACTION_COMMITTING = "transaction:committing",
    TRANSACTION_COMMITTED = "transaction:committed",
    TRANSACTION_ROLLING_BACK = "transaction:rolling_back",
    TRANSACTION_ROLLED_BACK = "transaction:rolled_back",
    TRANSACTION_FAILED = "transaction:failed",
    TRANSACTION_ABORTED = "transaction:aborted",
    OPERATION_ADDED = "operation:added",
    OPERATION_EXECUTED = "operation:executed",
    OPERATION_FAILED = "operation:failed",
    OPERATION_ROLLED_BACK = "operation:rolled_back",
    SAVEPOINT_CREATED = "savepoint:created",
    SAVEPOINT_ROLLED_BACK = "savepoint:rolled_back",
    SAVEPOINT_RELEASED = "savepoint:released",
    LOCK_ACQUIRED = "lock:acquired",
    LOCK_RELEASED = "lock:released",
    LOCKS_RELEASED = "locks:released",
    DEADLOCK_DETECTED = "deadlock:detected"
}
/**
 * Данные события транзакционной системы
 */
export interface TransactionEventData {
    type: TransactionEventType;
    timestamp: number;
    transactionId: string;
    operationId?: string;
    elementId?: string;
    savepointId?: string;
    error?: string;
    metadata?: any;
}
/**
 * Фабрика операций транзакций
 */
export interface TransactionOperationFactory {
    /**
     * Создание операции создания элемента
     */
    createElementOperation(elementId: string, name: string, options?: any): TransactionOperation;
    /**
     * Создание операции обновления элемента
     */
    updateElementOperation(elementId: string, updates: any, snapshot: ElementSnapshot): TransactionOperation;
    /**
     * Создание операции удаления элемента
     */
    deleteElementOperation(elementId: string, snapshot: ElementSnapshot): TransactionOperation;
    /**
     * Создание операции установки данных
     */
    setDataOperation(elementId: string, key: string, value: any, oldValue?: any): TransactionOperation;
    /**
     * Создание операции удаления данных
     */
    deleteDataOperation(elementId: string, key: string, oldValue: any): TransactionOperation;
    /**
     * Создание операции добавления дочернего элемента
     */
    addChildOperation(parentId: string, childId: string): TransactionOperation;
    /**
     * Создание операции удаления дочернего элемента
     */
    removeChildOperation(parentId: string, childId: string): TransactionOperation;
    /**
     * Создание пользовательской операции
     */
    customOperation(elementId: string, execute: () => Promise<any>, rollback: () => Promise<any>, metadata?: any): TransactionOperation;
}
//# sourceMappingURL=transaction-interfaces.d.ts.map