Function bodies 314 total

    def normalize_collection_association_reference(attribute_name)
      :"#{attribute_name.to_s.delete_suffix(PLURAL_IDS)}s"
    end

    def id_for_collection_association?(attribute_name)
      api_attribute_names.exclude?(attribute_name) && attribute_name.to_s.end_with?(PLURAL_IDS) # && api_attribute_names.include?(it_without_id_suffix)
    end

    def normalize_resource_association_reference(attribute_name)
      attribute_name.to_s.delete_suffix(SINGULAR_ID).to_sym
    end

    def id_for_resource_association?(attribute_name)
      api_attribute_names.exclude?(attribute_name) && attribute_name.to_s.end_with?(SINGULAR_ID) # && api_attribute_names.include?(it_without_id_suffix)
    end

  class NullTransformer < AbstractTransformer
    def execute
      nil
    end
  end

    def execute
      nil
    end

  class ValueObjectFactory
    class << self
      attr_reader :attribute_map_registry, :value_object_attributes

      def set_attribute_map_registry(registry)
        @attribute_map_registry = registry
        @value_object_attributes ||= {}
      end

      def model_attributes_containing_value_objects(*attributes, model_class:)
        @value_object_attributes ||= {}
        @value_object_attributes[model_class] = attributes
      end
    end

      def set_attribute_map_registry(registry)
        @attribute_map_registry = registry
        @value_object_attributes ||= {}
      end

      def model_attributes_containing_value_objects(*attributes, model_class:)
        @value_object_attributes ||= {}
        @value_object_attributes[model_class] = attributes
      end

    def create_object(model:, optional_attributes: nil)
      return nil if model.blank?

      options = attribute_map_options_cache.compute_if_absent(optional_attributes) { { optional_attributes: } }
      attribute_map = attribute_map(model.class, model, options)
      attribute_map.api_type.new(attribute_map.attributes)

    rescue Dry::Struct::Error => e
      model_id = model.respond_to?(:id) ? "(id #{model.id})" : ''
      raise PackAPI::InternalError, "Unable to convert #{model.class.name} #{model_id} to value object (#{e.message})"
    end

    def create_collection(models:, optional_attributes: nil)
      return [] if models.blank?

      models.filter_map { |model| create_object(model:, optional_attributes:) }
    end

    def create_errors(model:)
      attribute_map(model.class, model.errors).attributes
    end

    def attribute_map(klass, data_source, options = nil)
      attribute_map_cache.compute_if_absent(klass) { create_attribute_map(klass) }.tap do |map|
        map.data_source = data_source
        map.options = options
      end

    def convert(value, optional_attributes: nil)
      value_is_collection?(value) ?
        create_collection(models: value.to_a, optional_attributes:) :
        create_object(model: value, optional_attributes:)
    end

    def value_is_collection?(value)
      value.is_a?(ActiveRecord::Associations::CollectionProxy) || value.is_a?(Array)
    end

    def create_attribute_map(model_class)
      attribute_map_class = self.class.attribute_map_registry.new.attribute_map_class(model_class)
      convert_proc = method(:convert).to_proc
      attribute_map_class.new.tap do |attribute_map|
        self.class.value_object_attributes.fetch(model_class, []).each do |attribute|
          attribute_map.register_transformation_from_model_attribute(attribute, convert_proc)
        end

    def attribute_map_cache
      object_cache.compute_if_absent(:attribute_maps) { Concurrent::Map.new }
    end

    def object_cache
      @object_cache ||= Concurrent::Map.new
    end

    def attribute_map_options_cache
      object_cache.compute_if_absent(:attribute_map_options) { Concurrent::Map.new }
    end

  class OpaqueTokenV2
    def self.create(unencoded)
      Base64.strict_encode64(Brotli.deflate(unencoded.to_json))
    end

    def self.parse(encoded)
      raise JSON::ParserError if encoded.nil?

      decoded = Base64.strict_decode64(encoded)
      decompressed = Brotli.inflate(decoded)
      JSON.parse(decompressed, symbolize_names: true)
    end
  end

    def self.create(unencoded)
      Base64.strict_encode64(Brotli.deflate(unencoded.to_json))
    end

    def self.parse(encoded)
      raise JSON::ParserError if encoded.nil?

      decoded = Base64.strict_decode64(encoded)
      decompressed = Brotli.inflate(decoded)
      JSON.parse(decompressed, symbolize_names: true)
    end

  class PaginatorBuilder
    DEFAULT_SORT = 'id asc'

    attr_accessor :paginator

    def self.build
      builder = new
      yield(builder)
      builder.paginator
    end

    def initialize
      @paginator = Paginator.new
    end

    def set_cursor(cursor:, per_page: nil, sort: nil)
      cursor_params = PaginatorCursor.parse(cursor)
      effective_per_page = per_page.presence || cursor_params[:per_page]
      effective_per_page = :all if effective_per_page.to_s == 'all'

      @paginator.query = cursor_params[:query]
      @paginator.total_items = cursor_params[:total_items]
      @paginator.per_page = effective_per_page
      @paginator.sort = sort.presence || cursor_params[:sort]
      @paginator.offset = effective_offset(cursor_params, sort)
      @paginator.metadata = cursor_params[:metadata]
    end

    ###
    # @param [Proc<Hash>|Hash] query The query parameters used to define the recordset.
    # @param [String|Symbol|Hash|Arel] sort The ordering used to define the r

    def self.build
      builder = new
      yield(builder)
      builder.paginator
    end

    def initialize
      @paginator = Paginator.new
    end

    def set_cursor(cursor:, per_page: nil, sort: nil)
      cursor_params = PaginatorCursor.parse(cursor)
      effective_per_page = per_page.presence || cursor_params[:per_page]
      effective_per_page = :all if effective_per_page.to_s == 'all'

      @paginator.query = cursor_params[:query]
      @paginator.total_items = cursor_params[:total_items]
      @paginator.per_page = effective_per_page
      @paginator.sort = sort.presence || cursor_params[:sort]
      @paginator.offset = effective_offset(cursor_params, sort)
      @paginator.metadata = cursor_params[:metadata]
    end

    def set_params(query: nil, sort: nil, total_items: nil, per_page: nil, offset: nil, metadata: nil)
      @paginator.query ||= {}
      if query.present?
        original_query = @paginator.query
        @paginator.query = @paginator.query.deep_merge(resolve_query_params(query).deep_symbolize_keys)
        @recordset_changed = original_query.to_json != @paginator.query.to_json
      end

    def effective_offset(cursor_params, sort)
      sort_changed = sort.to_json != cursor_params[:sort].to_json
      sort_override = sort.present? && sort_changed
      sort_override ?
        0 :
        cursor_params[:offset]
    end

    def resolve_query_params(query)
      query.is_a?(Proc) ?
        query.call :
        query
    end

  class PaginatorCursor
    MAX_LENGTH = 2048
    CACHE_KEY_PREFIX = 'paginator_cursor'
    CACHE_EXPIRES_IN = 8.hours

    class << self
      def create(query:, sort:, total_items:, offset:, per_page:, metadata: nil)
        sort_ready_to_serialize = SqlLiteralSerializer.serialize(sort)
        cursor_params = { query:, sort: sort_ready_to_serialize, total_items:, offset:, per_page:, metadata: }
        token = OpaqueTokenV2.create(cursor_params)
        return token if token.size <= MAX_LENGTH

        cache_key = generate_cache_key
        Rails.cache.write(cache_key, cursor_params, expires_in: CACHE_EXPIRES_IN)
        OpaqueTokenV2.create(cache_key)
      end

      def parse(encoded)
        decoded = parse_opaque_token(encoded)
        decoded = decode_cache_key(decoded) if decoded.is_a?(String)
        decoded[:sort] = deserialize_sort_args(decoded)
        decoded
      end

      private

      def parse_opaque_token(encoded)
        OpaqueTokenV2.parse(encoded)
      rescue

      def create(query:, sort:, total_items:, offset:, per_page:, metadata: nil)
        sort_ready_to_serialize = SqlLiteralSerializer.serialize(sort)
        cursor_params = { query:, sort: sort_ready_to_serialize, total_items:, offset:, per_page:, metadata: }
        token = OpaqueTokenV2.create(cursor_params)
        return token if token.size <= MAX_LENGTH

        cache_key = generate_cache_key
        Rails.cache.write(cache_key, cursor_params, expires_in: CACHE_EXPIRES_IN)
        OpaqueTokenV2.create(cache_key)
      end

      def parse(encoded)
        decoded = parse_opaque_token(encoded)
        decoded = decode_cache_key(decoded) if decoded.is_a?(String)
        decoded[:sort] = deserialize_sort_args(decoded)
        decoded
      end

      def parse_opaque_token(encoded)
        OpaqueTokenV2.parse(encoded)
      rescue ArgumentError, Brotli::Error, JSON::ParserError => e
        raise_error(e.message)
      end

      def raise_error(message)
        raise(PackAPI::InternalError, "un-parsable paginator cursor: #{message}")
      end

      def decode_cache_key(cache_key)
        data = Rails.cache.read(cache_key)
        raise(PackAPI::InternalError, "no data found in cache for key #{cache_key}") if data.nil?

        data
      end

      def generate_cache_key
        "#{CACHE_KEY_PREFIX}:#{SecureRandom.uuid}"
      end

      def deserialize_sort_args(cursor)
        SqlLiteralSerializer.deserialize(cursor[:sort])
      rescue TypeError => e
        raise_error(e.message)
      end

      class SqlLiteralSerializer
        def self.serialize(args)
          return { sql_literal: { raw_sql: args.to_s } } if args.is_a?(Arel::Nodes::SqlLiteral)
          return args unless args.is_a?(Hash)

          args.map.with_index do |entry, index|
            next entry unless entry[0].is_a?(Arel::Nodes::SqlLiteral)

            ["sql_literal_#{index + 1}", { raw_sql: entry[0].to_s, hash_value: entry[1] }]
          end.to_h
        end

        def self.serialize(args)
          return { sql_literal: { raw_sql: args.to_s } } if args.is_a?(Arel::Nodes::SqlLiteral)
          return args unless args.is_a?(Hash)

          args.map.with_index do |entry, index|
            next entry unless entry[0].is_a?(Arel::Nodes::SqlLiteral)

            ["sql_literal_#{index + 1}", { raw_sql: entry[0].to_s, hash_value: entry[1] }]
          end.to_h

        def self.deserialize(args)
          return args unless args.is_a?(Hash)
          return Arel.sql(args[:sql_literal][:raw_sql]) if args.key?(:sql_literal)

          args.to_h do |key, value|
            next [key, value] unless key.start_with?('sql_literal_')

            [Arel.sql(value[:raw_sql]), value[:hash_value]]
          end

  class Paginator
    ###
    # @param [Hash] query The query parameters used to define the recordset.
    # @param [String|Symbol|Hash|Arel] sort The ordering used to define the recordset
    # @param [Integer|:all] per_page The count of items to include on each result page, or :all for single page results
    # @param [Integer] offset The starting index of the next result page
    # @param [Integer] total_items The count of items in the result set
    # @param [Any|nil] metadata optional, extra data structure to be passed along with the cursor
    attr_accessor :query, :sort, :total_items, :per_page, :offset, :metadata

    DEFAULT_PER_PAGE = 20

    ###
    # The range of items included in the results.
    def item_range
      return 0..0 if per_page != :all && per_page.zero?

      lower_bound = offset + 1
      upper_bound = per_page == :all ?
                      total_items :
                      [(offset + per_page), total_items].min
      lower_bound..upper_bound
    end

  

    def item_range
      return 0..0 if per_page != :all && per_page.zero?

      lower_bound = offset + 1
      upper_bound = per_page == :all ?
                      total_items :
                      [(offset + per_page), total_items].min
      lower_bound..upper_bound
    end

    def recordset_cursor
      make_cursor(recordset_cursor_params)
    end

    def current_page_cursor
      make_cursor(current_page_cursor_params)
    end

    def next_page_cursor
      make_cursor(next_page_params)
    end

    def previous_page_cursor
      make_cursor(previous_page_params)
    end

    def first_page_cursor
      make_cursor(first_page_params)
    end

    def last_page_cursor
      make_cursor(last_page_params)
    end

    def limit
      return nil if per_page == :all

      per_page
    end

    def more_pages?
      return false if per_page == :all || per_page.zero?

      offset + per_page < total_items
    end