amqplib

amqplib

Version 2.2.0
Published 17 days ago
577 kB
No dependencies
MIT license

Install

npm i amqplib

yarn add amqplib

pnpm add amqplib

Overview

An AMQP 0-9-1 (e.g., RabbitMQ) library and client.

Index

Variables

variable credentials

const credentials: {
    plain(
        username: string,
        password: string
    ): { mechanism: string; response(): Buffer; username: string; password: string };
    amqplain(
        username: string,
        password: string
    ): { mechanism: string; response(): Buffer; username: string; password: string };
    external(): { mechanism: string; response(): Buffer };
};

Functions

function connect

connect: {
    (
        url: string | Options.Connect,
        socketOptions: SocketOptions & { recovery: RecoveryOptions | true }
    ): Promise<RecoveringChannelModel>;
    (
        url: string | Options.Connect,
        socketOptions?: SocketOptions
    ): Promise<ChannelModel>;
};

Classes

class IllegalOperationError

class IllegalOperationError extends Error {}

constructor

constructor(msg: string, stack?: string);

property name

name: string;

property stackAtStateChange

stackAtStateChange: string;

Interfaces

interface Channel

interface Channel extends events.EventEmitter {}

property connection

readonly connection: Connection;

method ack

ack: (message: Message, allUpTo?: boolean) => void;

method ackAll

ackAll: () => void;

method assertExchange

assertExchange: (
    exchange: string,
    type: 'direct' | 'topic' | 'headers' | 'fanout' | 'match' | string,
    options?: Options.AssertExchange
) => Promise<Replies.AssertExchange>;

method assertQueue

assertQueue: (
    queue?: string,
    options?: Options.AssertQueue
) => Promise<Replies.AssertQueue>;

method bindExchange

