better_model 2.1.0 → 3.0.0

data/lib/better_model/repositable/base_repository.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module BetterModel
+  module Repositable
+    # Base repository class for implementing the Repository Pattern with BetterModel.
+    #
+    # Repositories encapsulate data access logic and provide a clean interface for querying models.
+    # This base class integrates seamlessly with BetterModel's Searchable, Predicable, and Sortable concerns.
+    #
+    # @example Basic usage
+    #   class ArticleRepository < BetterModel::Repositable::BaseRepository
+    #     def model_class = Article
+    #
+    #     def published
+    #       search({ status_eq: "published" })
+    #     end
+    #
+    #     def recent(days: 7)
+    #       search({ created_at_gteq: days.days.ago })
+    #     end
+    #   end
+    #
+    #   repo = ArticleRepository.new
+    #   articles = repo.search({ status_eq: "published" }, page: 1, per_page: 20)
+    #   article = repo.search({ id_eq: 1 }, limit: 1)
+    #
+    # @example With BetterModel Searchable
+    #   # If your model uses BetterModel::Searchable:
+    #   class Article < ApplicationRecord
+    #     include BetterModel
+    #
+    #     predicates :title, :status, :view_count, :published_at
+    #     sort :title, :view_count, :published_at
+    #   end
+    #
+    #   # The repository automatically uses the model's search() method
+    #   repo = ArticleRepository.new
+    #   repo.search({ title_cont: "Rails", view_count_gt: 100 })
+    #
+    class BaseRepository
+      attr_reader :model
+
+      # Initialize a new repository instance.
+      #
+      # @param model_class [Class] The ActiveRecord model class (optional if model_class method is defined)
+      def initialize(model_class = nil)
+        @model = model_class || self.class.instance_method(:model_class).bind(self).call
+      end
+
+      # Main search method with support for predicates, pagination, ordering, and limits.
+      #
+      # This method integrates with BetterModel's Searchable concern if available,
+      # otherwise falls back to standard ActiveRecord queries.
+      #
+      # @param predicates [Hash] Filter conditions using BetterModel predicates
+      # @param page [Integer] Page number for pagination (default: 1)
+      # @param per_page [Integer] Records per page (default: 20)
+      # @param includes [Array] Associations to eager load
+      # @param joins [Array] Associations to join
+      # @param order [String, Hash] SQL order clause
+      # @param order_scope [Hash] BetterModel sort scope (e.g., { field: :published_at, direction: :desc })
+      # @param limit [Integer, Symbol, nil] Result limit:
+      #   - Integer (1): Returns single record (first)
+      #   - Integer (2+): Returns limited relation
+      #   - nil: Returns all results (no limit)
+      #   - :default: Uses pagination (default behavior)
+      #
+      # @return [ActiveRecord::Relation, ActiveRecord::Base, nil] Query results
+      #
+      # @example Basic search with predicates
+      #   search({ status_eq: "published", view_count_gt: 100 })
+      #
+      # @example With pagination
+      #   search({ status_eq: "published" }, page: 2, per_page: 50)
+      #
+      # @example Single result
+      #   search({ id_eq: 1 }, limit: 1)
+      #
+      # @example All results (no pagination)
+      #   search({ status_eq: "published" }, limit: nil)
+      #
+      # @example With eager loading
+      #   search({ status_eq: "published" }, includes: [:author, :comments])
+      #
+      # @example With ordering
+      #   search({ status_eq: "published" }, order_scope: { field: :published_at, direction: :desc })
+      #
+      def search(predicates = {}, page: 1, per_page: 20, includes: [], joins: [], order: nil, order_scope: nil,
+                 limit: :default)
+        # Remove nil values (keep false for boolean predicates)
+        cleaned_predicates = (predicates || {}).compact
+
+        # Validate predicates if model supports it
+        validate_predicates!(cleaned_predicates) if cleaned_predicates.present?
+
+        # Use BetterModel's search() method if available, otherwise use all
+        result = if @model.respond_to?(:search) && cleaned_predicates.present?
+                   @model.search(cleaned_predicates)
+                 else
+                   @model.all
+                 end
+
+        # Apply joins BEFORE includes (necessary for ORDER BY on joined tables)
+        result = result.joins(*joins) if joins.present?
+
+        # Apply includes if specified
+        result = result.includes(*includes) if includes.present?
+
+        # Apply ordering: order_scope has priority over order
+        if order_scope.present?
+          scope_name = build_scope_name(order_scope)
+          result = result.send(scope_name) if result.respond_to?(scope_name)
+        elsif order.present?
+          result = result.order(order)
+        end
+
+        # Apply limit if specified (has priority over pagination)
+        case limit
+        when 1
+          result.first
+        when (2..)
+          result.limit(limit)
+        when nil
+          # limit: nil explicitly means unlimited - return all results
+          result
+        when :default
+          # :default means use pagination (this is the default when no limit is specified)
+          paginate(result, page: page, per_page: per_page)
+        else
+          # Fallback to pagination for any other case
+          paginate(result, page: page, per_page: per_page)
+        end
+      end
+
+      # Standard CRUD methods delegated to the model
+      delegate :find, to: :@model
+      delegate :find_by, to: :@model
+      delegate :create, to: :@model
+      delegate :create!, to: :@model
+
+      # Build a new model instance with the given attributes.
+      #
+      # @param attributes [Hash] Model attributes
+      # @return [ActiveRecord::Base] New model instance (not persisted)
+      def build(attributes = {})
+        @model.new(attributes)
+      end
+
+      # Update a record by ID.
+      #
+      # @param id [Integer] Record ID
+      # @param attributes [Hash] Attributes to update
+      # @return [ActiveRecord::Base] Updated record
+      # @raise [ActiveRecord::RecordNotFound] If record not found
+      # @raise [ActiveRecord::RecordInvalid] If validation fails
+      def update(id, attributes)
+        record = find(id)
+        record.update!(attributes)
+        record
+      end
+
+      # Delete a record by ID.
+      #
+      # @param id [Integer] Record ID
+      # @return [ActiveRecord::Base] Deleted record
+      # @raise [ActiveRecord::RecordNotFound] If record not found
+      def delete(id)
+        @model.destroy(id)
+      end
+
+      # Base ActiveRecord methods delegated to the model
+      delegate :where, to: :@model
+      delegate :all, to: :@model
+      delegate :count, to: :@model
+      delegate :exists?, to: :@model
+
+      private
+
+      # Validate that predicates are supported by the model.
+      #
+      # If the model includes BetterModel::Predicable, validates against predicable_scope?.
+      # Otherwise, checks if the model responds to the predicate method.
+      #
+      # @param predicates [Hash] Predicates to validate
+      def validate_predicates!(predicates)
+        predicates.each_key do |predicate|
+          # Check if model supports predicable_scope? validation
+          if @model.respond_to?(:predicable_scope?)
+            next if @model.predicable_scope?(predicate)
+
+            available_list = @model.predicable_scopes.to_a.sort.join(", ")
+            Rails.logger.error "Invalid predicate '#{predicate}' for model #{@model.name}. " \
+                               "Available: #{available_list}"
+          else
+            # Fallback to checking if method exists
+            next if @model.respond_to?(predicate)
+
+            available_list = available_predicates.join(", ")
+            Rails.logger.error "Invalid predicate '#{predicate}' for model #{@model.name}. " \
+                               "Available: #{available_list}"
+          end
+        end
+      end
+
+      # Get available predicates for models without BetterModel::Predicable.
+      #
+      # @return [Array<Symbol>] List of available predicate methods
+      def available_predicates
+        @model.methods.grep(/_eq$|_cont$|_gteq$|_lteq$|_in$|_not_null$|_null$/).sort
+      end
+
+      # Centralized pagination using ActiveRecord offset/limit.
+      #
+      # @param relation [ActiveRecord::Relation] Relation to paginate
+      # @param page [Integer] Page number (1-indexed)
+      # @param per_page [Integer] Records per page
+      # @return [ActiveRecord::Relation] Paginated relation
+      def paginate(relation, page:, per_page:)
+        offset_value = (page.to_i - 1) * per_page.to_i
+        relation.offset(offset_value).limit(per_page)
+      end
+
+      # Build scope name for ordering (e.g., "sort_published_at_desc").
+      #
+      # @param order_scope [Hash] Hash with :field and :direction keys
+      # @return [String] Scope name
+      def build_scope_name(order_scope)
+        "sort_#{order_scope[:field]}_#{order_scope[:direction]}"
+      end
+    end
+  end
+end

