Class AMQPChannel

Represents an AMQP Channel. Almost all actions in AMQP are performed on a Channel.

Hierarchy

AMQPChannel

Constructors

constructor

new AMQPChannel(connection, id): AMQPChannel
Parameters
- connection: AMQPBaseClient
  
  The connection this channel belongs to
- id: number
  
  ID of the channel
Returns AMQPChannel
- Defined in src/amqp-channel.ts:28

Properties

closed

closed: boolean = false

confirmId

confirmId: number = 0

`Readonly` connection

connection: AMQPBaseClient

`Readonly` consumers

consumers: Map<string, AMQPConsumer> = ...

`Optional` delivery

delivery?: AMQPMessage

`Optional` getMessage

getMessage?: AMQPMessage

`Readonly` id

id: number

onerror

onerror: ((reason) => void)

Type declaration

- (reason): void
- Parameters
  - reason: string
  Returns void

`Optional` returned

returned?: AMQPMessage

`Private` rpcQueue

rpcQueue: Promise<unknown> = ...

`Private` `Readonly` unconfirmedPublishes

unconfirmedPublishes: [number, ((confirmId) => void), ((err?) => void)][] = []

Accessors

`Private` logger

get logger(): undefined | null | Logger
Returns undefined | null | Logger
- Defined in src/amqp-channel.ts:34

Methods

basicAck

basicAck(deliveryTag, multiple?): Promise<void>
Acknowledge a delivered message
Parameters
- deliveryTag: number
  
  tag of the message
- Optional multiple: boolean = false
  
  batch confirm all messages up to this delivery tag
Returns Promise<void>
- Defined in src/amqp-channel.ts:204

basicCancel

basicCancel(tag): Promise<AMQPChannel>
Cancel/stop a consumer
Parameters
- tag: string
  
  consumer tag
Returns Promise<AMQPChannel>
- Defined in src/amqp-channel.ts:172

basicConsume

basicConsume(queue, param?, callback): Promise<AMQPConsumer>
Consume from a queue. Messages will be delivered asynchronously.
Parameters
- queue: string
  
  name of the queue to poll
- param: {
      args: undefined | {};
      exclusive: undefined | boolean;
      noAck: undefined | boolean;
      tag: undefined | string;
  } = {}
  - args: undefined | {}
    
    custom arguments
  - exclusive: undefined | boolean
    
    if this can be the only consumer of the queue, will return an Error if there are other consumers to the queue already
  - noAck: undefined | boolean
    
    if messages are removed from the server upon delivery, or have to be acknowledged
  - tag: undefined | string
    
    tag of the consumer, will be server generated if left empty
- callback: ((msg) => void)
  
  will be called for each message delivered to this consumer
  - - (msg): void
    - Parameters
      
      msg: AMQPMessage
      
      Returns void
Returns Promise<AMQPConsumer>
- Defined in src/amqp-channel.ts:135

basicFlow

basicFlow(active?): Promise<boolean>
Enable or disable flow. Disabling flow will stop the server from delivering messages to consumers. Not supported in RabbitMQ
Parameters
- active: boolean = true
  
  false to stop the flow, true to accept messages
Returns Promise<boolean>
- Defined in src/amqp-channel.ts:407

basicGet

basicGet(queue, param?): Promise<null | AMQPMessage>
Synchronously receive a message from a queue
Parameters
- queue: string
  
  name of the queue to poll
- param: {
  noAck: undefined | boolean;
  } = {}
  - noAck: undefined | boolean
    
    if message is removed from the server upon delivery, or have to be acknowledged
Returns Promise<null | AMQPMessage>
- returns null if the queue is empty otherwise a single message
- Defined in src/amqp-channel.ts:108

basicNack

basicNack(deliveryTag, requeue?, multiple?): Promise<void>
Acknowledge a delivered message
Parameters
- deliveryTag: number
  
  tag of the message
- Optional requeue: boolean = false
  
  if the message should be requeued or removed
- Optional multiple: boolean = false
  
  batch confirm all messages up to this delivery tag
Returns Promise<void>
- Defined in src/amqp-channel.ts:225

basicPublish

basicPublish(exchange, routingKey, data, properties?, mandatory?, immediate?): Promise<number>
Publish a message
Parameters
- exchange: string
  
  the exchange to publish to, the exchange must exists
- routingKey: string
  
  routing key
- data: null | string | ArrayBuffer | Buffer | Uint8Array
  
  the data to be published, can be a string or an uint8array
- properties: AMQPProperties = {}
  
  properties to be published
- Optional mandatory: boolean = false
  
  if the message should be returned if there's no queue to be delivered to
- Optional immediate: boolean = false
  
  if the message should be returned if it can't be delivered to a consumer immediately (not supported in RabbitMQ)
Returns Promise<number>
- fulfilled when the message is enqueue on the socket, or if publish confirm is enabled when the message is confirmed by the server
- Defined in src/amqp-channel.ts:291

basicQos

