bug_bunny 3.0.0 → 3.0.1

data/lib/bug_bunny/resource.rb

@@ -4,24 +4,20 @@ require 'active_support/core_ext/string/inflections'
 require 'uri'
 
 module BugBunny
-  # Clase base para modelos remotos que implementan el patrón **Active Record over AMQP**.
+  # Clase base para modelos remotos que implementan **Active Record over AMQP (RESTful)**.
   #
-  # Esta clase permite interactuar con microservicios remotos mediante RabbitMQ simulando
-  # una interfaz de Active Record. Soporta **Atributos Dinámicos** (Schema-less), lo que
-  # facilita la integración con APIs externas que no siguen convenciones de Rails (ej: Docker API en PascalCase).
+  # Esta clase transforma operaciones CRUD estándar en peticiones RPC utilizando
+  # verbos HTTP semánticos (GET, POST, PUT, DELETE) transportados sobre headers AMQP.
   #
-  # @example Configuración Básica (Routing Dinámico)
-  #   class Node < BugBunny::Resource
-  #     self.exchange = 'swarm.topic'
-  #     # resource_name se infiere como 'nodes' (pluralizado)
-  #     # Atributos accesibles dinámicamente: node.Hostname, node.Status
+  # @example
+  #   class User < BugBunny::Resource
+  #     self.exchange = 'app.topic'
+  #     self.resource_name = 'users'
   #   end
   #
-  # @example Configuración Estática (Cola Dedicada)
-  #   class Manager < BugBunny::Resource
-  #     self.exchange = 'swarm.direct'
-  #     self.routing_key = 'manager_queue' # Todo viaja a esta cola
-  #   end
+  #   User.create(name: 'Gaby') # Envía POST 'users'
+  #   u = User.find(1)          # Envía GET 'users/1'
+  #   u.destroy                 # Envía DELETE 'users/1'
   class Resource
     include ActiveModel::API
     include ActiveModel::Dirty
@@ -30,83 +26,61 @@ module BugBunny
 
     define_model_callbacks :save, :create, :update, :destroy
 
-    # @return [ActiveSupport::HashWithIndifferentAccess] Almacén de los datos crudos del recurso.
-    # @note Se llama remote_attributes para evitar conflictos con ActiveModel::AttributeSet.
     attr_reader :remote_attributes
-
-    # @return [Boolean] Estado de persistencia del objeto (true si existe en remoto).
     attr_accessor :persisted
 
     class << self
-      # @!group Configuración
-
       attr_writer :connection_pool, :exchange, :exchange_type, :resource_name, :routing_key
 
       # Resuelve la configuración buscando en la jerarquía de clases.
-      #
-      # Prioridad de resolución:
-      # 1. Override temporal (Thread-local via `.with`).
-      # 2. Configuración de la clase actual.
-      # 3. Configuración de la clase padre (Herencia).
-      #
-      # @param key [Symbol] Clave única para el almacenamiento thread-local.
-      # @param instance_var [Symbol] Variable de instancia a buscar (ej: :@connection_pool).
-      # @return [Object, nil] El valor configurado o nil.
       # @api private
       def resolve_config(key, instance_var)
         thread_key = "bb_#{object_id}_#{key}"
         return Thread.current[thread_key] if Thread.current.key?(thread_key)
-
         target = self
         while target <= BugBunny::Resource
           value = target.instance_variable_get(instance_var)
-          if !value.nil?
-            return value.respond_to?(:call) ? value.call : value
-          end
+          return value.respond_to?(:call) ? value.call : value unless value.nil?
           target = target.superclass
         end
         nil
       end
 
-      # @return [ConnectionPool] El pool de conexiones a RabbitMQ.
-      def connection_pool
-        resolve_config(:pool, :@connection_pool)
-      end
+      def connection_pool; resolve_config(:pool, :@connection_pool); end
+      def current_exchange; resolve_config(:exchange, :@exchange) || raise(ArgumentError, "Exchange not defined"); end
+      def current_exchange_type; resolve_config(:exchange_type, :@exchange_type) || 'direct'; end
 
-      # @return [String] Nombre del exchange de RabbitMQ.
-      # @raise [ArgumentError] Si no se ha definido el exchange.
-      def current_exchange
-        resolve_config(:exchange, :@exchange) || raise(ArgumentError, "Exchange not defined for #{name}")
+      def resource_name
+        resolve_config(:resource_name, :@resource_name) || name.demodulize.underscore.pluralize
       end
 
-      # @return [String] Tipo de exchange ('direct', 'topic', 'fanout'). Por defecto 'direct'.
-      def current_exchange_type
-        resolve_config(:exchange_type, :@exchange_type) || 'direct'
+      # Define middlewares para el cliente de este recurso.
+      def client_middleware(&block)
+        @client_middleware_stack ||= []
+        @client_middleware_stack << block
       end
 
