the-active-rpc 1.0.1

data/lib/active_rpc/rpc/base_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActiveRpc
+  module Rpc
+    # Base controller class that includes all our concerns
+    class BaseController < ::Gruf::Controllers::Base
+      include ActiveRpc::Rpc::Concerns::RequestProcessor
+      include ActiveRpc::Rpc::Concerns::QueryBuilder
+      include ActiveRpc::Rpc::Concerns::ResourceController
+      include ActiveRpc::Rpc::Concerns::Serializable
+
+      # Add common methods for all gRPC controllers here
+
+      private
+
+      # Provide a params method that Pagy can use
+      # Converts the protobuf request into a Rails-style params hash
+      def params
+        @params ||= build_params_from_request
+      end
+
+      def build_params_from_request
+        return {} unless request&.message
+
+        request_message = request.message
+        params_hash = {}
+
+        # Extract all supported parameters
+        extract_pagination_params(request_message, params_hash)
+        extract_query_params(request_message, params_hash)
+        extract_other_params(request_message, params_hash)
+
+        params_hash
+      end
+
+      def extract_pagination_params(request_message, params_hash)
+        params_hash[:page] = request_message.page if request_message.respond_to?(:page)
+        params_hash[:per_page] = request_message.per_page if request_message.respond_to?(:per_page)
+      end
+
+      def extract_query_params(request_message, params_hash)
+        if request_message.respond_to?(:q) && request_message.q
+          params_hash[:q] = convert_protobuf_value(request_message.q)
+        end
+
+        return unless request_message.respond_to?(:scope) && request_message.scope
+
+        params_hash[:scope] = convert_protobuf_value(request_message.scope)
+      end
+
+      def extract_other_params(request_message, params_hash)
+        params_hash[:sort] = request_message.sort if request_message.respond_to?(:sort)
+        params_hash[:include] = request_message.include if request_message.respond_to?(:include)
+        params_hash[:ids] = request_message.ids if request_message.respond_to?(:ids) && request_message.ids
+        params_hash[:where] = request_message.where.to_h if request_message.respond_to?(:where) && request_message.where
+      end
+
+      def convert_protobuf_value(value)
+        value.respond_to?(:to_h) ? value.to_h : value
+      end
+    end
+  end
+end

data/lib/active_rpc/rpc/concerns/includable.rb

