bug_bunny 3.0.0 → 3.0.1

data/lib/bug_bunny/consumer.rb

@@ -6,15 +6,13 @@ require 'uri'
 require 'cgi'
 
 module BugBunny
-  # Consumidor de mensajes y Router RPC.
+  # Consumidor de mensajes y Router RPC estilo REST.
   #
-  # Esta clase escucha en una cola RabbitMQ, parsea el header `type` como si fuera una URL,
-  # extrae el controlador, acción, ID y query params, y despacha la ejecución al controlador correspondiente.
+  # Parsea el header `type` (URL) y el header `x-http-method` (Verbo)
+  # para despachar al controlador y acción correctos siguiendo convenciones Rails.
   class Consumer
     attr_reader :session
 
-    # Método factory para instanciar y suscribir.
-    # @see #subscribe
     def self.subscribe(connection:, **args)
       new(connection).subscribe(**args)
     end
@@ -24,12 +22,6 @@ module BugBunny
     end
 
     # Inicia la suscripción a la cola.
-    #
-    # @param queue_name [String] Cola a escuchar.
-    # @param exchange_name [String] Exchange para binding.
-    # @param routing_key [String] Routing key.
-    # @param exchange_type [String] Tipo de exchange.
-    # @param block [Boolean] Bloquear el hilo principal (loop).
     def subscribe(queue_name:, exchange_name:, routing_key:, exchange_type: 'direct', queue_opts: {}, block: true)
       x = session.exchange(name: exchange_name, type: exchange_type)
       q = session.queue(queue_name, queue_opts)
@@ -50,11 +42,7 @@ module BugBunny
     private
 
     # Procesa el mensaje entrante.
-    #
-    # 1. Parsea la "URL" del header `type`.
-    # 2. Instancia el controlador dinámicamente.
-    # 3. Ejecuta la acción.
-    # 4. Envía respuesta RPC si `reply_to` está presente.
+    # Infiere la acción basándose en Verbo + URL.
     def process_message(delivery_info, properties, body)
       if properties.type.nil? || properties.type.empty?
         BugBunny.configuration.logger.error("[Consumer] Missing 'type'. Rejected.")
@@ -62,21 +50,26 @@ module BugBunny
         return
       end
 
-      # Parseo robusto de la URL (Path + Query Params)
-      route_info = parse_route(properties.type)
+      # 1. Leemos el verbo HTTP desde el header (Default: GET)
+      # Nota: Bunny devuelve los headers en propiedades.headers
+      http_method = properties.headers ? (properties.headers['x-http-method'] || 'GET') : 'GET'
+
+      # 2. Despachamos usando lógica Rails
+      route_info = router_dispatch(http_method, properties.type)
 
       headers = {
         type: properties.type,
+        http_method: http_method,
         controller: route_info[:controller],
         action: route_info[:action],
-        id: route_info[:id],            # ID extraído del path (ej: /users/show/12)
-        query_params: route_info[:params], # Hash de query params (ej: ?active=true)
+        id: route_info[:id],
+        query_params: route_info[:params],
         content_type: properties.content_type,
         correlation_id: properties.correlation_id,
         reply_to: properties.reply_to
       }
 
-      # Convention: "users" -> Rabbit::Controllers::UsersController (o namespace configurable)
+      # Convention: "users" -> Rabbit::Controllers::UsersController
       controller_class_name = "rabbit/controllers/#{route_info[:controller]}".camelize
       controller_class = controller_class_name.constantize
 
@@ -88,7 +81,7 @@ module BugBunny
 
       session.channel.ack(delivery_info.delivery_tag)
     rescue NameError => e
-      BugBunny.configuration.logger.error("[Consumer] Controller not found for route '#{properties.type}': #{e.message}")
+      BugBunny.configuration.logger.error("[Consumer] Controller/Action not found: #{e.message}")
       session.channel.reject(delivery_info.delivery_tag, false)
     rescue StandardError => e
       BugBunny.configuration.logger.error("[Consumer] Execution Error: #{e.message}")
@@ -98,6 +91,56 @@ module BugBunny
       end
     end
 
