@fedify/redis/dist/mq.d.ts

Redis drivers for Fedify

import { Temporal } from "@js-temporal/polyfill";
import { Codec } from "./codec.js";
import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
import { Cluster, Redis, RedisKey } from "ioredis";

//#region src/mq.d.ts
/**
 * Options for {@link RedisMessageQueue} class.
 */
interface RedisMessageQueueOptions {
  /**
   * The unique identifier for the worker that is processing messages from the
   * queue.  If this is not specified, a random identifier will be generated.
   * This is used to prevent multiple workers from processing the same message,
   * so it should be unique for each worker.
   */
  workerId?: string;
  /**
   * The Pub/Sub channel key to use for the message queue.  `"fedify_channel"`
   * by default.
   * @default `"fedify_channel"`
   */
  channelKey?: RedisKey;
  /**
   * The Sorted Set key to use for the delayed message queue.  `"fedify_queue"`
   * by default.
   * @default `"fedify_queue"`
   */
  queueKey?: RedisKey;
  /**
   * The key to use for locking the message queue.  `"fedify_lock"` by default.
   * @default `"fedify_lock"`
   */
  lockKey?: RedisKey;
  /**
   * The codec to use for encoding and decoding messages in the key–value store.
   * Defaults to {@link JsonCodec}.
   * @default {@link JsonCodec}
   */
  codec?: Codec;
  /**
   * The poll interval for the message queue.  5 seconds by default.
   * @default `{ seconds: 5 }`
   */
  pollInterval?: Temporal.Duration | Temporal.DurationLike;
}
/**
 * A message queue that uses Redis as the underlying storage.
 *
 * @example
 * ```ts ignore
 * import { createFederation } from "@fedify/fedify";
 * import { RedisMessageQueue } from "@fedify/redis";
 * import { Redis, Cluster } from "ioredis";
 *
 * // Using a standalone Redis instance:
 * const federation = createFederation({
 *   // ...
 *   queue: new RedisMessageQueue(() => new Redis()),
 * });
 *
 * // Using a Redis Cluster:
 * const federation = createFederation({
 *   // ...
 *   queue: new RedisMessageQueue(() => new Cluster([
 *     { host: "127.0.0.1", port: 7000 },
 *     { host: "127.0.0.1", port: 7001 },
 *     { host: "127.0.0.1", port: 7002 },
 *   ])),
 * });
 * ```
 */
declare class RedisMessageQueue implements MessageQueue, Disposable {
  #private;
  /**
   * Creates a new Redis message queue.
   * @param redis The Redis client factory.
   * @param options The options for the message queue.
   */
  constructor(redis: () => Redis | Cluster, options?: RedisMessageQueueOptions);
  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
  listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
  [Symbol.dispose](): void;
}
//#endregion
export { RedisMessageQueue, RedisMessageQueueOptions };