redis-smq/dist/types/index.d.ts

A simple high-performance Redis message queue for Node.js.

/// <reference types="node" />
/// <reference types="node" />
import { Message } from '../src/lib/message/message';
import { redisKeys } from '../src/common/redis-keys/redis-keys';
import { ICallback, TLoggerConfig, TRedisConfig } from 'redis-smq-common/dist/types';
import { EventEmitter } from 'events';
import { DirectExchange } from '../src/lib/exchange/direct-exchange';
import { TopicExchange } from '../src/lib/exchange/topic-exchange';
import { FanOutExchange } from '../src/lib/exchange/fan-out-exchange';
export declare type TEventListenerInitArgs = {
    eventProvider: EventEmitter;
    config: IRequiredConfig;
    instanceId: string;
};
export interface IEventListener {
    init(args: TEventListenerInitArgs, cb: ICallback<void>): void;
    quit(cb: ICallback<void>): void;
}
export interface IMessagesConfig {
    store?: boolean | IMessagesConfigStore;
}
export interface IMessagesConfigStoreOptions {
    queueSize?: number;
    expire?: number;
}
export interface IMessagesConfigStore {
    acknowledged?: boolean | IMessagesConfigStoreOptions;
    deadLettered?: boolean | IMessagesConfigStoreOptions;
}
export interface IEventListenersConfig {
    consumerEventListeners?: (new () => IEventListener)[];
    producerEventListeners?: (new () => IEventListener)[];
}
export interface IConfig {
    redis?: TRedisConfig;
    namespace?: string;
    logger?: TLoggerConfig;
    messages?: IMessagesConfig;
    eventListeners?: IEventListenersConfig;
}
export interface IRequiredStoreMessagesParams extends Required<IMessagesConfigStoreOptions> {
    store: boolean;
}
export interface IRequiredMessagesConfigStore {
    acknowledged: IRequiredStoreMessagesParams;
    deadLettered: IRequiredStoreMessagesParams;
}
export declare type TRequiredEventListenersConfig = Required<IEventListenersConfig>;
export interface IRequiredConfig extends Required<IConfig> {
    messages: {
        store: IRequiredMessagesConfigStore;
    };
    eventListeners: TRequiredEventListenersConfig;
}
export declare type TPaginatedResponse<T> = {
    total: number;
    items: T[];
};
export declare type TGetMessagesReply = TPaginatedResponse<{
    sequenceId: number;
    message: Message;
}>;
export declare type TConsumerRedisKeys = ReturnType<typeof redisKeys['getConsumerKeys']>;
export declare type TQueueConsumerRedisKeys = ReturnType<typeof redisKeys['getQueueConsumerKeys']>;
export interface IQueueMetrics {
    acknowledged: number;
    deadLettered: number;
    pending: number;
}
export declare enum EMessageDeadLetterCause {
    TTL_EXPIRED = "ttl_expired",
    RETRY_THRESHOLD_EXCEEDED = "retry_threshold_exceeded",
    PERIODIC_MESSAGE = "periodic_message"
}
export declare enum EMessageUnacknowledgedCause {
    TIMEOUT = "timeout",
    CONSUME_ERROR = "consumer_error",
    UNACKNOWLEDGED = "unacknowledged",
    OFFLINE_CONSUMER = "offline_consumer",
    TTL_EXPIRED = "ttl_expired"
}
export declare type TTopicParams = {
    topic: string;
    ns: string;
};
export declare type TQueueParams = {
    name: string;
    ns: string;
};
export declare type TQueueRateLimit = {
    limit: number;
    interval: number;
};
export declare type TQueueSettings = {
    priorityQueuing: boolean;
    type: EQueueType;
    rateLimit: TQueueRateLimit | null;
    exchange: string | null;
};
export declare enum EQueueSettingType {
    PRIORITY_QUEUING = "PRIORITY_QUEUING",
    QUEUE_TYPE = "QUEUE_TYPE",
    RATE_LIMIT = "RATE_LIMIT",
    EXCHANGE = "EXCHANGE"
}
export declare enum EQueueType {
    LIFO_QUEUE = 0,
    FIFO_QUEUE = 1,
    PRIORITY_QUEUE = 2
}
export declare type TConsumerInfo = {
    ipAddress: string[];
    hostname: string;
    pid: number;
    createdAt: number;
};
export declare type TConsumerHeartbeat = {
    timestamp: number;
    data: TConsumerHeartbeatPayload;
};
export declare type TConsumerHeartbeatPayload = {
    ram: {
        usage: NodeJS.MemoryUsage;
        free: number;
        total: number;
    };
    cpu: {
        user: number;
        system: number;
        percentage: string;
    };
};
export declare type TConsumerMessageHandler = (msg: Message, cb: ICallback<void>) => void;
export declare type TConsumerMessageHandlerParams = {
    queue: TQueueParams;
    messageHandler: TConsumerMessageHandler;
};
export declare type TMessageJSON = {
    createdAt: number;
    queue: TQueueParams | string | null;
    exchange: IDirectExchangeParams | ITopicExchangeParams | IFanOutExchangeParams | null;
    ttl: number;
    retryThreshold: number;
    retryDelay: number;
    consumeTimeout: number;
    body: unknown;
    priority: number | null;
    scheduledCron: string | null;
    scheduledDelay: number | null;
    scheduledRepeatPeriod: number | null;
    scheduledRepeat: number;
    messageState: TMessageState | null;
};
export declare enum EExchangeType {
    DIRECT = 0,
    FANOUT = 1,
    TOPIC = 2
}
export declare type TExchange = DirectExchange | TopicExchange | FanOutExchange;
export interface IExchangeParams<TBindingParams, TBindingType extends EExchangeType> {
    exchangeTag: string;
    destinationQueue: TQueueParams | null;
    bindingParams: TBindingParams;
    type: TBindingType;
}
export declare type IDirectExchangeParams = IExchangeParams<TQueueParams | string, EExchangeType.DIRECT>;
export declare type IFanOutExchangeParams = IExchangeParams<string, EExchangeType.FANOUT>;
export declare type ITopicExchangeParams = IExchangeParams<TTopicParams | string, EExchangeType.TOPIC>;
export declare type TMessageState = {
    uuid: string;
    publishedAt: number | null;
    scheduledAt: number | null;
    scheduledCronFired: boolean;
    attempts: number;
    scheduledRepeatCount: number;
    expired: boolean;
    nextScheduledDelay: number;
    nextRetryDelay: number;
};
export declare type TMessageConsumeOptions = {
    ttl: number;
    retryThreshold: number;
    retryDelay: number;
    consumeTimeout: number;
};
export declare type TProduceMessageReply = {
    messages: Message[];
    scheduled: boolean;
};