data/lib/better_model/repositable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "repositable/base_repository"
+
+module BetterModel
+  # Repositable provides the Repository Pattern infrastructure for BetterModel.
+  #
+  # Unlike other BetterModel concerns, Repositable is not included directly in models.
+  # Instead, it provides a BaseRepository class that you can inherit from to create
+  # repository classes for your models.
+  #
+  # @example Creating a repository
+  #   class ArticleRepository < BetterModel::Repositable::BaseRepository
+  #     def model_class = Article
+  #
+  #     def published
+  #       search({ status_eq: "published" })
+  #     end
+  #   end
+  #
+  # @example Using a repository
+  #   repo = ArticleRepository.new
+  #   articles = repo.published
+  #   article = repo.find(1)
+  #
+  # @see BetterModel::Repositable::BaseRepository
+  #
+  module Repositable
+    # Version of the Repositable module
+    VERSION = "1.0.0"
+  end
+end

data/lib/better_model/searchable.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
-# Searchable - Sistema di ricerca unificato per modelli Rails
+require_relative "errors/searchable/searchable_error"
+require_relative "errors/searchable/invalid_predicate_error"
+require_relative "errors/searchable/invalid_order_error"
+require_relative "errors/searchable/invalid_pagination_error"
+require_relative "errors/searchable/invalid_security_error"
+require_relative "errors/searchable/configuration_error"
+
+# Searchable - Unified search system for Rails models.
 #
