@pulzar/core/dist/tasks/task-scheduler.d.ts

Next-generation Node.js framework for ultra-fast web applications with zero-reflection DI, GraphQL, WebSockets, events, and edge runtime support

import { EventEmitter } from "events";
export interface TaskHandler<T = any> {
    (data?: T): Promise<void> | void;
}
export interface TaskMetadata {
    name: string;
    cron?: string;
    queue?: string;
    retries?: number;
    delay?: number;
    priority?: number;
    concurrency?: number;
    enabled?: boolean;
    timeout?: number;
}
export interface QueueJob<T = any> {
    id: string;
    name: string;
    data: T;
    options: {
        retries?: number;
        delay?: number;
        priority?: number;
        timeout?: number;
    };
    attempts: number;
    processedOn?: Date;
    finishedOn?: Date;
    failedReason?: string;
}
export interface TaskSchedulerOptions {
    adapter: "memory" | "bullmq" | "pgboss";
    redis?: {
        host: string;
        port: number;
        password?: string;
        db?: number;
    };
    postgres?: {
        connectionString: string;
    };
    defaultRetries?: number;
    defaultTimeout?: number;
    enableMetrics?: boolean;
}
export declare abstract class TaskAdapter extends EventEmitter {
    abstract connect(): Promise<void>;
    abstract disconnect(): Promise<void>;
    abstract scheduleJob(job: QueueJob): Promise<void>;
    abstract processQueue(queueName: string, handler: TaskHandler): Promise<void>;
    abstract getQueueInfo(queueName: string): Promise<any>;
    abstract removeJob(jobId: string): Promise<boolean>;
    abstract retryJob(jobId: string): Promise<boolean>;
    abstract pauseQueue(queueName: string): Promise<void>;
    abstract resumeQueue(queueName: string): Promise<void>;
    abstract isConnected(): boolean;
}
export declare class TaskScheduler extends EventEmitter {
    private adapter;
    private tasks;
    private cronJobs;
    private queues;
    private options;
    private connected;
    constructor(options: TaskSchedulerOptions);
    /**
     * Create adapter instance based on configuration
     */
    private createAdapter;
    /**
     * Initialize task scheduler
     */
    initialize(): Promise<void>;
    /**
     * Register a task
     */
    registerTask(metadata: TaskMetadata, handler: TaskHandler): void;
    /**
     * Setup cron jobs
     */
    private setupCronJobs;
    /**
     * Execute cron task and reschedule
     */
    private executeCronTask;
    /**
     * Setup queue processors
     */
    private setupQueueProcessors;
    /**
     * Add job to queue
     */
    addJob<T = any>(queueName: string, data: T, options?: {
        retries?: number;
        delay?: number;
        priority?: number;
        timeout?: number;
    }): Promise<string>;
    /**
     * Get queue information
     */
    getQueueInfo(queueName: string): Promise<any>;
    /**
     * Remove job from queue
     */
    removeJob(jobId: string): Promise<boolean>;
    /**
     * Retry failed job
     */
    retryJob(jobId: string): Promise<boolean>;
    /**
     * Pause queue processing
     */
    pauseQueue(queueName: string): Promise<void>;
    /**
     * Resume queue processing
     */
    resumeQueue(queueName: string): Promise<void>;
    /**
     * Enable/disable a task
     */
    setTaskEnabled(taskName: string, enabled: boolean): void;
    /**
     * Setup cron job for a specific task
     */
    private setupCronJobForTask;
    /**
     * Get scheduler statistics
     */
    getStats(): {
        connected: boolean;
        adapter: "memory" | "bullmq" | "pgboss";
        totalTasks: number;
        cronJobs: number;
        queues: number;
        enabledTasks: number;
    };
    /**
     * Generate unique job ID
     */
    private generateJobId;
    /**
     * Shutdown task scheduler
     */
    shutdown(): Promise<void>;
    /**
     * Check if scheduler is connected
     */
    isConnected(): boolean;
}
/**
 * Memory adapter for local task processing
 */
export declare class MemoryTaskAdapter extends TaskAdapter {
    private jobs;
    private processors;
    private paused;
    private connected;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    scheduleJob(job: QueueJob): Promise<void>;
    private processJob;
    processQueue(queueName: string, handler: TaskHandler): Promise<void>;
    getQueueInfo(queueName: string): Promise<any>;
    removeJob(jobId: string): Promise<boolean>;
    retryJob(jobId: string): Promise<boolean>;
    pauseQueue(queueName: string): Promise<void>;
    resumeQueue(queueName: string): Promise<void>;
    isConnected(): boolean;
}
/**
 * BullMQ adapter (placeholder - requires bullmq package)
 */
export declare class BullMQAdapter extends TaskAdapter {
    private client;
    private queues;
    private workers;
    private options;
    private connected;
    constructor(options: any);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    scheduleJob(job: QueueJob): Promise<void>;
    processQueue(queueName: string, handler: TaskHandler): Promise<void>;
    getQueueInfo(queueName: string): Promise<any>;
    removeJob(jobId: string): Promise<boolean>;
    retryJob(jobId: string): Promise<boolean>;
    pauseQueue(queueName: string): Promise<void>;
    resumeQueue(queueName: string): Promise<void>;
    private dynamicImportBullMQ;
    private dynamicImportIORedis;
    private createMockBullMQ;
    isConnected(): boolean;
}
/**
 * PgBoss adapter (placeholder - requires pg-boss package)
 */
export declare class PgBossAdapter extends TaskAdapter {
    private boss;
    private options;
    private connected;
    constructor(options: any);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    scheduleJob(job: QueueJob): Promise<void>;
    processQueue(queueName: string, handler: TaskHandler): Promise<void>;
    getQueueInfo(queueName: string): Promise<any>;
    removeJob(jobId: string): Promise<boolean>;
    retryJob(jobId: string): Promise<boolean>;
    pauseQueue(queueName: string): Promise<void>;
    resumeQueue(queueName: string): Promise<void>;
    private dynamicImportPgBoss;
    private createMockPgBoss;
    isConnected(): boolean;
}
/**
 * Task decorator for cron jobs
 */
export declare function Task(cron: string, options?: Partial<TaskMetadata>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
/**
 * Queue decorator for queue jobs
 */
export declare function Queue(queueName: string, options?: Partial<TaskMetadata>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
export default TaskScheduler;
//# sourceMappingURL=task-scheduler.d.ts.map