uploadcare-ruby 4.4.2 → 5.0.0.rc1

data/lib/uploadcare/api/rest/file_metadata.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+# REST API endpoint for file metadata operations.
+#
+# @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File-metadata
+class Uploadcare::Api::Rest::FileMetadata
+  # @return [Uploadcare::Api::Rest] Parent REST client
+  attr_reader :rest
+
+  # @param rest [Uploadcare::Api::Rest] Parent REST client
+  def initialize(rest:)
+    @rest = rest
+  end
+
+  # Get all metadata for a file.
+  #
+  # @param uuid [String] File UUID
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Hash of metadata key-value pairs
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File-metadata/operation/_fileMetadata
+  def index(uuid:, request_options: {})
+    encoded_uuid = URI.encode_www_form_component(uuid)
+    rest.get(path: "/files/#{encoded_uuid}/metadata/", params: {}, headers: {},
+             request_options: request_options)
+  end
+
+  # Get the value of a specific metadata key.
+  #
+  # @param uuid [String] File UUID
+  # @param key [String] Metadata key
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Metadata value
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File-metadata/operation/fileMetadata
+  def show(uuid:, key:, request_options: {})
+    encoded_uuid = URI.encode_www_form_component(uuid)
+    encoded_key = URI.encode_www_form_component(key)
+    rest.get(path: "/files/#{encoded_uuid}/metadata/#{encoded_key}/", params: {}, headers: {},
+             request_options: request_options)
+  end
+
+  # Update or create a metadata key for a file.
+  #
+  # @param uuid [String] File UUID
+  # @param key [String] Metadata key
+  # @param value [String] Metadata value
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Updated value
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File-metadata/operation/updateFileMetadataKey
+  def update(uuid:, key:, value:, request_options: {})
+    encoded_uuid = URI.encode_www_form_component(uuid)
+    encoded_key = URI.encode_www_form_component(key)
+    rest.put(path: "/files/#{encoded_uuid}/metadata/#{encoded_key}/", params: value.to_json, headers: {},
+             request_options: request_options)
+  end
+
+  # Delete a metadata key for a file.
+  #
+  # @param uuid [String] File UUID
+  # @param key [String] Metadata key to delete
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File-metadata/operation/deleteFileMetadata
+  def delete(uuid:, key:, request_options: {})
+    encoded_uuid = URI.encode_www_form_component(uuid)
+    encoded_key = URI.encode_www_form_component(key)
+    rest.request(method: :delete, path: "/files/#{encoded_uuid}/metadata/#{encoded_key}/",
+                 params: {}, headers: {}, request_options: request_options)
+  end
+end

