propel_api 0.3.1.6 → 0.3.3

data/lib/generators/propel_api/templates/lib/propel_dynamic_scope_generator.rb

@@ -0,0 +1,474 @@
+# frozen_string_literal: true
+
+# PropelDynamicScopeGenerator
+# 
+# Generates dynamic scopes and has_scope registrations for ActiveRecord models
+# based on database column types and filter operators.
+#
+# This class handles the creation of both model scopes and controller has_scope
+# registrations dynamically, ensuring they work together properly.
+#
+# Usage:
+#   generator = PropelDynamicScopeGenerator.new(Team)
+#   generator.generate_scopes!
+#   generator.register_controller_scopes(MyController)
+#
+class PropelDynamicScopeGenerator
+  attr_reader :model_class, :generated_scopes, :generated_has_scopes
+
+  def initialize(model_class)
+    @model_class = model_class
+    @generated_scopes = []
+    @generated_has_scopes = []
+  end
+
+  # Generate all scopes for the model based on its columns
+  def generate_scopes!
+    return if @generated_scopes.any?
+
+    @model_class.columns.each do |column|
+      generate_scopes_for_column(column)
+    end
+    
+    # Add sorting scope
+    generate_sort_scope
+  end
+
+  # Register has_scope calls for a controller
+  def register_controller_scopes(controller_class)
+    return if @generated_has_scopes.any?
+
+    @generated_scopes.each do |scope_name|
+      register_has_scope(controller_class, scope_name)
+    end
+  end
+
+  private
+
+  def generate_scopes_for_column(column)
+    name = column.name
+    type = column.type
+    sql_type = column.sql_type_metadata.sql_type
+    
+    operators = PropelFilterOperators.operators_for(type, sql_type)
+    
+    operators.each do |operator|
+      scope_name = "#{name}_#{operator}".to_sym
+      generate_scope_method(scope_name, name, operator, type)
+      @generated_scopes << scope_name
+    end
+  end
+
+  def generate_scope_method(scope_name, field_name, operator, field_type)
+    return if @model_class.respond_to?(scope_name)
+
+    case operator
+    when "eq"
+      generate_eq_scope(scope_name, field_name, field_type)
+    when "contains"
+      generate_contains_scope(scope_name, field_name)
+    when "starts_with"
+      generate_starts_with_scope(scope_name, field_name)
+    when "ends_with"
+      generate_ends_with_scope(scope_name, field_name)
+    when "gt"
+      generate_gt_scope(scope_name, field_name)
+    when "lt"
+      generate_lt_scope(scope_name, field_name)
+    when "gte", "min"
+      generate_gte_scope(scope_name, field_name)
+    when "lte", "max"
+      generate_lte_scope(scope_name, field_name)
+    when "before"
+      generate_before_scope(scope_name, field_name)
+    when "after"
+      generate_after_scope(scope_name, field_name)
+    when "in"
+      generate_in_scope(scope_name, field_name)
+    when "null"
+      generate_null_scope(scope_name, field_name)
+    when "range"
+      generate_range_scope(scope_name, field_name)
+    when "date"
+      generate_date_scope(scope_name, field_name)
+    when "year"
+      generate_year_scope(scope_name, field_name)
+    when "month"
+      generate_month_scope(scope_name, field_name)
+    when "day"
+      generate_day_scope(scope_name, field_name)
+    end
+  rescue StandardError => e
+    Rails.logger.warn "Error generating scope #{scope_name}: #{e.message}"
+  end
+
+  def generate_eq_scope(scope_name, field_name, field_type)
+    case field_type
+    when :boolean
+      @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        scope :#{scope_name}, ->(value) { 
+          return all if value.blank?
+          boolean_value = case value.to_s.downcase
+          when 'true', '1', 'yes', 'on'
+            true
+          when 'false', '0', 'no', 'off'
+            false
+          else
+            value
+          end
+          where(#{field_name}: boolean_value) 
+        }
+      RUBY
+    else
+      @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        scope :#{scope_name}, ->(value) { value.present? ? where(#{field_name}: value) : all }
+      RUBY
+    end
+  end
+
+  def generate_contains_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("#{field_name} #{like_operator} ?", "%\#{value}%") : all 
+      }
+    RUBY
+  end
+
+  def generate_starts_with_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("#{field_name} #{like_operator} ?", "\#{value}%") : all 
+      }
+    RUBY
+  end
+
+  def generate_ends_with_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("#{field_name} #{like_operator} ?", "%\#{value}") : all 
+      }
+    RUBY
+  end
+
+  def generate_gt_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("#{field_name} > ?", value) : all 
+      }
+    RUBY
+  end
+
+  def generate_lt_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("#{field_name} < ?", value) : all 
+      }
+    RUBY
+  end
+
+  def generate_gte_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("#{field_name} >= ?", value) : all 
+      }
+    RUBY
+  end
+
+  def generate_lte_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("#{field_name} <= ?", value) : all 
+      }
+    RUBY
+  end
+
+  def generate_before_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          begin
+            # Parse datetime string into proper datetime object
+            parsed_value = case value
+            when String
+              DateTime.parse(value)
+            when Time, Date, DateTime
+              value
+            else
+              DateTime.parse(value.to_s)
+            end
+            where("#{field_name} < ?", parsed_value)
+          rescue ArgumentError, TypeError
+            all
+          end
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_after_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          begin
+            # Parse datetime string into proper datetime object
+            parsed_value = case value
+            when String
+              DateTime.parse(value)
+            when Time, Date, DateTime
+              value
+            else
+              DateTime.parse(value.to_s)
+            end
+            where("#{field_name} > ?", parsed_value)
+          rescue ArgumentError, TypeError
+            all
+          end
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_in_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          values = value.is_a?(Array) ? value : value.to_s.split(",").map(&:strip)
+          values.any? ? where("#{field_name} IN (?)", values) : all
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_null_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          is_null = value.to_s.downcase == "true"
+          is_null ? where("#{field_name} IS NULL") : where("#{field_name} IS NOT NULL")
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_range_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          # Handle both array and string formats
+          if value.is_a?(Array) && value.size == 2
+            where("#{field_name} BETWEEN ? AND ?", value[0], value[1])
+          elsif value.is_a?(String) && value.include?(',')
+            # Handle string format like "150,350"
+            range_values = value.split(',').map(&:strip)
+            if range_values.size == 2
+              where("#{field_name} BETWEEN ? AND ?", range_values[0], range_values[1])
+            else
+              all
+            end
+          else
+            all
+          end
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_date_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          date = value.is_a?(Date) ? value : Date.parse(value.to_s)
+          where("DATE(#{field_name}) = ?", date)
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_year_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          begin
+            # Parse the datetime value to extract year
+            parsed_value = case value
+            when String
+              DateTime.parse(value)
+            when Time, Date, DateTime
+              value
+            else
+              DateTime.parse(value.to_s)
+            end
+            
+            # Create date range for the entire year
+            start_of_year = parsed_value.beginning_of_year
+            end_of_year = parsed_value.end_of_year
+            
+            where("#{field_name} >= ? AND #{field_name} <= ?", start_of_year, end_of_year)
+          rescue ArgumentError, TypeError
+            all
+          end
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_month_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          begin
+            # Parse the datetime value to extract month
+            parsed_value = case value
+            when String
+              DateTime.parse(value)
+            when Time, Date, DateTime
+              value
+            else
+              DateTime.parse(value.to_s)
+            end
+            
+            # Create date range for the entire month
+            start_of_month = parsed_value.beginning_of_month
+            end_of_month = parsed_value.end_of_month
+            
+            where("#{field_name} >= ? AND #{field_name} <= ?", start_of_month, end_of_month)
+          rescue ArgumentError, TypeError
+            all
+          end
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_day_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        if value.present?
+          begin
+            # Parse the datetime value to extract day
+            parsed_value = case value
+            when String
+              DateTime.parse(value)
+            when Time, Date, DateTime
+              value
+            else
+              DateTime.parse(value.to_s)
+            end
+            
+            # Create date range for the entire day
+            start_of_day = parsed_value.beginning_of_day
+            end_of_day = parsed_value.end_of_day
+            
+            where("#{field_name} >= ? AND #{field_name} <= ?", start_of_day, end_of_day)
+          rescue ArgumentError, TypeError
+            all
+          end
+        else
+          all
+        end
+      }
+    RUBY
+  end
+
+  def generate_sort_scope
+    scope_name = :order_by
+    return if @generated_scopes.include?(scope_name)
+
+    begin
+      # Get all sortable columns (exclude sensitive fields)
+      sortable_columns = @model_class.columns.reject do |column|
+        sensitive_fields.include?(column.name.to_s)
+      end.map(&:name)
+
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) {
+        return all if value.blank?
+        
+        # Parse sort parameter (e.g., "name", "-name", "name:asc", "name:desc")
+        field = value.to_s
+        direction = 'asc'
+        
+        # Handle "-field" format for descending
+        if field.start_with?('-')
+          field = field[1..-1]
+          direction = 'desc'
+        else
+          # Handle "field:direction" format
+          field, direction = field.split(':')
+          direction ||= 'asc'
+        end
+        
+        # Validate field is sortable
+        sortable_fields = #{sortable_columns.inspect}
+        return all unless sortable_fields.include?(field)
+        
+        # Validate direction
+        direction = direction.downcase
+        direction = 'asc' unless %w[asc desc].include?(direction)
+        
+        order("\#{field} \#{direction}")
+      }
+    RUBY
+
+    @generated_scopes << scope_name
+    rescue => e
+      Rails.logger.error "Error generating sort scope: #{e.message}"
+      Rails.logger.error e.backtrace.first(5)
+    end
+  end
+
+  def register_has_scope(controller_class, scope_name)
+    return if controller_class.respond_to?(:has_scope_registered?) && 
+              controller_class.has_scope_registered?(scope_name)
+
+    controller_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      has_scope :#{scope_name}
+    RUBY
+    
+    @generated_has_scopes << scope_name
+  rescue StandardError => e
+    Rails.logger.warn "Error registering has_scope #{scope_name}: #{e.message}"
+  end
+
+  # Returns the appropriate LIKE operator for the current database adapter
+  def like_operator
+    case @model_class.connection.adapter_name.downcase
+    when 'postgresql', 'postgres'
+      'ILIKE'
+    when 'mysql', 'mysql2'
+      'LIKE'
+    when 'sqlite', 'sqlite3'
+      'LIKE'
+    else
+      'LIKE' # Default to LIKE for unknown adapters
+    end
+  end
+
+  # Returns a list of sensitive field names that should not be sortable
+  def sensitive_fields
+    %w[
+      password password_digest encrypted_password
+      token secret_key api_key
+      encrypted_data encrypted_attributes
+      salt iv
+      created_at updated_at
+    ]
+  end
+
+end

