amqplib

amqplib

Version 2.0.1
Published 21 days ago
546 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>;

interface RecoveryOptions

interface RecoveryOptions {}

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 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. Default: Infinity

property setup

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

Optional setup function called after each successful connection

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 19 days ago.
Package analyzed in 4942 ms.
Missing or incorrect documentation? Open an issue for this package.