paystack-gateway 0.1.0 → 0.2.0

data/lib/paystack_gateway/plans.rb

@@ -1,82 +1,3 @@
 # frozen_string_literal: true
 
-module PaystackGateway
-  # Create and manage installment payment options
-  # https://paystack.com/docs/api/plan/#create
-  module Plans
-    include PaystackGateway::RequestModule
-
-    # Response from POST /plan endpoint.
-    class CreatePlanResponse < PaystackGateway::Response
-      delegate :id, to: :data, prefix: :plan
-      delegate :id, :plan_code, to: :data
-    end
-
-    api_method def self.create_plan(name:, amount:, interval:)
-      use_connection do |connection|
-        connection.post(
-          '/plan',
-          {
-            name:,
-            interval:,
-            amount: amount * 100,
-            send_invoices: false,
-            send_sms: false,
-          },
-        )
-      end
-    end
-
-    # Response from GET /plan endpoint.
-    class ListPlansResponse < PaystackGateway::Response
-      def active_plans = data.select { |plan| !plan.is_deleted && !plan.is_archived }
-
-      def find_active_plan_by_name(name)
-        active_plans.sort_by { -Time.parse(_1.createdAt).to_i }.find { _1.name == name }
-      end
-    end
-
-    api_method def self.list_plans
-      use_connection do |connection|
-        connection.get('/plan')
-      end
-    end
-
-    # Response from GET /plan/:code endpoint.
-    class FetchPlanResponse < PaystackGateway::Response
-      delegate :subscriptions, to: :data
-
-      def active_subscriptions = subscriptions.select { _1.status.to_sym == :active }
-
-      def active_subscription_codes(email: nil)
-        subscriptions =
-          if email
-            active_subscriptions.select { _1.customer.email.casecmp?(email) }
-          else
-            active_subscriptions
-          end
-        subscriptions.map(&:subscription_code)
-      end
-    end
-
-    api_method def self.fetch_plan(code:)
-      use_connection do |connection|
-        connection.get("/plan/#{code}")
-      end
-    end
-
-    class UpdatePlanResponse < PaystackGateway::Response; end
-
-    api_method def self.update_plan(code:, amount:, interval:)
-      use_connection do |connection|
-        connection.put(
-          "/plan/#{code}",
-          {
-            amount: amount * 100,
-            interval:,
-          },
-        )
-      end
-    end
-  end
-end
+require 'paystack_gateway/legacy/plans'