bindExchange: (
    destination: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

method bindQueue

bindQueue: (
    queue: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

method cancel

cancel: (consumerTag: string) => Promise<Replies.Empty>;

method checkExchange

checkExchange: (exchange: string) => Promise<Replies.Empty>;

method checkQueue

checkQueue: (queue: string) => Promise<Replies.AssertQueue>;

method close

close: () => Promise<void>;

method consume

consume: (
    queue: string,
    onMessage: (msg: ConsumeMessage | null) => void,
    options?: Options.Consume
) => Promise<Replies.Consume>;

method deleteExchange

deleteExchange: (
    exchange: string,
    options?: Options.DeleteExchange
) => Promise<Replies.Empty>;

method deleteQueue

deleteQueue: (
    queue: string,
    options?: Options.DeleteQueue
) => Promise<Replies.DeleteQueue>;

method get

get: (queue: string, options?: Options.Get) => Promise<GetMessage | false>;

method nack

nack: (message: Message, allUpTo?: boolean, requeue?: boolean) => void;

method nackAll

nackAll: (requeue?: boolean) => void;

method on

on: {
    (event: 'close', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'drain', listener: () => void): this;
    (
        event: 'ack',
        listener: (fields: { deliveryTag: number; multiple: boolean }) => void
    ): this;
    (
        event: 'nack',
        listener: (fields: {
            deliveryTag: number;
            multiple: boolean;
            requeue: boolean;
        }) => void
    ): this;
    (event: 'cancel', listener: (fields: { consumerTag: string }) => void): this;
    (event: 'delivery', listener: (message: ConsumeMessage) => void): this;
    (event: 'return', listener: (message: Message) => void): this;
    (
        event: 'handler-error',
        listener: (err: Error, eventName: string) => void
    ): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prefetch

prefetch: (count: number, global?: boolean) => Promise<Replies.Empty>;

method publish

publish: (
    exchange: string,
    routingKey: string,
    content: Buffer,
    options?: Options.Publish
) => boolean;

method purgeQueue

purgeQueue: (queue: string) => Promise<Replies.PurgeQueue>;

method recover

recover: () => Promise<Replies.Empty>;

method reject

reject: (message: Message, requeue?: boolean) => void;

method sendToQueue

sendToQueue: (
    queue: string,
    content: Buffer,
    options?: Options.Publish
) => boolean;

method unbindExchange

unbindExchange: (
    destination: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

method unbindQueue

unbindQueue: (
    queue: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

interface ChannelModel

interface ChannelModel extends events.EventEmitter {}

property connection

readonly connection: Connection;

method close

close: () => Promise<void>;

method createChannel

createChannel: (options?: ChannelOptions) => Promise<Channel>;

method createConfirmChannel

createConfirmChannel: (options?: ChannelOptions) => Promise<ConfirmChannel>;

method on

on: {
    (event: 'close', listener: (err?: Error) => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'blocked', listener: (reason: string) => void): this;
    (event: 'unblocked', listener: () => void): this;
    (event: 'update-secret-ok', listener: () => void): this;
    (
        event: 'handler-error',
        listener: (err: Error, eventName: string) => void
    ): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method updateSecret

updateSecret: (newSecret: Buffer, reason: string) => Promise<void>;

interface ChannelOptions

interface ChannelOptions {}

property highWaterMark

highWaterMark?: number;

interface CommonMessageFields

interface CommonMessageFields {}

property deliveryTag

deliveryTag: number;

property exchange

exchange: string;

property redelivered

redelivered: boolean;

property routingKey

routingKey: string;

interface ConfirmChannel

interface ConfirmChannel extends Channel {}

method publish

publish: (
    exchange: string,
    routingKey: string,
    content: Buffer,
    options?: Options.Publish,
    callback?: (err: any, ok: Replies.Empty) => void
) => boolean;

method sendToQueue

sendToQueue: (
    queue: string,
    content: Buffer,
    options?: Options.Publish,
    callback?: (err: any, ok: Replies.Empty) => void
) => boolean;

method waitForConfirms

waitForConfirms: () => Promise<void>;

interface Connection

interface Connection {}

property serverProperties

readonly serverProperties: ServerProperties;

interface ConsumeMessage

interface ConsumeMessage extends Message {}

property fields

fields: ConsumeMessageFields;

interface ConsumeMessageFields

interface ConsumeMessageFields extends CommonMessageFields {}

property consumerTag

consumerTag: string;

interface GetMessage

interface GetMessage extends Message {}

property fields

fields: GetMessageFields;

interface GetMessageFields

interface GetMessageFields extends CommonMessageFields {}

property messageCount

messageCount: number;

interface Message

interface Message {}

property content

content: Buffer;

property fields

fields: MessageFields;

property properties

properties: MessageProperties;

interface MessageFields

interface MessageFields extends CommonMessageFields {}

property consumerTag

consumerTag?: string;

property messageCount

messageCount?: number;

interface MessageProperties

interface MessageProperties {}

property appId

appId: any | undefined;

property clusterId

clusterId: any | undefined;

property contentEncoding

contentEncoding: any | undefined;

property contentType

contentType: any | undefined;

property correlationId

correlationId: any | undefined;

property deliveryMode

deliveryMode: any | undefined;

property expiration

expiration: any | undefined;

property headers

headers: MessagePropertyHeaders | undefined;

property messageId

messageId: any | undefined;

property priority

priority: any | undefined;

property replyTo

replyTo: any | undefined;

property timestamp

timestamp: any | undefined;

property type

type: any | undefined;

property userId

userId: any | undefined;

interface MessagePropertyHeaders

interface MessagePropertyHeaders {}

property 'x-death'

'x-death'?: XDeath[];

property 'x-first-death-exchange'

'x-first-death-exchange'?: string;

property 'x-first-death-queue'

'x-first-death-queue'?: string;

property 'x-first-death-reason'

'x-first-death-reason'?: string;

index signature

[key: string]: any;

interface RecoveringChannelModel

interface RecoveringChannelModel extends events.EventEmitter {}

method close

close: () => Promise<void>;

method createChannel

createChannel: (options?: ChannelOptions) => Promise<Channel>;

method createConfirmChannel

createConfirmChannel: (options?: ChannelOptions) => Promise<ConfirmChannel>;

method on

on: {
    (event: 'connect', listener: (model: ChannelModel) => void): this;
    (event: 'disconnect', listener: (err: Error) => void): this;
    (event: 'connect-failed', listener: (err: Error) => void): this;
    (
        event: 'reconnect-scheduled',
        listener: (info: {
            attempt: number;
            delay: number;
            error: Error;
        }) => void
    ): this;
    (event: 'reconnect-failed', listener: (err: Error) => void): this;
    (event: 'blocked', listener: (reason: string) => void): this;
    (event: 'unblocked', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'update-secret-ok', listener: () => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method updateSecret

updateSecret: (newSecret: Buffer, reason: string) => Promise<void>;

method waitForConnect

waitForConnect: () => Promise<this>;

Resolves once the first connection has been established

interface RecoveryOptions

interface RecoveryOptions {}

property calculateDelay

calculateDelay?: (attempt: number) => number;

Optional custom delay strategy. Called with the reconnect attempt number (starting at 1) and must return the delay in milliseconds. Falls back to the built-in exponential-backoff-with-jitter strategy when absent. If it throws, or returns something other than a finite, non-negative number, recovery gives up as if maxRetries were exhausted: the initial connection fails with the error and reconnect-failed is emitted.

property factor

factor?: number;

Backoff multiplier applied to delay on each attempt. Default: 2

property initialDelay

initialDelay?: number;

Initial reconnect delay in milliseconds. Default: 100

property initialMaxRetries

initialMaxRetries?: number;

Maximum number of retries before the first successful connection. Once connected, maxRetries applies instead. Lets startup fail fast against an unreachable broker while steady-state recovery keeps retrying. Default: the value of maxRetries

property jitter

jitter?: number;

Jitter factor (0–1) applied to delay to avoid thundering herd. Default: 0.2

property maxDelay

maxDelay?: number;

Maximum reconnect delay in milliseconds. Default: 30000

property maxRetries

maxRetries?: number;

Maximum number of reconnect attempts. Also bounds the initial connection unless initialMaxRetries is set. Default: Infinity

property setup

setup?:
    | ((model: ChannelModel) => Promise<void>)
    | ((model: ChannelModel, done: (err?: Error) => void) => void);

Optional setup function called after each successful connection

property waitForConnect

waitForConnect?: boolean;

When false, connect() resolves immediately with the recovering connection without waiting for the first successful connection, so listeners can be attached before the initial attempt. Use waitForConnect() to await the first connection. Default: true

interface ServerProperties

interface ServerProperties {}

property copyright

copyright?: string;

property host

host: string;

property information

information: string;

property platform

platform: string;

property product

product: string;

property version

version: string;

index signature

[key: string]: string | undefined;

interface SocketOptions

interface SocketOptions extends tls.ConnectionOptions {}

property clientProperties

clientProperties?: Record<string, unknown>;

property credentials

credentials?: {
    mechanism: string;
    response(): Buffer;
    username?: string;
    password?: string;
};

property keepAlive

keepAlive?: boolean;

property keepAliveDelay

keepAliveDelay?: number;

property noDelay

noDelay?: boolean;

property timeout

timeout?: number;

interface XDeath

interface XDeath {}

property 'original-expiration'

'original-expiration'?: any;

property 'routing-keys'

'routing-keys': string[];

property count

count: number;

property exchange

exchange: string;

property queue

queue: string;

property reason

reason: 'rejected' | 'expired' | 'maxlen';

property time

time: {
    '!': 'timestamp';
    value: number;
};

Namespaces

namespace Options

namespace Options {}

interface AssertExchange

interface AssertExchange {}

property alternateExchange

alternateExchange?: string;

property arguments

arguments?: any;

property autoDelete

autoDelete?: boolean;

property durable

durable?: boolean;

property internal

internal?: boolean;

interface AssertQueue

interface AssertQueue {}

property arguments

arguments?: any;

property autoDelete

autoDelete?: boolean;

property deadLetterExchange

deadLetterExchange?: string;

property deadLetterRoutingKey

deadLetterRoutingKey?: string;

property durable

durable?: boolean;

property exclusive

exclusive?: boolean;

property expires

expires?: number;

property maxLength

maxLength?: number;

property maxPriority

maxPriority?: number;

property messageTtl

messageTtl?: number;

property overflow

overflow?: string;

property queueMode

queueMode?: string;

interface Connect

interface Connect {}

property channelMax

channelMax?: number;

property credentials

credentials?: {
    mechanism: string;
    response(): Buffer;
    username?: string;
    password?: string;
};

property frameMax

frameMax?: number;

property heartbeat

heartbeat?: number;

property hostname

hostname?: string;

property locale

locale?: string;

property password

password?: string;

property port

port?: number;

property protocol

protocol?: string;

property username

username?: string;

property vhost

vhost?: string;

interface Consume

interface Consume {}

property arguments

arguments?: any;

property consumerTag

consumerTag?: string;

property exclusive

exclusive?: boolean;

property noAck

noAck?: boolean;

property noLocal

noLocal?: boolean;

property priority

priority?: number;

interface DeleteExchange

interface DeleteExchange {}

property ifUnused

ifUnused?: boolean;

interface DeleteQueue

interface DeleteQueue {}

property ifEmpty

ifEmpty?: boolean;

property ifUnused

ifUnused?: boolean;

interface Get

interface Get {}

property noAck

noAck?: boolean;

interface Publish

interface Publish {}

property appId

appId?: string;

property BCC

BCC?: string | string[];

property CC

CC?: string | string[];

property contentEncoding

contentEncoding?: string;

property contentType

contentType?: string;

property correlationId

correlationId?: string;

property deliveryMode

deliveryMode?: boolean | number;

property expiration

expiration?: string | number;

property headers

headers?: any;

property mandatory

mandatory?: boolean;

property messageId

messageId?: string;

property persistent

persistent?: boolean;

property priority

priority?: number;

property replyTo

replyTo?: string;

property timestamp

timestamp?: number;

property type

type?: string;

property userId

userId?: string;

namespace Replies

namespace Replies {}

interface AssertExchange

interface AssertExchange {}

property exchange

exchange: string;

interface AssertQueue

interface AssertQueue {}

property consumerCount

consumerCount: number;

property messageCount

messageCount: number;

property queue

queue: string;

interface Consume

interface Consume {}

property consumerTag

consumerTag: string;

interface DeleteQueue

interface DeleteQueue {}

property messageCount

messageCount: number;

interface Empty

interface Empty {}

interface PurgeQueue

interface PurgeQueue {}

property messageCount

messageCount: number;

Package Files (2)

Dependencies (0)

No dependencies.

Dev Dependencies (6)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/amqplib.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/amqplib)

HTML

<a href="https://www.jsdocs.io/package/amqplib"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 14 days ago.
Package analyzed in 4537 ms.
Missing or incorrect documentation? Open an issue for this package.