Class AMQPChannel

constructor

• new AMQPChannel(connection: AMQPBaseClient, id: number): AMQPChannel

  Parameters

  • connection: AMQPBaseClient

    The connection this channel belongs to
  • id: number

    ID of the channel

  Returns AMQPChannel

closed

confirmId

Readonlyconnection

Readonlyconsumers

Optionaldelivery

OptionalgetMessage

Readonlyid

onerror

Optionalreturned

basicAck

• basicAck(deliveryTag: number, multiple?: boolean): Promise<void>

  Acknowledge a delivered message

  Parameters

  • deliveryTag: number

    tag of the message
  • Optionalmultiple: boolean = false

    batch confirm all messages up to this delivery tag

  Returns Promise<void>

basicCancel

• basicCancel(tag: string): Promise<AMQPChannel>

  Cancel/stop a consumer

  Parameters

  • tag: string

    consumer tag

  Returns Promise<AMQPChannel>

basicConsume

• basicConsume(
      queue: string,
      param?: { args?: {}; exclusive?: boolean; noAck?: boolean; tag?: string },
      callback: (msg: AMQPMessage) => void,
  ): Promise<AMQPConsumer>

  Consume from a queue. Messages will be delivered asynchronously.

  Parameters

  • queue: string

    name of the queue to poll
  • param: { args?: {}; exclusive?: boolean; noAck?: boolean; tag?: string } = {}

    • Optionalargs?: {}

      custom arguments

    • Optionalexclusive?: boolean

      if this can be the only consumer of the queue, will return an Error if there are other consumers to the queue already

    • OptionalnoAck?: boolean

      if messages are removed from the server upon delivery, or have to be acknowledged

    • Optionaltag?: string

      tag of the consumer, will be server generated if left empty
  • callback: (msg: AMQPMessage) => void

    will be called for each message delivered to this consumer

  Returns Promise<AMQPConsumer>

basicFlow

• basicFlow(active?: boolean): 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>

basicGet

• basicGet(
      queue: string,
      param?: { noAck?: boolean },
  ): Promise<null | AMQPMessage>

  Synchronously receive a message from a queue

  Parameters

  • queue: string

    name of the queue to poll
  • param: { noAck?: boolean } = {}

    • OptionalnoAck?: 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

basicNack

• basicNack(
      deliveryTag: number,
      requeue?: boolean,
      multiple?: boolean,
  ): Promise<void>

  Acknowledge a delivered message

  Parameters

  • deliveryTag: number

    tag of the message
  • Optionalrequeue: boolean = false

    if the message should be requeued or removed
  • Optionalmultiple: boolean = false

    batch confirm all messages up to this delivery tag

  Returns Promise<void>

basicPublish

• basicPublish(
      exchange: string,
      routingKey: string,
      data:
          | null
          | string
          | ArrayBuffer
          | Uint8Array<ArrayBufferLike>
          | Buffer<ArrayBufferLike>,
      properties?: AMQPProperties,
      mandatory?: boolean,
      immediate?: boolean,
  ): 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
        | Uint8Array<ArrayBufferLike>
        | Buffer<ArrayBufferLike>

    the data to be published, can be a string or an uint8array
  • properties: AMQPProperties = {}

    properties to be published
  • Optionalmandatory: boolean = false

    if the message should be returned if there's no queue to be delivered to
  • Optionalimmediate: 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

basicQos

• basicQos(
      prefetchCount: number,
      prefetchSize?: number,
      global?: boolean,
  ): 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>

basicRecover

• basicRecover(requeue?: boolean): Promise<void>

  Tell the server to redeliver all unacknowledged messages again, or reject and requeue them.

  Parameters

  • Optionalrequeue: boolean = false

    if the message should be requeued or redeliviered to this channel

  Returns Promise<void>

basicReject

• basicReject(deliveryTag: number, requeue?: boolean): Promise<void>

  Acknowledge a delivered message

  Parameters

  • deliveryTag: number

    tag of the message
  • Optionalrequeue: boolean = false

    if the message should be requeued or removed

  Returns Promise<void>

close