data/lib/generators/propel_api/templates/lib/propel_filter_operators.rb

@@ -0,0 +1,16 @@
+module PropelFilterOperators
+  def self.operators_for(type, sql_type = nil)
+    case type
+    when :string, :text
+      %w[eq contains starts_with ends_with in]
+    when :integer, :float, :decimal
+      %w[eq gt lt gte lte min max range in]
+    when :boolean
+      %w[eq null]
+    when :datetime, :date
+      %w[before after date year month day]
+    else
+      sql_type == "jsonb" ? %w[eq contains starts_with ends_with gt lt null in range before after] : []
+    end
+  end
+end

data/lib/generators/propel_api/templates/scaffold/facet_model_template.rb.tt

@@ -117,6 +117,20 @@ json_facet :short, fields: [:id<%
     # Always exclude if the field contains security-sensitive words
     security_patterns = /\A(password|password_digest|password_confirmation|digest|token|secret|key|salt|encrypted|confirmation|unlock|reset|api_key|access_token|refresh_token)\z|.*(_digest|_token|_secret|_key|_salt|_encrypted)$/i
     
+    # Include all boolean fields except specific ones that shouldn't be in short facet
+    if attr.type == :boolean
+      excluded_boolean_fields = %w[internal_flag system_generated admin_only debug_mode test_mode]
+      next false if excluded_boolean_fields.include?(attr.name.to_s)
+      next attr
+    end
+    
+    # Include all datetime fields except specific ones that shouldn't be in short facet
+    if [:datetime, :date, :time].include?(attr.type)
+      excluded_datetime_fields = %w[confirmed_at]
+      next false if excluded_datetime_fields.include?(attr.name.to_s)
+      next attr
+    end
+    
     identifying_fields.include?(attr.name.to_s) || 
     (simple_types.include?(attr.type) && 
      attr.name.to_s !~ excluded_patterns && 

data/lib/generators/propel_api/templates/seeds/seeds_template.rb.tt

@@ -193,9 +193,60 @@ end
 <% unless (has_organization_reference? && reference.name == 'organization') || (has_agency_reference? && reference.name == 'agency') -%>
 <% if reference.name.to_s.match?(/user/) -%>
   <%= singular_table_name %>_attributes[:<%= reference.name %>] = user
+<% elsif reference.name.to_s.match?(/agent/) -%>
+<% if has_organization_reference? -%>
+  # Find or create agent for the user within the same organization/agency
+  agent = Agent.find_by(user: user, organization: organization, agency: agency)
+  unless agent
+    agent = Agent.create!(user: user, organization: organization, agency: agency, role: 'member')
+  end
+  <%= singular_table_name %>_attributes[:<%= reference.name %>] = agent
+<% else -%>
+  # Find or create agent for the user (no tenancy)
+  agent = Agent.find_by(user: user) || Agent.create!(user: user, agency: agencies.sample, organization: organizations.sample, role: 'member')
+  <%= singular_table_name %>_attributes[:<%= reference.name %>] = agent
+<% end -%>
+<% elsif reference.name.to_s.include?('parent') -%>
+  # Handle parent relationships (often self-referential)
+  <% parent_class_name = reference.name.to_s.gsub(/parent$/, '').camelize -%>
+  <% if parent_class_name.blank? -%>
+    <% parent_class_name = class_name -%>
+  <% end -%>
+  # Self-referential or parent relationship: skip to avoid circular dependencies in initial seeding
+  # This will be handled in a second pass after main records are created
+  # <%= singular_table_name %>_attributes[:<%= reference.name %>] = nil
+<% elsif reference.name.to_s.match?(/meeting/) -%>
+  # Handle meeting references - find existing meetings from the same organization/agency
+<% if has_organization_reference? -%>
+  available_meetings = Meeting.where(organization: organization).limit(10).to_a
+<% else -%>
+  available_meetings = Meeting.limit(10).to_a
+<% end -%>
+  <%= singular_table_name %>_attributes[:<%= reference.name %>] = available_meetings.sample if available_meetings.any?
+<% else -%>
+  # Handle other reference types with generic logic
+  <% reference_class_name = reference.name.to_s.classify -%>
+  begin
+    # Try to find existing records of the reference type, preferably from the same organization
+<% if has_organization_reference? -%>
+    if defined?(<%= reference_class_name %>) && <%= reference_class_name %>.respond_to?(:where)
+      if <%= reference_class_name %>.column_names.include?('organization_id')
+        available_<%= reference.name.pluralize %> = <%= reference_class_name %>.where(organization: organization).limit(10).to_a
+      else
+        available_<%= reference.name.pluralize %> = <%= reference_class_name %>.limit(10).to_a
+      end
+      <%= singular_table_name %>_attributes[:<%= reference.name %>] = available_<%= reference.name.pluralize %>.sample if available_<%= reference.name.pluralize %>.any?
+    end
 <% else -%>
-  # Handle other reference types - you may need to customize this
-  # <%= singular_table_name %>_attributes[:<%= reference.name %>] = # TODO: Assign appropriate value
+    if defined?(<%= reference_class_name %>) && <%= reference_class_name %>.respond_to?(:where)
+      available_<%= reference.name.pluralize %> = <%= reference_class_name %>.limit(10).to_a
+      <%= singular_table_name %>_attributes[:<%= reference.name %>] = available_<%= reference.name.pluralize %>.sample if available_<%= reference.name.pluralize %>.any?
+    end
+<% end -%>
+  rescue => e
+    # Skip unknown reference types to avoid breaking seeds
+    puts "⚠️  Skipped unknown reference '<%= reference.name %>': #{e.message}" if Rails.env.development?
+  end
 <% end -%>
 <% end -%>
 <% end -%>
@@ -367,9 +418,39 @@ organizations.each do |org|
 <% unless reference.name == 'organization' || reference.name == 'agency' -%>
 <% if reference.name.to_s.match?(/user/) -%>
   minimal_<%= singular_table_name %>[:<%= reference.name %>] = user
+<% elsif reference.name.to_s.match?(/agent/) -%>
+<% if has_organization_reference? -%>
+  # Find or create agent for the user within the same organization/agency
+  agent = Agent.find_by(user: user, organization: org, agency: agency)
+  unless agent
+    agent = Agent.create!(user: user, organization: org, agency: agency, role: 'member')
+  end
+  minimal_<%= singular_table_name %>[:<%= reference.name %>] = agent
 <% else -%>
-  # Handle other reference types as needed
-  # minimal_<%= singular_table_name %>[:<%= reference.name %>] = # TODO: Assign appropriate value
+  # Find or create agent for the user (no tenancy)
+  agent = Agent.find_by(user: user) || Agent.create!(user: user, agency: agencies.sample, organization: organizations.sample, role: 'member')
+  minimal_<%= singular_table_name %>[:<%= reference.name %>] = agent
+<% end -%>
+<% else -%>
+  # Handle other reference types with generic logic (test scenario minimal case)
+  <% reference_class_name = reference.name.to_s.classify -%>
+  begin
+    if defined?(<%= reference_class_name %>) && <%= reference_class_name %>.respond_to?(:where)
+<% if has_organization_reference? -%>
+      if <%= reference_class_name %>.column_names.include?('organization_id')
+        available_<%= reference.name.pluralize %> = <%= reference_class_name %>.where(organization: org).limit(5).to_a
+      else
+        available_<%= reference.name.pluralize %> = <%= reference_class_name %>.limit(5).to_a
+      end
+<% else -%>
+      available_<%= reference.name.pluralize %> = <%= reference_class_name %>.limit(5).to_a
+<% end -%>
+      minimal_<%= singular_table_name %>[:<%= reference.name %>] = available_<%= reference.name.pluralize %>.sample if available_<%= reference.name.pluralize %>.any?
+    end
+  rescue => e
+    # Skip unknown reference types in minimal test scenarios
+    puts "⚠️  Skipped minimal reference '<%= reference.name %>': #{e.message}" if Rails.env.development?
+  end
 <% end -%>
 <% end -%>
 <% end -%>
@@ -443,9 +524,22 @@ end
 <% attributes.select { |attr| attr.type == :references && !(attr.respond_to?(:polymorphic?) && attr.polymorphic?) }.each do |reference| -%>
 <% if reference.name.to_s.match?(/user/) -%>
   minimal_<%= singular_table_name %>[:<%= reference.name %>] = users.sample if users.any?
+<% elsif reference.name.to_s.match?(/agent/) -%>
+  # Find or create agent for the user (simple case for minimal scenario)
+  agent = Agent.find_by(user: users.sample) || Agent.create!(user: users.sample, agency: agencies.sample, organization: organizations.sample, role: 'member')
+  minimal_<%= singular_table_name %>[:<%= reference.name %>] = agent
 <% else -%>
-  # Handle other reference types as needed
-  # minimal_<%= singular_table_name %>[:<%= reference.name %>] = # TODO: Assign appropriate value
+  # Handle other reference types with generic logic (minimal scenario)
+  <% reference_class_name = reference.name.to_s.classify -%>
+  begin
+    if defined?(<%= reference_class_name %>) && <%= reference_class_name %>.respond_to?(:where)
+      available_<%= reference.name.pluralize %> = <%= reference_class_name %>.limit(5).to_a
+      minimal_<%= singular_table_name %>[:<%= reference.name %>] = available_<%= reference.name.pluralize %>.sample if available_<%= reference.name.pluralize %>.any?
+    end
+  rescue => e
+    # Skip unknown reference types in minimal scenarios
+    puts "⚠️  Skipped minimal reference '<%= reference.name %>': #{e.message}" if Rails.env.development?
+  end
 <% end -%>
 <% end -%>
   

data/lib/generators/propel_api/templates/tests/controller_test_template.rb.tt

@@ -42,6 +42,8 @@ class <%= controller_class_name_with_namespace %>ControllerTest < ActionDispatch
     @<%= singular_table_name %> = <%= table_name %>(:john_user)
 <% elsif singular_table_name == 'agency' -%>
     @<%= singular_table_name %> = <%= table_name %>(:marketing_agency)
+<% elsif singular_table_name == 'agent' -%>
+    @<%= singular_table_name %> = <%= table_name %>(:john_marketing_agent)
 <% else -%>
     @<%= singular_table_name %> = <%= table_name %>(:one)
 <% end -%>
@@ -681,6 +683,13 @@ class <%= controller_class_name_with_namespace %>ControllerTest < ActionDispatch
     excluded_patterns = /\A(description|content|body|notes|comment|bio|about|summary|created_at|updated_at|deleted_at|password|digest|token|secret|key|salt|encrypted|confirmation|unlock|reset|api_key|access_token|refresh_token)\z/i
     security_patterns = /(password|digest|token|secret|key|salt|encrypted|confirmation|unlock|reset|api_key)/i
     
+    # Include all boolean fields except specific ones that shouldn't be in short facet
+    if attr.type == :boolean
+      excluded_boolean_fields = %w[internal_flag system_generated admin_only debug_mode test_mode]
+      next false if excluded_boolean_fields.include?(attr.name.to_s)
+      next attr
+    end
+    
     identifying_fields.include?(attr.name.to_s) || 
     (simple_types.include?(attr.type) && 
      attr.name.to_s !~ excluded_patterns &&