activeproject 0.3.0 → 0.5.0

data/lib/active_project/adapters/http_client.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "faraday/retry"
-require "json"
-
-module ActiveProject
-  module Adapters
-    module HttpClient
-      include Pagination
-      DEFAULT_HEADERS = {
-        "Content-Type" => "application/json",
-        "Accept"       => "application/json",
-        "User-Agent"   => -> { ActiveProject.user_agent }
-      }.freeze
-      RETRY_OPTS = { max: 5, interval: 0.5, backoff_factor: 2 }.freeze
-
-      def build_connection(base_url:, auth_middleware:, extra_headers: {})
-        @connection = Faraday.new(url: base_url) do |conn|
-          auth_middleware.call(conn)                 # <-- adapter-specific
-          conn.request  :retry, **RETRY_OPTS
-          conn.response :raise_error
-          default_adapter = ENV.fetch("AP_DEFAULT_ADAPTER", "net_http").to_sym
-          conn.adapter default_adapter
-          conn.headers.merge!(DEFAULT_HEADERS.transform_values { |v| v.respond_to?(:call) ? v.call : v })
-          conn.headers.merge!(extra_headers)
-          yield conn if block_given?                 # optional extra tweaks
-        end
-      end
-
-      def request(method, path, body: nil, query: nil, headers: {})
-        raise "HTTP connection not initialised" unless @connection
-
-        json_body = body.is_a?(String) ? body : (body ? JSON.generate(body) : nil)
-        response  = @connection.run_request(method, path, json_body, headers) do |req|
-          req.params.update(query) if query&.any?
-        end
-
-        return nil if response.status == 204 || response.body.to_s.empty?
-        JSON.parse(response.body)
-      rescue Faraday::Error => e
-        raise translate_faraday_error(e)
-      rescue JSON::ParserError => e
-        raise ActiveProject::ApiError.new("Non-JSON response from #{path}",
-                                          original_error: e,
-                                          status_code: response&.status,
-                                          response_body: response&.body)
-      end
-
-      private
-
-      def translate_faraday_error(err)
-        status = err.response_status
-        body   = err.response_body.to_s
-        msg    = begin JSON.parse(body)["message"] rescue body end
-
-        case status
-        when 401, 403 then ActiveProject::AuthenticationError.new(msg)
-        when 404      then ActiveProject::NotFoundError.new(msg)
-        when 429      then ActiveProject::RateLimitError.new(msg)
-        when 400, 422 then ActiveProject::ValidationError.new(msg, status_code: status, response_body: body)
-        else
-          ActiveProject::ApiError.new("HTTP #{status || 'N/A'}: #{msg}",
-                                      original_error: err,
-                                      status_code: status,
-                                      response_body: body)
-        end
-      end
-    end
-  end
-end

data/lib/active_project/adapters/pagination.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveProject
-  module Adapters
-    module Pagination
-      # RFC 5988 Link header parsing. Returns { "next" => url, "prev" => url, … }
-      def parse_link_header(link_header)
-        return {} unless link_header
-
-        link_header.split(",").each_with_object({}) do |part, acc|
-          url, rel = part.split(";")
-          next unless rel && url
-
-          url = url[/\<([^>]+)\>/, 1]  # strip angle brackets
-          rel = rel[/rel=\"?([^\";]+)\"?/, 1]
-          acc[rel] = url if url && rel
-        end
-      end
-
-      # Synchronous enumerator – works with any Faraday adapter.
-      #
-      # @param path   [String] first request path or full URL
-      # @param method [Symbol] :get or :post
-      # @param body   [Hash,String,nil]
-      # @param query  [Hash]
-      def each_page(path, method: :get, body: nil, query: {})
-        next_path = path
-        loop do
-          data, link_header = perform_page_request(method, next_path, body, query)
-          yield data
-          next_path = parse_link_header(link_header)["next"]
-          break unless next_path
-          # After the first hop the URL is absolute; zero-out body/query for GETs
-          body = nil if method == :get
-          query = {}
-        end
-      end
-
-      # Fibre-friendly variant; launches a child task for every hop _after_ the
-      # first one, so JSON parsing in the current page overlaps the download of
-      # the next page (requires AP_DEFAULT_ADAPTER=async_http + Async scheduler).
-      def each_page_async(path, method: :get, body: nil, query: {}, &block)
-        require "async"       # soft-require so callers don’t need Async unless used
-        Async do |task|
-          current_path = path
-          while current_path
-            data, link = perform_page_request(method, current_path, body, query)
-            next_url = parse_link_header(link)["next"]
-            body = nil if method == :get # as above
-            query = {}
-            # Prefetch next page while the caller consumes this one
-            fut = next_url ? task.async { perform_page_request(method, next_url, body, query) } : nil
-            yield data
-            current_path, data, link = next_url, *fut&.wait
-          end
-        end
-      end
-
-      private
-
-      # One tiny helper so the logic is not duplicated.
-      def perform_page_request(method, path, body, query)
-        json = request(method, path, body: body, query: query)
-        [ json, @last_response.headers["Link"] ]
-      end
-    end
-  end
-end