firestore-queue/dist/core/FireQueue.d.ts

A powerful, scalable queue system built on Google Firestore with time-based indexing, auto-configuration, and connection reuse

import { EventEmitter } from 'events';
import { QueueConfig, QueueMessage, QueueMessageInput, QueueDocument, MessageHandler, QueueMetrics, BeforeEnqueueHook, AfterEnqueueHook, BeforeProcessHook, AfterProcessHook } from '../types';
export interface TriggerConfiguration {
    /**
     * Pub/Sub topic to trigger when messages are enqueued
     */
    pubsubTopic?: string;
    /**
     * Custom trigger function to call after enqueue
     */
    onEnqueue?: (messageId: string, message: QueueDocument) => Promise<void>;
}
/**
 * Fire Queue - A powerful Firestore-based queue system
 *
 * Key features:
 * - Time-based indexing for optimal performance
 * - Updatable messages while in queue
 * - Consumer progress tracking with timestamp-based resume
 * - TTL support with automatic cleanup
 * - Batch processing capabilities
 * - Built-in monitoring and metrics
 */
export declare class FireQueue extends EventEmitter {
    private config;
    private db;
    private isInitialized;
    private consumers;
    private cleanupTimer?;
    private indexesCreated;
    private indexRetryCount;
    private triggerConfig?;
    private beforeEnqueueHooks;
    private afterEnqueueHooks;
    private beforeProcessHooks;
    private afterProcessHooks;
    constructor(config: QueueConfig);
    /**
     * Initialize Firestore connection
     */
    private initializeFirestore;
    /**
     * Initialize the queue system
     */
    initialize(): Promise<void>;
    /**
     * Create necessary Firestore indexes for optimal performance
     */
    private createIndexes;
    /**
     * Create indexes for a specific topic/collection
     * Useful when using topic-based queues
     */
    createTopicIndexes(topicName: string): Promise<void>;
    /**
     * Create indexes for topic consumers collection
     * This ensures consumer tracking works efficiently
     */
    createConsumerIndexes(topicName: string): Promise<void>;
    /**
     * Enqueue a message to the queue
     */
    enqueue(message: QueueMessageInput): Promise<string>;
    /**
     * Update an existing message in the queue
     */
    updateMessage(messageId: string, updates: Partial<QueueMessage>): Promise<void>;
    /**
     * Start consuming messages with a given consumer ID
     */
    consume(consumerId: string, handler: MessageHandler): Promise<void>;
    /**
     * Stop consuming messages for a given consumer
     */
    stopConsumer(consumerId: string): Promise<void>;
    /**
     * Initialize consumer state tracking
     */
    private initializeConsumerState;
    /**
     * Update consumer state
     */
    private updateConsumerState;
    /**
     * Main consumer processing loop
     */
    private startConsumerLoop;
    /**
     * Process a batch of messages for a consumer
     */
    private processBatch;
    /**
     * Get messages ready for processing by a consumer (Kafka-style: multiple consumers can process same messages)
     */
    private getMessagesForProcessing;
    /**
     * Lock messages for processing (Kafka-style: per-consumer locking without global status change)
     */
    private lockMessages;
    /**
     * Unlock messages (remove per-consumer processing lock)
     */
    private unlockMessages;
    /**
     * Acknowledge a message (mark as completed by specific consumer)
     */
    private ackMessage;
    /**
     * Negative acknowledge a message (mark as failed or retry for specific consumer)
     */
    private nackMessage;
    /**
     * Get queue metrics and statistics
     */
    getMetrics(): Promise<QueueMetrics>;
    /**
     * Clean up expired and old completed messages
     */
    cleanup(): Promise<{
        expired: number;
        completed: number;
    }>;
    /**
     * Start automatic cleanup timer
     */
    private startCleanupTimer;
    /**
     * Set trigger configuration for the queue
     */
    setTriggerConfig(config: TriggerConfiguration): void;
    /**
     * Add hooks for extensibility
     */
    addBeforeEnqueueHook(hook: BeforeEnqueueHook): void;
    addAfterEnqueueHook(hook: AfterEnqueueHook): void;
    addBeforeProcessHook(hook: BeforeProcessHook): void;
    addAfterProcessHook(hook: AfterProcessHook): void;
    /**
     * Shutdown the queue system gracefully
     */
    shutdown(): Promise<void>;
    /**
     * Utility methods
     */
    private generateMessageId;
    private sleep;
}
export * from '../types';
//# sourceMappingURL=FireQueue.d.ts.map