+    # Router: Simula el config/routes.rb de Rails.
+    #
+    # @param method [String] Verbo HTTP (GET, POST, etc).
+    # @param path [String] URL Path (ej: 'users/1').
+    # @return [Hash] {controller, action, id, params}
+    def router_dispatch(method, path)
+      uri = URI.parse("http://dummy/#{path}")
+      segments = uri.path.split('/').reject(&:empty?) # ["users", "123"]
+      query_params = uri.query ? CGI.parse(uri.query).transform_values(&:first) : {}
+
+      controller_name = segments[0] # "users"
+      id = segments[1]              # "123" o nil
+
+      # Lógica de Inferencia Rails Standard
+      # GET users      -> index
+      # GET users/1    -> show
+      # POST users     -> create
+      # PUT users/1    -> update
+      # DELETE users/1 -> destroy
+      action = case method.to_s.upcase
+               when 'GET'
+                 id ? 'show' : 'index'
+               when 'POST'
+                 'create'
+               when 'PUT', 'PATCH'
+                 'update'
+               when 'DELETE'
+                 'destroy'
+               else
+                 id || 'index' # Fallback para verbos custom
+               end
+
+      # Soporte para Member Actions Custom (ej: POST users/1/activate)
+      # Path: users/1/activate -> segments: [users, 1, activate]
+      if segments.size >= 3
+         id = segments[1]
+         action = segments[2]
+      end
+
+      # Inyectar ID en params para acceso unificado en el controller
+      query_params['id'] = id if id
+
+      {
+        controller: controller_name,
+        action: action,
+        id: id,
+        params: query_params
+      }
+    end
+
     def reply(payload, reply_to, correlation_id)
       session.channel.default_exchange.publish(
         payload.to_json,
@@ -114,38 +157,5 @@ module BugBunny
         session.close
       end.execute
     end
-
-    # Analiza el string `type` como una URL.
-    #
-    # Soporta:
-    # * `users/index?active=true` -> {controller: users, action: index, params: {active: true}}
-    # * `users/show/12`           -> {controller: users, action: show, id: 12}
-    # * `users/update/12`         -> {controller: users, action: update, id: 12}
-    #
-    # @param route_string [String] El valor del header type.
-    # @return [Hash] Keys: :controller, :action, :id, :params.
-    def parse_route(route_string)
-      # Anteponemos un host dummy para usar URI estándar con paths relativos
-      uri = URI.parse("http://dummy/#{route_string}")
-      # 1. Query Params (?foo=bar)
-      query_params = uri.query ? CGI.parse(uri.query).transform_values(&:first) : {}
-
-      # 2. Path Segments (/users/show/12)
-      segments = uri.path.split('/').reject(&:empty?)
-
-      controller = segments[0] # "users"
-      action = segments[1]     # "index", "show", "update"
-      id = segments[2]         # "12" (opcional)
-
-      # Inyectamos el ID en los params si existe en la ruta para facilitar acceso unificado
-      query_params['id'] = id if id
-
-      {
-        controller: controller,
-        action: action || 'index',
-        id: id,
-        params: query_params
-      }
-    end
   end
 end

data/lib/bug_bunny/request.rb

@@ -4,79 +4,37 @@ module BugBunny
   # Encapsula toda la información necesaria para realizar una petición o publicación.
   #
   # Actúa como el objeto "Environment" en la arquitectura de middlewares.
-  # Contiene el cuerpo del mensaje, la configuración de enrutamiento y todos los
-  # metadatos estándar del protocolo AMQP 0.9.1.
+  # Contiene el cuerpo del mensaje, la configuración de enrutamiento y el **Verbo HTTP**.
+  #
+  # @attr body [Object] El cuerpo del mensaje (Hash, Array o String).
+  # @attr headers [Hash] Cabeceras personalizadas (Headers AMQP).
+  # @attr path [String] La ruta lógica del recurso (ej: 'users', 'users/123').
+  # @attr method [Symbol, String] El verbo HTTP (:get, :post, :put, :delete). Default: :get.
+  # @attr exchange [String] El nombre del Exchange destino.
+  # @attr exchange_type [String] El tipo de exchange ('direct', 'topic', 'fanout').
+  # @attr routing_key [String] La routing key específica. Si es nil, se usará {#path}.
+  # @attr timeout [Integer] Tiempo máximo en segundos para timeout RPC.
   class Request
-    # === DATOS (Payload) ===
-
-    # @return [Object] El cuerpo del mensaje (Hash, Array o String) antes de ser serializado.
     attr_accessor :body
-
-    # @return [Hash] Cabeceras personalizadas (Headers AMQP) para pasar metadatos extra.
     attr_accessor :headers
-
-    # === ENRUTAMIENTO ===
-
-    # @return [String] La "ruta" lógica del mensaje (ej: 'users/create'). Se usa por defecto como routing key y type.
-    attr_accessor :action
-
-    # @return [String] El nombre del Exchange destino donde se publicará el mensaje.
+    attr_accessor :path
+    attr_accessor :method
     attr_accessor :exchange
-
-    # @return [String] El tipo de exchange ('direct', 'topic', 'fanout', 'headers'). Default: 'direct'.
     attr_accessor :exchange_type
-
-    # @return [String] La routing key específica para RabbitMQ. Si es nil, se usará {#action}.
     attr_accessor :routing_key
-
-    # === CONFIGURACIÓN ===
-
-    # @return [Integer] Tiempo máximo en segundos que el cliente RPC esperará la respuesta.
     attr_accessor :timeout
 
-    # === METADATOS AMQP ===
-
-    # @return [String] Identificador de la aplicación origen (App ID).
-    attr_accessor :app_id
-
-    # @return [String] Tipo MIME del contenido (Default: 'application/json').
-    attr_accessor :content_type
-
-    # @return [String] Codificación del contenido (ej: 'gzip').
-    attr_accessor :content_encoding
-
-    # @return [Integer] Prioridad del mensaje (0-9).
-    attr_accessor :priority
-
-    # @return [Integer] Timestamp UNIX del momento de creación.
-    attr_accessor :timestamp
-
-    # @return [String, Integer] Tiempo de vida (TTL) del mensaje en milisegundos.
-    attr_accessor :expiration
-
-    # @return [Boolean] Si es `true`, el mensaje se guardará en disco (más lento, más seguro). Default: `false`.
-    attr_accessor :persistent
-
-    # @return [String] Cola específica donde se espera la respuesta (usado internamente para RPC).
-    attr_accessor :reply_to
-
-    # @return [String] ID único para correlacionar petición y respuesta (RPC).
-    attr_accessor :correlation_id
-
-    # @return [String] Sobrescribe el header 'type' de AMQP. Vital para el enrutamiento en el Consumer.
-    attr_accessor :type
+    # Metadatos AMQP Estándar
+    attr_accessor :app_id, :content_type, :content_encoding, :priority,
+                  :timestamp, :expiration, :persistent, :reply_to,
+                  :correlation_id, :type
 
     # Inicializa un nuevo Request.
     #
-    # Establece valores por defecto sensatos:
-    # * Content-Type: application/json
-    # * Timestamp: Ahora
-    # * Persistent: false (Modo rápido/volátil por defecto)
-    # * Exchange Type: direct
-    #
-    # @param action [String] La acción o ruta lógica del mensaje (ej: 'users/update').
-    def initialize(action)
-      @action = action
+    # @param path [String] La ruta del recurso o acción (ej: 'users/123').
+    def initialize(path)
+      @path = path
+      @method = :get # Verbo por defecto
       @headers = {}
       @content_type = 'application/json'
       @timestamp = Time.now.to_i
@@ -87,29 +45,31 @@ module BugBunny
     # Calcula la Routing Key final que se usará en RabbitMQ.
     #
     # Principio: "Convention over Configuration".
-    # Si no se define una `routing_key` manual, se asume que la `action` actúa como tal.
+    # Si no se define una `routing_key` manual, se asume que el `path` actúa como tal.
     #
     # @return [String] La routing key definitiva.
     def final_routing_key
-      routing_key || action
+      routing_key || path
     end
 
     # Calcula el valor para el header AMQP 'type'.
-    #
-    # Este valor es utilizado por {BugBunny::Consumer} para decidir qué Controlador ejecutar.
-    # Si no se define manualmente, usa la `action`.
+    # En esta arquitectura REST, el 'type' es la URL del recurso (el path).
     #
     # @return [String] El tipo de mensaje definitivo.
     def final_type
-      type || action
+      type || path
     end
 
     # Genera el Hash de opciones limpio para la gema Bunny.
     #
-    # Elimina las claves con valor `nil` (`compact`) para reducir el tamaño del paquete de red.
+    # **Importante:** Inyecta el verbo HTTP en los headers bajo la clave `x-http-method`.
+    # Esto permite al Consumer enrutar correctamente a la acción del controlador.
     #
     # @return [Hash] Opciones listas para pasar a `exchange.publish`.
     def amqp_options
+      # Inyectamos el verbo HTTP en los headers para el Router del Consumer
+      final_headers = headers.merge('x-http-method' => method.to_s.upcase)
+
       {
         type: final_type,
         app_id: app_id,
@@ -119,7 +79,7 @@ module BugBunny
         timestamp: timestamp,
         expiration: expiration,
         persistent: persistent,
-        headers: headers,
+        headers: final_headers,
         reply_to: reply_to,
         correlation_id: correlation_id
       }.compact