-      # Nombre lógico del recurso. Se usa para construir la URL en el header `type`.
-      # Si no se configura explícitamente, infiere el nombre de la clase y lo pluraliza.
-      # @return [String] Ej: 'services' (si la clase es Manager::Service).
-      def resource_name
-        resolve_config(:resource_name, :@resource_name) || name.demodulize.underscore.pluralize
+      # @api private
+      def resolve_middleware_stack
+        stack = []
+        target = self
+        while target <= BugBunny::Resource
+          middlewares = target.instance_variable_get(:@client_middleware_stack)
+          stack.unshift(*middlewares) if middlewares
+          target = target.superclass
+        end
+        stack
       end
 
-      # Instancia el cliente RPC utilizando el pool configurado.
-      # @return [BugBunny::Client]
       def bug_bunny_client
         pool = connection_pool
         raise BugBunny::Error, "Connection pool missing for #{name}" unless pool
-        BugBunny::Client.new(pool: pool)
+        
+        BugBunny::Client.new(pool: pool) do |conn|
+          resolve_middleware_stack.each { |block| block.call(conn) }
+        end
       end
 
-      # Permite ejecutar un bloque con una configuración temporal (Thread-Safe).
-      # Útil para cambiar de exchange, routing key o pool en tiempo de ejecución.
-      #
-      # @param exchange [String] Override del exchange.
-      # @param routing_key [String] Override forzado de la routing key.
-      # @param pool [ConnectionPool] Override del pool.
-      # @yield Bloque de código donde aplica la configuración.
-      # @return [Object] El resultado del bloque o un Proxy si no hay bloque.
       def with(exchange: nil, routing_key: nil, exchange_type: nil, pool: nil)
         keys = { exchange: "bb_#{object_id}_exchange", exchange_type: "bb_#{object_id}_exchange_type", pool: "bb_#{object_id}_pool", routing_key: "bb_#{object_id}_routing_key" }
         old_values = {}
@@ -115,90 +89,42 @@ module BugBunny
         Thread.current[keys[:exchange_type]] = exchange_type if exchange_type
         Thread.current[keys[:pool]] = pool if pool
         Thread.current[keys[:routing_key]] = routing_key if routing_key
-
         if block_given?
           begin; yield; ensure; keys.each { |k, v| Thread.current[v] = old_values[k] }; end
         else
           ScopeProxy.new(self, keys, old_values)
         end
       end
-
-      # @api private
+      
       class ScopeProxy < BasicObject
-        def initialize(target, keys, old_values)
-          @target = target
-          @keys = keys
-          @old_values = old_values
-        end
-
-        def method_missing(method, *args, &block)
-          @target.public_send(method, *args, &block)
-        ensure
-          @keys.each { |k, v| ::Thread.current[v] = @old_values[k] }
-        end
+        def initialize(target, keys, old_values); @target = target; @keys = keys; @old_values = old_values; end
+        def method_missing(method, *args, &block); @target.public_send(method, *args, &block); ensure; @keys.each { |k, v| ::Thread.current[v] = @old_values[k] }; end
       end
 
-      # Calcula la Routing Key para una acción específica.
-      #
-      # @param action [Symbol] La acción a realizar (:create, :update, :index, :show).
-      # @param id [String, nil] El ID del recurso (opcional).
-      # @return [String] La routing key calculada.
-      def calculate_routing_key(action, id = nil)
+      # Calcula la Routing Key.
+      # @note En REST, por defecto es el resource_name (Topic 'users'), pero puede ser forzada.
+      def calculate_routing_key(id = nil)
         manual_rk = Thread.current["bb_#{object_id}_routing_key"]
         return manual_rk if manual_rk
-
         static_rk = resolve_config(:routing_key, :@routing_key)
         return static_rk if static_rk.present?
-
-        key = "#{resource_name}.#{action}"
-        key = "#{key}.#{id}" if id
-        key
-      end
-
-      # @!group Acciones CRUD
-
-      def index_action
-        :index
+        resource_name
       end
 
-      def show_action
-        :show
-      end
-
-      def create_action
-        :create
-      end
+      # @!group Acciones CRUD RESTful
 
-      def update_action
-        :update
-      end
-
-      def destroy_action
-        :destroy
-      end
-
-      # Busca recursos que coincidan con los filtros dados.
-      # Envía una petición con header type: `resource/index?query_params`.
+      # GET resource?query
       #
-      # @param filters [Hash] Filtros de búsqueda.
-      # @return [Array<Resource>] Lista de objetos instanciados.
+      # @param filters [Hash] Parámetros de consulta (Query params).
       def where(filters = {})
