paypal-rest-api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb3399d7f3412a84242a4ba9bf2c38447cc1987ca7a90a7e9a51a2628edb7809
+  data.tar.gz: ab029c43b63e930b30727a127b356c75388df84d8410fd45aac8edac2a37fa53
+SHA512:
+  metadata.gz: b33f4638da4db6992030b9a5fcae5d8836e6cf50cf600adbec07518e8e182f79cb86802f271b8b7276d2391078e8ec11f4a1472865af8bc4a496bbd42f7cb290
+  data.tar.gz: 583f9a28508b386c282fd9d1b793042abe461425da3cc4227d17f033263e71b8c17ad2abff09c722f90f62d598f09fe5bbf84c0a9ce789cbf29e948d7c223957

data/README.md

@@ -0,0 +1,189 @@
+# PaypalAPI
+
+## Installation
+
+```bash
+bundle add paypal-rest-api
+```
+
+## Features
+
+- No dependencies;
+- Automatic authorization & reauthorization;
+- Auto-retries (configured);
+- Automatically added Paypal-Request-Id header for idempotent requests if not
+  provided;
+
+## Usage
+
+- All APIs accept `:query`, `:body` and `:headers` keyword parameters.
+- Some APIs (like show, update, delete) require positional parameters with ID of
+  a resource.
+- Response has `#body` method to get parsed JSON body.
+  This body has `symbolized` hash keys.
+- Response contains methods to get original HTTP response.
+- Failed request error (for non `2**` status codes) contains HTTP request and
+  response
+- Failed request error (for network errors) contains request and original error
+
+```ruby
+# Initiate client
+client = PaypalAPI::Client.new(
+  client_id: ENV['PAYPAL_CLIENT_ID'],
+  client_secret: ENV['PAYPAL_CLIENT_SECRET'],
+  live: false
+)
+
+# APIs calls examples:
+response = client.orders.create(body: body)
+response = client.orders.show(order_id)
+response = client.payments.capture(authorization_id, headers: headers)
+response = client.webhooks.list(query: query)
+
+# Client can be used directly to send request to any path
+response = client.post(path, query: query, body: body, headers: headers)
+response = client.get(path, query: query, body: body, headers: headers)
+response = client.patch(path, query: query, body: body, headers: headers)
+response = client.put(path, query: query, body: body, headers: headers)
+response = client.delete(path, query: query, body: body, headers: headers)
+
+# Getting response
+response.body # parsed JSON. Parsed with `JSON.load(http_body, symbolyzed_keys: true)`
+response[:foo] # Gets :foo attribute from parsed body
+response.fetch(:foo) # Fetches :foo attribute from parsed body
+response.http_response # original Net::HTTP::Response
+response.http_body # original response string
+response.http_status # Integer http status
+response.http_headers # Hash with response headers (keys are strings)
+response.requested_at # Time when request was sent
+```
+
+Also PaypalAPI client can be added globally and class methods can be used instead:
+
+```ruby
+# in config/initializers/paypal_api.rb
+PaypalAPI.client = PaypalAPI::Client.new(...)
+
+# in your business logic
+response = PaypalAPI.orders.create(body: body)
+response = PaypalAPI.webhooks.verify(body: body)
+
+# same
+PaypalAPI::Orders.create(body: body)
+PaypalAPI::Webhooks.verify(body: body)
+
+# Also now PaypalAPI class can be used as a client
+response = PaypalAPI.post(path, query: query, body: body, headers: headers)
+response = PaypalAPI.get(path, query: query, body: body, headers: headers)
+response = PaypalAPI.patch(path, query: query, body: body, headers: headers)
+response = PaypalAPI.put(path, query: query, body: body, headers: headers)
+response = PaypalAPI.delete(path, query: query, body: body, headers: headers)
+```
+
+## Configuration options
+
+PaypalAPI client accepts this additional options: `:live`, `:retries`, `:http_opts`
+
+### Option `:live`
+
+PaypalAPI client can be defined with `live` option which is `false` by default.
+When `live` is `false` all requests will be send to the sandbox endpoints.
+
+```ruby
+client = PaypalAPI::Client.new(
+  live: true,
+  # ...
+)
+```
+
+### Option `:retries`
+
+This is a Hash with retries configuration.
+By default retries are enabled, 3 retries with 0.25, 0.75, 1.5 seconds delay.
+Default config: `{enabled: true, count: 3, sleep: [0.25, 0.75, 1.5]}`.
+New options are merged with defaults.
+Please keep `sleep` array same size as `count`.
+
+Retries happen on any network error, on 409, 429, 5xx response status code.
+
+```ruby
+client = PaypalAPI::Client.new(
+  retries: {count: 2, sleep: [0, 0]}
+  # ...
+)
+```
+
+### Option `:http_opts`
+
+This are the options that are provided to the `Net::HTTP.start` method,
+like `:read_timeout`, `:write_timeout`, etc.
+
+You can find full list of available options here <https://docs.ruby-lang.org/en/master/Net/HTTP.html#method-c-start>
+(Please choose you version of ruby).
+
+By default it is an empty hash.
+
+```ruby
+client = PaypalAPI::Client.new(
+  http_opts: {read_timeout: 30, write_timeout: 30, open_timeout: 30}
+  # ...
+)
+```
+
+## Errors
+
+All APIs can raise error in case of network error or non-2xx response status code.
+
+Errors structure:
+
+- `PaypalAPI::Error`
+   - `PaypalAPI::NetworkError` - any network error
+   - `PaypalAPI::FailedRequest` - any non-2xx code error
+      - 400 - `PaypalAPI::BadRequestError`
+      - 401 - `PaypalAPI::UnauthorizedError`
+      - 403 - `PaypalAPI::ForbiddenError`
+      - 404 - `PaypalAPI::NotFoundError`
+      - 405 - `PaypalAPI::MethodNotAllowedError`
+      - 406 - `PaypalAPI::NotAcceptableError`
+      - 409 - `PaypalAPI::ConflictError`
+      - 415 - `PaypalAPI::UnsupportedMediaTypeError`
+      - 422 - `PaypalAPI::UnprocessableEntityError`
+      - 429 - `PaypalAPI::TooManyRequestsError`
+      - 5xx - `PaypalAPI::FatalError`
+         - 500 - `PaypalAPI::InternalServerError`
+         - 503 - `PaypalAPI::ServiceUnavailableError`
+
+All errors have additional methods:
+
+- `#response` - Original response object, can be nil in case of NetworkError
+- `#request` - Original request object
+- `#error_name` - Original error name
+- `#error_message` - Original PayPal error `:message` or error `:description`
+- `#error_debug_id` - Paypal debug_id found in response
+- `#error_details` - Parsed PayPal error details found in parsed response
+  (with symbolized keys)
+
+```ruby
+begin
+  response = PaypalAPI.payments.capture(authorization_id, body: body)
+rescue PaypalAPI::Error => error
+  YourLogger.error(...)
+end
+
+```
+
+## Development
+
+```bash
+  bundle install
+  rubocop
+  rspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/aglushkov/paypal-api>.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/paypal-api/access_token.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # AccessToken object stores authorization string and its expire time.
+  #
+  class AccessToken
+    attr_reader :requested_at, :expires_at, :authorization_string
+
+    def initialize(requested_at:, expires_in:, access_token:, token_type:)
+      @requested_at = requested_at
+      @expires_at = requested_at + expires_in
+      @authorization_string = "#{token_type} #{access_token}"
+      freeze
+    end
+
+    def expired?
+      Time.now >= expires_at
+    end
+
+    def inspect
+      "#<#{self.class.name} methods: (requested_at, expires_at, expired?, authorization_string)>"
+    end
+
+    alias_method :to_s, :inspect
+  end
+end

data/lib/paypal-api/client.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # PaypalAPI Client
+  #
+  class Client
+    attr_reader :config
+
+    def initialize(client_id:, client_secret:, live: nil, http_opts: nil, retries: nil)
+      @config = PaypalAPI::Config.new(
+        client_id: client_id,
+        client_secret: client_secret,
+        live: live,
+        http_opts: http_opts,
+        retries: retries
+      )
+
+      @access_token = nil
+    end
+
+    def access_token
+      (@access_token.nil? || @access_token.expired?) ? refresh_access_token : @access_token
+    end
+
+    def refresh_access_token
+      response = authorization.generate_access_token
+
+      @access_token = AccessToken.new(
+        requested_at: response.requested_at,
+        expires_in: response.fetch(:expires_in),
+        access_token: response.fetch(:access_token),
+        token_type: response.fetch(:token_type)
+      )
+    end
+
+    def post(path, query: nil, body: nil, headers: nil)
+      execute_request(Net::HTTP::Post, path, query: query, body: body, headers: headers)
+    end
+
+    def get(path, query: nil, body: nil, headers: nil)
+      execute_request(Net::HTTP::Get, path, query: query, body: body, headers: headers)
+    end
+
+    def patch(path, query: nil, body: nil, headers: nil)
+      execute_request(Net::HTTP::Patch, path, query: query, body: body, headers: headers)
+    end
+
+    def put(path, query: nil, body: nil, headers: nil)
+      execute_request(Net::HTTP::Put, path, query: query, body: body, headers: headers)
+    end
+
+    def delete(path, query: nil, body: nil, headers: nil)
+      execute_request(Net::HTTP::Delete, path, query: query, body: body, headers: headers)
+    end
+
+    def authorization
+      Authentication.new(self)
+    end
+
+    def orders
+      Orders.new(self)
+    end
+
+    def payments
+      Payments.new(self)
+    end
+
+    def webhooks
+      Webhooks.new(self)
+    end
+
+    private
+
+    def execute_request(http_method, path, query: nil, body: nil, headers: nil)
+      request = Request.new(self, http_method, path, query: query, body: body, headers: headers)
+      RequestExecutor.call(request)
+    end
+  end
+end

data/lib/paypal-api/collection.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # Base class for all PayPal API collections classes
+  #
+  class Collection
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def self.client
+      PaypalAPI.client
+    end
+  end
+end

data/lib/paypal-api/collections/authentication.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # Authentication APIs collection
+  #
+  # @see https://developer.paypal.com/api/rest/authentication/
+  #
+  class Authentication < Collection
+    #
+    # Generate access-token API request path
+    #
+    PATH = "/v1/oauth2/token"
+
+    #
+    # Common class and instance methods
+    #
+    module APIs
+      #
+      # Generates access token.
+      #
+      # @see https://developer.paypal.com/api/rest/authentication/
+      #
+      # Default headers are:
+      #   { "content-type" => "application/x-www-form-urlencoded", "authorization" => "Basic <TOKEN>" }
+      #
+      # Default body is:
+      #   {grant_type: "client_credentials"}
+      #
+      # @example
+      #   PaypalAPI::Authentication.generate_access_token
+      #   PaypalAPI.client.authorization.generate_access_token # same
+      #
+      # @param query [Hash, nil] Request query string parameters
+      # @param body [Hash, nil] Request body parameters
+      # @param body [Hash, nil] Request headers
+      #
+      # @raise [Error] on network error or non 2** status code returned from PayPal
+      # @return [Response] detailed http request-response representation
+      #
+      def generate_access_token(query: nil, body: nil, headers: nil)
+        body ||= {grant_type: "client_credentials"}
+
+        default_headers = {
+          "content-type" => "application/x-www-form-urlencoded",
+          "authorization" => "Basic #{["#{client.config.client_id}:#{client.config.client_secret}"].pack("m0")}"
+        }
+
+        client.post(PATH, query: query, body: body, headers: merge_headers!(default_headers, headers))
+      end
+
+      private
+
+      def merge_headers!(headers, other_headers)
+        return headers unless other_headers
+
+        other_headers = other_headers.transform_keys { |key| key.to_s.downcase }
+        headers.merge!(other_headers)
+      end
+    end
+
+    include APIs
+    extend APIs
+  end
+end

data/lib/paypal-api/collections/orders.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # Create, update, retrieve, authorize, and capture orders.
+  #
+  # https://developer.paypal.com/docs/api/orders/v2/
+  #
+  class Orders < Collection
+    module APIs
+      #
+      # @see https://developer.paypal.com/docs/api/orders/v2/#orders_authorize
+      #
+      def authorize(id, query: nil, body: nil, headers: nil)
+        client.post("/v2/checkout/orders/#{id}/authorize", query: query, body: body, headers: headers)
+      end
+
+      #
+      # @see https://developer.paypal.com/docs/api/orders/v2/#orders_create
+      #
+      def create(query: nil, body: nil, headers: nil)
+        client.post("/v2/checkout/orders", query: query, body: body, headers: headers)
+      end
+
+      #
+      # @see https://developer.paypal.com/docs/api/orders/v2/#orders_get
+      #
+      def show(id, query: nil, body: nil, headers: nil)
+        client.get("/v2/checkout/orders/#{id}", query: query, body: body, headers: headers)
+      end
+    end
+
+    include APIs
+    extend APIs
+  end
+end

data/lib/paypal-api/collections/payments.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # Use in conjunction with the Orders API to authorize payments, capture authorized payments,
+  # refund payments that have already been captured, and show payment information.
+  #
+  # https://developer.paypal.com/docs/api/payments/v2
+  #
+  class Payments < Collection
+    module APIs
+      #
+      # @see https://developer.paypal.com/docs/api/payments/v2/#authorizations_capture
+      #
+      def capture(authorization_id, query: nil, body: nil, headers: nil)
+        client.post("/v2/payments/authorizations/#{authorization_id}/capture", query: query, body: body, headers: headers)
+      end
+
+      #
+      # @see https://developer.paypal.com/docs/api/payments/v2/#captures_refund
+      #
+      def refund(capture_id, query: nil, body: nil, headers: nil)
+        client.post("/v2/payments/captures/#{capture_id}/refund", query: query, body: body, headers: headers)
+      end
+
+      #
+      # @see https://developer.paypal.com/docs/api/payments/v2/#authorizations_get
+      #
+      def show_authorized(authorization_id, query: nil, body: nil, headers: nil)
+        client.get("/v2/payments/authorizations/#{authorization_id}", query: query, body: body, headers: headers)
+      end
+
+      #
+      # @see https://developer.paypal.com/docs/api/payments/v2/#captures_get
+      #
+      def show_captured(capture_id, query: nil, body: nil, headers: nil)
+        client.get("/v2/payments/captures/#{capture_id}", query: query, body: body, headers: headers)
+      end
+
+      #
+      # @see https://developer.paypal.com/docs/api/payments/v2/#authorizations_void
+      #
+      def void(authorization_id, query: nil, body: nil, headers: nil)
+        client.post("/v2/payments/authorizations/#{authorization_id}/void", query: query, body: body, headers: headers)
+      end
+    end
+
+    include APIs
+    extend APIs
+  end
+end

data/lib/paypal-api/collections/webhooks.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # https://developer.paypal.com/docs/api/webhooks/v1/
+  #
+  class Webhooks < Collection
+    module APIs
+      #
+      # https://developer.paypal.com/docs/api/webhooks/v1/#webhooks_post
+      #
+      def create(query: nil, body: nil, headers: nil)
+        client.post("/v1/notifications/webhooks", query: query, body: body, headers: headers)
+      end
+
+      #
+      # https://developer.paypal.com/docs/api/webhooks/v1/#webhooks_delete
+      #
+      def delete(webhook_id, query: nil, body: nil, headers: nil)
+        client.delete("/v1/notifications/webhooks/#{webhook_id}", query: query, body: body, headers: headers)
+      end
+
+      #
+      # https://developer.paypal.com/docs/api/webhooks/v1/#webhooks_list
+      #
+      def list(query: nil, body: nil, headers: nil)
+        client.get("/v1/notifications/webhooks", query: query, body: body, headers: headers)
+      end
+
+      #
+      # https://developer.paypal.com/docs/api/webhooks/v1/#webhooks_get
+      #
+      def show(webhook_id, query: nil, body: nil, headers: nil)
+        client.get("/v1/notifications/webhooks/#{webhook_id}", query: query, body: body, headers: headers)
+      end
+
+      #
+      # https://developer.paypal.com/docs/api/webhooks/v1/#webhooks_update
+      #
+      def update(webhook_id, query: nil, body: nil, headers: nil)
+        client.patch("/v1/notifications/webhooks/#{webhook_id}", query: query, body: body, headers: headers)
+      end
+
+      #
+      # https://developer.paypal.com/docs/api/webhooks/v1/#verify-webhook-signature_post
+      #
+      def verify(query: nil, body: nil, headers: nil)
+        client.post("/v1/notifications/verify-webhook-signature", query: query, body: body, headers: headers)
+      end
+    end
+
+    include APIs
+    extend APIs
+  end
+end

data/lib/paypal-api/config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  LIVE_URL = "https://api-m.paypal.com"
+  SANDBOX_URL = "https://api-m.sandbox.paypal.com"
+
+  DEFAULTS = {
+    live: false,
+    http_opts: {}.freeze,
+    retries: {enabled: true, count: 3, sleep: [0.25, 0.75, 1.5].freeze}.freeze
+  }.freeze
+
+  #
+  # Stores configuration for PaypalAPI Client
+  #
+  class Config
+    attr_reader :client_id, :client_secret, :live, :http_opts, :retries
+
+    def initialize(client_id:, client_secret:, live: nil, http_opts: nil, retries: nil)
+      @client_id = client_id
+      @client_secret = client_secret
+      @live = with_default(:live, live)
+      @http_opts = with_default(:http_opts, http_opts)
+      @retries = with_default(:retries, retries)
+      freeze
+    end
+
+    def url
+      live ? LIVE_URL : SANDBOX_URL
+    end
+
+    def inspect
+      "#<#{self.class.name} live: #{live}>"
+    end
+
+    alias_method :to_s, :inspect
+
+    private
+
+    def with_default(option_name, value)
+      default = DEFAULTS.fetch(option_name)
+
+      case value
+      when NilClass then default
+      when Hash then default.merge(value)
+      else value
+      end
+    end
+  end
+end

data/lib/paypal-api/error.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # Common interface for all errors
+  #
+  class Error < StandardError
+    attr_reader :response, :request, :error_name, :error_message, :error_debug_id, :error_details
+  end
+
+  #
+  # Raised when PayPal responds with any status code except 200, 201, 202, 204
+  #
+  class FailedRequest < Error
+    def initialize(message = nil, request:, response:)
+      super(message)
+      @request = request
+      @response = response
+
+      body = response.body
+      data = body.is_a?(Hash) ? body : {}
+      @error_name = data[:name] || data[:error] || response.http_response.class.name
+      @error_message = data[:message] || data[:error_description] || response.http_body.to_s
+      @error_debug_id = data[:debug_id]
+      @error_details = data[:details]
+    end
+  end
+
+  #
+  # Raised when a network raised when executing the request
+  # List of network errors can be found in errors/network_error_builder.rb
+  #
+  class NetworkError < Error
+    def initialize(message = nil, request:, error:)
+      super(message)
+      @request = request
+      @response = nil
+      @error_name = error.class.name
+      @error_message = error.message
+      @error_debug_id = nil
+      @error_details = nil
+    end
+  end
+
+  # 400
+  class BadRequestError < FailedRequest
+  end
+
+  # 401
+  class UnauthorizedError < FailedRequest
+  end
+
+  # 403
+  class ForbiddenError < FailedRequest
+  end
+
+  # 404
+  class NotFoundError < FailedRequest
+  end
+
+  # 405
+  class MethodNotAllowedError < FailedRequest
+  end
+
+  # 406
+  class NotAcceptableError < FailedRequest
+  end
+
+  # 409
+  class ConflictError < FailedRequest
+  end
+
+  # 415
+  class UnsupportedMediaTypeError < FailedRequest
+  end
+
+  # 422
+  class UnprocessableEntityError < FailedRequest
+  end
+
+  # 429
+  class TooManyRequestsError < FailedRequest
+  end
+
+  # 5xx
+  class FatalError < FailedRequest
+  end
+
+  # 500
+  class InternalServerError < FatalError
+  end
+
+  # 503
+  class ServiceUnavailableError < FatalError
+  end
+end

data/lib/paypal-api/failed_request_error_builder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module PaypalAPI
+  #
+  # Builds PaypalAPI::FailedRequest error
+  #
+  class FailedRequestErrorBuilder
+    RESPONSE_ERROR_MAP = {
+      Net::HTTPBadRequest => BadRequestError,                     # 400
+      Net::HTTPUnauthorized => UnauthorizedError,                 # 401
+      Net::HTTPForbidden => ForbiddenError,                       # 403
+      Net::HTTPNotFound => NotFoundError,                         # 404
+      Net::HTTPMethodNotAllowed => MethodNotAllowedError,         # 405
+      Net::HTTPNotAcceptable => NotAcceptableError,               # 406
+      Net::HTTPConflict => ConflictError,                         # 409
+      Net::HTTPUnsupportedMediaType => UnsupportedMediaTypeError, # 415
+      Net::HTTPUnprocessableEntity => UnprocessableEntityError,   # 422
+      Net::HTTPTooManyRequests => TooManyRequestsError,           # 429
+      Net::HTTPInternalServerError => InternalServerError,        # 500
+      Net::HTTPServiceUnavailable => ServiceUnavailableError      # 503
+    }.freeze
+
+    class << self
+      def call(request:, response:)
+        http_response = response.http_response
+        error_message = "#{http_response.code} #{http_response.message}"
+        error_class = RESPONSE_ERROR_MAP.fetch(http_response.class, FailedRequest)
+        error_class.new(error_message, response: response, request: request)
+      end
+    end
+  end
+end

data/lib/paypal-api/network_error_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # Builds PaypalAPI::NetowrkError error
+  #
+  class NetworkErrorBuilder
+    ERRORS = [
+      EOFError,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EPIPE,
+      Errno::ETIMEDOUT,
+      IOError,
+      OpenSSL::SSL::SSLError,
+      SocketError,
+      Timeout::Error # Net::OpenTimeout, Net::ReadTimeout
+    ].freeze
+
+    class << self
+      def call(request:, error:)
+        NetworkError.new(error.message, request: request, error: error)
+      end
+    end
+  end
+end

data/lib/paypal-api/request.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+
+module PaypalAPI
+  #
+  # Builds PaypalAPI::Request:
+  # - assigns query params
+  # - assigns body params
+  # - assigns Authentication header
+  # - assigns paypal-request-id header
+  # - assigns content-type header
+  #
+  class Request
+    attr_reader :client, :http_request
+    attr_accessor :requested_at
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(client, request_type, path, body: nil, query: nil, headers: nil)
+      @client = client
+      @http_request = build_http_request(request_type, path, body: body, query: query, headers: headers)
+      @requested_at = nil
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    private
+
+    def build_http_request(request_type, path, body:, query:, headers:)
+      uri = request_uri(path, query)
+      http_request = request_type.new(uri)
+
+      add_headers(http_request, headers || {})
+      add_body(http_request, body)
+
+      http_request
+    end
+
+    def add_headers(http_request, headers)
+      headers.each { |key, value| http_request[key] = value }
+
+      http_request["content-type"] ||= "application/json"
+      http_request["authorization"] ||= client.access_token.authorization_string
+      http_request["paypal-request-id"] ||= SecureRandom.uuid if idempotent?(http_request)
+    end
+
+    def add_body(http_request, body)
+      return unless body
+
+      json?(http_request) ? http_request.body = JSON.dump(body) : http_request.set_form_data(body)
+    end
+
+    def request_uri(path, query)
+      uri = URI.join(client.config.url, path)
+      uri.query = URI.encode_www_form(query) if query && !query.empty?
+      uri
+    end
+
+    def idempotent?(http_request)
+      http_request.method != Net::HTTP::Get::METHOD
+    end
+
+    def json?(http_request)
+      http_request["content-type"].include?("json")
+    end
+  end
+end

data/lib/paypal-api/request_executor.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  #
+  # Executes PaypalAPI::Request and returns PaypalAPI::Response or raises PaypalAPI::Error
+  #
+  class RequestExecutor
+    RETRYABLE_RESPONSES = [
+      Net::HTTPServerError,    # 5xx
+      Net::HTTPConflict,       # 409
+      Net::HTTPTooManyRequests # 429
+    ].freeze
+
+    class << self
+      def call(request)
+        http_response = execute(request)
+        response = Response.new(http_response, requested_at: request.requested_at)
+        raise FailedRequestErrorBuilder.call(request: request, response: response) unless http_response.is_a?(Net::HTTPSuccess)
+
+        response
+      end
+
+      private
+
+      def execute(request, retry_number: 0)
+        http_response = execute_http_request(request)
+      rescue *NetworkErrorBuilder::ERRORS => error
+        retry_on_network_error(request, error, retry_number)
+      else
+        retryable?(request, http_response, retry_number) ? retry_request(request, retry_number) : http_response
+      end
+
+      def execute_http_request(request)
+        http_request = request.http_request
+        http_opts = request.client.config.http_opts
+        uri = http_request.uri
+        request.requested_at = Time.now
+
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, **http_opts) do |http|
+          http.max_retries = 0 # we have custom retries logic
+          http.request(http_request)
+        end
+      end
+
+      def retry_on_network_error(request, error, retry_number)
+        raise NetworkErrorBuilder.call(request: request, error: error) if retries_limit_reached?(request, retry_number)
+
+        retry_request(request, retry_number)
+      end
+
+      def retry_request(request, current_retry_number)
+        sleep(retry_sleep_seconds(request, current_retry_number))
+        execute(request, retry_number: current_retry_number + 1)
+      end
+
+      def retries_limit_reached?(request, retry_number)
+        retry_number >= request.client.config.retries[:count]
+      end
+
+      def retry_sleep_seconds(request, current_retry_number)
+        seconds_per_retry = request.client.config.retries[:sleep]
+        seconds_per_retry[current_retry_number] || seconds_per_retry.last || 1
+      end
+
+      def retryable?(request, http_response, retry_number)
+        !http_response.is_a?(Net::HTTPSuccess) &&
+          !retries_limit_reached?(request, retry_number) &&
+          retryable_request?(request, http_response)
+      end
+
+      def retryable_request?(request, http_response)
+        return true if RETRYABLE_RESPONSES.any? { |retryable_class| http_response.is_a?(retryable_class) }
+
+        retry_unauthorized?(request, http_response)
+      end
+
+      def retry_unauthorized?(request, http_response)
+        return false unless http_response.is_a?(Net::HTTPUnauthorized) # 401
+        return false if http_response.uri.path == Authentication::PATH # it's already an Authentication request
+
+        # set new access-token
+        request.http_request["authorization"] = request.client.refresh_access_token.authorization_string
+        true
+      end
+    end
+  end
+end

data/lib/paypal-api/response.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PaypalAPI
+  #
+  # PaypalAPI::Response object
+  #
+  class Response
+    attr_reader :http_response, :requested_at
+
+    def initialize(http_response, requested_at:)
+      @requested_at = requested_at
+      @http_response = http_response
+      @http_status = nil
+      @http_headers = nil
+      @http_body = nil
+      @body = nil
+    end
+
+    def body
+      @body ||= json_response? ? parse_json(http_body) : http_body
+    end
+
+    def http_status
+      @http_status ||= http_response.code.to_i
+    end
+
+    def http_headers
+      @http_headers ||= http_response.each_header.to_h
+    end
+
+    def http_body
+      @http_body ||= http_response.body
+    end
+
+    def [](key)
+      body[key.to_sym] if body.is_a?(Hash)
+    end
+
+    def fetch(key)
+      data = body.is_a?(Hash) ? body : {}
+      data.fetch(key.to_sym)
+    end
+
+    def inspect
+      "#<#{self.class.name} (#{http_response.code})>"
+    end
+
+    private
+
+    def json_response?
+      content_type = http_response["content-type"]
+      !content_type.nil? && content_type.include?("json")
+    end
+
+    def parse_json(json)
+      JSON.parse(json, symbolize_names: true)
+    rescue JSON::ParserError, TypeError
+      json
+    end
+  end
+end

data/lib/paypal-api/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PaypalAPI
+  # PaypalAPI gem version
+  #
+  # @return [String] SemVer gem version
+  #
+  VERSION = File.read(File.join(File.dirname(__FILE__), "../../VERSION")).strip
+end

data/lib/paypal-api.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+#
+# PaypalAPI is a main gem module.
+# It can store global PaypalAPI::Client for easier access to APIs.
+#
+# For example:
+#   # setup client in an initializer
+#   PaypalAPI.client = PaypalAPI::Client.new(...)
+#
+#   # And then use anywhere
+#   PaypalAPI::Webhooks.list # or PaypalAPI.webhooks.list
+#
+module PaypalAPI
+  class << self
+    attr_writer :client
+
+    [:post, :get, :patch, :put, :delete].each do |method_name|
+      define_method(method_name) do |path, query: nil, body: nil, headers: nil|
+        client.public_send(method_name, path, query: query, body: body, headers: headers)
+      end
+    end
+
+    %i[
+      authorization
+      orders
+      payments
+      webhooks
+    ].each do |method_name|
+      define_method(method_name) do
+        client.public_send(method_name)
+      end
+    end
+
+    def client
+      raise "#{name}.client must be set" unless @client
+
+      @client
+    end
+  end
+end
+
+require_relative "paypal-api/access_token"
+require_relative "paypal-api/client"
+require_relative "paypal-api/collection"
+require_relative "paypal-api/config"
+require_relative "paypal-api/error"
+require_relative "paypal-api/failed_request_error_builder"
+require_relative "paypal-api/network_error_builder"
+require_relative "paypal-api/request"
+require_relative "paypal-api/request_executor"
+require_relative "paypal-api/response"
+require_relative "paypal-api/collections/authentication"
+require_relative "paypal-api/collections/orders"
+require_relative "paypal-api/collections/payments"
+require_relative "paypal-api/collections/webhooks"

data/lib/paypal-rest-api.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "paypal-api"

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: paypal-rest-api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey Glushkov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-06 00:00:00.000000000 Z
+dependencies: []
+description: PayPal REST API with no dependencies.
+email:
+- aglushkov@shakuro.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- VERSION
+- lib/paypal-api.rb
+- lib/paypal-api/access_token.rb
+- lib/paypal-api/client.rb
+- lib/paypal-api/collection.rb
+- lib/paypal-api/collections/authentication.rb
+- lib/paypal-api/collections/orders.rb
+- lib/paypal-api/collections/payments.rb
+- lib/paypal-api/collections/webhooks.rb
+- lib/paypal-api/config.rb
+- lib/paypal-api/error.rb
+- lib/paypal-api/failed_request_error_builder.rb
+- lib/paypal-api/network_error_builder.rb
+- lib/paypal-api/request.rb
+- lib/paypal-api/request_executor.rb
+- lib/paypal-api/response.rb
+- lib/paypal-api/version.rb
+- lib/paypal-rest-api.rb
+homepage: https://github.com/aglushkov/paypal-api
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/aglushkov/paypal-api
+  documentation_uri: https://www.rubydoc.info/gems/serega
+  changelog_uri: https://github.com/aglushkov/paypal-api/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.17
+signing_key:
+specification_version: 4
+summary: PayPal REST API
+test_files: []