Class AMQPSession

Optionalonconnect

Optionalonfailed

closed

• get closed(): boolean

  true when the underlying connection is closed.

  Returns boolean

directExchange

• directExchange(
      name?: string,
      params?: ExchangeParams,
      args?: Record<string, unknown>,
  ): Promise<AMQPExchange>

  Declare a direct exchange and return a session-bound AMQPExchange handle.

  Parameters

  • Optionalname: string = "amq.direct"

    exchange name
  • Optionalparams: ExchangeParams
  • Optionalargs: Record<string, unknown>

  Returns Promise<AMQPExchange>

exchange

• exchange(
      name: string,
      type: string,
      params?: ExchangeParams,
      args?: Record<string, unknown>,
  ): Promise<AMQPExchange>

  Declare an exchange and return a session-bound AMQPExchange handle.

  Parameters

  • name: string

    exchange name
  • type: string

    exchange type: "direct", "fanout", "topic", "headers", or a custom type
  • Optionalparams: ExchangeParams

    exchange declaration parameters
  • Optionalargs: Record<string, unknown>

    optional exchange arguments

  Returns Promise<AMQPExchange>

fanoutExchange

• fanoutExchange(
      name?: string,
      params?: ExchangeParams,
      args?: Record<string, unknown>,
  ): Promise<AMQPExchange>

  Declare a fanout exchange and return a session-bound AMQPExchange handle.

  Parameters

  • Optionalname: string = "amq.fanout"

    exchange name
  • Optionalparams: ExchangeParams
  • Optionalargs: Record<string, unknown>

  Returns Promise<AMQPExchange>

headersExchange

• headersExchange(
      name?: string,
      params?: ExchangeParams,
      args?: Record<string, unknown>,
  ): Promise<AMQPExchange>

  Declare a headers exchange and return a session-bound AMQPExchange handle.

  Parameters

  • Optionalname: string = "amq.headers"

    exchange name
  • Optionalparams: ExchangeParams
  • Optionalargs: Record<string, unknown>

  Returns Promise<AMQPExchange>

queue

• queue(
      name: string,
      params?: QueueParams,
      args?: Record<string, unknown>,
  ): Promise<AMQPQueue>

  Declare a queue and return a session-bound AMQPQueue handle. The returned queue's subscribe uses auto-recovery and publish waits for a broker confirm.

  Parameters

  • name: string

    queue name (use "" to let the broker generate a name)
  • Optionalparams: QueueParams

    queue declaration parameters
  • Optionalargs: Record<string, unknown>

    optional queue arguments (e.g. x-message-ttl)

  Returns Promise<AMQPQueue>

rpcCall

• rpcCall(
      queue: string,
      body: Body,
      options?: AMQPProperties & { timeout?: number },
  ): Promise<AMQPMessage>

  Perform an RPC call: publish a message and wait for the response. Creates a temporary client per call — simple and sufficient for most use cases.

  For high-throughput scenarios where the per-call channel overhead matters, use rpcClient to create a reusable client instead.

  Parameters

  • queue: string

    The routing key / queue name of the RPC server
  • body: Body

    The request body
  • Optionaloptions: AMQPProperties & { timeout?: number }

    Optional AMQP properties and timeout

    • Optionaltimeout?: number

      Timeout in milliseconds

  Returns Promise<AMQPMessage>

  The reply AMQPMessage

rpcClient

• rpcClient(): Promise<AMQPRPCClient>

  Create and start a reusable RPC client that keeps its channel open across multiple calls. Prefer rpcCall for simplicity; use this when you need to avoid the per-call channel overhead.

  Returns Promise<AMQPRPCClient>

  A started AMQPRPCClient ready for AMQPRPCClient.call invocations.

rpcServer

• rpcServer(
      queue: string,
      handler: RPCHandler,
      prefetch?: number,
  ): Promise<AMQPRPCServer>

  Create and start an RPC server that consumes from the given queue. Each incoming message is passed to handler; the returned value is published back to the caller's replyTo address.

  Parameters

  • queue: string

    Queue name to consume from
  • handler: RPCHandler

    Callback that receives the message body and full message, returns the response body
  • Optionalprefetch: number

    Channel prefetch count (default: 1)

  Returns Promise<AMQPRPCServer>

  A started AMQPRPCServer

stop

• stop(reason?: string): Promise<void>

  Stop the session: cancel reconnection, clear consumer tracking, and close the underlying connection.

  Parameters

  • Optionalreason: string

  Returns Promise<void>

topicExchange

• topicExchange(
      name?: string,
      params?: ExchangeParams,
      args?: Record<string, unknown>,
  ): Promise<AMQPExchange>

  Declare a topic exchange and return a session-bound AMQPExchange handle.

  Parameters

  • Optionalname: string = "amq.topic"

    exchange name
  • Optionalparams: ExchangeParams
  • Optionalargs: Record<string, unknown>

  Returns Promise<AMQPExchange>

Staticconnect

• connect(url: string, options?: AMQPSessionOptions): Promise<AMQPSession>

  Connect to an AMQP broker and return a session with automatic reconnection.

  The transport is chosen from the URL scheme:

  • amqp:// / amqps:// → TCP socket (AMQPClient)
  • ws:// / wss:// → WebSocket (AMQPWebSocketClient)

  Parameters

  • url: string
  • Optionaloptions: AMQPSessionOptions

  Returns Promise<AMQPSession>