bug_bunny 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e154bfecb70c1fc85408e87876976dfc8c64c01c2816c4f811a05e39e8432f9
-  data.tar.gz: 3b4e1508cd1a7f019fb638831c58117d00c46729b4f6bad4f8ecaf1b75914b47
+  metadata.gz: 730ae48562650742b536036de0db8b811efa48855790ef08bffc15713867654e
+  data.tar.gz: c4d16c6b17307831dd9cfc3be7ef2f78ecc52254034ded5187b2a19f00490aa3
 SHA512:
-  metadata.gz: b43ec72552e6d17601665f7640aedd1e9c390463f6df5ca950b082e17316e387d0a10fa9e5ddfd3611d3f928a5d7d2af71367fa6c5409ba1f242402bd46843a1
-  data.tar.gz: cdd64f5401a653a0fe839ea2a3cf926e1af7de6e8498892bbd20876ea2ed808f97d4db1daa1a31f70c54533a00f73e834a547943d34f8a95543b1befeb5a9591
+  metadata.gz: 5551a1bff89d318faf4155dead6e042ac991b57a30459efa2bfcad9029191b12391e6e058e275dda39bdaa4ed7cd2413e46ececa048905836009e4294b8d85e2
+  data.tar.gz: dd6af676b128f77d01c885d1107b773080d3ebd80b0a49477f3f6d4db511f91acdf8d2775281fa4cae529e17161cf7180caf41c983aece183112f6ab93fedf69

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [3.0.1] - 2026-02-10
+
+### 🚀 Features: RESTful Architecture
+* **HTTP Verbs over AMQP:** Implemented support for semantic HTTP verbs (`GET`, `POST`, `PUT`, `DELETE`) within AMQP headers (`x-http-method`). This enables a true RESTful design over RabbitMQ.
+* **Smart Router:** The `BugBunny::Consumer` now behaves like a Rails Router. It automatically infers the controller action based on the combination of the **Verb** and the **URL Path** (e.g., `GET users/1` dispatches to `show`, `POST users` to `create`).
+* **Resource CRUD Mapping:** `BugBunny::Resource` now maps Ruby operations to their specific REST verbs:
+    * `create` -> `POST`
+    * `update` -> `PUT`
+    * `destroy` -> `DELETE`
+    * `find/where` -> `GET`.
+
+### 🛠 Improvements
+* **Client API:** Updated `BugBunny::Client#request` and `#publish` to accept a `method:` argument (e.g., `client.request('users', method: :post)`), giving developers full control over the request semantics without changing the method signature.
+* **Request Metadata:** `BugBunny::Request` now handles the `method` attribute and ensures it is properly injected into the AMQP headers for the consumer to read.
+
 ## [3.0.0] - 2026-02-05
 
 ### ⚠ Breaking Changes

data/README.md

@@ -2,7 +2,9 @@
 
 **BugBunny** es un framework RPC para Ruby on Rails sobre **RabbitMQ**.
 
-Su filosofía es **"Active Record over AMQP"**. Abstrae la complejidad de colas y exchanges transformando patrones de mensajería en una arquitectura **RESTful simulada**, donde los mensajes contienen "URLs" y "Query Params" que son enrutados automáticamente a controladores.
+Su filosofía es **"Active Record over AMQP"**. Abstrae la complejidad de colas y exchanges transformando patrones de mensajería en una arquitectura **RESTful simulada**.
+
+A diferencia de otros clientes de RabbitMQ, BugBunny viaja con **Verbos HTTP** (`GET`, `POST`, `PUT`, `DELETE`) inyectados en los headers AMQP. Esto permite construir una API semántica donde un **Router Inteligente** despacha los mensajes a controladores Rails estándar.
 
 ---
 
@@ -20,7 +22,7 @@ Ejecuta el bundle:
 bundle install
 ```
 
-Corre el instalador para generar la configuración:
+Corre el instalador para generar la configuración inicial:
 
 ```bash
 rails g bug_bunny:install
@@ -30,11 +32,9 @@ rails g bug_bunny:install
 
 ## ⚙️ Configuración
 