data/lib/uploadcare/api/rest/files.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# REST API endpoint for file operations.
+#
+# Provides methods for listing, retrieving, storing, deleting, and copying files.
+#
+# @example
+#   rest = Uploadcare::Api::Rest.new(config: config)
+#   rest.files.list(params: { limit: 10 })
+#   rest.files.info(uuid: "file-uuid")
+#
+# @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File
+class Uploadcare::Api::Rest::Files
+  # @return [Uploadcare::Api::Rest] Parent REST client
+  attr_reader :rest
+
+  # @param rest [Uploadcare::Api::Rest] Parent REST client
+  def initialize(rest:)
+    @rest = rest
+  end
+
+  # List files with optional filtering and pagination.
+  #
+  # @param params [Hash] Query parameters (limit, ordering, etc.)
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Paginated file list
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/filesList
+  def list(params: {}, request_options: {})
+    rest.get(path: '/files/', params: params, headers: {}, request_options: request_options)
+  end
+
+  # Get file information by UUID.
+  #
+  # @param uuid [String] The file UUID
+  # @param params [Hash] Optional parameters (e.g., include: "appdata")
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] File details
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/fileInfo
+  def info(uuid:, params: {}, request_options: {})
+    encoded_uuid = URI.encode_www_form_component(uuid.to_s)
+    rest.get(path: "/files/#{encoded_uuid}/", params: params, headers: {}, request_options: request_options)
+  end
+
+  # Store a file by UUID, making it permanently available.
+  #
+  # @param uuid [String] The file UUID
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Updated file details
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/filesStore
+  def store(uuid:, request_options: {})
+    encoded_uuid = URI.encode_www_form_component(uuid.to_s)
+    rest.put(path: "/files/#{encoded_uuid}/storage/", params: {}, headers: {}, request_options: request_options)
+  end
+
+  # Delete a file by UUID.
+  #
+  # @param uuid [String] The file UUID
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Deleted file details
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/deleteFileStorage
+  def delete(uuid:, request_options: {})
+    encoded_uuid = URI.encode_www_form_component(uuid.to_s)
+    rest.request(method: :delete, path: "/files/#{encoded_uuid}/storage/", params: {}, headers: {},
+                 request_options: request_options)
+  end
+
+  # Batch store files by UUIDs.
+  #
+  # @param uuids [Array<String>] List of file UUIDs to store
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Hash with 'result' and 'problems' keys
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/filesStoring
+  def batch_store(uuids:, request_options: {})
+    rest.put(path: '/files/storage/', params: uuids, headers: {}, request_options: request_options)
+  end
+
+  # Batch delete files by UUIDs.
+  #
+  # @param uuids [Array<String>] List of file UUIDs to delete
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Hash with 'result' and 'problems' keys
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/filesDelete
+  def batch_delete(uuids:, request_options: {})
+    rest.request(method: :delete, path: '/files/storage/', params: uuids, headers: {},
+                 request_options: request_options)
+  end
+
+  # Copy a file to local storage.
+  #
+  # @param source [String] CDN URL or UUID of the file to copy
+  # @param options [Hash] Optional parameters (:store, :metadata)
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Hash with 'type' and 'result' keys
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/createLocalCopy
+  def local_copy(source:, options: {}, request_options: {})
+    params = { source: source }.merge(options)
+    rest.post(path: '/files/local_copy/', params: params, headers: {}, request_options: request_options)
+  end
+
+  # Copy a file to remote storage.
+  #
+  # @param source [String] CDN URL or UUID of the file to copy
+  # @param target [String] Name of the custom storage
+  # @param options [Hash] Optional parameters (:make_public, :pattern)
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Hash with 'type' and 'result' keys
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#operation/createRemoteCopy
+  def remote_copy(source:, target:, options: {}, request_options: {})
+    params = { source: source, target: target }.merge(options)
+    rest.post(path: '/files/remote_copy/', params: params, headers: {}, request_options: request_options)
+  end
+end

data/lib/uploadcare/api/rest/groups.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+# REST API endpoint for group operations.
+#
+# @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Group
+class Uploadcare::Api::Rest::Groups
+  # @return [Uploadcare::Api::Rest] Parent REST client
+  attr_reader :rest
+
+  # @param rest [Uploadcare::Api::Rest] Parent REST client
+  def initialize(rest:)
+    @rest = rest
+  end
+
+  # List groups with optional filtering and pagination.
+  #
+  # @param params [Hash] Query parameters (limit, ordering, etc.)
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Paginated group list
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Group/operation/groupsList
+  def list(params: {}, request_options: {})
+    rest.get(path: '/groups/', params: params, headers: {}, request_options: request_options)
+  end
+
+  # Get group information by UUID.
+  #
+  # @param uuid [String] Group UUID (formatted as UUID~size)
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Group details
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Group/operation/groupInfo
+  def info(uuid:, request_options: {})
+    encoded_uuid = URI::DEFAULT_PARSER.escape(uuid.to_s, /[^A-Za-z0-9\-._~]/)
+    rest.get(path: "/groups/#{encoded_uuid}/", params: {}, headers: {}, request_options: request_options)
+  end
+
+  # Delete a group by UUID.
+  #
+  # @param uuid [String] Group UUID (formatted as UUID~size)
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Group/operation/deleteGroup
+  def delete(uuid:, request_options: {})
+    encoded_uuid = URI::DEFAULT_PARSER.escape(uuid.to_s, /[^A-Za-z0-9\-._~]/)
+    rest.request(method: :delete, path: "/groups/#{encoded_uuid}/", params: {}, headers: {},
+                 request_options: request_options)
+  end
+end

data/lib/uploadcare/api/rest/project.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# REST API endpoint for project information.
+#
+# @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Project
+class Uploadcare::Api::Rest::Project
+  # @return [Uploadcare::Api::Rest] Parent REST client
+  attr_reader :rest
+
+  # @param rest [Uploadcare::Api::Rest] Parent REST client
+  def initialize(rest:)
+    @rest = rest
+  end
+
+  # Get current project information.
+  #
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Project details (name, pub_key, autostore_enabled, collaborators)
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Project
+  def show(request_options: {})
+    rest.get(path: '/project/', params: {}, headers: {}, request_options: request_options)
+  end
+end