@@ -0,0 +1,68 @@
+module ActiveRpc
+  module Rpc
+    module Concerns
+      # The Includable concern provides methods for applying includes (eager loading)
+      # to ActiveRecord queries in gRPC controllers.
+      #
+      # @example
+      #   def list_users
+      #     process_request do
+      #       base_query = User.all
+      #       query = apply_includes(base_query, request.message)
+      #       # ...
+      #     end
+      #   end
+      module Includable
+        extend ActiveSupport::Concern
+
+        # Apply includes to a query
+        def apply_includes(query, params)
+          return query unless params.respond_to?(:include) && params.include.present?
+
+          begin
+            # Convert the array to symbols
+            includes = params.include.map(&:to_sym)
+
+            # Get query configuration
+            query_config = get_query_config(query.model)
+            includable_assocs = query_config[:includable] || []
+
+            # Filter out non-includable associations if we have defined includable associations
+            filtered_includes = if includable_assocs.empty?
+                                  includes
+            else
+                                  includes.select do |assoc|
+                                    includable_assocs.include?(assoc)
+                                  end
+            end
+
+            # Apply includes
+            query.includes(filtered_includes)
+          rescue StandardError => e
+            Rails.logger.error("Error applying includes: #{e.message}")
+            # Return original query if includes fails
+            query
+          end
+        end
+
+        # Get query configuration for a model
+        def get_query_config(model_class)
+          if model_class.respond_to?(:active_rpc_config) && model_class.active_rpc_config
+            resource = model_class.active_rpc_config[:resource].to_s.underscore
+            query_config_method = "#{resource}_query_config"
+
+            return model_class.send(query_config_method) if model_class.respond_to?(query_config_method)
+          end
+
+          # Default configuration if none is defined
+          {
+            searchable: model_class.column_names,
+            filterable: model_class.column_names,
+            sortable: model_class.column_names,
+            includable: model_class.reflect_on_all_associations.map(&:name)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/active_rpc/rpc/concerns/paginatable.rb

@@ -0,0 +1,155 @@
+require 'pagy'
+require 'pagy/classes/request'
+require 'pagy/toolbox/paginators/offset'
+
+module ActiveRpc
+  module Rpc
+    module Concerns
+      # The Paginatable concern provides methods for applying pagination
+      # to ActiveRecord queries in gRPC controllers.
+      #
+      # It supports:
+      # - Standard pagination with page and per_page parameters
+      # - Integration with the Pagy gem if available
+      # - Pagination metadata for responses
+      #
+      # @example
+      #   def list_users
+      #     process_request do
+      #       base_query = User.all
+      #       query = apply_pagination(base_query, request.message)
+      #       # ...
+      #     end
+      #   end
+      module Paginatable
+        extend ActiveSupport::Concern
+
+        # Apply pagination to a query only if explicitly requested
+        def apply_pagination(query, params)
+          return query unless pagination_params?(params)
+
+          begin
+            page, per_page = sanitized_page_params(params)
+            base_options = defined?(Pagy::OPTIONS) ? Pagy::OPTIONS : Pagy::DEFAULT
+            options = base_options.merge(rpc_pagy_options(page, per_page))
+            pagy, records = Pagy::OffsetPaginator.paginate(query, options)
+            @last_pagy = pagy
+            records
+          rescue StandardError => e
+            Rails.logger.error("Error applying pagination: #{e.message}")
+            # Return original query if pagination fails
+            query
+          end
+        end
+
+        # Get pagination metadata
+        def pagination_metadata(query, params, total_count = nil)
+          # If Pagy was used, get metadata from it
+          if defined?(@last_pagy) && @last_pagy
+            return {
+              total_count: @last_pagy.count,
+              page: @last_pagy.page,
+              per_page: @last_pagy.limit,
+              total_pages: @last_pagy.last
+            }
+          end
+
+          # If pagination is not requested, return metadata with all records
+          unless params.respond_to?(:page) && params.respond_to?(:per_page) &&
+                 params.page.present? && params.per_page.present?
+            total_count = query.count
+            return {
+              total_count: total_count,
+              page: 1,
+              per_page: total_count,
+              total_pages: 1
+            }
+          end
+
+          # Calculate total count and pages
+          total_count ||= query.except(:limit, :offset).count
+
+          # Validate and sanitize per_page parameter
+          per_page = params.per_page.to_i
+          if per_page <= 0
+            Rails.logger.warn("Invalid per_page value: #{params.per_page}. Using default value.")
+            per_page = ActiveRpc::Rpc.configuration.default_per_page || 20
+          end
+
+          # Ensure per_page doesn't exceed maximum allowed
+          max_per_page = ActiveRpc::Rpc.configuration.max_per_page || 100
+          per_page = [ per_page, max_per_page ].min
+
+          # Calculate total pages safely
+          total_pages = total_count > 0 ? (total_count.to_f / per_page).ceil : 1
+
+          {
+            total_count: total_count,
+            page: params.page,
+            per_page: per_page,
+            total_pages: total_pages
+          }
+        end
+
+        private
+
+        def pagination_params?(params)
+          params.respond_to?(:page) && params.respond_to?(:per_page) &&
+            params.page.present? && params.per_page.present?
+        end
+
+        def sanitized_page_params(params)
+          page = [ params.page.to_i, 1 ].max
+          per_page = [ [ params.per_page.to_i, 1 ].max, ActiveRpc::Rpc.configuration.max_per_page ].min
+          [page, per_page]
+        end
+
+        def rpc_pagy_options(page, per_page)
+          page_key = (Pagy::OPTIONS[:page_key] || Pagy::DEFAULT[:page_key]).to_s
+          limit_key = (Pagy::OPTIONS[:limit_key] || Pagy::DEFAULT[:limit_key]).to_s
+          client_max = ActiveRpc::Rpc.configuration.max_per_page || Pagy::OPTIONS[:client_max_limit] || Pagy::DEFAULT[:limit]
+
+          request_payload = {
+            base_url: '',
+            path: '',
+            params: {
+              'page' => {
+                page_key => page,
+                limit_key => per_page
+              }
+            },
+            cookie: nil
+          }
+
+          request_wrapper = if Pagy::Request.instance_method(:initialize).parameters.any? { |type, _| type == :key || type == :keyreq }
+            Pagy::Request.new(
+              request: request_payload,
+              root_key: 'page',
+              page_key: page_key,
+              limit_key: limit_key,
+              client_max_limit: client_max,
+              jsonapi: true
+            )
+          else
+            Pagy::Request.new(
+              request_payload.transform_keys { |key| key == :params ? :query : key },
+              jsonapi: true,
+              page_key: page_key,
+              limit_key: limit_key,
+              client_max_limit: client_max
+            )
+          end
+
+          {
+            request: request_wrapper,
+            jsonapi: true,
+            client_max_limit: client_max,
+            page_key: page_key,
+            limit_key: limit_key,
+            limit: per_page
+          }
+        end
+      end
+    end
+  end
+end

data/lib/active_rpc/rpc/concerns/query_builder.rb

@@ -0,0 +1,178 @@
+module ActiveRpc
+  module Rpc
+    module Concerns
+      # The QueryBuilder concern combines all query-related concerns and provides
+      # high-level methods for building and executing queries in gRPC controllers.
+      #
+      # @example
+      #   def list_users
+      #     process_request do
+      #       execute_query(User, request.message,
+      #         response_class: ::Core::UserListResponse,
+      #         transformer: :to_rpc_response
+      #       )
+      #     end
+      #   end
+      module QueryBuilder
+        extend ActiveSupport::Concern
+
+        include ActiveRpc::Rpc::Concerns::Ransackable
+        include ActiveRpc::Rpc::Concerns::Scopable
+        include ActiveRpc::Rpc::Concerns::Includable
+        include ActiveRpc::Rpc::Concerns::Paginatable
+        include ActiveRpc::Rpc::Concerns::Sortable
+
+        # Build a query with all parameters
+        def build_query(base_query, params)
+          query = base_query
+
+          # Apply filters in a specific order
+          query = apply_where_filters(query, params)
+          query = apply_ransack(query, params)
+          query = apply_scopes(query, params)
+          query = apply_includes(query, params)
+          apply_sorting(query, params)
+
+          # TEMPORARILY DISABLE PAGINATION TO TEST BULK LOADING
+          # Apply pagination last
+          # query = apply_pagination(query, params)
+        end
+
+        # Execute a query and return results with pagination metadata
+        def execute_query(query_or_class, request_payload, options = {})
+          # Determine the base query
+          base_query = if query_or_class.is_a?(Class)
+                         # If a class is provided, start with all records
+                         options[:base_query] || query_or_class.all
+          else
+                         # If a query is provided, use it directly
+                         query_or_class
+          end
+
+          # Filter by specific IDs if provided
+          if request_payload.respond_to?(:ids) && request_payload.ids.present?
+            Rails.logger.info("[DEBUG] IDs found: #{request_payload.ids.inspect} (#{request_payload.ids.class})")
+
+            # Convert Google::Protobuf::RepeatedField to Ruby Array
+            ids_array = if request_payload.ids.is_a?(Google::Protobuf::RepeatedField)
+                          request_payload.ids.to_a
+            else
+                          request_payload.ids
+            end
+
+            Rails.logger.info("[DEBUG] Converted IDs: #{ids_array.inspect} (#{ids_array.class})")
+            base_query = base_query.where(id: ids_array)
+          else
+            Rails.logger.info("[DEBUG] No IDs found. respond_to?(:ids): #{request_payload.respond_to?(:ids)}, ids.present?: #{request_payload.respond_to?(:ids) ? request_payload.ids.present? : 'N/A'}")
+            Rails.logger.info("[DEBUG] Request payload: #{request_payload.inspect}")
+          end
+
+          # Apply additional filters if provided
+          base_query = options[:additional_filters].call(base_query) if options[:additional_filters].is_a?(Proc)
+
+          # Apply includes from options if provided
+          # Note: includes are applied BEFORE scopes to avoid conflicts
+          base_query = base_query.includes(options[:includes]) if options[:includes].present?
+
+          # Build the query with all parameters
+          query = build_query(base_query, request_payload)
+
+          # Execute the query
+          records = query.to_a
+
+          # Transform records if a transformer is provided
+          if options[:transformer].is_a?(Proc)
+            records = records.map(&options[:transformer])
+          elsif options[:transformer] == :to_rpc_response
+            records = records.map(&:to_rpc_response)
+          end
+
+          # Return the response with pagination metadata
+          response_class = options[:response_class]
+          if response_class
+            paginated_response(response_class, records, query, request_payload, records.size)
+          else
+            {
+              records: records,
+              metadata: pagination_metadata(query, request_payload, records.size)
+            }
+          end
+        end
+
+        # Get the response with pagination metadata
+        def paginated_response(response_class, items, query, params, total_count = nil)
+          # Get pagination metadata
+          metadata = pagination_metadata(query, params, total_count)
+
+          # Check if pagination was requested
+          pagination_requested = params.respond_to?(:page) && params.respond_to?(:per_page) &&
+                                 params.page.present? && params.per_page.present?
+
+          # Create the response with items and pagination metadata
+          response_class.new(
+            items: items,
+            total_count: metadata[:total_count],
+            page: pagination_requested ? metadata[:page] : 1,
+            per_page: pagination_requested ? metadata[:per_page] : metadata[:total_count],
+            total_pages: pagination_requested ? metadata[:total_pages] : 1
+          )
+        end
+
+        private
+
+        # Apply ActiveRecord-style where conditions
+        def apply_where_filters(query, params)
+          return query unless params.respond_to?(:where) && params.where.present?
+
+          begin
+            # Convert protobuf map to hash if needed
+            where_conditions = params.where.respond_to?(:to_h) ? params.where.to_h : params.where
+
+            # Apply each condition
+            where_conditions.each do |field, value|
+              # Validate field is allowed (security)
+              if allowed_where_field?(query.model, field)
+                query = query.where(field => value)
+              else
+                Rails.logger.warn("Filtered out disallowed where field: #{field}")
+              end
+            end
+
+            query
+          rescue StandardError => e
+            Rails.logger.error("Error applying where filters: #{e.message}")
+            query
+          end
+        end
+
+        # Check if a field is allowed for where filtering
+        def allowed_where_field?(model_class, field)
+          # Get allowed fields from query config or default to column names
+          query_config = get_query_config(model_class)
+          allowed_fields = query_config[:filterable] || model_class.column_names
+
+          # Check if field is in allowed list
+          allowed_fields.include?(field.to_s) || allowed_fields.include?(field.to_sym)
+        end
+
+        # Get query configuration for a model (from Ransackable concern)
+        def get_query_config(model_class)
+          if model_class.respond_to?(:active_rpc_config) && model_class.active_rpc_config
+            resource = model_class.active_rpc_config[:resource].to_s.underscore
+            query_config_method = "#{resource}_query_config"
+
+            return model_class.send(query_config_method) if model_class.respond_to?(query_config_method)
+          end
+
+          # Default configuration if none is defined
+          {
+            searchable: model_class.column_names,
+            filterable: model_class.column_names,
+            sortable: model_class.column_names,
+            includable: model_class.reflect_on_all_associations.map(&:name)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/active_rpc/rpc/concerns/ransackable.rb

@@ -0,0 +1,113 @@
+module ActiveRpc
+  module Rpc
+    module Concerns
+      # The Ransackable concern provides methods for applying Ransack-based filtering
+      # to ActiveRecord queries in gRPC controllers.
+      #
+      # It supports:
+      # - Standard Ransack predicates (e.g., q[name_cont]=John)
+      # - Full-text search via q[search]=query
+      #
+      # @example
+      #   def list_users
+      #     process_request do
+      #       base_query = User.all
+      #       query = apply_ransack(base_query, request.message)
+      #       # ...
+      #     end
+      #   end
+      module Ransackable
+        extend ActiveSupport::Concern
+
+        # Apply Ransack search parameters to a query
+        def apply_ransack(query, params)
+          return query unless params.respond_to?(:q) && params.q.present?
+
+          begin
+            # Convert the map to a hash
+            search_params = params.q.to_h
+
+            # Get query configuration
+            query_config = get_query_config(query.model)
+            searchable_attrs = query_config[:searchable] || []
+
+            # Filter out non-searchable attributes
+            filtered_params = {}
+            search_params.each do |key, value|
+              # Extract the attribute name from the Ransack predicate
+              attr_name = key.to_s.split('_').first
+
+              # Include the parameter if the attribute is searchable
+              if searchable_attrs.include?(attr_name.to_sym) || searchable_attrs.include?(attr_name.to_s) || searchable_attrs.empty?
+                filtered_params[key] = value
+              end
+            end
+
+            # Check for special search parameter
+            if ActiveRpc::Rpc.configuration.enable_full_text_search &&
+               filtered_params.key?('search') && filtered_params['search'].present?
+              search_query = filtered_params.delete('search')
+              query = apply_full_text_search(query, search_query)
+            end
+
+            # Apply standard Ransack filters
+            query.ransack(filtered_params).result
+          rescue => e
+            Rails.logger.error("Error applying ransack: #{e.message}")
+            # Return original query if ransack fails
+            query
+          end
+        end
+
+        private
+
+        # Apply full-text search to a query
+        def apply_full_text_search(query, search_query)
+          resource_class = query.model
+
+          # Try different search method patterns in order of preference
+          resource_name = resource_class.name.underscore.pluralize
+
+          # 1. Try model-specific search method
+          specific_search_method = "search_#{resource_name}"
+          if resource_class.respond_to?(specific_search_method)
+            return resource_class.send(specific_search_method, search_query)
+          end
+
+          # 2. Try generic search method
+          if resource_class.respond_to?(:search)
+            return resource_class.search(search_query)
+          end
+
+          # 3. Try full_text_search method
+          if resource_class.respond_to?(:full_text_search)
+            return resource_class.full_text_search(search_query)
+          end
+
+          # If no search method is found, return the original query
+          query
+        end
+
+        # Get query configuration for a model
+        def get_query_config(model_class)
+          if model_class.respond_to?(:active_rpc_config) && model_class.active_rpc_config
+            resource = model_class.active_rpc_config[:resource].to_s.underscore
+            query_config_method = "#{resource}_query_config"
+
+            if model_class.respond_to?(query_config_method)
+              return model_class.send(query_config_method)
+            end
+          end
+
+          # Default configuration if none is defined
+          {
+            searchable: model_class.column_names,
+            filterable: model_class.column_names,
+            sortable: model_class.column_names,
+            includable: model_class.reflect_on_all_associations.map(&:name)
+          }
+        end
+      end
+    end
+  end
+end