-Configura tus credenciales y el Pool de conexiones en el inicializador.
+Configura tus credenciales y el Pool de conexiones en el inicializador `config/initializers/bug_bunny.rb`.
 
 ```ruby
-# config/initializers/bug_bunny.rb
-
 BugBunny.configure do |config|
   config.host     = ENV.fetch('RABBITMQ_HOST', 'localhost')
   config.username = ENV.fetch('RABBITMQ_USER', 'guest')
@@ -46,7 +46,9 @@ BugBunny.configure do |config|
   config.network_recovery_interval = 5
 end
 
-# Definimos el Pool Global (Vital para Puma/Sidekiq)
+# ⚠️ CRÍTICO: Definimos el Pool Global
+# Es vital usar ConnectionPool para garantizar la seguridad en entornos
+# multi-hilo como Puma o Sidekiq.
 BUG_BUNNY_POOL = ConnectionPool.new(size: ENV.fetch('RAILS_MAX_THREADS', 5).to_i, timeout: 5) do
   BugBunny.create_connection
 end
@@ -59,128 +61,152 @@ BugBunny::Resource.connection_pool = BUG_BUNNY_POOL
 
 ## 🚀 Modo Resource (ORM / Active Record)
 
-Define modelos que actúan como proxis de recursos remotos. BugBunny separa la **Lógica de Transporte** (RabbitMQ) de la **Lógica de Aplicación** (Controladores).
+Define modelos que actúan como proxies de recursos remotos. BugBunny separa la **Lógica de Transporte** (RabbitMQ) de la **Lógica de Aplicación** (Controladores).
 
-### Escenario A: Routing Dinámico (Topic / Estándar)
-Ideal cuando quieres enrutar por acción. La Routing Key se genera automáticamente usando `resource_name.action`.
+### Definición del Modelo
 
 ```ruby
 class RemoteUser < BugBunny::Resource
-  # --- Configuración ---
+  # 1. Configuración de Transporte
   self.exchange = 'app.topic'
   self.exchange_type = 'topic'
   
-  # Define el nombre lógico del recurso.
-  # 1. Routing Key: 'users.create', 'users.show.12'
-  # 2. Header Type: 'users/create', 'users/show/12'
+  # 2. Configuración Lógica (Routing)
+  # Define el nombre del recurso. Se usa para:
+  # - Routing Key automática: 'users' (Topic)
+  # - URL Base: 'users'
   self.resource_name = 'users'
 
-  # No necesitas definir atributos, BugBunny soporta atributos dinámicos (Schema-less)
-end
-```
-
-### Escenario B: Routing Estático (Direct / Cola Dedicada)
-Ideal cuando quieres enviar todo a una cola específica (ej: un Manager), independientemente de la acción.
-
-```ruby
-class BoxManager < BugBunny::Resource
-  # --- Configuración ---
-  self.exchange = 'warehouse.direct'
-  self.exchange_type = 'direct'
-  
-  # FORZAMOS LA ROUTING KEY.
-  # Todo viaja con esta key, sin importar la acción.
-  self.routing_key = 'manager_queue'
-
-  # Define el nombre lógico para el Controlador.
-  # Header Type: 'box_manager/create', 'box_manager/show/12'
-  self.resource_name = 'box_manager'
+  # Nota: BugBunny es Schema-less. No necesitas definir atributos.
+  # Soporta acceso dinámico: user.Name, user.email, etc.
 end
 ```
 
-### Consumiendo el Servicio (CRUD)
+### Consumiendo el Servicio (CRUD RESTful)
 
-La API simula ActiveRecord. Por debajo, construye una "URL" en el header `type` para que el consumidor sepa qué hacer.
+BugBunny traduce automáticamente las llamadas de Ruby a peticiones HTTP simuladas.
 
 ```ruby
-# --- READ (Colección con Filtros) ---
-# Header Type: "users/index?active=true" (Query Params)
-# Routing Key: "users.index" (Dinámico) o "manager_queue" (Estático)
+# --- READ COLLECTION (Index) ---
+# Envia: GET users?active=true
+# Routing Key: "users"
 users = RemoteUser.where(active: true)
 
-# --- READ (Singular) ---
-# Header Type: "users/show/123" (ID en Path)
-# Routing Key: "users.show.123" (Dinámico) o "manager_queue" (Estático)
+# --- READ MEMBER (Show) ---
+# Envia: GET users/123
+# Routing Key: "users"
 user = RemoteUser.find(123)