data/lib/paystack_gateway/product.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+module PaystackGateway
+  # https://paystack.com/docs/api/product
+  #
+  # Products
+  # A collection of endpoints for creating and managing inventories
+  module Product
+    include PaystackGateway::RequestModule
+
+    # Successful response from calling #list.
+    class ListResponse < PaystackGateway::Response; end
+
+    # Error response from #list.
+    class ListError < ApiError; end
+
+    # https://paystack.com/docs/api/product/#list
+    # List Products: GET /product
+    # List all previously created products
+    #
+    # @param per_page [Integer]
+    #        Number of records to fetch per page
+    # @param page [Integer]
+    #        The section to retrieve
+    # @param active [Boolean]
+    #        The state of the product
+    # @param from [Time]
+    #        The start date
+    # @param to [Time]
+    #        The end date
+    #
+    # @return [ListResponse] successful response
+    # @raise [ListError] if the request fails
+    api_method def self.list(per_page: nil, page: nil, active: nil, from: nil, to: nil)
+      use_connection do |connection|
+        connection.get(
+          '/product',
+          { perPage: per_page, page:, active:, from:, to: }.compact,
+        )
+      end
+    end
+
+    # Successful response from calling #create.
+    class CreateResponse < PaystackGateway::Response
+      delegate :variants_options,
+               :variants,
+               :name,
+               :description,
+               :currency,
+               :price,
+               :quantity,
+               :type,
+               :is_shippable,
+               :unlimited,
+               :files,
+               :shipping_fields,
+               :integration,
+               :domain,
+               :metadata,
+               :slug,
+               :product_code,
+               :quantity_sold,
+               :active,
+               :deleted_at,
+               :in_stock,
+               :minimum_orderable,
+               :maximum_orderable,
+               :low_stock_alert,
+               :id,
+               :createdAt,
+               :updatedAt, to: :data
+    end
+
+    # Error response from #create.
+    class CreateError < ApiError; end
+
+    # https://paystack.com/docs/api/product/#create
+    # Create Product: POST /product
+    # Create a new product on your integration
+    #
+    # @param name [String] (required)
+    #        Name of product
+    # @param description [String] (required)
+    #        The description of the product
+    # @param price [Integer] (required)
+    #        Price should be in kobo if currency is NGN, pesewas, if currency is GHS, and cents,
+    #        if currency is ZAR
+    # @param currency [String] (required)
+    #        Currency in which price is set. Allowed values are: NGN, GHS, ZAR or USD
+    # @param unlimited [Boolean]
+    #        Set to true if the product has unlimited stock. Leave as false if the product has
+    #        limited stock
+    # @param quantity [Integer]
+    #        Number of products in stock. Use if limited is true
+    # @param split_code [String]
+    #        The split code if sharing the transaction with partners
+    # @param metadata [String]
+    #        Stringified JSON object of custom data
+    #
+    # @return [CreateResponse] successful response
+    # @raise [CreateError] if the request fails
+    api_method def self.create(
+      name:,
+      description:,
+      price:,
+      currency:,
+      unlimited: nil,
+      quantity: nil,
+      split_code: nil,
+      metadata: nil
+    )
+      use_connection do |connection|
+        connection.post(
+          '/product',
+          {
+            name:,
+            description:,
+            price:,
+            currency:,
+            unlimited:,
+            quantity:,
+            split_code:,
+            metadata:,
+          }.compact,
+        )
+      end
+    end
+
+    # Successful response from calling #fetch.
+    class FetchResponse < PaystackGateway::Response
+      delegate :digital_assets,
+               :integration,
+               :name,
+               :description,
+               :product_code,
+               :price,
+               :currency,
+               :quantity,
+               :quantity_sold,
+               :type,
+               :files,
+               :file_path,
+               :is_shippable,
+               :shipping_fields,
+               :unlimited,
+               :domain,
+               :active,
+               :features,
+               :in_stock,
+               :metadata,
+               :slug,
+               :success_message,
+               :redirect_url,
+               :split_code,
+               :notification_emails,
+               :minimum_orderable,
+               :maximum_orderable,
+               :low_stock_alert,
+               :stock_threshold,
+               :expires_in,
+               :id,
+               :createdAt,
+               :updatedAt, to: :data
+    end
+
+    # Error response from #fetch.
+    class FetchError < ApiError; end
+
+    # https://paystack.com/docs/api/product/#fetch
+    # Fetch Product: GET /product/{id}
+    # Fetch a previously created product
+    #
+    # @param id [Integer] (required)
+    #        The unique identifier of the product
+    #
+    # @return [FetchResponse] successful response
+    # @raise [FetchError] if the request fails
+    api_method def self.fetch(id:)
+      use_connection do |connection|
+        connection.get(
+          "/product/#{id}",
+        )
+      end
+    end
+
+    # Successful response from calling #update.
+    class UpdateResponse < PaystackGateway::Response
+      delegate :name,
+               :description,
+               :product_code,
+               :price,
+               :currency,
+               :quantity,
+               :quantity_sold,
+               :type,
+               :files,
+               :file_path,
+               :is_shippable,
+               :shipping_fields,
+               :unlimited,
+               :domain,
+               :active,
+               :features,
+               :in_stock,
+               :metadata,
+               :slug,
+               :success_message,
+               :redirect_url,
+               :split_code,
+               :notification_emails,
+               :minimum_orderable,
+               :maximum_orderable,
+               :low_stock_alert,
+               :stock_threshold,
+               :expires_in,
+               :id,
+               :integration,
+               :createdAt,
+               :updatedAt, to: :data
+    end
+
+    # Error response from #update.
+    class UpdateError < ApiError; end
+
+    # https://paystack.com/docs/api/product/#update
+    # Update product: PUT /product/{id}
+    # Update a previously created product
+    #
+    # @param id [Integer] (required)
+    #        The unique identifier of the product
+    # @param name [String]
+    #        Name of product
+    # @param description [String]
+    #        The description of the product
+    # @param price [Integer]
+    #        Price should be in kobo if currency is NGN, pesewas, if currency is GHS, and cents,
+    #        if currency is ZAR
+    # @param currency [String]
+    #        Currency in which price is set. Allowed values are: NGN, GHS, ZAR or USD
+    # @param unlimited [Boolean]
+    #        Set to true if the product has unlimited stock. Leave as false if the product has
+    #        limited stock
+    # @param quantity [Integer]
+    #        Number of products in stock. Use if limited is true
+    # @param split_code [String]
+    #        The split code if sharing the transaction with partners
+    # @param metadata [Hash]
+    #        JSON object of custom data
+    #
+    # @return [UpdateResponse] successful response
+    # @raise [UpdateError] if the request fails
+    api_method def self.update(
+      id:,
+      name: nil,
+      description: nil,
+      price: nil,
+      currency: nil,
+      unlimited: nil,
+      quantity: nil,
+      split_code: nil,
+      metadata: nil
+    )
+      use_connection do |connection|
+        connection.put(
+          "/product/#{id}",
+          {
+            name:,
+            description:,
+            price:,
+            currency:,
+            unlimited:,
+            quantity:,
+            split_code:,
+            metadata:,
+          }.compact,
+        )
+      end
+    end
+
+    # Successful response from calling #delete.
+    class DeleteResponse < PaystackGateway::Response; end
+
+    # Error response from #delete.
+    class DeleteError < ApiError; end
+
+    # https://paystack.com/docs/api/product/#delete
+    # Delete Product: DELETE /product/{id}
+    # Delete a previously created product
+    #
+    # @param id [Integer] (required)
+    #        The unique identifier of the product
+    #
+    # @return [DeleteResponse] successful response
+    # @raise [DeleteError] if the request fails
+    api_method def self.delete(id:)
+      use_connection do |connection|
+        connection.delete(
+          "/product/#{id}",
+        )
+      end
+    end
+  end
+end