-# Questo concern orchestra Predicable e Sortable per fornire un'interfaccia
-# di ricerca completa con filtri, ordinamento e paginazione.
+# This concern orchestrates Predicable and Sortable to provide a complete
+# search interface with filters, sorting, and pagination.
 #
-# Esempio di utilizzo:
+# @example Basic Usage
 #   class Article < ApplicationRecord
 #     include BetterModel
 #
@@ -18,7 +25,7 @@
 #     end
 #   end
 #
-# Utilizzo:
+# @example Search with Filters, Pagination, and Sorting
 #   Article.search(
 #     { title_cont: "Rails", status_eq: "published" },
 #     pagination: { page: 1, per_page: 25 },
@@ -29,17 +36,11 @@ module BetterModel
   module Searchable
     extend ActiveSupport::Concern
 
-    # Error classes
-    class Error < StandardError; end
-    class InvalidPredicateError < Error; end
-    class InvalidOrderError < Error; end
-    class InvalidPaginationError < Error; end
-    class InvalidSecurityError < Error; end
 
     included do
-      # Valida che sia incluso solo in modelli ActiveRecord
+      # Validate ActiveRecord inheritance
       unless ancestors.include?(ActiveRecord::Base)
-        raise ArgumentError, "BetterModel::Searchable can only be included in ActiveRecord models"
+        raise BetterModel::Errors::Searchable::ConfigurationError, "Invalid configuration"
       end
 
       # Configuration registry
@@ -52,28 +53,35 @@ module BetterModel
     end
 
     class_methods do
-      # Interfaccia principale di ricerca
+      # Main search interface.
       #
-      # @param predicates [Hash] Condizioni di filtro (usa scope Predicable)
-      # @option predicates [Array<Hash>] :or Condizioni OR
-      # @param pagination [Hash] Parametri di paginazione (opzionale)
-      # @option pagination [Integer] :page Numero pagina
-      # @option pagination [Integer] :per_page Risultati per pagina
-      # @param orders [Array<Symbol>] Array di symbol scope sortable (opzionale)
+      # Provides a unified search interface combining predicates (filters),
+      # sorting, and pagination with support for OR conditions and security policies.
       #
-      # @return [ActiveRecord::Relation] Relation concatenabile
+      # @param predicates [Hash] Filter conditions (uses Predicable scopes)
+      # @option predicates [Array<Hash>] :or OR conditions
+      # @param pagination [Hash] Pagination parameters (optional)
+      # @option pagination [Integer] :page Page number
+      # @option pagination [Integer] :per_page Results per page
+      # @param orders [Array<Symbol>] Array of sortable scope symbols (optional)
+      # @param security [Symbol] Security policy name (optional)
+      # @param includes [Array, Symbol] Associations to eager load with LEFT OUTER JOIN
+      # @param preload [Array, Symbol] Associations to preload with separate queries
+      # @param eager_load [Array, Symbol] Associations to eager load (forces LEFT OUTER JOIN)
       #