basicQos(prefetchCount, prefetchSize?, global?): Promise<void>
Set prefetch limit. Recommended to set as each unacknowledged message will be stored in memory of the client. The server won't deliver more messages than the limit until messages are acknowledged.
Parameters
- prefetchCount: number
  
  number of messages to limit to
- prefetchSize: number = 0
  
  number of bytes to limit to (not supported by RabbitMQ)
- global: boolean = false
  
  if the prefetch is limited to the channel, or if false to each consumer
Returns Promise<void>
- Defined in src/amqp-channel.ts:386

basicRecover

basicRecover(requeue?): Promise<void>
Tell the server to redeliver all unacknowledged messages again, or reject and requeue them.
Parameters
- Optional requeue: boolean = false
  
  if the message should be requeued or redeliviered to this channel
Returns Promise<void>
- Defined in src/amqp-channel.ts:267

basicReject

basicReject(deliveryTag, requeue?): Promise<void>
Acknowledge a delivered message
Parameters
- deliveryTag: number
  
  tag of the message
- Optional requeue: boolean = false
  
  if the message should be requeued or removed
Returns Promise<void>
- Defined in src/amqp-channel.ts:248

close

close(reason?, code?): Promise<void>
Close the channel gracefully
Parameters
- Optional reason: string = ""
  
  might be logged by the server
- code: number = 200
Returns Promise<void>
- Defined in src/amqp-channel.ts:82

confirmSelect

confirmSelect(): Promise<void>
Enable publish confirm. The server will then confirm each publish with an Ack or Nack when the message is enqueued.

Returns Promise<void>
- Defined in src/amqp-channel.ts:424

exchangeBind

exchangeBind(destination, source, routingKey?, args?): Promise<void>
Exchange to exchange binding.
Parameters
- destination: string
  
  name of the destination exchange
- source: string
  
  name of the source exchange
- routingKey: string = ""
  
  key to bind with
- args: {} = {}
  
  optional arguments, e.g. for header exchanges
Returns Promise<void>
fulfilled when confirmed by the server
- Defined in src/amqp-channel.ts:654

exchangeDeclare

exchangeDeclare(name, type, param?, args?): Promise<void>
Declare an exchange
Parameters
- name: string
  
  name of the exchange
- type: string
  
  type of exchange (direct, fanout, topic, header, or a custom type)
- param: ExchangeParams = ...
- args: {} = {}
  
  optional arguments
Returns Promise<void>
Fulfilled when the exchange is created or if it already exists
- Defined in src/amqp-channel.ts:594

exchangeDelete

exchangeDelete(name, param?): Promise<void>
Delete an exchange
Parameters
- name: string
  
  name of the exchange
- param: {
  ifUnused: undefined | boolean;
  } = {}
  - ifUnused: undefined | boolean
    
    only delete if the exchange doesn't have any bindings
Returns Promise<void>
Fulfilled when the exchange is deleted or if it's already deleted
- Defined in src/amqp-channel.ts:626

exchangeUnbind

exchangeUnbind(destination, source, routingKey?, args?): Promise<void>
Delete an exchange-to-exchange binding
Parameters
- destination: string
  
  name of destination exchange
- source: string
  
  name of the source exchange
- routingKey: string = ""
  
  key that was bound
- args: {} = {}
  
  arguments, e.g. for header exchanges
Returns Promise<void>
fulfilled when confirmed by the server
- Defined in src/amqp-channel.ts:682

onReturn

onReturn(message): void
Default handler for Returned messages
Parameters
- message: AMQPMessage
  
  returned from server
Returns void
- Defined in src/amqp-channel.ts:74

open

open(): Promise<AMQPChannel>
Returns Promise<AMQPChannel>
- Defined in src/amqp-channel.ts:38

prefetch

prefetch(prefetchCount): Promise<void>
Alias for basicQos
Parameters
- prefetchCount: number
  
  max inflight messages
Returns Promise<void>
- Defined in src/amqp-channel.ts:66

queue

queue(name?, __namedParameters?, args?): Promise<AMQPQueue>
Declare a queue and return an AMQPQueue instance.
Parameters
- name: string = ""
- __namedParameters: QueueParams = ...
- args: {} = {}
Returns Promise<AMQPQueue>
- Defined in src/amqp-channel.ts:54

queueBind

queueBind(queue, exchange, routingKey, args?): Promise<void>
Bind a queue to an exchange
Parameters
- queue: string
  
  name of the queue
- exchange: string
  
  name of the exchange
- routingKey: string
  
  key to bind with
- args: {} = {}
  
  optional arguments, e.g. for header exchanges
Returns Promise<void>
fulfilled when confirmed by the server
- Defined in src/amqp-channel.ts:511

queueDeclare

queueDeclare(name?, params?, args?): Promise<QueueOk>
Declare a queue
Parameters
- name: string = ""
  
  name of the queue, if empty the server will generate a name
- params: QueueParams = ...
- args: {} = {}
  
  optional custom queue arguments
