propel_api 0.3.1.6 → 0.3.3

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

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+# DynamicScopeGenerator
+# 
+# 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 = DynamicScopeGenerator.new(Team)
+#   generator.generate_scopes!
+#   generator.register_controller_scopes(MyController)
+#
+class DynamicScopeGenerator
+  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) { 
+        value.present? ? where("#{field_name} < ?", value) : all 
+      }
+    RUBY
+  end
+
+  def generate_after_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_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}: 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? && value.is_a?(Array) && value.size == 2
+          where("#{field_name} BETWEEN ? AND ?", value[0], value[1])
+        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) { 
+        value.present? ? where("EXTRACT(YEAR FROM #{field_name}) = ?", value) : all 
+      }
+    RUBY
+  end
+
+  def generate_month_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("EXTRACT(MONTH FROM #{field_name}) = ?", value) : all 
+      }
+    RUBY
+  end
+
+  def generate_day_scope(scope_name, field_name)
+    @model_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      scope :#{scope_name}, ->(value) { 
+        value.present? ? where("EXTRACT(DAY FROM #{field_name}) = ?", value) : all 
+      }
+    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