• close(reason?: string, code?: number): Promise<void>

  Close the channel gracefully

  Parameters

  • Optionalreason: string = ""

    might be logged by the server
  • code: number = 200

  Returns Promise<void>

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>

exchangeBind

• exchangeBind(
      destination: string,
      source: string,
      routingKey?: string,
      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

exchangeDeclare

• exchangeDeclare(
      name: string,
      type: string,
      param?: ExchangeParams,
      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 = ...

    • OptionalautoDelete?: boolean

      if the exchange should be deleted when the last binding from it is deleted

    • Optionaldurable?: boolean

      if the exchange should survive server restarts

    • Optionalinternal?: boolean

      if exchange is internal to the server. Client's can't publish to internal exchanges.

    • Optionalpassive?: boolean

      if the exchange name doesn't exist the channel will be closed with an error, fulfilled if the exchange name does exists
  • args: {} = {}

    optional arguments

  Returns Promise<void>

  Fulfilled when the exchange is created or if it already exists

exchangeDelete

• exchangeDelete(name: string, param?: { ifUnused?: boolean }): Promise<void>

  Delete an exchange

  Parameters

  • name: string

    name of the exchange
  • param: { ifUnused?: boolean } = {}

    • OptionalifUnused?: 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

exchangeUnbind

• exchangeUnbind(
      destination: string,
      source: string,
      routingKey?: string,
      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

onReturn

• onReturn(message: AMQPMessage): void

  Default handler for Returned messages

  Parameters

  • message: AMQPMessage

    returned from server

  Returns void

open

• open(): Promise<AMQPChannel>

  Returns Promise<AMQPChannel>

prefetch

• prefetch(prefetchCount: number): Promise<void>

  Alias for basicQos

  Parameters

  • prefetchCount: number

    max inflight messages

  Returns Promise<void>

queue

• queue(
      name?: string,
      __namedParameters?: QueueParams,
      args?: {},
  ): Promise<AMQPQueue>

  Declare a queue and return an AMQPQueue instance.

  Parameters

  • name: string = ""
  • __namedParameters: QueueParams = ...
  • args: {} = {}

  Returns Promise<AMQPQueue>

queueBind

• queueBind(
      queue: string,
      exchange: string,
      routingKey: string,
      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

queueDeclare

• queueDeclare(name?: string, params?: QueueParams, args?: {}): Promise<QueueOk>

  Declare a queue

  Parameters

  • name: string = ""

    name of the queue, if empty the server will generate a name
  • params: QueueParams = ...

    • OptionalautoDelete?: boolean

      if the queue should be deleted when the last consumer of the queue disconnects

    • Optionaldurable?: boolean

      if the queue should survive server restarts

    • Optionalexclusive?: boolean

      if the queue should be deleted when the channel is closed

    • Optionalpassive?: boolean

      if the queue name doesn't exist the channel will be closed with an error, fulfilled if the queue name does exists
  • args: {} = {}

    optional custom queue arguments

  Returns Promise<QueueOk>

  fulfilled when confirmed by the server

queueDelete

• queueDelete(
      name?: string,
      params?: { ifEmpty?: boolean; ifUnused?: boolean },
  ): Promise<MessageCount>

  Delete a queue

  Parameters

  • name: string = ""

    name of the queue, if empty it will delete the last declared queue
  • params: { ifEmpty?: boolean; ifUnused?: boolean } = {}

    • OptionalifEmpty?: boolean

      only delete if the queue is empty

    • OptionalifUnused?: boolean

      only delete if the queue doesn't have any consumers

  Returns Promise<MessageCount>

queuePurge

• queuePurge(queue: string): Promise<MessageCount>

  Purge a queue

  Parameters

  • queue: string

    name of the queue

  Returns Promise<MessageCount>

  fulfilled when confirmed by the server

queueUnbind

• queueUnbind(
      queue: string,
      exchange: string,
      routingKey: string,
      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

txCommit

• txCommit(): Promise<void>

  Commit a transaction

  Returns Promise<void>

txRollback

• txRollback(): Promise<void>

  Rollback a transaction

  Returns Promise<void>

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>