-puts user.name # Acceso dinámico a atributos
+puts user.email 
 
 # --- CREATE ---
-# Header Type: "users/create"
-user = RemoteUser.create(email: "test@test.com")
+# Envia: POST users
+# Routing Key: "users"
+# Body: { "email": "test@test.com", "role": "admin" }
+user = RemoteUser.create(email: "test@test.com", role: "admin")
 
 # --- UPDATE ---
-# Header Type: "users/update/123"
+# Envia: PUT users/123
+# Routing Key: "users"
 user.update(email: "edit@test.com") 
-# Dirty Tracking: Solo se envían los atributos modificados.
+# Dirty Tracking: Solo se envían los campos modificados.
 
 # --- DESTROY ---
-# Header Type: "users/destroy/123"
+# Envia: DELETE users/123
+# Routing Key: "users"
 user.destroy
 ```
 
+### Estrategias de Routing
+
+Tienes 3 formas de controlar la `routing_key` hacia donde se envían los mensajes:
+
+| Nivel | Método | Descripción | Ejemplo Config |
+| :--- | :--- | :--- | :--- |
+| **1. Dinámico** | `resource_name` | (Por defecto) Usa el nombre del recurso. | `self.resource_name = 'users'` -> Key `users` |
+| **2. Estático** | `routing_key` | Fuerza TODO a una sola cola. | `self.routing_key = 'cola_manager'` |
+| **3. Temporal** | `.with(...)` | Override solo para esa petición. | `User.with(routing_key: 'urgent').create` |
+
 ---
 
 ## 🔌 Modo Publisher (Cliente Manual)
 
-Si no necesitas mapear un recurso o quieres enviar mensajes crudos ("Fire-and-Forget"), puedes usar `BugBunny::Client` directamente.
+Si no necesitas mapear un recurso o quieres enviar mensajes crudos, utiliza `BugBunny::Client`. Soporta semántica REST pasando el argumento `method:`.
 
 ### 1. Instanciar el Cliente
 
 ```ruby
-# Puedes inyectar middlewares personalizados aquí si lo deseas
 client = BugBunny::Client.new(pool: BUG_BUNNY_POOL) do |conn|
+  # Puedes inyectar middlewares aquí
   conn.use BugBunny::Middleware::JsonResponse
 end
 ```
 
-### 2. Publicar Asíncronamente (Fire-and-Forget)
-Envía el mensaje y retorna inmediatamente. Ideal para eventos o logs.
+### 2. Request (RPC Síncrono)
+
+Envía el mensaje, **bloquea el hilo** y espera la respuesta JSON. Ideal para obtener datos.
 
 ```ruby
-# publish(url_logica, opciones)
-client.publish('notifications/alert', 
-  exchange: 'events.topic', 
-  exchange_type: 'topic',
-  routing_key: 'alerts.critical',
-  body: { message: 'CPU High', server: 'web-1' }
-)
+# GET (Leer)
+response = client.request('users/123', method: :get)
+puts response['body']
+
+# POST (Crear / Ejecutar)
+response = client.request('math/calc', method: :post, body: { a: 10, b: 20 })
+
+# PUT (Actualizar)
+client.request('users/123', method: :put, body: { active: true })
+
+# DELETE (Borrar)
+client.request('users/123', method: :delete)
 ```
 
-### 3. Petición Síncrona (RPC)
-Envía el mensaje y bloquea el hilo esperando la respuesta del consumidor.
+### 3. Publish (Asíncrono / Fire-and-Forget)
+
+Envía el mensaje y retorna inmediatamente. No espera respuesta. Por defecto usa `method: :post` si no se especifica.
 
 ```ruby
