redis-smq 8.0.0-rc.19 → 8.0.0-rc.20

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 
 
+## [8.0.0-rc.20](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.19...v8.0.0-rc.20) (2024-03-24)
+
+
+### Bug Fixes
+
+* include missing enums when exporting esm/cjs modules ([2ee6802](https://github.com/weyoss/redis-smq/commit/2ee680205dbde78af46f4e4347cdf4fa80adfe3b))
+
 ## [8.0.0-rc.19](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.18...v8.0.0-rc.19) (2024-03-24)
 
 

package/dist/cjs/src/lib/consumer/types/consumer-heartbeat.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+export interface IConsumerHeartbeat {
+    timestamp: number;
+    data: IConsumerHeartbeatPayload;
+}
+export interface IConsumerHeartbeatPayload {
+    ram: {
+        usage: NodeJS.MemoryUsage;
+        free: number;
+        total: number;
+    };
+    cpu: {
+        user: number;
+        system: number;
+        percentage: string;
+    };
+}
+//# sourceMappingURL=consumer-heartbeat.d.ts.map

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './src/common/index.js';
+export * from './src/config/index.js';
+export * from './src/lib/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/common/redis-client/errors/redis-client-instance-lock.error.d.ts

@@ -0,0 +1,4 @@
+import { RedisSMQError } from 'redis-smq-common';
+export declare class RedisClientInstanceLockError extends RedisSMQError {
+}
+//# sourceMappingURL=redis-client-instance-lock.error.d.ts.map

package/dist/esm/src/common/redis-client/redis-client-factory.d.ts

@@ -0,0 +1,4 @@
+import { TUnaryFunction } from 'redis-smq-common';
+import { RedisClientInstance } from './redis-client-instance.js';
+export declare function RedisClientFactory(id: string, onError: TUnaryFunction<Error>): RedisClientInstance;
+//# sourceMappingURL=redis-client-factory.d.ts.map

package/dist/esm/src/common/redis-client/redis-client-instance.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter, ICallback, IRedisClient, TRedisClientEvent } from 'redis-smq-common';
+export declare class RedisClientInstance extends EventEmitter<Pick<TRedisClientEvent, 'error'>> {
+    protected instance: IRedisClient | null;
+    protected locked: boolean;
+    init: (cb: ICallback<void>) => void;
+    getSetInstance: (cb: ICallback<IRedisClient>) => void;
+    shutdown: (cb: ICallback<void>) => void;
+    getInstance(): IRedisClient | Error;
+}
+//# sourceMappingURL=redis-client-instance.d.ts.map

package/dist/esm/src/common/redis-client/scripts/scripts.d.ts

@@ -0,0 +1,16 @@
+export declare enum ELuaScriptName {
+    PUBLISH_SCHEDULED_MESSAGE = "PUBLISH_SCHEDULED_MESSAGE",
+    PUBLISH_MESSAGE = "PUBLISH_MESSAGE",
+    REQUEUE_MESSAGE = "REQUEUE_MESSAGE",
+    SCHEDULE_MESSAGE = "SCHEDULE_MESSAGE",
+    HAS_QUEUE_RATE_EXCEEDED = "HAS_QUEUE_RATE_EXCEEDED",
+    CREATE_QUEUE = "CREATE_QUEUE",
+    INIT_CONSUMER_QUEUE = "INIT_CONSUMER_QUEUE",
+    HANDLE_PROCESSING_QUEUE = "HANDLE_PROCESSING_QUEUE",
+    ACKNOWLEDGE_MESSAGE = "ACKNOWLEDGE_MESSAGE",
+    DELETE_MESSAGE = "DELETE_MESSAGE",
+    FETCH_MESSAGE_FOR_PROCESSING = "FETCH_MESSAGE_FOR_PROCESSING",
+    DELETE_CONSUMER_GROUP = "DELETE_CONSUMER_GROUP",
+    CLEANUP_OFFLINE_CONSUMER = "CLEANUP_OFFLINE_CONSUMER"
+}
+//# sourceMappingURL=scripts.d.ts.map

package/dist/esm/src/common/redis-keys/redis-keys.d.ts

@@ -0,0 +1,38 @@
+import { IQueueParams } from '../../lib/index.js';
+import { RedisKeysError } from './redis-keys.error.js';
+export declare const redisKeys: {
+    getNamespaceKeys(ns: string): {
+        keyNamespaceQueues: string;
+    };
+    getQueueKeys(queueParams: IQueueParams, consumerGroupId: string | null): {
+        keyQueuePending: string;
+        keyQueuePriorityPending: string;
+        keyQueueDL: string;
+        keyQueueProcessingQueues: string;
+        keyQueueAcknowledged: string;
+        keyQueueScheduled: string;
+        keyQueueConsumers: string;
+        keyQueueRateLimitCounter: string;
+        keyQueueProperties: string;
+        keyQueueMessages: string;
+        keyQueueMessageIds: string;
+        keyQueueConsumerGroups: string;
+    };
+    getMessageKeys(messageId: string): {
+        keyMessage: string;
+    };
+    getFanOutExchangeKeys(bindingKey: string): {
+        keyExchangeBindings: string;
+    };
+    getConsumerKeys(instanceId: string): {
+        keyConsumerQueues: string;
+    };
+    getQueueConsumerKeys(queueParams: IQueueParams, instanceId: string): {
+        keyQueueProcessing: string;
+    };
+    getMainKeys(): Record<"keyQueues" | "keyProcessingQueues" | "keyHeartbeats" | "keyHeartbeatTimestamps" | "keyScheduledMessages" | "keyLockConsumerWorkersRunner" | "keyDelayedMessages" | "keyRequeueMessages" | "keyNamespaces" | "keyFanOutExchanges" | "keyDeletedQueues", string>;
+    validateNamespace(ns: string): string | RedisKeysError;
+    validateRedisKey(key: string | null | undefined): string | RedisKeysError;
+    getKeySegmentSeparator(): string;
+};
+//# sourceMappingURL=redis-keys.d.ts.map

package/dist/esm/src/common/redis-keys/redis-keys.error.d.ts

@@ -0,0 +1,4 @@
+import { RedisSMQError } from 'redis-smq-common';
+export declare class RedisKeysError extends RedisSMQError {
+}
+//# sourceMappingURL=redis-keys.error.d.ts.map

package/dist/esm/src/common/types/event.d.ts

@@ -0,0 +1,50 @@
+import { EConsumeMessageDeadLetterCause, EConsumeMessageUnacknowledgedCause, IConsumerHeartbeat, IQueueParams, IQueueParsedParams, IQueueProperties } from '../../lib/index.js';
+export type TConsumerHeartbeatEvent = {
+    'consumerHeartbeat.heartbeat': (consumerId: string, timestamp: number, heartbeatPayload: IConsumerHeartbeat) => void;
+    'consumerHeartbeat.error': (err: Error) => void;
+};
+export type TConsumerConsumeMessageEvent = {
+    'consumer.consumeMessage.messageAcknowledged': (messageId: string, queue: IQueueParsedParams, messageHandlerId: string, consumerId: string) => void;
+    'consumer.consumeMessage.messageUnacknowledged': (messageId: string, queue: IQueueParsedParams, messageHandlerId: string, consumerId: string, cause: EConsumeMessageUnacknowledgedCause) => void;
+    'consumer.consumeMessage.messageDeadLettered': (messageId: string, queue: IQueueParsedParams, messageHandlerId: string, consumerId: string, cause: EConsumeMessageDeadLetterCause) => void;
+    'consumer.consumeMessage.messageRequeued': (messageId: string, queue: IQueueParsedParams, messageHandlerId: string, consumerId: string) => void;
+    'consumer.consumeMessage.messageDelayed': (messageId: string, queue: IQueueParsedParams, messageHandlerId: string, consumerId: string) => void;
+    'consumer.consumeMessage.error': (err: Error, consumerId: string, queue: IQueueParsedParams) => void;
+};
+export type TConsumerDequeueMessageEvent = {
+    'consumer.dequeueMessage.messageReceived': (messageId: string, queue: IQueueParsedParams, consumerId: string) => void;
+    'consumer.dequeueMessage.nextMessage': () => void;
+    'consumer.dequeueMessage.error': (err: Error, consumerId: string, queue: IQueueParsedParams) => void;
+};
+export type TConsumerMessageHandlerEvent = {
+    'consumer.messageHandler.error': (err: Error, consumerId: string, queue: IQueueParsedParams) => void;
+};
+export type TConsumerMessageHandlerRunnerEvent = {
+    'consumer.messageHandlerRunner.error': (err: Error, consumerId: string) => void;
+};
+export type TConsumerEvent = {
+    'consumer.up': (consumerId: string) => void;
+    'consumer.goingDown': (consumerId: string) => void;
+    'consumer.down': (consumerId: string) => void;
+    'consumer.goingUp': (consumerId: string) => void;
+    'consumer.error': (err: Error, consumerId: string) => void;
+};
+export type TProducerEvent = {
+    'producer.messagePublished': (messageId: string, queue: IQueueParsedParams, producerId: string) => void;
+    'producer.up': (producerId: string) => void;
+    'producer.goingDown': (producerId: string) => void;
+    'producer.down': (producerId: string) => void;
+    'producer.goingUp': (producerId: string) => void;
+    'producer.error': (err: Error, producerId: string) => void;
+};
+export type TQueueEvent = {
+    'queue.consumerGroupCreated': (queue: IQueueParams, groupId: string) => void;
+    'queue.consumerGroupDeleted': (queue: IQueueParams, groupId: string) => void;
+    'queue.queueCreated': (queue: IQueueParams, properties: IQueueProperties) => void;
+    'queue.queueDeleted': (queue: IQueueParams) => void;
+};
+export type TEventBusEvent = {
+    error: (err: Error) => void;
+};
+export type TRedisSMQEvent = TEventBusEvent & TConsumerEvent & TConsumerHeartbeatEvent & TConsumerMessageHandlerRunnerEvent & TConsumerMessageHandlerEvent & TConsumerConsumeMessageEvent & TConsumerDequeueMessageEvent & TProducerEvent & TQueueEvent;
+//# sourceMappingURL=event.d.ts.map

package/dist/esm/src/common/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/config/configuration.d.ts

@@ -0,0 +1,11 @@
+import { IRedisSMQConfig, IRedisSMQConfigRequired } from './types/index.js';
+export declare class Configuration {
+    protected static instance: Configuration | null;
+    protected config: IRedisSMQConfigRequired;
+    protected constructor(config: IRedisSMQConfig);
+    static getSetConfig(config?: IRedisSMQConfig): IRedisSMQConfigRequired;
+    static reset(): void;
+    getConfig(): IRedisSMQConfigRequired;
+    protected parseConfiguration(config: IRedisSMQConfig): IRedisSMQConfigRequired;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/esm/src/config/configuration.error.d.ts

@@ -0,0 +1,4 @@
+import { RedisSMQError } from 'redis-smq-common';
+export declare class ConfigurationError extends RedisSMQError {
+}
+//# sourceMappingURL=configuration.error.d.ts.map

package/dist/esm/src/config/event-bus.d.ts

@@ -0,0 +1,3 @@
+import { IRedisSMQConfig, IRedisSMQConfigRequired } from './types/index.js';
+export default function EventBus(userConfig: IRedisSMQConfig): IRedisSMQConfigRequired['eventBus'];
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/esm/src/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types/index.js';
+export * from './configuration.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/config/logger.d.ts

@@ -0,0 +1,3 @@
+import { IRedisSMQConfig, IRedisSMQConfigRequired } from './types/index.js';
+export default function Logger(userConfig: IRedisSMQConfig): IRedisSMQConfigRequired['logger'];
+//# sourceMappingURL=logger.d.ts.map

package/dist/esm/src/config/messages/messages.d.ts

@@ -0,0 +1,3 @@
+import { IRedisSMQConfig, IRedisSMQConfigRequired } from '../types/index.js';
+export default function Messages(userConfig: IRedisSMQConfig): IRedisSMQConfigRequired['messages'];
+//# sourceMappingURL=messages.d.ts.map

package/dist/esm/src/config/messages/store.d.ts

@@ -0,0 +1,4 @@
+import { IMessagesConfigStorageRequired } from '../../lib/index.js';
+import { IRedisSMQConfig } from '../types/index.js';
+export default function Store(config: IRedisSMQConfig): IMessagesConfigStorageRequired;
+//# sourceMappingURL=store.d.ts.map

package/dist/esm/src/config/namespace.d.ts

@@ -0,0 +1,3 @@
+import { IRedisSMQConfig } from './types/index.js';
+export default function Namespace(userConfig: IRedisSMQConfig): string;
+//# sourceMappingURL=namespace.d.ts.map

package/dist/esm/src/config/redis.d.ts

@@ -0,0 +1,3 @@
+import { IRedisSMQConfig, IRedisSMQConfigRequired } from './types/index.js';
+export default function Redis(userConfig: IRedisSMQConfig): IRedisSMQConfigRequired['redis'];
+//# sourceMappingURL=redis.d.ts.map

package/dist/esm/src/config/types/config.d.ts

@@ -0,0 +1,16 @@
+import { ILoggerConfig, IRedisConfig } from 'redis-smq-common';
+import { IEventBusConfig, IMessagesConfig, IMessagesConfigStorageRequired } from '../../lib/index.js';
+export interface IRedisSMQConfig {
+    redis?: IRedisConfig;
+    namespace?: string;
+    logger?: ILoggerConfig;
+    messages?: IMessagesConfig;
+    eventBus?: IEventBusConfig;
+}
+export interface IRedisSMQConfigRequired extends Required<IRedisSMQConfig> {
+    messages: {
+        store: IMessagesConfigStorageRequired;
+    };
+    eventBus: Required<IEventBusConfig>;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/esm/src/config/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/lib/consumer/consumer/consumer.d.ts

@@ -0,0 +1,34 @@
+import { ICallback, ILogger, Runnable, TRedisClientEvent, TUnaryFunction, WorkerResourceGroup } from 'redis-smq-common';
+import { TConsumerEvent } from '../../../common/index.js';
+import { IQueueParsedParams, TQueueExtendedParams } from '../../queue/index.js';
+import { ConsumerHeartbeat } from '../consumer-heartbeat/consumer-heartbeat.js';
+import { MessageHandlerRunner } from '../message-handler-runner/message-handler-runner.js';
+import { TConsumerMessageHandler } from '../types/index.js';
+export declare class Consumer extends Runnable<TConsumerEvent> {
+    protected messageHandlerRunner: MessageHandlerRunner;
+    protected logger: ILogger;
+    protected redisClient: import("../../../common/redis-client/redis-client-instance.js").RedisClientInstance;
+    protected eventBus: import("../../index.js").EventBusRedisInstance | undefined;
+    protected heartbeat: ConsumerHeartbeat | null;
+    protected workerResourceGroup: WorkerResourceGroup | null;
+    constructor(enableMultiplexing?: boolean);
+    protected onRedisError: TRedisClientEvent['error'];
+    protected setUpHeartbeat: (cb: ICallback<void>) => void;
+    protected shutDownHeartbeat: (cb: ICallback<void>) => void;
+    protected setUpConsumerWorkers: (cb: ICallback<void>) => void;
+    protected shutDownConsumerWorkers: (cb: ICallback<void>) => void;
+    protected runMessageHandlers: (cb: ICallback<void>) => void;
+    protected shutdownMessageHandlers: (cb: ICallback<void>) => void;
+    protected initRedisClient: (cb: ICallback<void>) => void;
+    protected shutDownRedisClient: (cb: ICallback<void>) => void;
+    protected goingUp(): TUnaryFunction<ICallback<void>>[];
+    protected goingDown(): TUnaryFunction<ICallback<void>>[];
+    protected up(cb: ICallback<boolean>): void;
+    protected down(cb: ICallback<boolean>): void;
+    protected getLogger(): ILogger;
+    protected handleError(err: Error): void;
+    consume(queue: TQueueExtendedParams, messageHandler: TConsumerMessageHandler, cb: ICallback<void>): void;
+    cancel(queue: TQueueExtendedParams, cb: ICallback<void>): void;
+    getQueues(): IQueueParsedParams[];
+}
+//# sourceMappingURL=consumer.d.ts.map

package/dist/esm/src/lib/consumer/consumer/event-bus-publisher.d.ts

@@ -0,0 +1,4 @@
+import { ILogger } from 'redis-smq-common';
+import { Consumer } from './consumer.js';
+export declare function eventBusPublisher(consumer: Consumer, logger: ILogger): void;
+//# sourceMappingURL=event-bus-publisher.d.ts.map

package/dist/esm/src/lib/consumer/consumer-heartbeat/_/_cleanup-offline-consumer.d.ts

@@ -0,0 +1,3 @@
+import { ICallback, IRedisClient } from 'redis-smq-common';
+export declare function _cleanupOfflineConsumer(redisClient: IRedisClient, consumerIds: string[], cb: ICallback<void>): void;
+//# sourceMappingURL=_cleanup-offline-consumer.d.ts.map

package/dist/esm/src/lib/consumer/consumer-heartbeat/consumer-heartbeat.d.ts

@@ -0,0 +1,25 @@
+import { ICallback, ILogger, IRedisClient, IRedisTransaction, Runnable, Timer } from 'redis-smq-common';
+import { TConsumerHeartbeatEvent } from '../../../common/index.js';
+import { Consumer } from '../consumer/consumer.js';
+import { IConsumerHeartbeat } from '../types/index.js';
+export declare class ConsumerHeartbeat extends Runnable<TConsumerHeartbeatEvent> {
+    protected static readonly heartbeatTTL: number;
+    protected timer: Timer;
+    protected keyHeartbeats: string;
+    protected keyHeartbeatTimestamps: string;
+    protected consumer: Consumer;
+    protected logger: ILogger;
+    protected redisClient: import("../../../common/redis-client/redis-client-instance.js").RedisClientInstance;
+    protected eventBus: import("../../index.js").EventBusRedisInstance | undefined;
+    constructor(consumer: Consumer, logger: ILogger);
+    protected static isExpiredHeartbeat(heartbeat: IConsumerHeartbeat): boolean;
+    protected getLogger(): ILogger;
+    protected getPayload(): IConsumerHeartbeat;
+    protected beat(): void;
+    protected goingUp(): ((cb: ICallback<void>) => void)[];
+    protected goingDown(): ((cb: ICallback<void>) => void)[];
+    static getConsumersHeartbeats(redisClient: IRedisClient, consumerIds: string[], cb: ICallback<Record<string, IConsumerHeartbeat | false>>): void;
+    static getExpiredHeartbeatIds(redisClient: IRedisClient, offset: number, count: number, cb: ICallback<string[]>): void;
+    static handleExpiredHeartbeatId(consumerId: string | string[], multi: IRedisTransaction): void;
+}
+//# sourceMappingURL=consumer-heartbeat.d.ts.map

package/dist/esm/src/lib/consumer/consumer-heartbeat/event-bus-publisher.d.ts

@@ -0,0 +1,4 @@
+import { ILogger } from 'redis-smq-common';
+import { ConsumerHeartbeat } from './consumer-heartbeat.js';
+export declare function eventBusPublisher(consumerHeartbeat: ConsumerHeartbeat, consumerId: string, logger: ILogger): void;
+//# sourceMappingURL=event-bus-publisher.d.ts.map

package/dist/esm/src/lib/consumer/consumer-queues.d.ts

@@ -0,0 +1,10 @@
+import { ICallback, IRedisClient, IRedisTransaction } from 'redis-smq-common';
+import { IQueueParams, TQueueConsumer } from '../queue/index.js';
+export declare const consumerQueues: {
+    removeConsumer(multi: IRedisTransaction, queue: IQueueParams, consumerId: string): void;
+    getQueueConsumers(client: IRedisClient, queue: IQueueParams, transform: boolean, cb: ICallback<Record<string, TQueueConsumer | string>>): void;
+    getQueueConsumerIds(client: IRedisClient, queue: IQueueParams, cb: ICallback<string[]>): void;
+    countQueueConsumers(client: IRedisClient, queue: IQueueParams, cb: ICallback<number>): void;
+    getConsumerQueues(client: IRedisClient, consumerId: string, cb: ICallback<IQueueParams[]>): void;
+};
+//# sourceMappingURL=consumer-queues.d.ts.map

package/dist/esm/src/lib/consumer/errors/consumer-group-delete.error.d.ts

@@ -0,0 +1,4 @@
+import { ConsumerError } from './consumer.error.js';
+export declare class ConsumerGroupDeleteError extends ConsumerError {
+}
+//# sourceMappingURL=consumer-group-delete.error.d.ts.map

package/dist/esm/src/lib/consumer/errors/consumer-group-id-not-found.error.d.ts

@@ -0,0 +1,5 @@
+import { ConsumerError } from './consumer.error.js';
+export declare class ConsumerGroupIdNotFoundError extends ConsumerError {
+    constructor();
+}
+//# sourceMappingURL=consumer-group-id-not-found.error.d.ts.map

package/dist/esm/src/lib/consumer/errors/consumer-group-id-not-supported.error.d.ts

@@ -0,0 +1,5 @@
+import { ConsumerError } from './consumer.error.js';
+export declare class ConsumerGroupIdNotSupportedError extends ConsumerError {
+    constructor();
+}
+//# sourceMappingURL=consumer-group-id-not-supported.error.d.ts.map

package/dist/esm/src/lib/consumer/errors/consumer-group-id-required.error.d.ts

@@ -0,0 +1,5 @@
+import { ConsumerError } from './consumer.error.js';
+export declare class ConsumerGroupIdRequiredError extends ConsumerError {
+    constructor();
+}
+//# sourceMappingURL=consumer-group-id-required.error.d.ts.map

package/dist/esm/src/lib/consumer/errors/consumer-invalid-group-id.error.d.ts

@@ -0,0 +1,5 @@
+import { ConsumerError } from './consumer.error.js';
+export declare class ConsumerInvalidGroupIdError extends ConsumerError {
+    constructor();
+}
+//# sourceMappingURL=consumer-invalid-group-id.error.d.ts.map

package/dist/esm/src/lib/consumer/errors/consumer-message-handler-already-exists.error.d.ts

@@ -0,0 +1,6 @@
+import { IQueueParsedParams } from '../../queue/index.js';
+import { ConsumerError } from './consumer.error.js';
+export declare class ConsumerMessageHandlerAlreadyExistsError extends ConsumerError {
+    constructor(queue: IQueueParsedParams);
+}
+//# sourceMappingURL=consumer-message-handler-already-exists.error.d.ts.map

package/dist/esm/src/lib/consumer/errors/consumer.error.d.ts

@@ -0,0 +1,4 @@
+import { RedisSMQError } from 'redis-smq-common';
+export declare class ConsumerError extends RedisSMQError {
+}
+//# sourceMappingURL=consumer.error.d.ts.map

package/dist/esm/src/lib/consumer/errors/index.d.ts

@@ -0,0 +1,8 @@
+export { ConsumerError } from './consumer.error.js';
+export { ConsumerMessageHandlerAlreadyExistsError } from './consumer-message-handler-already-exists.error.js';
+export { ConsumerGroupDeleteError } from './consumer-group-delete.error.js';
+export { ConsumerGroupIdNotFoundError } from './consumer-group-id-not-found.error.js';
+export { ConsumerGroupIdNotSupportedError } from './consumer-group-id-not-supported.error.js';
+export { ConsumerGroupIdRequiredError } from './consumer-group-id-required.error.js';
+export { ConsumerInvalidGroupIdError } from './consumer-invalid-group-id.error.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/lib/consumer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './errors/index.js';
+export * from './types/index.js';
+export * from './consumer/consumer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/consume-message/consume-message.d.ts

@@ -0,0 +1,31 @@
+import { ICallback, ILogger, Runnable, WorkerCallable } from 'redis-smq-common';
+import { TConsumerConsumeMessageEvent } from '../../../../common/index.js';
+import { RedisClientInstance } from '../../../../common/redis-client/redis-client-instance.js';
+import { IMessageTransferable } from '../../../message/index.js';
+import { MessageEnvelope } from '../../../message/message-envelope.js';
+import { IQueueParsedParams } from '../../../queue/index.js';
+import { EConsumeMessageUnacknowledgedCause, TConsumerMessageHandler } from '../../types/index.js';
+export declare class ConsumeMessage extends Runnable<TConsumerConsumeMessageEvent> {
+    protected logger: ILogger;
+    protected keyQueueProcessing: string;
+    protected keyQueueAcknowledged: string;
+    protected queue: IQueueParsedParams;
+    protected consumerId: string;
+    protected messageHandler: TConsumerMessageHandler;
+    protected messageHandlerId: string;
+    protected redisClient: RedisClientInstance;
+    protected consumeMessageWorker: WorkerCallable<IMessageTransferable, void> | null;
+    constructor(redisClient: RedisClientInstance, consumerId: string, queue: IQueueParsedParams, messageHandlerId: string, messageHandler: TConsumerMessageHandler, logger: ILogger);
+    protected getLogger(): ILogger;
+    protected acknowledgeMessage(message: MessageEnvelope): void;
+    protected unacknowledgeMessage(msg: MessageEnvelope, cause: EConsumeMessageUnacknowledgedCause): void;
+    protected getConsumeMessageWorker(messageHandlerFilename: string): WorkerCallable<IMessageTransferable, void>;
+    protected invokeMessageHandler(messageHandler: TConsumerMessageHandler, msg: IMessageTransferable, cb: ICallback<void>): void;
+    protected consumeMessage(msg: MessageEnvelope): void;
+    protected validateMessageHandler: (cb: ICallback<void>) => void;
+    protected goingUp(): ((cb: ICallback<void>) => void)[];
+    protected goingDown(): ((cb: ICallback<void>) => void)[];
+    protected handleError(err: Error): void;
+    handleReceivedMessage(message: MessageEnvelope): void;
+}
+//# sourceMappingURL=consume-message.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/consume-message/event-bus-publisher.d.ts

@@ -0,0 +1,4 @@
+import { ILogger } from 'redis-smq-common';
+import { ConsumeMessage } from './consume-message.js';
+export declare function eventBusPublisher(consumeMessage: ConsumeMessage, consumerId: string, logger: ILogger): void;
+//# sourceMappingURL=event-bus-publisher.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/dequeue-message/dequeue-message.d.ts

@@ -0,0 +1,43 @@
+import { ICallback, ILogger, IRedisClient, Runnable, Timer } from 'redis-smq-common';
+import { TConsumerDequeueMessageEvent } from '../../../../common/index.js';
+import { RedisClientInstance } from '../../../../common/redis-client/redis-client-instance.js';
+import { EQueueType, IQueueParsedParams, IQueueRateLimit } from '../../../queue/index.js';
+export declare class DequeueMessage extends Runnable<TConsumerDequeueMessageEvent> {
+    protected redisClient: RedisClientInstance;
+    protected queue: IQueueParsedParams;
+    protected consumerId: string;
+    protected timer: Timer;
+    protected keyQueues: string;
+    protected keyQueueConsumers: string;
+    protected keyConsumerQueues: string;
+    protected keyProcessingQueues: string;
+    protected keyQueueProcessingQueues: string;
+    protected keyQueueProcessing: string;
+    protected keyQueuePending: string;
+    protected keyQueuePriorityPending: string;
+    protected logger: ILogger;
+    protected blockUntilMessageReceived: boolean;
+    protected autoCloseRedisConnection: boolean;
+    protected eventBus: import("../../../index.js").EventBusRedisInstance;
+    protected queueRateLimit: IQueueRateLimit | null;
+    protected queueType: EQueueType | null;
+    protected idleThreshold: number;
+    protected idleTrigger: number;
+    constructor(redisClient: RedisClientInstance, queue: IQueueParsedParams, consumerId: string, logger: ILogger, blockUntilMessageReceived?: boolean, autoCloseRedisConnection?: boolean);
+    protected getLogger(): ILogger;
+    protected handleError(err: Error): void;
+    protected goingUp(): ((cb: ICallback<void>) => void)[];
+    protected goingDown(): ((cb: ICallback<void>) => void)[];
+    protected updateIdle(): void;
+    protected resetIdle(): void;
+    protected isIdle(): boolean;
+    protected isPriorityQueuingEnabled(): boolean;
+    protected handleMessage: ICallback<string | null>;
+    protected dequeueWithRateLimit: (redisClient: IRedisClient) => boolean;
+    protected dequeueWithRateLimitExec: (redisClient: IRedisClient) => void;
+    protected dequeueWithPriority: (redisClient: IRedisClient) => boolean;
+    protected dequeueAndBlock: (redisClient: IRedisClient) => boolean;
+    protected dequeueAndReturn: (redisClient: IRedisClient) => void;
+    dequeue(): void;
+}
+//# sourceMappingURL=dequeue-message.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/dequeue-message/event-bus-publisher.d.ts

@@ -0,0 +1,4 @@
+import { ILogger } from 'redis-smq-common';
+import { DequeueMessage } from './dequeue-message.js';
+export declare function eventBusPublisher(dequeueMessage: DequeueMessage, consumerId: string, logger: ILogger): void;
+//# sourceMappingURL=event-bus-publisher.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/errors/consumer-message-handler-file.error.d.ts

@@ -0,0 +1,5 @@
+import { ConsumerMessageHandlerError } from './consumer-message-handler.error.js';
+export declare class ConsumerMessageHandlerFileError extends ConsumerMessageHandlerError {
+    constructor();
+}
+//# sourceMappingURL=consumer-message-handler-file.error.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/errors/consumer-message-handler-filename-extension.error.d.ts

@@ -0,0 +1,5 @@
+import { ConsumerMessageHandlerError } from './consumer-message-handler.error.js';
+export declare class ConsumerMessageHandlerFilenameExtensionError extends ConsumerMessageHandlerError {
+    constructor();
+}
+//# sourceMappingURL=consumer-message-handler-filename-extension.error.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/errors/consumer-message-handler.error.d.ts

@@ -0,0 +1,5 @@
+import { ConsumerError } from '../../errors/index.js';
+export declare class ConsumerMessageHandlerError extends ConsumerError {
+    constructor(msg?: string);
+}
+//# sourceMappingURL=consumer-message-handler.error.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/errors/index.d.ts

@@ -0,0 +1,4 @@
+export { ConsumerMessageHandlerError } from './consumer-message-handler.error.js';
+export { ConsumerMessageHandlerFilenameExtensionError } from './consumer-message-handler-filename-extension.error.js';
+export { ConsumerMessageHandlerFileError } from './consumer-message-handler-file.error.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/message-handler/even-bus-publisher.d.ts

@@ -0,0 +1,4 @@
+import { ILogger } from 'redis-smq-common';
+import { MessageHandler } from './message-handler.js';
+export declare function evenBusPublisher(messageHandler: MessageHandler, consumerId: string, logger: ILogger): void;
+//# sourceMappingURL=even-bus-publisher.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/message-handler/message-handler.d.ts

@@ -0,0 +1,38 @@
+import { ICallback, ILogger, Runnable } from 'redis-smq-common';
+import { TConsumerMessageHandlerEvent, TRedisSMQEvent } from '../../../../common/index.js';
+import { RedisClientInstance } from '../../../../common/redis-client/redis-client-instance.js';
+import { IQueueParsedParams } from '../../../queue/index.js';
+import { Consumer } from '../../consumer/consumer.js';
+import { IConsumerMessageHandlerArgs } from '../../types/index.js';
+import { ConsumeMessage } from '../consume-message/consume-message.js';
+import { DequeueMessage } from '../dequeue-message/dequeue-message.js';
+export declare class MessageHandler extends Runnable<TConsumerMessageHandlerEvent> {
+    protected consumer: Consumer;
+    protected consumerId: string;
+    protected queue: IQueueParsedParams;
+    protected logger: ILogger;
+    protected dequeueMessage: DequeueMessage;
+    protected consumeMessage: ConsumeMessage;
+    protected messageHandler: import("../../types/message-handler.js").TConsumerMessageHandler;
+    protected autoDequeue: boolean;
+    protected redisClient: RedisClientInstance;
+    constructor(consumer: Consumer, logger: ILogger, handlerParams: IConsumerMessageHandlerArgs, autoDequeue?: boolean);
+    protected initDequeueMessageInstance(): DequeueMessage;
+    protected initConsumeMessageInstance(): ConsumeMessage;
+    protected onMessageReceived: TRedisSMQEvent['consumer.dequeueMessage.messageReceived'];
+    protected onMessageUnacknowledged: TRedisSMQEvent['consumer.consumeMessage.messageUnacknowledged'];
+    protected onMessageAcknowledged: TRedisSMQEvent['consumer.consumeMessage.messageAcknowledged'];
+    protected onMessageNext: TRedisSMQEvent['consumer.dequeueMessage.nextMessage'];
+    protected onError: (err: Error) => void;
+    protected registerSystemEvents: () => void;
+    protected cleanUp(cb: ICallback<void>): void;
+    protected getLogger(): ILogger;
+    protected handleError(err: Error): void;
+    protected goingUp(): ((cb: ICallback<void>) => void)[];
+    protected goingDown(): ((cb: ICallback<void>) => void)[];
+    processMessage(messageId: string): void;
+    next(): void;
+    dequeue(): void;
+    getQueue(): IQueueParsedParams;
+}
+//# sourceMappingURL=message-handler.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/multiplexed-message-handler.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from 'redis-smq-common';
+import { Consumer } from '../consumer/consumer.js';
+import { DequeueMessage } from './dequeue-message/dequeue-message.js';
+import { MessageHandler } from './message-handler/message-handler.js';
+import { IConsumerMessageHandlerArgs } from '../types/index.js';
+export declare class MultiplexedMessageHandler extends MessageHandler {
+    protected dequeueNextFn: () => void;
+    constructor(consumer: Consumer, handlerParams: IConsumerMessageHandlerArgs, logger: ILogger, dequeueNextFn: () => void);
+    protected initDequeueMessageInstance(): DequeueMessage;
+    next(): void;
+}
+//# sourceMappingURL=multiplexed-message-handler.d.ts.map

package/dist/esm/src/lib/consumer/message-handler/processing-queue.d.ts

@@ -0,0 +1,12 @@
+import { ICallback, ILogger, IRedisClient } from 'redis-smq-common';
+import { MessageEnvelope } from '../../message/message-envelope.js';
+import { IQueueParams } from '../../queue/index.js';
+import { EConsumeMessageUnacknowledgedCause } from '../types/index.js';
+import { TGetRetryActionReply } from './retry-message.js';
+export type THandleProcessingQueueReply = TGetRetryActionReply | false;
+export declare const processingQueue: {
+    handleProcessingQueue(redisClient: IRedisClient, consumerIds: string[], queues: IQueueParams[], logger: ILogger, unacknowledgedCause: EConsumeMessageUnacknowledgedCause, cb: ICallback<THandleProcessingQueueReply>): void;
+    fetchProcessingQueueMessage(redisClient: IRedisClient, keyQueueProcessing: string, cb: ICallback<MessageEnvelope>): void;
+    getQueueProcessingQueues(redisClient: IRedisClient, queue: IQueueParams, cb: ICallback<Record<string, string>>): void;
+};
+//# sourceMappingURL=processing-queue.d.ts.map