data/lib/paystack_gateway/refund.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module PaystackGateway
+  # https://paystack.com/docs/api/refund
+  #
+  # Refunds
+  # A collection of endpoints for creating and managing transaction reimbursement
+  module Refund
+    include PaystackGateway::RequestModule
+
+    # Successful response from calling #list.
+    class ListResponse < PaystackGateway::Response; end
+
+    # Error response from #list.
+    class ListError < ApiError; end
+
+    # https://paystack.com/docs/api/refund/#list
+    # List Refunds: GET /refund
+    # List previously created refunds
+    #
+    # @param per_page [Integer]
+    #        Number of records to fetch per page
+    # @param page [Integer]
+    #        The section to retrieve
+    # @param from [Time]
+    #        The start date
+    # @param to [Time]
+    #        The end date
+    #
+    # @return [ListResponse] successful response
+    # @raise [ListError] if the request fails
+    api_method def self.list(per_page: nil, page: nil, from: nil, to: nil)
+      use_connection do |connection|
+        connection.get(
+          '/refund',
+          { perPage: per_page, page:, from:, to: }.compact,
+        )
+      end
+    end
+
+    # Successful response from calling #create.
+    class CreateResponse < PaystackGateway::Response
+      delegate :transaction,
+               :integration,
+               :deducted_amount,
+               :channel,
+               :merchant_note,
+               :customer_note,
+               :refunded_by,
+               :expected_at,
+               :currency,
+               :domain,
+               :amount,
+               :fully_deducted,
+               :id,
+               :createdAt,
+               :updatedAt, to: :data
+    end
+
+    # Error response from #create.
+    class CreateError < ApiError; end
+
+    # https://paystack.com/docs/api/refund/#create
+    # Create Refund: POST /refund
+    # Initiate a refund for a previously completed transaction
+    #
+    # @param transaction [String] (required)
+    #        The reference of a previosuly completed transaction
+    # @param amount [Integer]
+    #        Amount to be refunded to the customer. It cannot be more than the original transaction
+    #        amount
+    # @param currency ["GHS", "KES", "NGN", "USD", "ZAR"]
+    #        Three-letter ISO currency
+    # @param customer_note [String]
+    #        Customer reason
+    # @param merchant_note [String]
+    #        Merchant reason
+    #
+    # @return [CreateResponse] successful response
+    # @raise [CreateError] if the request fails
+    api_method def self.create(transaction:, amount: nil, currency: nil, customer_note: nil, merchant_note: nil)
+      use_connection do |connection|
+        connection.post(
+          '/refund',
+          { transaction:, amount:, currency:, customer_note:, merchant_note: }.compact,
+        )
+      end
+    end
+
+    # Successful response from calling #retry.
+    class RetryResponse < PaystackGateway::Response
+      delegate :integration,
+               :transaction,
+               :dispute,
+               :settlement,
+               :id,
+               :domain,
+               :currency,
+               :amount,
+               :refunded_at,
+               :expected_at,
+               :channel,
+               :refunded_by,
+               :customer_note,
+               :merchant_note,
+               :deducted_amount,
+               :fully_deducted,
+               :bank_reference,
+               :reason,
+               :customer,
+               :initiated_by,
+               :reversed_at,
+               :session_id, to: :data
+    end
+
+    # Error response from #retry.
+    class RetryError < ApiError; end
+
+    # https://paystack.com/docs/api/refund/#retry
+    # Retry Refund: POST /refund/retry_with_customer_details/{id}
+    # Retry a refund with a `needs-attention` status by providing the bank account details
+    # of a customer.
+    #
+    # @param id [Integer] (required)
+    #        The identifier of the refund
+    # @param refund_account_details [Hash] (required)
+    #        An object that contains the customer’s account details for refund
+    #   @option refund_account_details [String] :currency
+    #           The currency of the customer's bank account. It should be the same as the currency
+    #           the payment was made
+    #   @option refund_account_details [String] :account_number
+    #           The customer's account number
+    #   @option refund_account_details [String] :bank_id
+    #           The ID representing the customer's bank. You can get the list of bank IDs by calling
+    #           the List Banks endpoint.
+    #
+    # @return [RetryResponse] successful response
+    # @raise [RetryError] if the request fails
+    api_method def self.retry(id:, refund_account_details:)
+      use_connection do |connection|
+        connection.post(
+          "/refund/retry_with_customer_details/#{id}",
+          { refund_account_details: }.compact,
+        )
+      end
+    end
+
+    # Successful response from calling #fetch.
+    class FetchResponse < PaystackGateway::Response
+      delegate :integration,
+               :transaction,
+               :dispute,
+               :settlement,
+               :id,
+               :domain,
+               :currency,
+               :amount,
+               :refunded_at,
+               :refunded_by,
+               :customer_note,
+               :merchant_note,
+               :deducted_amount,
+               :fully_deducted,
+               :createdAt,
+               :bank_reference,
+               :transaction_reference,
+               :reason,
+               :customer,
+               :refund_type,
+               :transaction_amount,
+               :initiated_by,
+               :refund_channel,
+               :session_id,
+               :collect_account_number, to: :data
+    end
+
+    # Error response from #fetch.
+    class FetchError < ApiError; end
+
+    # https://paystack.com/docs/api/refund/#fetch
+    # Fetch Refund: GET /refund/{id}
+    # Get a previously created refund
+    #
+    # @param id [Integer] (required)
+    #        The identifier of the refund
+    #
+    # @return [FetchResponse] successful response
+    # @raise [FetchError] if the request fails
+    api_method def self.fetch(id:)
+      use_connection do |connection|
+        connection.get(
+          "/refund/#{id}",
+        )
+      end
+    end
+  end
+end