-        rk = calculate_routing_key(index_action)
-        path = "#{resource_name}/#{index_action}"
+        rk = calculate_routing_key
+        path = resource_name
+        path += "?#{URI.encode_www_form(filters)}" if filters.present?
 
-        if filters.present?
-          query_string = URI.encode_www_form(filters)
-          type_header = "#{path}?#{query_string}"
-        else
-          type_header = path
-        end
-
-        response = bug_bunny_client.request(type_header, exchange: current_exchange, exchange_type: current_exchange_type) do |req|
-          req.routing_key = rk
-        end
+        # REST: GET collection
+        response = bug_bunny_client.request(path, method: :get, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
 
         return [] unless response['body'].is_a?(Array)
-
         response['body'].map do |attrs|
           inst = new(attrs)
           inst.persisted = true
@@ -207,27 +133,20 @@ module BugBunny
         end
       end
 
-      # Retorna todos los registros del recurso remoto.
-      # @return [Array<Resource>]
-      def all
-        where({})
-      end
+      def all; where({}); end
 
-      # Busca un recurso por su ID.
-      # Envía una petición con header type: `resource/show/:id`.
+      # GET resource/id
       #
       # @param id [String, Integer] ID del recurso.
-      # @return [Resource, nil] El recurso encontrado o nil si retorna 404.
       def find(id)
-        rk = calculate_routing_key(show_action, id)
-        type_header = "#{resource_name}/#{show_action}/#{id}"
+        rk = calculate_routing_key(id)
+        path = "#{resource_name}/#{id}"
 
-        response = bug_bunny_client.request(type_header, exchange: current_exchange, exchange_type: current_exchange_type) do |req|
-          req.routing_key = rk
-        end
+        # REST: GET member
+        response = bug_bunny_client.request(path, method: :get, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
 
         return nil if response.nil? || response['status'] == 404
-
+        
         attributes = response['body']
         return nil unless attributes.is_a?(Hash)
 
@@ -237,9 +156,6 @@ module BugBunny
         instance
       end
 
-      # Crea un nuevo recurso y lo persiste remotamente.
-      # @param payload [Hash] Atributos iniciales.
-      # @return [Resource] La instancia creada (persisted? será true si tuvo éxito).
       def create(payload)
         instance = new(payload)
         instance.save
@@ -248,141 +164,84 @@ module BugBunny
     end
 
     # @!group Instancia
-    def current_exchange
-      self.class.current_exchange
-    end
-
-    def current_exchange_type
-      self.class.current_exchange_type
-    end
-
-    def calculate_routing_key(action, id=nil)
-      self.class.calculate_routing_key(action, id)
-    end
 
-    def bug_bunny_client
-      self.class.bug_bunny_client
-    end
+    def current_exchange; self.class.current_exchange; end
+    def current_exchange_type; self.class.current_exchange_type; end
+    def calculate_routing_key(id=nil); self.class.calculate_routing_key(id); end
+    def bug_bunny_client; self.class.bug_bunny_client; end
 
-    # Inicializa una nueva instancia del recurso.
-    # @param attributes [Hash] Atributos iniciales (snake_case o PascalCase).
     def initialize(attributes = {})
       @remote_attributes = {}.with_indifferent_access
       @persisted = false
       assign_attributes(attributes)
-      super() # Inicializa ActiveModel
+      super()
     end
 
-    # Verifica si el objeto ha sido guardado en el servicio remoto.
-    def persisted?
-      !!@persisted
-    end
+    def persisted?; !!@persisted; end
 
-    # Asigna atributos masivamente. Utiliza los setters dinámicos.
-    # @param new_attributes [Hash] Atributos a asignar.
     def assign_attributes(new_attributes)
       return if new_attributes.nil?
-
-      new_attributes.each do |k, v|
-        public_send("#{k}=", v)
-      end
+      new_attributes.each { |k, v| public_send("#{k}=", v) }
     end
-
-    # Actualiza los atributos y guarda el registro.
-    # @param attributes [Hash] Nuevos valores.
-    # @return [Boolean] Resultado de save.
+    
     def update(attributes)
       assign_attributes(attributes)
       save
     end
 
-    # Calcula el payload JSON a enviar.
-    # Si hay cambios (Dirty Tracking), envía solo los cambios.
-    # Si es nuevo, envía todo excepto los IDs internos.
-    # @return [Hash] Payload.
     def changes_to_send
       return changes.transform_values(&:last) unless changes.empty?
-
       @remote_attributes.except('id', 'ID', 'Id', '_id')
     end
 
-    # @!group Atributos Dinámicos (Magic Methods)
-
-    # Intercepta llamadas a métodos desconocidos para leer/escribir en @remote_attributes.
-    # Permite acceder a propiedades como `node.Hostname` o `node.Spec` dinámicamente.
+    # Magic Methods para atributos dinámicos
     def method_missing(method_name, *args, &block)
       attribute_name = method_name.to_s
-
       if attribute_name.end_with?('=')
-        # Setter: node.Status = 'active'
         key = attribute_name.chop
         val = args.first
-
-        # Dirty Tracking manual
         attribute_will_change!(key) unless @remote_attributes[key] == val
-
         @remote_attributes[key] = val
       else
-        # Getter: node.Status
-        if @remote_attributes.key?(attribute_name)
-          @remote_attributes[attribute_name]
-        else
-          super
-        end
+        @remote_attributes.key?(attribute_name) ? @remote_attributes[attribute_name] : super
       end
     end
 
-    # @api private
     def respond_to_missing?(method_name, include_private = false)
       @remote_attributes.key?(method_name.to_s.sub(/=$/, '')) || super
     end
 
-    # Retorna el ID del recurso buscando en variantes comunes (id, ID, Id, _id).
-    # @return [String, Integer, nil]
     def id
       @remote_attributes['id'] || @remote_attributes['ID'] || @remote_attributes['Id'] || @remote_attributes['_id']
     end
 
-    # Asigna el ID manualmente.
-    # @param value [Object] Nuevo ID.
     def id=(value)
       @remote_attributes['id'] = value
     end
 
-    # Método requerido por ActiveModel::Validations para leer atributos.
-    # @param attr [Symbol] Nombre del atributo.
-    # @return [Object] Valor del atributo.
-    # @api private
     def read_attribute_for_validation(attr)
       @remote_attributes[attr.to_s]
     end
 
-    # @!group Persistencia
+    # @!group Persistencia RESTful
 
-    # Guarda el recurso en el servicio remoto (Create o Update).
-    #
-    # * Create: POST a `resource/create`
-    # * Update: POST a `resource/update/:id`
-    #
-    # @return [Boolean] true si fue exitoso, false si hubo error de validación o red.
+    # Guarda el registro (POST si es nuevo, PUT si existe).
     def save
       return false unless valid?
 
       run_callbacks(:save) do
         is_new = !persisted?
-        action_verb = is_new ? self.class.create_action : self.class.update_action
-
+        rk = calculate_routing_key(id)
+        
+        # Mapeo a verbos HTTP usando client.request(method: ...)
         if is_new
-          type_header = "#{self.class.resource_name}/#{action_verb}"
-          rk = calculate_routing_key(action_verb)
+          # REST: POST resource (Create)
+          path = self.class.resource_name
+          response = bug_bunny_client.request(path, method: :post, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk, body: changes_to_send)
         else
-          type_header = "#{self.class.resource_name}/#{action_verb}/#{id}"
-          rk = calculate_routing_key(action_verb, id)
-        end
-
-        response = bug_bunny_client.request(type_header, exchange: current_exchange, exchange_type: current_exchange_type) do |req|
-          req.routing_key = rk
-          req.body = changes_to_send
+          # REST: PUT resource/id (Update)
+          path = "#{self.class.resource_name}/#{id}"
+          response = bug_bunny_client.request(path, method: :put, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk, body: changes_to_send)
         end
 
         handle_save_response(response)
@@ -392,19 +251,16 @@ module BugBunny
       false
     end
 
-    # Elimina el recurso remoto.
-    # Envía petición a `resource/destroy/:id`.
-    # @return [Boolean] true si fue eliminado exitosamente.
+    # Elimina el registro (DELETE).
     def destroy
       return false unless persisted?
 
       run_callbacks(:destroy) do
-        type_header = "#{self.class.resource_name}/#{self.class.destroy_action}/#{id}"
-        rk = calculate_routing_key(self.class.destroy_action, id)
+        # REST: DELETE resource/id
+        path = "#{self.class.resource_name}/#{id}"
+        rk = calculate_routing_key(id)
 
-        bug_bunny_client.request(type_header, exchange: current_exchange, exchange_type: current_exchange_type) do |req|
-          req.routing_key = rk
-        end
+        bug_bunny_client.request(path, method: :delete, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
 
         self.persisted = false
       end
@@ -415,7 +271,6 @@ module BugBunny
 
     private
 
-    # Procesa la respuesta exitosa del servidor RPC.
     def handle_save_response(response)
       if response['status'] == 422
         raise BugBunny::UnprocessableEntity.new(response['body']['errors'] || response['body'])
@@ -431,10 +286,8 @@ module BugBunny
       true
     end
 
-    # Carga errores remotos en el objeto local ActiveModel::Errors.
     def load_remote_rabbit_errors(errors_hash)
       return if errors_hash.nil?
-
       if errors_hash.is_a?(String)
         errors.add(:base, errors_hash)
       else

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = "3.0.0"
+  VERSION = "3.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-05 00:00:00.000000000 Z
+date: 2026-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny