@re-shell/cli/dist/utils/operation-queue.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

/**
 * Operation queue management with priority scheduling
 */
import { EventEmitter } from 'events';
export interface QueuedTask<T = any> {
    id: string;
    name: string;
    priority: number;
    operation: () => Promise<T>;
    dependencies?: string[];
    timeout?: number;
    retries?: number;
    retryDelay?: number;
    metadata?: Record<string, any>;
    createdAt: number;
    scheduledAt?: number;
    startedAt?: number;
    completedAt?: number;
    attempts: number;
    status: 'pending' | 'scheduled' | 'running' | 'completed' | 'failed' | 'cancelled';
}
export interface QueueStats {
    total: number;
    pending: number;
    scheduled: number;
    running: number;
    completed: number;
    failed: number;
    cancelled: number;
    averageWaitTime: number;
    averageExecutionTime: number;
    throughput: number;
}
export declare class OperationQueue extends EventEmitter {
    private static instance;
    private tasks;
    private runningTasks;
    private completedTasks;
    private maxConcurrent;
    private processing;
    private processingInterval?;
    static readonly PRIORITY: {
        readonly CRITICAL: 100;
        readonly HIGH: 75;
        readonly NORMAL: 50;
        readonly LOW: 25;
        readonly BACKGROUND: 0;
    };
    private constructor();
    static getInstance(maxConcurrent?: number): OperationQueue;
    /**
     * Add a task to the queue
     */
    add<T>(name: string, operation: () => Promise<T>, options?: {
        priority?: number;
        dependencies?: string[];
        timeout?: number;
        retries?: number;
        retryDelay?: number;
        metadata?: Record<string, any>;
    }): string;
    /**
     * Add multiple related tasks as a batch
     */
    addBatch<T>(tasks: Array<{
        name: string;
        operation: () => Promise<T>;
        priority?: number;
        dependencies?: string[];
        timeout?: number;
        retries?: number;
        metadata?: Record<string, any>;
    }>): string[];
    /**
     * Cancel a task
     */
    cancel(id: string): boolean;
    /**
     * Cancel all tasks with specific priority or lower
     */
    cancelByPriority(maxPriority: number): number;
    /**
     * Get task by ID
     */
    getTask(id: string): QueuedTask | undefined;
    /**
     * Get all tasks by status
     */
    getTasksByStatus(status: QueuedTask['status']): QueuedTask[];
    /**
     * Get queue statistics
     */
    getStats(): QueueStats;
    /**
     * Wait for all tasks to complete
     */
    waitForCompletion(timeout?: number): Promise<void>;
    /**
     * Clear completed tasks from memory
     */
    clearCompleted(): number;
    /**
     * Start processing queue
     */
    private startProcessing;
    /**
     * Stop processing queue
     */
    private stopProcessing;
    /**
     * Process tasks from queue
     */
    private processQueue;
    /**
     * Get next executable task considering priority and dependencies
     */
    private getNextExecutableTask;
    /**
     * Check if all dependencies are completed
     */
    private areDependenciesCompleted;
    /**
     * Execute a single task
     */
    private executeTask;
    /**
     * Generate unique task ID
     */
    private generateId;
}
export declare const operationQueue: OperationQueue;