paginator.rb

# frozen_string_literal: true

require "faraday"
require_relative "http"
require_relative "response"

module Seam
  THREAD_CONTEXT_KEY = :seam_pagination_context
  PaginationContext = Struct.new(:body, :path)

  class Paginator
    def initialize(request, params = {})
      raise ArgumentError, "request must be a Method" unless request.is_a?(Method)
      raise ArgumentError, "params must be a Hash" unless params.is_a?(Hash)
      unless request.parameters.any? { |_, name| name == :page_cursor }
        raise ArgumentError, "request does not support pagination"
      end

      @request = request
      @params = params.transform_keys(&:to_sym)
    end

    def first_page
      fetch_page(@params)
    end

    def next_page(next_page_cursor)
      if next_page_cursor.nil? || next_page_cursor.empty?
        raise ArgumentError,
          "Cannot get the next page with a nil or empty next_page_cursor."
      end

      fetch_page(@params.merge(page_cursor: next_page_cursor))
    end

    def flatten_to_list
      all_items = []
      current_items, pagination = first_page

      all_items.concat(current_items) if current_items

      while pagination&.has_next_page? && (cursor = pagination.next_page_cursor)
        current_items, pagination = next_page(cursor)
        all_items.concat(current_items) if current_items
      end

      all_items
    end

    def flatten
      Enumerator.new do |yielder|
        current_items, pagination = first_page
        current_items&.each { |item| yielder << item }

        while pagination&.has_next_page? && (cursor = pagination.next_page_cursor)
          current_items, pagination = next_page(cursor)
          current_items&.each { |item| yielder << item }
        end
      end
    end

    private

    def fetch_page(params)
      context = PaginationContext.new(nil, nil)
      Thread.current[THREAD_CONTEXT_KEY] = context

      begin
        res_data = @request.call(**params)
        pagination_result = Pagination.from_hash(Http::Response.read_pagination(context.body, context.path))
        [res_data, pagination_result]
      ensure
        Thread.current[THREAD_CONTEXT_KEY] = nil
      end
    end
  end

  Pagination = Struct.new(:has_next_page, :next_page_cursor, :next_page_url) do
    def self.from_hash(hash)
      return nil unless hash.is_a?(Hash) && !hash.empty?

      new(
        has_next_page: hash.fetch("has_next_page", false),
        next_page_cursor: hash.fetch("next_page_cursor", nil),
        next_page_url: hash.fetch("next_page_url", nil)
      )
    end

    def has_next_page?
      has_next_page == true
    end
  end

  class PaginationMiddleware < Faraday::Middleware
    def on_complete(env)
      context = Thread.current[THREAD_CONTEXT_KEY]
      return unless context.is_a?(PaginationContext)

      context.body = env[:body]
      context.path = env.url.path
    end
  end
end