Function bodies 314 total

    def recordset_cursor_params
      cursor_params.deep_merge(offset: 0, per_page: :all, metadata: { kind: :recordset })
    end

    def current_page_cursor_params
      return nil if per_page != :all && per_page.zero?

      cursor_params.deep_merge(offset: offset, metadata: { kind: :current_page })
    end

    def next_page_params
      return nil unless more_pages?

      cursor_params.deep_merge(offset: offset + per_page, metadata: { kind: :next_page })
    end

    def previous_page_params
      return nil if offset.zero?

      cursor_params.deep_merge(offset: offset - per_page, metadata: { kind: :previous_page })
    end

    def first_page_params
      return nil if offset.zero?

      cursor_params.deep_merge(offset: 0, metadata: { kind: :first_page })
    end

    def last_page_params
      return nil unless more_pages?

      last_page_offset = (last_item_offset / per_page).floor * per_page
      cursor_params.deep_merge(offset: last_page_offset, metadata: { kind: :last_page })
    end

    def last_item_offset
      total_items - 1
    end

    def make_cursor(params)
      return nil if params.nil?

      PaginatorCursor.create(**params)
    end

    def cursor_params
      {
        offset:,
        sort:,
        total_items:,
        per_page:,
        query:,
        metadata:
      }
    end

  class SnapshotPaginator
    METADATA_KEY = :snapshot

    attr_accessor :paginator, :results, :cursor

    ###
    # Create a snapshot from the current page results of a record set.
    def self.cursor_for_results(results, table_name:, collection_key:)
      offsets = {}
      case_statement = results.map.with_index do |record, index|
        record_id = record.send(collection_key)
        offsets[record_id.to_s] = index.to_s
        # Use SQL standard CAST to convert both sides to strings for comparison
        "WHEN CAST(\"#{table_name}\".\"#{collection_key}\" AS VARCHAR) = '#{record_id}' THEN #{index}"
      end
      sort_sql = "CASE #{case_statement.join("\n")} END"
      filters = { collection_key => results.pluck(collection_key) }
      paginator = PaginatorBuilder.build do |builder|
        builder.set_params(query: { filters: },
                           metadata: { METADATA_KEY => true, offsets:, collection_key: },
                           sort: Arel.sql(sort_sql),
     

    def self.cursor_for_results(results, table_name:, collection_key:)
      offsets = {}
      case_statement = results.map.with_index do |record, index|
        record_id = record.send(collection_key)
        offsets[record_id.to_s] = index.to_s
        # Use SQL standard CAST to convert both sides to strings for comparison
        "WHEN CAST(\"#{table_name}\".\"#{collection_key}\" AS VARCHAR) = '#{record_id}' THEN #{index}"
      end

    def initialize(paginator)
      raise PackAPI::InternalError, 'Paginator does not represent CachedResultsQuery' if paginator.metadata.nil?

      @paginator = paginator
    end

    def apply_to(query, record_id: nil)
      if has_valid_offsets?
        # if no record_id is provided, no customization is needed
        return query unless record_id.present?

        self.target_record_id = record_id
        updated_query = query.offset(paginator.offset).limit(paginator.limit)
        @results = updated_query.to_a
        @cursor = paginator.current_page_cursor
        updated_query
      else
        # unless we have either a record_id or an offset, there is no customization needed
        return query unless paginator.offset.present? || record_id.present?

        # Step 1: If we don't have a record_id, try to guess what record_id the user was trying to access
        record_id ||= target_record_id

        # Step 2: Fetch all the records in the snapshot -- remove the offset and limits on the current query
        snapshot_results = query.unscope(:offset, :limit).to_a

        # Step 3: Update the offsets based on the current query results
        update_offse

    def self.generated?(paginator)
      paginator.metadata&.fetch(METADATA_KEY, nil).presence
    end

    def has_valid_offsets?
      paginator.metadata[:offsets].size == paginator.total_items
    end

    def update_offsets(results)
      paginator.metadata.merge!(offsets: results_offsets(results))
    end

    def target_record_id
      return unless paginator.offset

      paginator.metadata[:offsets].key(paginator.offset.to_s).to_s
    end

    def target_record_id=(record_id)
      paginator.offset = lookup_offset(record_id)
      paginator.per_page = 1
    end

    def results_offsets(results)
      collection_key = paginator.metadata[:collection_key]
      results.map.with_index do |record, index|
        record_id = record.send(collection_key)
        [record_id.to_s, index.to_s]
      end.to_h

    def lookup_offset(record_id)
      metadata = paginator.metadata[:offsets]
      return 0 unless metadata

      stringified_record_id = record_id.to_s
      # metadata can have symbol keys or string keys, depending on how the cursor was created.
      offset =  metadata.include?(stringified_record_id) ?
                  metadata[stringified_record_id] :
                  metadata[stringified_record_id.to_sym]
      offset.to_i
    end

  class AbstractBooleanFilter < DiscoverableFilter
    attr_accessor :value

    YES_VALUE = 'Yes'
    NO_VALUE = 'No'
    NOT_APPLICABLE_VALUE = ''

    def self.type
      :tri_state_boolean
    end

    def self.definition(**)
      options = [
        PackAPI::Types::FilterOption.new(label: 'N/A', value: NOT_APPLICABLE_VALUE),
        PackAPI::Types::FilterOption.new(label: 'Yes', value: YES_VALUE),
        PackAPI::Types::FilterOption.new(label: 'No', value: NO_VALUE)
      ]

      PackAPI::Types::BooleanFilterDefinition.new(name: filter_name, type:, options:)
    end

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

    delegate :present?, to: :value

    def to_h
      raise NotImplementedError unless self.class.filter_name

      { self.class.filter_name => { value: } }
    end
  end

    def self.type
      :tri_state_boolean
    end

    def self.definition(**)
      options = [
        PackAPI::Types::FilterOption.new(label: 'N/A', value: NOT_APPLICABLE_VALUE),
        PackAPI::Types::FilterOption.new(label: 'Yes', value: YES_VALUE),
        PackAPI::Types::FilterOption.new(label: 'No', value: NO_VALUE)
      ]

      PackAPI::Types::BooleanFilterDefinition.new(name: filter_name, type:, options:)
    end

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

    def to_h
      raise NotImplementedError unless self.class.filter_name

      { self.class.filter_name => { value: } }
    end

  class AbstractEnumFilter < DiscoverableFilter
    attr_accessor :value, :exclude_param
    validates :exclude_param, inclusion: { in: %w[true false], allow_nil: true, message: 'must be either true or false' }

    def self.type
      :enum
    end

    def self.definition(**)
      PackAPI::Types::EnumFilterDefinition.new(name: filter_name,
                                      type:,
                                      options: filter_options(**),
                                      can_exclude: can_exclude?)
    end

    def self.filter_options(**)
      raise NotImplementedError
    end

    private_class_method :filter_options

    def initialize(value: nil, exclude: nil)
      super()
      @present = !value.nil?
      @value = Array.wrap(value.presence)
      @exclude_param = exclude
    end

    def present?
      @present
    end

    def exclude?
      exclude_param.to_s.downcase == 'true'
    end

    def to_h
      raise NotImplementedError unless self.class.filter_nam

    def self.type
      :enum
    end

    def self.definition(**)
      PackAPI::Types::EnumFilterDefinition.new(name: filter_name,
                                      type:,
                                      options: filter_options(**),
                                      can_exclude: can_exclude?)
    end

    def self.filter_options(**)
      raise NotImplementedError
    end

    def initialize(value: nil, exclude: nil)
      super()
      @present = !value.nil?
      @value = Array.wrap(value.presence)
      @exclude_param = exclude
    end

    def present?
      @present
    end

    def exclude?
      exclude_param.to_s.downcase == 'true'
    end

    def to_h
      raise NotImplementedError unless self.class.filter_name

      payload = present? ?
                  { value: } :
                  { value: nil }
      payload[:exclude] = exclude?.to_s if self.class.can_exclude?
      { self.class.filter_name => payload }
    end

    def self.can_exclude?
      true
    end

  class AbstractFilter
    def present?
      false
    end

    ###
    # Applies the filter to the given query.
    # @param [ComposableQuery] query the active record relation to apply the filter to
    def apply_to(query)
    end
  end

    def present?
      false
    end

  class AbstractNumericFilter < DiscoverableFilter
    attr_accessor :operator, :value

    def self.type
      :numeric
    end

    def self.definition(**)
      operators = [
        PackAPI::Types::FilterOption.new(label: 'Greater than', value: '>'),
        PackAPI::Types::FilterOption.new(label: 'Greater than or equal to', value: '>='),
        PackAPI::Types::FilterOption.new(label: 'Equal to', value: '='),
        PackAPI::Types::FilterOption.new(label: 'Less than or equal to', value: '<='),
        PackAPI::Types::FilterOption.new(label: 'Less than', value: '<')
      ]

      PackAPI::Types::NumericFilterDefinition.new(name: filter_name, operators:)
    end

    def initialize(operator:, value:)
      super()
      @operator = operator
      @value = value
    end

    delegate :present?, to: :value

    def to_h
      raise NotImplementedError unless self.class.filter_name

      { self.class.filter_name => { operator:, value: } }
    end
  end

    def self.type
      :numeric
    end

    def self.definition(**)
      operators = [
        PackAPI::Types::FilterOption.new(label: 'Greater than', value: '>'),
        PackAPI::Types::FilterOption.new(label: 'Greater than or equal to', value: '>='),
        PackAPI::Types::FilterOption.new(label: 'Equal to', value: '='),
        PackAPI::Types::FilterOption.new(label: 'Less than or equal to', value: '<='),
        PackAPI::Types::FilterOption.new(label: 'Less than', value: '<')
      ]

      PackAPI::Types::NumericFilterDefinition.new(name: filter_name, operators:)
    end

    def initialize(operator:, value:)
      super()
      @operator = operator
      @value = value
    end

    def to_h
      raise NotImplementedError unless self.class.filter_name

      { self.class.filter_name => { operator:, value: } }
    end

  class AbstractRangeFilter < DiscoverableFilter
    attr_accessor :min_value, :max_value

    def self.type
      :range
    end

    def self.definition(**)
      PackAPI::Types::RangeFilterDefinition.new(name: filter_name)
    end

    def initialize(min_value:, max_value:)
      super()
      @min_value = min_value
      @max_value = max_value
    end

    def present?
      min_value.present? || max_value.present?
    end

    def to_h
      raise NotImplementedError unless self.class.filter_name

      { self.class.filter_name => { min_value:, max_value: } }
    end
  end

    def self.type
      :range
    end

    def self.definition(**)
      PackAPI::Types::RangeFilterDefinition.new(name: filter_name)
    end

    def initialize(min_value:, max_value:)
      super()
      @min_value = min_value
      @max_value = max_value
    end

    def present?
      min_value.present? || max_value.present?
    end

    def to_h
      raise NotImplementedError unless self.class.filter_name

      { self.class.filter_name => { min_value:, max_value: } }
    end

  class AttributeFilterFactory
    include Enumerable

    DATA_TYPE_REGEXP = /\S+$/
    private_constant :DATA_TYPE_REGEXP

    def self.attribute_filter_cache
      @attribute_filter_cache ||= Concurrent::Map.new
    end

    attr_reader :attribute_map_class

    def initialize(attribute_map_class)
      @attribute_map_class = attribute_map_class
    end

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

    def self.attribute_filter_cache
      @attribute_filter_cache ||= Concurrent::Map.new
    end

    def initialize(attribute_map_class)
      @attribute_map_class = attribute_map_class
    end