Function bodies 314 total

    def from_api_type
      filterable_attributes.each do |attribute_name, attribute_type|
        yield define_filter(attribute_name, attribute_type)
      end

    def filterable_attributes
      @filterable_attributes ||= attribute_map_class.api_type.filterable_attributes
    end

    def model_attribute_names
      return @model_attribute_names if defined?(@model_attribute_names)

      names = {}
      filterable_attributes.each_key { |name| names[name] = name }
      @model_attribute_names = attribute_map_class.model_attribute_keys(names).invert
    end

    def data_type(attribute_type)
      return 'Bool' if attribute_type.name.end_with?('TrueClass | FalseClass')

      attribute_type.name.include?(' | ') ?
        attribute_type.name[DATA_TYPE_REGEXP] :
        attribute_type.name
    end

    def define_filter(attribute_name, attribute_type)
      filter_name = model_attribute_names[attribute_name]
      data_type = data_type(attribute_type)
      self.class
          .attribute_filter_cache
          .compute_if_absent(filter_name) { Concurrent::Map.new }
          .compute_if_absent(data_type) do
        Class.new(AttributeFilter) do
          define_singleton_method(:filter_name) { filter_name }
          define_singleton_method(:data_type) { data_type }
        end

  class AttributeFilter < DiscoverableFilter
    attr_accessor :value

    def self.type
      :attribute
    end

    def self.data_type
      raise NotImplementedError
    end

    def self.definition(**)
      PackAPI::Types::SimpleFilterDefinition.new(name: filter_name, data_type:)
    end

    def initialize(value)
      super()
      @value = value
    end

    def present?
      !value.nil?
    end

    def to_h
      { filter_name => value }
    end

    def apply_to(query)
      query.add(query.build.where(to_h))
    end
  end

    def self.type
      :attribute
    end

    def self.data_type
      raise NotImplementedError
    end

    def self.definition(**)
      PackAPI::Types::SimpleFilterDefinition.new(name: filter_name, data_type:)
    end

    def initialize(value)
      super()
      @value = value
    end

    def present?
      !value.nil?
    end

    def to_h
      { filter_name => value }
    end

    def apply_to(query)
      query.add(query.build.where(to_h))
    end

  class CollectionQuery
    attr_accessor :collection, :collection_key, :filter_factory, :default_sort, :paginator, :sort, :results

    ###
    # Create the query object.
    #
    # @ param [ActiveRecord::Relation] collection The collection to query
    # @ param [Object] value_object_factory The factory to use to convert model objects to value objects
    # @ param [String|Symbol|Hash|Arel] default_sort The default sort to use if none is specified in the query
    # @ param [String|Symbol] collection_key Unique and indexed key to use for the collection.
    #  Used for tie-breaker sort criteria and drives the record id lookup when in record iteration mode.
    def initialize(collection:, collection_key: nil, default_sort: nil)
      @collection = collection
      @collection_key = (collection_key || collection.primary_key).to_sym
      @default_sort = default_sort
      @filter_factory = FilterFactory.new
      @filter_factory.use_default_filter = true
    end

    ###
    # Perform

    def initialize(collection:, collection_key: nil, default_sort: nil)
      @collection = collection
      @collection_key = (collection_key || collection.primary_key).to_sym
      @default_sort = default_sort
      @filter_factory = FilterFactory.new
      @filter_factory.use_default_filter = true
    end

    def call(cursor: nil, per_page: nil, sort: nil, search: nil, filters: {})
      record_id = filters.delete(collection_key) if cursor.present? && filters[collection_key].present?
      build_paginator(cursor, filters, per_page, search, sort)
      build_active_record_query(record_id)
    end

    def to_sql
      @query.to_sql
    end

    def reset
      @results = nil
      @query = nil
      @paginator = nil
      @sort = nil
      @current_page_snapshot_cursor = nil
    end

    def current_page_snapshot_cursor
      @current_page_snapshot_cursor ||= PackAPI::Pagination::SnapshotPaginator.cursor_for_results(results,
                                                                                                  table_name: collection.klass.table_name,
                                                                                                  collection_key:)
    end

    def build_active_record_query(record_id)
      @query = collection
      if paginator.query&.fetch(:search, nil).present?
        apply_search(search: paginator.query[:search])
      end

    def build_paginator(cursor, filters, per_page, search, sort)
      @paginator = PackAPI::Pagination::PaginatorBuilder.build do |builder|
        cursor.present? ?
          builder.set_cursor(cursor:) :
          builder.set_params(sort: stable_sort(default_sort)) # set a default sort for a new query

        builder.set_params(sort: stable_sort(sort.presence)) if sort.present?
        builder.set_params(query: { filters: }) if filters.present?
        builder.set_params(query: { search: }) if search.present?
        builder.set_params(per_page:) if per_page.present?
      end

    def apply_search(search:)
      search.keys.each_with_index do |column, index|
        value = search[column]
        @query = index.positive? ?
                   @query.or(collection.where("LOWER(#{column}) LIKE LOWER(?)", "%#{value}%")) :
                   @query.where("LOWER(#{column}) LIKE LOWER(?)", "%#{value}%")
      end

    def apply_filters(filters:)
      filter_objects = filter_factory.create_filters(filters)
      validate_filters(filter_objects)
      filtered_query = filter_objects.each_with_object(ComposableQuery.new(@query)) do |filter, composable_query|
        filter.apply_to(composable_query)
      end

    def validate_filters(filter_objects)
      errors = filter_objects.select { |filter| filter.respond_to?(:valid?) && !filter.valid? }
                             .map { |invalid_filter| { invalid_filter.filter_name => invalid_filter.errors.messages } }
                             .reduce({}, :merge)
      raise PackAPI::InternalError.new(object: errors) if errors.present?
    end

    def stable_sort(sort)
      return sort if sort.is_a?(Arel::Nodes::SqlLiteral)

      SortHash.new(sort).tap do |sort_hash|
        sort_hash[collection_key] = :asc unless sort_hash.key?(collection_key)
      end

  class ComposableQuery
    attr_reader :composer

    def initialize(initial_query, composer: :merge)
      @query = initial_query
      @composer = composer
    end

    def add(query_clause)
      @query = @query.send(composer, query_clause)
      self
    end

    def build
      @query
    end

    def to_sql
      @query.to_sql
    end
  end

    def initialize(initial_query, composer: :merge)
      @query = initial_query
      @composer = composer
    end

    def add(query_clause)
      @query = @query.send(composer, query_clause)
      self
    end

    def build
      @query
    end

    def to_sql
      @query.to_sql
    end

  class DefaultFilter < AbstractFilter
    attr_accessor :arguments

    def initialize(arguments)
      super()
      @arguments = arguments
    end

    def present?
      arguments.present?
    end

    def apply_to(query)
      query.add(query.build.where(arguments))
    end
  end

    def initialize(arguments)
      super()
      @arguments = arguments
    end

    def present?
      arguments.present?
    end

    def apply_to(query)
      query.add(query.build.where(arguments))
    end

  class DiscoverableFilter < AbstractFilter
    include ActiveModel::Validations

    def filter_name
      self.class.filter_name
    end

    def self.filter_name
      raise NotImplementedError
    end

    def type
      self.class.type
    end

    def self.type
      raise NotImplementedError
    end

    def to_h
      raise NotImplementedError
    end

    def self.definition(**)
      raise NotImplementedError
    end
  end

    def filter_name
      self.class.filter_name
    end

    def self.filter_name
      raise NotImplementedError
    end

    def type
      self.class.type
    end

    def self.type
      raise NotImplementedError
    end

    def to_h
      raise NotImplementedError
    end

    def self.definition(**)
      raise NotImplementedError
    end

      def type = :dynamic_enum

      ###
      # Retrieve options for this filter based on user input.
      # @param relation [ActiveRecord::Relation] The base relation to query against for options.
      # @param search [String, nil] An optional search term to filter options by (using wildcard matching)
      # @param value [String, Array<String>, nil] An optional value or array of values to filter options by (exact match)
      def dynamic_options(relation:, search: nil, value: nil) = raise NotImplementedError

      private

      ###
      # Static filter options is an empty array.
      def filter_options(**) = PackAPI::FrozenEmpty::ARRAY
    end
  end