data/lib/uploadcare/api/rest/video_conversions.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# REST API endpoint for video conversion operations.
+#
+# @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Video
+class Uploadcare::Api::Rest::VideoConversions
+  # @return [Uploadcare::Api::Rest] Parent REST client
+  attr_reader :rest
+
+  # @param rest [Uploadcare::Api::Rest] Parent REST client
+  def initialize(rest:)
+    @rest = rest
+  end
+
+  # Convert a video to a specified format.
+  #
+  # @param paths [Array<String>] Conversion paths (e.g., ["uuid/video/-/format/mp4/-/quality/normal/"])
+  # @param options [Hash] Optional parameters (:store)
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Conversion details
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Video/operation/convertVideo
+  def convert(paths:, options: {}, request_options: {})
+    params = { paths: paths }
+    params[:store] = normalize_bool_param(options[:store]) if options.key?(:store)
+    params.merge!(options.except(:store))
+    params.compact!
+    rest.post(path: '/convert/video/', params: params, headers: {}, request_options: request_options)
+  end
+
+  # Get video conversion job status.
+  #
+  # @param token [String, Integer] Conversion job token
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Job status and result
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Conversion/operation/videoConvertStatus
+  def status(token:, request_options: {})
+    rest.get(path: "/convert/video/status/#{token}/", params: {}, headers: {},
+             request_options: request_options)
+  end
+
+  private
+
+  def normalize_bool_param(value)
+    normalized = value.is_a?(String) ? value.strip.downcase : value
+
+    case normalized
+    when true, 1, '1', 'true' then '1'
+    when false, 0, '0', 'false' then '0'
+    else value
+    end
+  end
+end

data/lib/uploadcare/api/rest/webhooks.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# REST API endpoint for webhook operations.
+#
+# @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Webhook
+class Uploadcare::Api::Rest::Webhooks
+  # @return [Uploadcare::Api::Rest] Parent REST client
+  attr_reader :rest
+
+  # @param rest [Uploadcare::Api::Rest] Parent REST client
+  def initialize(rest:)
+    @rest = rest
+  end
+
+  # List all project webhooks.
+  #
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Array of webhook hashes
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Webhook/operation/webhooksList
+  def list(request_options: {})
+    rest.get(path: '/webhooks/', params: {}, headers: {}, request_options: request_options)
+  end
+
+  # Create a new webhook.
+  #
+  # @param options [Hash] Webhook options
+  # @option options [String] :target_url Webhook target URL (required)
+  # @option options [String] :event Event type (default: "file.uploaded")
+  # @option options [Boolean] :is_active Active flag (default: true)
+  # @option options [String] :signing_secret Signing secret
+  # @option options [String] :version Webhook payload version
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Created webhook attributes
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Webhook/operation/webhookCreate
+  def create(options: {}, request_options: {})
+    payload = {
+      target_url: options[:target_url],
+      event: options[:event] || 'file.uploaded',
+      is_active: options[:is_active].nil? || options[:is_active]
+    }
+    payload.merge!({ signing_secret: options[:signing_secret] }.compact)
+    payload.merge!({ version: options[:version] }.compact)
+
+    rest.post(path: '/webhooks/', params: payload, headers: {}, request_options: request_options)
+  end
+
+  # Update a webhook.
+  #
+  # @param id [Integer] Webhook ID
+  # @param options [Hash] Webhook options to update
+  # @option options [String] :target_url Target URL
+  # @option options [String] :event Event type
+  # @option options [Boolean] :is_active Active flag
+  # @option options [String] :signing_secret Signing secret
+  # @option options [String] :version Webhook payload version
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result] Updated webhook attributes
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Webhook/operation/updateWebhook
+  def update(id:, options: {}, request_options: {})
+    rest.put(path: "/webhooks/#{id}/", params: options, headers: {}, request_options: request_options)
+  end
+
+  # Delete a webhook by target URL.
+  #
+  # @param target_url [String] Target URL of the webhook to delete
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/Webhook/operation/webhookUnsubscribe
+  def delete(target_url:, request_options: {})
+    payload = { target_url: target_url }
+    rest.request(method: :delete, path: '/webhooks/unsubscribe/', params: payload, headers: {},
+                 request_options: request_options)
+  end
+end