-begin
-  # request(url_logica, opciones)
-  response = client.request('math/calculate', 
-    exchange: 'rpc.direct', 
-    routing_key: 'calculator',
-    body: { a: 10, b: 20 },
-    timeout: 5 # Segundos de espera máxima
-  )
-  
-  puts response['body'] # => { "result": 30 }
+# Enviar log o evento
+client.publish('logs/error', method: :post, body: { msg: 'Disk full' })
+```
 
-rescue BugBunny::RequestTimeout
-  puts "El servidor tardó demasiado."
+### 4. Configuración Avanzada (Bloques)
+
+Puedes usar un bloque para configurar opciones de bajo nivel de AMQP (prioridad, expiración, headers, app_id).
+
+```ruby
+client.publish('jobs/process') do |req|
+  req.method = :post
+  req.body = { image_id: 99 }
+  
+  # Metadatos AMQP
+  req.priority = 9         # Alta prioridad (0-9)
+  req.expiration = '5000'  # TTL 5 segundos (ms)
+  req.app_id = 'web-frontend'
+  req.headers['X-Trace-Id'] = 'abc-123'
 end
 ```
 
+### 5. Referencia de Opciones
+
+Estas opciones pueden pasarse como argumentos (`client.request(key: val)`) o dentro del bloque (`req.key = val`).
+
+| Opción / Atributo | Tipo | Descripción | Default |
+| :--- | :--- | :--- | :--- |
+| `body` | `Hash/String` | El contenido del mensaje. | `nil` |
+| `method` | `Symbol` | Verbo HTTP (`:get`, `:post`, `:put`, `:delete`). | `:get` (en request) |
+| `exchange` | `String` | Nombre del Exchange destino. | `''` (Default Ex) |
+| `routing_key` | `String` | Clave de ruteo. Si falta, usa el `path`. | `path` |
+| `headers` | `Hash` | Headers personalizados. | `{}` |
+| `timeout` | `Integer` | (Solo RPC) Segundos máx de espera. | Config global |
+| `app_id` | `String` | ID de la aplicación origen. | `nil` |
+| `priority` | `Integer` | Prioridad del mensaje (0-9). | `0` |
+| `expiration` | `String` | TTL del mensaje en ms. | `nil` |
+
 ---
 
 ## 📡 Modo Servidor (El Worker)
 
-BugBunny incluye un **Router Inteligente** que parsea el header `type` (la URL simulada), extrae parámetros y despacha al controlador.
+BugBunny incluye un **Router Inteligente** que funciona igual que el `config/routes.rb` de Rails. Infiere la acción basándose en el **Verbo HTTP** y la estructura de la **URL**.
 
 ### 1. Definir Controladores
 
@@ -190,26 +216,19 @@ Crea tus controladores en `app/rabbit/controllers/`. Heredan de `BugBunny::Contr
 # app/rabbit/controllers/users_controller.rb
 class UsersController < BugBunny::Controller
 
-  # Acción para type: "users/index?active=true"
+  # GET users
   def index
-    # params fusiona Query Params y Body
     users = User.where(active: params[:active])
     render status: 200, json: users
   end
 
-  # Acción para type: "users/show/12"
+  # GET users/123
   def show
-    # params[:id] se extrae automáticamente del Path de la URL
-    user = User.find_by(id: params[:id])
-    
-    if user
-      render status: 200, json: user
-    else
-      render status: 404, json: { error: 'Not Found' }
-    end
+    user = User.find(params[:id])
+    render status: 200, json: user
   end
 
-  # Acción para type: "users/create"
+  # POST users
   def create
     user = User.new(params)
     if user.save
@@ -219,10 +238,33 @@ class UsersController < BugBunny::Controller
       render status: 422, json: { errors: user.errors }
     end
   end
+  
+  # PUT users/123
+  def update
+    # ...
+  end
+
+  # DELETE users/123
+  def destroy
+    # ...
+  end
 end
 ```
 
-### 2. Ejecutar el Worker
+### 2. Tabla de Ruteo (Convención)
+
+El Router despacha automáticamente según esta tabla:
+
+| Header `x-http-method` | Header `type` (URL) | Controlador | Acción |
+| :--- | :--- | :--- | :--- |
+| `GET` | `users` | `UsersController` | `index` |
+| `GET` | `users/12` | `UsersController` | `show` |
+| `POST` | `users` | `UsersController` | `create` |
+| `PUT` | `users/12` | `UsersController` | `update` |
+| `DELETE` | `users/12` | `UsersController` | `destroy` |
+| `POST` | `users/12/promote` | `UsersController` | `promote` (Custom) |
+
+### 3. Ejecutar el Worker
 
 ```bash
 bundle exec rake bug_bunny:work
@@ -232,21 +274,20 @@ bundle exec rake bug_bunny:work
 
 ## 🏗 Arquitectura REST-over-AMQP
 