data/lib/paystack_gateway/refunds.rb

@@ -1,61 +1,3 @@
 # frozen_string_literal: true
 
-module PaystackGateway
-  # Create and manage transaction refunds.
-  # https://paystack.com/docs/api/refund
-  module Refunds
-    include PaystackGateway::RequestModule
-
-    # Common helpers for responses from refunds endpoints
-    module TransactionRefundResponse
-      def refund_success? = transaction_status == :processed
-      def refund_failed? = transaction_status == :failed
-      def refund_pending? = transaction_status.in?(%i[pending processing])
-    end
-
-    # Response from POST /refund endpoint.
-    class CreateResponse < PaystackGateway::Response
-      include TransactionResponse
-      include TransactionRefundResponse
-    end
-
-    api_method def self.create(transaction_reference_or_id:)
-      use_connection do |connection|
-        connection.post('/refund', { transaction: transaction_reference_or_id })
-      end
-    end
-
-    # Response from GET /refund endpoint.
-    class ListRefundsResponse < PaystackGateway::Response
-      def pending_or_successful
-        filtered = data.select { _1.status&.to_sym.in?(%i[processed pending processing]) }
-
-        ListRefundsResponse.new({ **self, data: filtered })
-      end
-
-      def with_amount(amount)
-        filtered = data.select { _1.amount == amount * 100 }
-
-        ListRefundsResponse.new({ **self, data: filtered })
-      end
-    end
-
-    api_method def self.list_refunds(transaction_id:)
-      use_connection do |connection|
-        connection.get('/refund', { transaction: transaction_id })
-      end
-    end
-
-    # Response from GET /refund/:id endpoint.
-    class FetchRefundResponse < PaystackGateway::Response
-      include TransactionResponse
-      include TransactionRefundResponse
-    end
-
-    api_method def self.fetch_refund(refund_id:)
-      use_connection do |connection|
-        connection.get("/refund/#{refund_id}")
-      end
-    end
-  end
-end
+require 'paystack_gateway/legacy/refunds'