data/lib/uploadcare/api/rest.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'uri'
+
+# Base client for the Uploadcare REST API.
+#
+# Provides authenticated HTTP methods (GET, POST, PUT, DELETE) for all REST API
+# endpoints. Includes automatic error handling and throttle retry logic.
+#
+# Endpoint classes are accessed via lazy-loaded accessors:
+#   rest = Uploadcare::Api::Rest.new(config: config)
+#   rest.files.list
+#   rest.groups.info(uuid: "...")
+#
+# @see https://uploadcare.com/api-refs/rest-api/v0.7.0/
+class Uploadcare::Api::Rest
+  include Uploadcare::Internal::ErrorHandler
+  include Uploadcare::Internal::ThrottleHandler
+
+  # Verb name used when deciding whether params belong in the query string.
+  HTTP_GET = 'GET'
+
+  # @return [Uploadcare::Configuration]
+  attr_reader :config
+
+  # @return [Faraday::Connection]
+  attr_reader :connection
+
+  # @return [Uploadcare::Internal::Authenticator]
+  attr_reader :authenticator
+
+  # Initialize a new REST API client.
+  #
+  # @param config [Uploadcare::Configuration] Configuration object (defaults to global config)
+  def initialize(config: Uploadcare.configuration)
+    @config = config
+    @memo_mutex = Mutex.new
+    @connection = Faraday.new(url: config.rest_api_root) do |conn|
+      conn.request :json
+      conn.response :json, content_type: /\bjson$/
+      conn.response :raise_error
+    end
+    @authenticator = Uploadcare::Internal::Authenticator.new(config: config)
+  end
+
+  # --- Endpoint accessors ---
+
+  # @return [Uploadcare::Api::Rest::Files] File operations endpoint
+  def files
+    memoized(:@files) { Uploadcare::Api::Rest::Files.new(rest: self) }
+  end
+
+  # @return [Uploadcare::Api::Rest::Groups] Group operations endpoint
+  def groups
+    memoized(:@groups) { Uploadcare::Api::Rest::Groups.new(rest: self) }
+  end
+
+  # @return [Uploadcare::Api::Rest::Project] Project information endpoint
+  def project
+    memoized(:@project) { Uploadcare::Api::Rest::Project.new(rest: self) }
+  end
+
+  # @return [Uploadcare::Api::Rest::Webhooks] Webhook operations endpoint
+  def webhooks
+    memoized(:@webhooks) { Uploadcare::Api::Rest::Webhooks.new(rest: self) }
+  end
+
+  # @return [Uploadcare::Api::Rest::FileMetadata] File metadata operations endpoint
+  def file_metadata
+    memoized(:@file_metadata) { Uploadcare::Api::Rest::FileMetadata.new(rest: self) }
+  end
+
+  # @return [Uploadcare::Api::Rest::Addons] Add-on operations endpoint
+  def addons
+    memoized(:@addons) { Uploadcare::Api::Rest::Addons.new(rest: self) }
+  end
+
+  # @return [Uploadcare::Api::Rest::DocumentConversions] Document conversion endpoint
+  def document_conversions
+    memoized(:@document_conversions) { Uploadcare::Api::Rest::DocumentConversions.new(rest: self) }
+  end
+
+  # @return [Uploadcare::Api::Rest::VideoConversions] Video conversion endpoint
+  def video_conversions
+    memoized(:@video_conversions) { Uploadcare::Api::Rest::VideoConversions.new(rest: self) }
+  end
+
+  # --- HTTP methods ---
+
+  # Make an HTTP request to the REST API.
+  #
+  # @param method [Symbol] HTTP method (:get, :post, :put, :delete)
+  # @param path [String] API endpoint path
+  # @param params [Hash, Array, String] Request parameters
+  # @param headers [Hash] Additional request headers
+  # @param request_options [Hash] Request options (timeout, etc.)
+  # @return [Hash, Array, nil] Parsed JSON response body
+  # @raise [Uploadcare::Exception::RequestError] on API errors
+  def make_request(method:, path:, params: {}, headers: {}, request_options: {})
+    handle_throttling(max_attempts: request_options[:max_throttle_attempts]) do
+      response = connection.public_send(method, path) do |req|
+        prepare_request(req, method, path, params, headers, request_options)
+      end
+      response.body
+    end
+  rescue Faraday::Error => e
+    handle_error(e)
+  end
+
+  # Make a POST request wrapped in a Result.
+  #
+  # @param path [String] API endpoint path
+  # @param params [Hash] Request body parameters
+  # @param headers [Hash] Additional request headers
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  def post(path:, params: {}, headers: {}, request_options: {})
+    request(method: :post, path: path, params: params, headers: headers, request_options: request_options)
+  end
+
+  # Make a GET request wrapped in a Result.
+  #
+  # @param path [String] API endpoint path
+  # @param params [Hash] Query parameters
+  # @param headers [Hash] Additional request headers
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  def get(path:, params: {}, headers: {}, request_options: {})
+    request(method: :get, path: path, params: params, headers: headers, request_options: request_options)
+  end
+
+  # Make a PUT request wrapped in a Result.
+  #
+  # @param path [String] API endpoint path
+  # @param params [Hash] Request body parameters
+  # @param headers [Hash] Additional request headers
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  def put(path:, params: {}, headers: {}, request_options: {})
+    request(method: :put, path: path, params: params, headers: headers, request_options: request_options)
+  end
+
+  # Make a DELETE request wrapped in a Result.
+  #
+  # @param path [String] API endpoint path
+  # @param params [Hash] Request body parameters
+  # @param headers [Hash] Additional request headers
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  def delete(path:, params: {}, headers: {}, request_options: {})
+    request(method: :delete, path: path, params: params, headers: headers, request_options: request_options)
+  end
+
+  # Wraps a request in a Result object.
+  #
+  # @param method [Symbol] HTTP method
+  # @param path [String] API path
+  # @param params [Hash] Request parameters
+  # @param headers [Hash] Request headers
+  # @param request_options [Hash] Request options
+  # @return [Uploadcare::Result]
+  def request(method:, path:, params: {}, headers: {}, request_options: {})
+    Uploadcare::Result.capture do
+      make_request(method: method, path: path, params: params, headers: headers, request_options: request_options)
+    end
+  end
+
+  private
+
+  def prepare_request(req, method, path, params, headers, request_options)
+    upcase_method_name = method.to_s.upcase
+    uri = build_request_uri(path, params, upcase_method_name)
+
+    prepare_headers(req, upcase_method_name, uri, params, headers)
+    prepare_body_or_params(req, upcase_method_name, params)
+    apply_request_options(req, request_options)
+  end
+
+  def build_request_uri(path, params, method)
+    if method == HTTP_GET && !params.nil? && params.is_a?(Hash) && !params.empty?
+      build_uri(path, params)
+    else
+      path
+    end
+  end
+
+  def prepare_headers(req, method, uri, params, headers)
+    body_content = body_content_for_signature(method, params)
+    content_type = extract_content_type(headers) || authenticator.default_headers['Content-Type']
+    auth_headers = authenticator.headers(method, uri, body_content, content_type)
+    normalized_headers = normalize_content_type_header(headers, content_type)
+    req.headers.merge!(auth_headers)
+    req.headers.merge!(normalized_headers)
+  end
+
+  def body_content_for_signature(method, params)
+    return '' if method == HTTP_GET
+    return '' if params.nil? || (params.respond_to?(:empty?) && params.empty?)
+    return params if params.is_a?(String)
+
+    params.to_json
+  end
+
+  def prepare_body_or_params(req, method, params)
+    if method == HTTP_GET
+      req.params.update(params) unless params.nil? || params.empty?
+    else
+      return if params.nil? || params.empty?
+
+      req.body = params
+    end
+  end
+
+  def apply_request_options(req, request_options)
+    return if request_options.nil? || request_options.empty?
+
+    req.options.timeout = request_options[:timeout] if request_options[:timeout]
+    req.options.open_timeout = request_options[:open_timeout] if request_options[:open_timeout]
+  end
+
+  def extract_content_type(headers)
+    headers['Content-Type'] || headers['content-type'] || headers[:content_type] || headers[:'Content-Type']
+  end
+
+  def normalize_content_type_header(headers, content_type)
+    normalized_headers = headers.dup
+    normalized_headers.delete('content-type')
+    normalized_headers.delete(:content_type)
+    normalized_headers.delete(:'Content-Type')
+    normalized_headers['Content-Type'] = content_type if content_type
+    normalized_headers
+  end
+
+  def build_uri(path, query_params = {})
+    if query_params.empty?
+      path
+    else
+      separator = path.include?('?') ? '&' : '?'
+      params_encoder = connection.options.params_encoder || Faraday::Utils.default_params_encoder
+      encoded_query = params_encoder.encode(query_params)
+      "#{path}#{separator}#{encoded_query}"
+    end
+  end
+
+  def memoized(ivar)
+    cached = instance_variable_get(ivar)
+    return cached if cached
+
+    @memo_mutex.synchronize do
+      instance_variable_get(ivar) || instance_variable_set(ivar, yield)
+    end
+  end
+end