-BugBunny desacopla el transporte de la lógica usando headers.
+BugBunny desacopla el transporte de la lógica usando headers AMQP estándar.
 
-| Concepto | REST (HTTP) | BugBunny (AMQP) | Configuración |
-| :--- | :--- | :--- | :--- |
-| **Endpoint** | URL Path (`/users/1`) | Header `type` (`users/show/1`) | `resource_name` |
-| **Filtros** | Query String (`?active=true`) | Header `type` (`users/index?active=true`) | Automático (`where`) |
-| **Destino Físico** | IP/Dominio | Routing Key (`users.create` o `manager`) | `routing_key` (Estático) o `resource_name` (Dinámico) |
-| **Payload** | Body (JSON) | Body (JSON) | N/A |
-| **Status** | HTTP Code (200, 404) | JSON Response `status` | N/A |
+| Concepto | REST (HTTP) | BugBunny (AMQP) |
+| :--- | :--- | :--- |
+| **Recurso** | `POST /users` | Header `type`: `users` + Header `x-http-method`: `POST` |
+| **Parametros** | Query String / Body | Header `type` (Query) + Body (Payload) |
+| **Destino** | DNS / IP | Routing Key (ej: `users`) |
+| **Status** | HTTP Code (200, 404) | JSON Response `status` |
 
 ---
 
 ## 🛠 Middlewares
 
-BugBunny usa una pila de middlewares para procesar respuestas.
+BugBunny usa una pila de middlewares para procesar peticiones y respuestas, permitiendo logging, manejo de errores y transformación de datos.
 
 ```ruby
 # Configuración global en el Resource
@@ -259,12 +300,13 @@ BugBunny::Resource.client_middleware do |conn|
 end
 ```
 
-### Excepciones
+### Excepciones Soportadas
 
-* `BugBunny::UnprocessableEntity` (422): Error de validación.
-* `BugBunny::NotFound` (404): Recurso no encontrado.
-* `BugBunny::RequestTimeout`: Timeout RPC.
-* `BugBunny::CommunicationError`: Fallo de red RabbitMQ.
+* `BugBunny::BadRequest` (400)
+* `BugBunny::NotFound` (404)
+* `BugBunny::RequestTimeout` (408)
+* `BugBunny::UnprocessableEntity` (422) - Incluye errores de validación.
+* `BugBunny::InternalServerError` (500)
 
 ---
 

data/lib/bug_bunny/client.rb

@@ -4,31 +4,25 @@ require_relative 'middleware/stack'
 module BugBunny
   # Cliente principal para realizar peticiones a RabbitMQ.
   #
-  # Implementa el patrón "Onion Middleware" (Arquitectura de Cebolla) similar a Faraday,
-  # permitiendo interceptar, transformar y procesar tanto las peticiones salientes
-  # como las respuestas entrantes mediante una pila de middlewares.
+  # Implementa el patrón "Onion Middleware" (Arquitectura de Cebolla) similar a Faraday.
+  # Mantiene una interfaz flexible donde el verbo HTTP se pasa como opción.
   #
-  # @example Inicialización básica
-  #   client = BugBunny::Client.new(pool: MY_POOL)
+  # @example Petición RPC (GET)
+  #   client.request('users/123', method: :get)
   #
-  # @example Con Middlewares personalizados
-  #   client = BugBunny::Client.new(pool: MY_POOL) do |conn|
-  #     conn.use BugBunny::Middleware::RaiseError
-  #     conn.use BugBunny::Middleware::JsonResponse
-  #     conn.use BugBunny::Middleware::Logger, Rails.logger
-  #   end
+  # @example Publicación Fire-and-Forget (POST)
+  #   client.publish('logs', method: :post, body: { msg: 'Error' })
   class Client
     # @return [ConnectionPool] El pool de conexiones subyacente a RabbitMQ.
     attr_reader :pool
 
-    # @return [BugBunny::Middleware::Stack] La pila de middlewares configurada para este cliente.
+    # @return [BugBunny::Middleware::Stack] La pila de middlewares configurada.
     attr_reader :stack
 
     # Inicializa un nuevo cliente.
     #
     # @param pool [ConnectionPool] Pool de conexiones a RabbitMQ configurado previamente.
     # @yield [stack] Bloque opcional para configurar la pila de middlewares.