-      # @example Ricerca base
+      # @return [ActiveRecord::Relation] Chainable relation
+      #
+      # @example Basic search
       #   Article.search({ title_cont: "Rails" })
       #
-      # @example Con paginazione e ordinamento
+      # @example With pagination and sorting
       #   Article.search(
       #     { title_cont: "Rails", status_eq: "published" },
       #     pagination: { page: 1, per_page: 25 },
       #     orders: [:sort_published_at_desc]
       #   )
       #
-      # @example Con OR conditions
+      # @example With OR conditions
       #   Article.search(
       #     {
       #       or: [
@@ -96,8 +104,7 @@ module BetterModel
 
         # If there are remaining unknown options, they might be misplaced predicates
         if options.any?
-          raise ArgumentError, "Unknown keyword arguments: #{options.keys.join(', ')}. " \
-            "Did you mean to pass predicates as a hash? Use: search({#{options.keys.first}: ...})"
+          raise BetterModel::Errors::Searchable::ConfigurationError, "Invalid search options provided"
         end
 
         # Sanitize predicates
@@ -143,7 +150,9 @@ module BetterModel
         scope
       end
 
-      # DSL per configurare searchable
+      # DSL to configure searchable.
+      #
+      # @yield [configurator] Configuration block
       #
       # @example
       #   searchable do
@@ -156,20 +165,21 @@ module BetterModel
         self.searchable_config = configurator.to_h.freeze
       end
 
-      # Verifica se un campo è predicable
-      def searchable_field?(field_name)
-        respond_to?(:predicable_field?) && predicable_field?(field_name)
-      end
+      # Check if a field is searchable (predicable).
+      #
+      # @param field_name [Symbol] Field name to check
+      # @return [Boolean] true if field is searchable
+      def searchable_field?(field_name) = respond_to?(:predicable_field?) && predicable_field?(field_name)
 
-      # Ritorna tutti i campi predicable
-      def searchable_fields
-        respond_to?(:predicable_fields) ? predicable_fields : Set.new
-      end
+      # Returns all searchable (predicable) fields.
+      #
+      # @return [Set<Symbol>] Set of searchable field names
+      def searchable_fields = respond_to?(:predicable_fields) ? predicable_fields : Set.new
 
-      # Ritorna i predicati disponibili per un campo
+      # Returns available predicates for a field.
       #
-      # @param field_name [Symbol] Nome del campo
-      # @return [Array<Symbol>] Array di predicati disponibili
+      # @param field_name [Symbol] Field name
+      # @return [Array<Symbol>] Array of available predicates
       #
       # @example
       #   Article.searchable_predicates_for(:title)
@@ -183,10 +193,10 @@ module BetterModel
           .map { |scope| scope.to_s.delete_prefix("#{field_name}_").to_sym }
       end
 
-      # Ritorna gli ordinamenti disponibili per un campo
+      # Returns available sorts for a field.
       #
-      # @param field_name [Symbol] Nome del campo
-      # @return [Array<Symbol>] Array di scope sortable disponibili
+      # @param field_name [Symbol] Field name
+      # @return [Array<Symbol>] Array of available sortable scopes
       #
       # @example
       #   Article.searchable_sorts_for(:title)
@@ -201,9 +211,14 @@ module BetterModel
 
       private
 
-      # Sanitizza e normalizza parametri predicates
-      # IMPORTANTE: Non usa più to_unsafe_h per sicurezza. Se passi ActionController::Parameters,
-      # devi chiamare .permit! o .to_h esplicitamente nel controller prima di passarlo qui.
+      # Sanitize and normalize predicate parameters.
+      #
+      # @param predicates [Hash, ActionController::Parameters] Predicates to sanitize
+      # @return [Hash] Sanitized predicates hash
+      # @api private
+      #
+      # @note Does not use to_unsafe_h for security. If passing ActionController::Parameters,
+      #   you must call .permit! or .to_h explicitly in your controller before passing here.
       def sanitize_predicates(predicates)
         return {} if predicates.nil?
 