end

      def dynamic_options(relation:, search: nil, value: nil) = raise NotImplementedError

      private

      ###
      # Static filter options is an empty array.
      def filter_options(**) = PackAPI::FrozenEmpty::ARRAY
    end
  end

  class FilterFactory
    attr_accessor :filter_classes, :use_default_filter

    def initialize
      @filter_classes = Hash.new { |_hash, key| raise NotImplementedError, "Unsupported filter #{key}" }
    end

    def register_filter(name:, klass:)
      filter_classes[name] = klass
    end

    def create_filters(filter_hash)
      filter_objects(filter_hash).select(&:present?)
    end

    private

    def filter_objects(filter_options)
      if filter_options.is_a?(Hash)
        filter_objects_from_hash(filter_options)
      elsif use_default_filter
        [DefaultFilter.new(filter_options)]
      else
        raise ArgumentError, "Unsupported filter configuration: #{filter_options}"
      end

    end

    def initialize
      @filter_classes = Hash.new { |_hash, key| raise NotImplementedError, "Unsupported filter #{key}" }
    end

    def register_filter(name:, klass:)
      filter_classes[name] = klass
    end

    def create_filters(filter_hash)
      filter_objects(filter_hash).select(&:present?)
    end

    def filter_objects(filter_options)
      if filter_options.is_a?(Hash)
        filter_objects_from_hash(filter_options)
      elsif use_default_filter
        [DefaultFilter.new(filter_options)]
      else
        raise ArgumentError, "Unsupported filter configuration: #{filter_options}"
      end

    def filter_objects_from_hash(filter_options)
      filter_options.deep_symbolize_keys.map(&method(:filter_object_by_name))
    end

    def filter_object_by_name(filter_name, options)
      if filter_classes.key?(filter_name)
        registered_filter_object(filter_name, options)
      elsif use_default_filter
        DefaultFilter.new(filter_name => options)
      else
        raise NotImplementedError, "Unsupported filter: #{filter_name}"
      end