-    # @yieldparam stack [BugBunny::Middleware::Stack] El objeto stack para registrar middlewares con {#use}.
     # @raise [ArgumentError] Si no se proporciona un `pool`.
     def initialize(pool:)
       raise ArgumentError, "BugBunny::Client requiere un 'pool:'" if pool.nil?
@@ -39,21 +33,16 @@ module BugBunny
 
     # Realiza una petición Síncrona (RPC / Request-Response).
     #
-    # Envía un mensaje y bloquea la ejecución del hilo actual hasta recibir una respuesta
-    # correlacionada del servidor o hasta que se supere el tiempo de espera (timeout).
+    # Envía un mensaje y bloquea la ejecución del hilo actual hasta recibir respuesta.
     #
-    # @param url [String] La ruta o acción del mensaje (ej: 'users/create').
-    # @param args [Hash] Opciones de configuración de la petición.
-    # @option args [Object] :body El cuerpo del mensaje (Hash o String).
-    # @option args [String] :exchange Nombre del exchange destino.
-    # @option args [String] :exchange_type Tipo de exchange ('direct', 'topic', 'fanout').
-    # @option args [String] :routing_key Routing key manual (opcional).
-    # @option args [Integer] :timeout Tiempo máximo de espera en segundos antes de lanzar timeout.
-    # @option args [Hash] :headers Headers AMQP adicionales para metadatos.
-    # @yield [req] Bloque opcional para configurar el objeto Request directamente.
-    # @yieldparam req [BugBunny::Request] Objeto request configurable.
-    # @return [Hash] La respuesta del servidor, conteniendo habitualmente `status` y `body`.
-    # @raise [BugBunny::RequestTimeout] Si no se recibe respuesta en el tiempo límite.
+    # @param url [String] La ruta del recurso (ej: 'users/1').
+    # @param args [Hash] Opciones de configuración.
+    # @option args [Symbol] :method El verbo HTTP (:get, :post, :put, :delete). Default: :get.
+    # @option args [Object] :body El cuerpo del mensaje.
+    # @option args [Hash] :headers Headers AMQP adicionales.
+    # @option args [Integer] :timeout Tiempo máximo de espera.
+    # @yield [req] Bloque para configurar el objeto Request directamente.
+    # @return [Hash] La respuesta del servidor.
     def request(url, **args)
       run_in_pool(:rpc, url, args) do |req|
         yield req if block_given?
@@ -62,13 +51,9 @@ module BugBunny
 
     # Realiza una publicación Asíncrona (Fire-and-Forget).
     #
-    # Envía el mensaje al exchange y retorna el control inmediatamente sin esperar
-    # ninguna confirmación o respuesta del consumidor.
-    #
-    # @param url [String] La ruta o acción del mensaje.
-    # @param args [Hash] Mismas opciones que {#request}, excepto `:timeout` (no aplica).
-    # @yield [req] Bloque opcional para configurar el objeto Request.
-    # @yieldparam req [BugBunny::Request] Objeto request configurable.
+    # @param url [String] La ruta del evento/recurso.
+    # @param args [Hash] Mismas opciones que {#request}, excepto `:timeout`.
+    # @yield [req] Bloque para configurar el objeto Request.
     # @return [void]
     def publish(url, **args)
       run_in_pool(:fire, url, args) do |req|
@@ -78,16 +63,14 @@ module BugBunny
 
     private
 
-    # Ejecuta la lógica de envío dentro del contexto del Pool y aplica la cadena de middlewares.
-    #
-    # @param method_name [Symbol] El método a invocar en el Producer (:rpc o :fire).
-    # @param url [String] La URL/Acción del request.
-    # @param args [Hash] Argumentos pasados al método público.
+    # Ejecuta la lógica de envío dentro del contexto del Pool.
+    # Mapea los argumentos al objeto Request y ejecuta la cadena de middlewares.
     def run_in_pool(method_name, url, args)
       # 1. Builder del Request
       req = BugBunny::Request.new(url)
 
       # 2. Syntactic Sugar: Mapeo de argumentos a atributos del Request
+      req.method        = args[:method]        if args[:method]
       req.body          = args[:body]          if args[:body]
       req.exchange      = args[:exchange]      if args[:exchange]
       req.exchange_type = args[:exchange_type] if args[:exchange_type]