@@ -211,9 +226,7 @@ module BetterModel
         # Ma richiedi che sia già stato permesso (non bypassa strong parameters)
         if defined?(ActionController::Parameters) && predicates.is_a?(ActionController::Parameters)
           unless predicates.permitted?
-            raise ArgumentError,
-              "ActionController::Parameters must be explicitly permitted before passing to search. " \
-              "Use .permit! or .to_h in your controller."
+            raise BetterModel::Errors::Searchable::ConfigurationError, "Invalid configuration"
           end
           predicates = predicates.to_h
         end
@@ -226,9 +239,7 @@ module BetterModel
         predicates.each do |predicate_scope, value|
           # Validate scope exists
           unless respond_to?(:predicable_scope?) && predicable_scope?(predicate_scope)
-            raise InvalidPredicateError,
-              "Invalid predicate scope: #{predicate_scope}. " \
-              "Available predicable scopes: #{predicable_scopes.to_a.join(', ')}"
+            raise BetterModel::Errors::Searchable::InvalidPredicateError, "Invalid predicate"
           end
 
           # Skip nil/blank values (but not false)
@@ -257,13 +268,11 @@ module BetterModel
           temp_scope = all
           condition_hash.symbolize_keys.each do |predicate_scope, value|
             unless respond_to?(:predicable_scope?) && predicable_scope?(predicate_scope)
-              raise InvalidPredicateError,
-                "Invalid predicate in OR condition: #{predicate_scope}. " \
-                "Available predicable scopes: #{predicable_scopes.to_a.join(', ')}"
+              raise BetterModel::Errors::Searchable::InvalidPredicateError, "Invalid predicate"
             end
 
             temp_scope = if value == true || value == "true"
-              temp_scope.public_send(predicate_scope)
+              temp_scope.public_send(predicate_scope, true)
             elsif value.is_a?(Array)
               # Splat array values for predicates like _between that expect multiple args
               temp_scope.public_send(predicate_scope, *value)
@@ -284,9 +293,7 @@ module BetterModel
 
           # Validate scope exists
           unless respond_to?(:sortable_scope?) && sortable_scope?(order_scope)
-            raise InvalidOrderError,
-              "Invalid order scope: #{order_scope}. " \
-              "Available sortable scopes: #{sortable_scopes.to_a.join(', ')}"
+            raise BetterModel::Errors::Searchable::InvalidOrderError, "Invalid order scope"
           end
 
           # Apply scope
@@ -302,26 +309,28 @@ module BetterModel
         per_page = pagination_params[:per_page]&.to_i
 
         # Validate page >= 1 (always, even without per_page)
-        raise InvalidPaginationError, "page must be >= 1" if page < 1
+        if page < 1
+          raise BetterModel::Errors::Searchable::InvalidPaginationError, "Invalid pagination parameters"
+        end
 
         # DoS protection: limita il numero massimo di pagina per evitare offset enormi
         # Default 10000, configurabile tramite searchable config
         max_page = searchable_config[:max_page] || 10_000
         if page > max_page
-          raise InvalidPaginationError,
-            "page must be <= #{max_page} (DoS protection). " \
-            "Configure max_page in searchable block to change this limit."
+          raise BetterModel::Errors::Searchable::InvalidPaginationError, "Page number exceeds maximum allowed"
         end
 
         # If per_page is not provided, return scope without LIMIT
         return scope if per_page.nil?
 
         # Validate per_page >= 1
-        raise InvalidPaginationError, "per_page must be >= 1" if per_page < 1
+        if per_page < 1
+          raise BetterModel::Errors::Searchable::InvalidPaginationError, "Invalid pagination parameters"
+        end
 
-        # Respect max_per_page limit if configured
-        if searchable_config[:max_per_page].present?
-          per_page = [ per_page, searchable_config[:max_per_page] ].min
+        # Respect max_per_page limit if configured - raise error if exceeded
+        if searchable_config[:max_per_page].present? && per_page > searchable_config[:max_per_page]
+          raise BetterModel::Errors::Searchable::InvalidPaginationError, "per_page must be <= #{searchable_config[:max_per_page]}"
         end
 
         offset = (page - 1) * per_page
@@ -355,9 +364,7 @@ module BetterModel
         securities_config = searchable_config[:securities] || {}
 
         unless securities_config.key?(security_name)