data/lib/paystack_gateway/request_module.rb

@@ -54,29 +54,28 @@ module PaystackGateway
       def api_method(method_name)
         @api_method_names ||= Set.new
         @api_method_names << method_name
-
-        decorate_api_methods(method_name)
       end
 
-      def decorate_api_methods(*method_names)
+      def decorate_api_methods(method_names = api_methods)
         singleton_class.class_exec do
-          prepend(Module.new do
-            method_names.flatten.each do |method_name|
-              define_method(method_name) do |*args, **kwargs, &block|
-                Current.with(api_module: self, api_method_name: method_name) do
-                  super(*args, **kwargs, &block)
-                rescue Faraday::Error => e
-                  handle_error(e)
-                end
+          method_names.flatten.each do |method_name|
+            implementation = instance_method(method_name)
+            remove_method(method_name)
+
+            define_method(method_name) do |*args, **kwargs, &block|
+              PaystackGateway::Current.with(api_module: self, api_method_name: method_name) do
+                implementation.bind_call(self, *args, **kwargs, &block)
+              rescue Faraday::Error => e
+                handle_error(e)
               end
             end
-          end)
+          end
         end
       end
 
       def handle_error(error)
-        PaystackGateway.logger.error "#{Current.qualified_api_method_name}: #{error.message}"
-        PaystackGateway.logger.error JSON.pretty_generate(filtered_response(error.response) || {}) if error.response
+        PaystackGateway.logger.error { "#{Current.qualified_api_method_name}: #{error.message}" }
+        PaystackGateway.logger.debug { JSON.pretty_generate(filtered_response(error.response) || {}) } if error.response
 
         raise Current.error_class.new(
           "Paystack error: #{error.message}, status: #{error.response_status}, response: #{error.response_body}",
@@ -91,7 +90,13 @@ module PaystackGateway
           request_method: response.dig(:request, :method),
           request_url: response.dig(:request, :url),
           request_headers: PaystackGateway.log_filter.call(response.dig(:request, :headers)),
-          request_body: PaystackGateway.log_filter.call(JSON.parse(response.dig(:request, :body) || '{}')),
+          request_body: PaystackGateway.log_filter.call(
+            begin
+              JSON.parse(response.dig(:request, :body) || '{}')
+            rescue JSON::ParserError
+              response.dig(:request, :body)
+            end,
+          ),
 
           response_status: response[:status],
           response_headers: PaystackGateway.log_filter.call(response[:headers]),