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

AMQP/RabbitMQ driver for Fedify

import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
import { ChannelModel } from "amqplib";

//#region src/mq.d.ts

/**
 * Options for {@link AmqpMessageQueue}.
 */
interface AmqpMessageQueueOptions {
  /**
   * The name of the queue to use.  Defaults to `"fedify_queue"`.
   * @default `"fedify_queue"`
   */
  queue?: string;
  /**
   * The prefix to use for the delayed queue.  Defaults to `"fedify_delayed_"`.
   * Defaults to `"fedify_delayed_"`.
   * @default `"fedify_delayed_"`
   */
  delayedQueuePrefix?: string;
  /**
   * Whether the queue will survive a broker restart.  Defaults to `true`.
   * @default `true`
   */
  durable?: boolean;
  /**
   * Whether to use native retrial mechanism. If set to `true`, the queue will
   * not acknowledge messages that are not processed successfully, allowing
   * them to be retried later. If set to `false`, messages will be acknowledged
   * whether they are processed successfully or not.
   *
   * Both approaches have their own advantages and disadvantages.  With native
   * retrials, much less chance of losing messages, but timing of retrials is
   * less predictable.  With non-native retrials, retrials are handled by Fedify
   * itself, which allows for more control over the timing and behavior of
   * retrials, but may result in lost messages if the process crashes before
   * acknowledging the message.
   * @default `false`
   * @since 0.3.0
   */
  nativeRetrial?: boolean;
}
/**
 * A message queue that uses AMQP.
 *
 * @example
 * ``` typescript
 * import { createFederation } from "@fedify/fedify";
 * import { AmqpMessageQueue } from "@fedify/amqp";
 * import { connect } from "amqplib";
 *
 * const federation = createFederation({
 *   queue: new AmqpMessageQueue(await connect("amqp://localhost")),
 *   // ... other configurations
 * });
 * ```
 */
declare class AmqpMessageQueue implements MessageQueue {
  #private;
  readonly nativeRetrial: boolean;
  /**
   * Creates a new `AmqpMessageQueue`.
   * @param connection A connection to the AMQP server.
   * @param options Options for the message queue.
   */
  constructor(connection: ChannelModel, options?: AmqpMessageQueueOptions);
  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>;
}
//#endregion
export { AmqpMessageQueue, AmqpMessageQueueOptions };