-          raise InvalidSecurityError,
-            "Unknown security: #{security_name}. " \
-            "Available securities: #{securities_config.keys.join(', ')}"
+          raise BetterModel::Errors::Searchable::InvalidSecurityError, "Unknown security policy"
         end
 
         # Ottieni i predicati obbligatori per questa security
@@ -373,9 +380,7 @@ module BetterModel
         end
 
         if missing_or_blank.any?
-          raise InvalidSecurityError,
-            "Security :#{security_name} requires the following predicates with valid values: #{missing_or_blank.join(', ')}. " \
-            "These predicates must be present and have non-blank values in the search parameters."
+          raise BetterModel::Errors::Searchable::InvalidSecurityError, "Required security predicates missing"
         end
       end
 
@@ -388,9 +393,7 @@ module BetterModel
         securities_config = searchable_config[:securities] || {}
 
         unless securities_config.key?(security_name)
-          raise InvalidSecurityError,
-            "Unknown security: #{security_name}. " \
-            "Available securities: #{securities_config.keys.join(', ')}"
+          raise BetterModel::Errors::Searchable::InvalidSecurityError, "Unknown security policy"
         end
 
         # Ottieni i predicati obbligatori per questa security
@@ -410,10 +413,7 @@ module BetterModel
           end
 
           if missing_or_blank.any?
-            raise InvalidSecurityError,
-              "Security :#{security_name} violation in OR condition ##{index + 1}. " \
-              "Each OR condition must include the following predicates with valid values: #{missing_or_blank.join(', ')}. " \
-              "This prevents bypassing security rules through OR logic."
+            raise BetterModel::Errors::Searchable::InvalidSecurityError, "Required security predicates missing in OR condition"
           end
         end
       end
@@ -425,9 +425,7 @@ module BetterModel
         total_predicates = predicates.size
 
         if total_predicates > max_predicates
-          raise ArgumentError,
-            "Query too complex: #{total_predicates} predicates exceeds maximum of #{max_predicates}. " \
-            "Configure max_predicates in searchable block to change this limit."
+          raise BetterModel::Errors::Searchable::ConfigurationError, "Invalid configuration"
         end
 
         # Limita il numero di condizioni OR (default 50, configurabile)
@@ -437,9 +435,7 @@ module BetterModel
         or_count = Array(or_conditions).size
 
         if or_count > max_or_conditions
-          raise ArgumentError,
-            "Query too complex: #{or_count} OR conditions exceeds maximum of #{max_or_conditions}. " \
-            "Configure max_or_conditions in searchable block to change this limit."
+          raise BetterModel::Errors::Searchable::ConfigurationError, "Invalid configuration"
         end
 
         # Conta anche i predicati dentro ogni condizione OR
@@ -447,18 +443,16 @@ module BetterModel
         total_with_or = total_predicates + or_predicates_count
 
         if total_with_or > max_predicates
-          raise ArgumentError,
-            "Query too complex: #{total_with_or} total predicates (including OR conditions) exceeds maximum of #{max_predicates}. " \
-            "Configure max_predicates in searchable block to change this limit."
+          raise BetterModel::Errors::Searchable::ConfigurationError, "Query complexity exceeds maximum allowed predicates"
         end
       end
     end
 
-    # Metodi di istanza
+    # Instance Methods
 
-    # Ritorna metadata di ricerca per questo record
+    # Returns search metadata for this record.
     #
-    # @return [Hash] Hash con informazioni sui campi ricercabili e ordinabili
+    # @return [Hash] Hash with information about searchable and sortable fields
     #
     # @example
     #   article.search_metadata
@@ -532,13 +526,19 @@ module BetterModel
       @config[:max_or_conditions] = count.to_i
     end
 
-    def security(name, predicates_array)
+    def security(name, predicates_array = nil)
       name = name.to_sym
+
+      # Check if predicates_array is provided
+      if predicates_array.nil?
+        raise BetterModel::Errors::Searchable::ConfigurationError, "Invalid configuration"
+      end
+
       predicates_array = Array(predicates_array).map(&:to_sym)
 
       # Valida che i predicati richiesti siano simboli validi
       if predicates_array.empty?
-        raise ArgumentError, "Security :#{name} must have at least one required predicate"
+        raise BetterModel::Errors::Searchable::ConfigurationError, "Invalid configuration"
       end
 
       @config[:securities][name] = predicates_array