Returns Promise<QueueOk>
fulfilled when confirmed by the server
- Defined in src/amqp-channel.ts:449

queueDelete

queueDelete(name?, params?): Promise<MessageCount>
Delete a queue
Parameters
- name: string = ""
  
  name of the queue, if empty it will delete the last declared queue
- params: {
  ifEmpty: undefined | boolean;
  ifUnused: undefined | boolean;
  } = {}
  - ifEmpty: undefined | boolean
    
    only delete if the queue is empty
  - ifUnused: undefined | boolean
    
    only delete if the queue doesn't have any consumers
Returns Promise<MessageCount>
- Defined in src/amqp-channel.ts:481

queuePurge

queuePurge(queue): Promise<MessageCount>
Purge a queue
Parameters
- queue: string
  
  name of the queue
Returns Promise<MessageCount>
fulfilled when confirmed by the server
- Defined in src/amqp-channel.ts:564

queueUnbind

queueUnbind(queue, exchange, routingKey, args?): Promise<void>
Unbind a queue from an exchange
Parameters
- queue: string
  
  name of the queue
- exchange: string
  
  name of the exchange
- routingKey: string
  
  key that was bound
- args: {} = {}
  
  arguments, e.g. for header exchanges
Returns Promise<void>
fulfilled when confirmed by the server
- Defined in src/amqp-channel.ts:540

`Private` rejectClosed

rejectClosed(): Promise<never>
Returns Promise<never>
Rejected promise with an error
- Defined in src/amqp-channel.ts:782

`Private` sendRpc

sendRpc(frame, frameSize): Promise<any>
Send a RPC request, will resolve a RPC promise when RPC response arrives
Parameters
- frame: AMQPView
  
  with data
- frameSize: number
  
  bytes the frame actually is
Returns Promise<any>
- Defined in src/amqp-channel.ts:743

txCommit

txCommit(): Promise<void>
Commit a transaction

Returns Promise<void>
- Defined in src/amqp-channel.ts:713

`Private` txMethod

txMethod(methodId): Promise<void>
Parameters
- methodId: number
Returns Promise<void>
- Defined in src/amqp-channel.ts:724

txRollback

txRollback(): Promise<void>
Rollback a transaction

Returns Promise<void>
- Defined in src/amqp-channel.ts:720

txSelect

txSelect(): Promise<void>
Set this channel in Transaction mode. Rember to commit the transaction, overwise the server will eventually run out of memory.

Returns Promise<void>
- Defined in src/amqp-channel.ts:706

Class AMQPChannel

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

connection: AMQPBaseClient

id: number

Returns AMQPChannel

Properties

closed

confirmId

Readonly connection

Readonly consumers

Optional delivery

Optional getMessage

Readonly id

onerror

Type declaration

Parameters

reason: string

Returns void

Optional returned

Private rpcQueue

Private Readonly unconfirmedPublishes

Accessors

Private logger

Returns undefined | null | Logger

Methods

basicAck

Parameters

deliveryTag: number

Optional multiple: boolean = false

Returns Promise<void>

basicCancel

Parameters

tag: string

Returns Promise<AMQPChannel>

basicConsume

Parameters

queue: string

param: { args: undefined | {}; exclusive: undefined | boolean; noAck: undefined | boolean; tag: undefined | string; } = {}

args: undefined | {}

exclusive: undefined | boolean

noAck: undefined | boolean

tag: undefined | string

callback: ((msg) => void)

Parameters

msg: AMQPMessage

Returns void

Returns Promise<AMQPConsumer>

basicFlow

Parameters

active: boolean = true

Returns Promise<boolean>

basicGet

Parameters

queue: string

param: { noAck: undefined | boolean; } = {}

noAck: undefined | boolean

Returns Promise<null | AMQPMessage>

basicNack

Parameters

deliveryTag: number

Optional requeue: boolean = false

Optional multiple: boolean = false

Returns Promise<void>

basicPublish

Parameters

exchange: string

routingKey: string

data: null | string | ArrayBuffer | Buffer | Uint8Array

properties: AMQPProperties = {}

Optional mandatory: boolean = false

Optional immediate: boolean = false

Returns Promise<number>

`Readonly` connection

`Readonly` consumers

`Optional` delivery

`Optional` getMessage

`Readonly` id

`Optional` returned

`Private` rpcQueue

`Private` `Readonly` unconfirmedPublishes

`Private` logger

`Optional` multiple: boolean = false

param: {
args: undefined | {};
exclusive: undefined | boolean;
noAck: undefined | boolean;
tag: undefined | string;
} = {}

param: {
noAck: undefined | boolean;
} = {}

`Optional` requeue: boolean = false

`Optional` multiple: boolean = false

`Optional` mandatory: boolean = false

`Optional` immediate: boolean = false

`Optional` requeue: boolean = false

`Optional` requeue: boolean = false

`Optional` reason: string = ""

param: {
ifUnused: undefined | boolean;
} = {}