dlocal_go 0.1.1 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 742994b45e67cb4d844d69cd4570795367e3f51fa0f6aaaa57d620679b1bbd99
-  data.tar.gz: 25fb5000d012caa135caa37c432ab3282d9e4a4eae875a5356aa209ce3a59836
+  metadata.gz: 23d32c3c1f09afe545b9d6337792969bf19a3b07068a60e77e3d1f41a8837061
+  data.tar.gz: 04acfaa27fc1ac98fa0222d7c9d3d427d3ab075378cd01983cbbb7242993b5b2
 SHA512:
-  metadata.gz: bf2f018e82417debfb6f3108da4d0fbd4552509861ee16cb5cae9d1ffb5b068eb008d8fc2e43c994c811af188ceb042e72eff4e160e89b0bbe5a82d6882d772b
-  data.tar.gz: 42e6313c58bfc8ee44bedb9144f67cad7d49e90976897f3c3eb988fa46b57b6e278ba9f46c820524d2bade6d0d9f3ec2e52e66caedd924f4e5ddade9d2880db8
+  metadata.gz: 0be8022f5d868dbec5a81808e9e7a2c1f9d38b247e31cb94ab485359a1ec7564f24b3e96681aaa93237fe053f3bcce8d0b994befcb51d718829765c97ff734b3
+  data.tar.gz: 33c6ec1f139e3f07b4ae407c5475fb946d01c73c43632efd4f0d824d9d7eefafc964b4318d096179b8728c141daa906f0e6715ed369a702cefdb53527b5c9e74

data/.rubocop.yml

@@ -10,7 +10,10 @@ Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
 
 Layout/LineLength:
-  Max: 120
+  Max: 200
+
+Metrics/MethodLength:
+  Max: 15
 
 Metrics/BlockLength:
   Enabled: true

data/Gemfile.lock

@@ -1,43 +1,64 @@
 PATH
   remote: .
   specs:
-    dlocal_go (0.1.1)
+    dlocal_go (1.0)
+      activesupport
       http
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.1.3)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
     addressable (2.8.1)
       public_suffix (>= 2.0.2, < 6.0)
     ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.6)
+    concurrent-ruby (1.2.3)
+    connection_pool (2.4.1)
     crack (0.4.5)
       rexml
     debug (1.6.2)
       irb (>= 1.3.6)
       reline (>= 0.3.1)
     diff-lcs (1.5.0)
-    domain_name (0.5.20190701)
-      unf (>= 0.0.5, < 1.0.0)
-    ffi (1.15.5)
+    domain_name (0.6.20240107)
+    drb (2.2.0)
+      ruby2_keywords
+    ffi (1.16.3)
     ffi-compiler (1.0.1)
       ffi (>= 1.0.0)
       rake
     hashdiff (1.0.1)
-    http (5.1.1)
+    http (5.2.0)
       addressable (~> 2.8)
+      base64 (~> 0.1)
       http-cookie (~> 1.0)
       http-form_data (~> 2.2)
-      llhttp-ffi (~> 0.4.0)
+      llhttp-ffi (~> 0.5.0)
     http-cookie (1.0.5)
       domain_name (~> 0.5)
     http-form_data (2.3.0)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
     io-console (0.5.11)
     irb (1.4.1)
       reline (>= 0.3.0)
     json (2.6.2)
-    llhttp-ffi (0.4.0)
+    llhttp-ffi (0.5.0)
       ffi-compiler (~> 1.0)
       rake (~> 13.0)
+    minitest (5.22.2)
+    mutex_m (0.2.0)
     parallel (1.22.1)
     parser (3.1.2.1)
       ast (~> 2.4.1)
@@ -74,9 +95,9 @@ GEM
     rubocop-ast (1.21.0)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
-    unf (0.1.4)
-      unf_ext
-    unf_ext (0.0.8.2)
+    ruby2_keywords (0.0.5)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.2.0)
     webmock (3.18.1)
       addressable (>= 2.8.0)
@@ -85,6 +106,7 @@ GEM
 
 PLATFORMS
   arm64-darwin-21
+  arm64-darwin-23
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -13,14 +13,9 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install dlocal_go
 
-## Preview
-
-https://user-images.githubusercontent.com/57004457/222937723-c95ca31c-2871-4f0f-a61e-fd4c9738e75f.mp4
-
-
 ## Usage
 
-1. Configure DlocalGo in a initializer
+1. Configure DlocalGo inside an initializer
 
 ```ruby
   DlocalGo.setup do |config|
@@ -31,46 +26,85 @@ https://user-images.githubusercontent.com/57004457/222937723-c95ca31c-2871-4f0f-
   end
 ```
 
+2. Use the client to interact with the API
 
-2. Use the client to create a payment, get a payment, or create a refund.
+- If you need to send body parameters just pass a hash:
+
+```ruby
+  client = DlocalGo::Client.new
+  response = client.create_payment({country: "UY", currency: "UYU", amount: 500, notification_url: "https://notification.url"})
+  # or
+  # response = client.create_payment(country: "UY", currency: "UYU", amount: 500, notification_url: "https://notification.url")
+```
 
-- Create Payment
+- If you need to use path variables for specific endpoints you can also pass them as arguments
 
 ```ruby
-  params = {
-    country_code: "UY",
-    currency: "USD", # Optional, if not supplied, it uses the default currency for the country
-    amount: 100,
-    success_url: "https://success.url", # Where the user will be redirected after the payment is approved
-    back_url: "https://back.url", # Where the user is redirected if they go back from the checkout page
-    notification_url: "https://notification.url" # Optional, where the notification will be sent when payment state changes, (It will send a POST request with a payment_id param in the body, which can be used to retrieve the payment)
-  }
-  response = DlocalGo::Client.create_payment(params)
-  # If request is not successful, it will raise a DlocalGo::Error, otherwise the response will be a DlocalGo::Response::Payment object
-
-  # You might want to save the payment from the response before redirecting, so you can update the state later via a webhook (notification_url)
-  redirect_to response.redirect_url, allow_other_host: true
+  client = DlocalGo::Client.new
+
+  # This will replace the payment_id path variable in the uri: /v1/payments/:payment_id
+  response = client.get_payment(payment_id: "payment_id")
 ```
 
-- Get Payment
+- If you need to send query parameters just pass as a hash under a query_params key
 
 ```ruby
-  response = DlocalGo::Client.get_payment("payment_id")
-  # If request is not successful, it will raise a DlocalGo::Error, otherwise the response will be a DlocalGo::Response::Payment object
+  client = DlocalGo::Client.new
+  response = client.get_all_subscription_plans(query_params: {page: 2})
+  
+  # You can also use it with endpoints that require path variables. Eg:
+  response = client.get_subscriptions_by_plan(plan_id: 1234, query_params: {page: 2})
 ```
 
-- Create Refund
+3. Handle the response
+
+- We return DlocalGo::Responses objects (eg: DlocalGo::Responses::Payment) which have the same schema as the documentation responses.
+- All attributes inside responses use the snake_case syntax
+
+- NOTE: If the request fails we raise a DlocalGo::Error with an error code and message, so you might want to rescue it. (We'll make it optional in the future, for now we always raise an error when the request fails)
 
 ```ruby
-  params = {
-    payment_id: "payment_id_sample",
-    amount: 100,
-    reason: "reason_sample"
-  }
-  response = DlocalGo::Client.create_refund(params)
-  # If request is not successful, it will raise a DlocalGo::Error, otherwise the response will be a DlocalGo::Response::Refund object
+  def create
+    # Example:
+    response = client.create_payment({country: "UY", currency: "UYU", amount: 500, notification_url: "https://notification.url"})
+    redirect_to response.redirect_url, allow_other_host: true
+
+  rescue DlocalGo::Error => e
+    # Do sth else
+  end
 ```
 
+## Supported Endpoints
+
+We support all endpoints from the [DlocalGo API](https://docs.dlocalgo.com/integration-api)
+
+### Payments
+- [x] Create Payment: `client.create_payment(params)`
+- [x] Get Payment: `client.get_payment(payment_id: "the_id")`
+- [x] Create Refund: `client.create_refund(params)`
+- [x] Get Refund: `client.get_refund(refund_id: "the_id")`
+
+## Recurring Payments
+- [x] Create Recurring Payment: `client.create_recurring_payment(params)`
+- [x] Get Recurring Payment: `client.get_recurring_payment(recurring_link_token: "the_token")`
+- [x] Get All Recurring Payments: `client.get_all_recurring_payments`
+
+## Subscriptions
+- [x] Create Subscription Plan: `client.create_subscription_plan(params)`
+- [x] Update Subscription Plan: `client.update_subscription_plan(plan_id: "the_id", params)`
+- [x] Get All Subscription Plans: `client.get_all_subscription_plans`
+- [x] Get Subscription Plan: `client.get_subscription_plan(plan_id: "the_id")`
+- [x] Get Subscriptions by Plan: `client.get_subscriptions_by_plan(plan_id: "the_id")`
+- [x] Get All Executions by Subscription: `client.get_all_executions_by_subscription(plan_id: "the_id", subscription_id: "the_id")`
+- [x] Get Subscription Execution: `client.get_subscription_execution(subscription_id: "the_id", order_id: "the_id")`
+- [x] Cancel Plan: `client.cancel_plan(plan_id: "the_id")`
+- [x] Cancel Subscription: `client.cancel_subscription(plan_id: "the_id", subscription_id: "the_id")`
+
+
+# Endpoints request and response schema details
+
+- See the [DlocalGo API](https://docs.dlocalgo.com/integration-api) docs for more details on the request and response schema for each endpoint
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/MetaLabs-inc/dlocal_go.

data/lib/dlocal_go/client.rb

@@ -2,78 +2,58 @@
 
 require_relative "responses/payment"
 require_relative "responses/refund"
+require_relative "responses/recurring_payment"
+require_relative "responses/subscription_plan"
+require_relative "responses/subscription"
+require_relative "responses/subscription_execution"
+require_relative "endpoint_generator"
 
 module DlocalGo
   # Client for Dlocal Go API
   class Client
-    SANDBOX_URL = "https://api-sbx.dlocalgo.com"
-    PRODUCTION_URL = "https://api.dlocalgo.com"
-    DEFAULT_SUPPORTED_COUNTRIES = %w[UY AR CL BO BR CO CR EC GT ID MX MY PE PY].freeze
-    CURRENCY_FOR_COUNTRY = { UY: "UYU", AR: "ARS", CL: "CLP", BO: "BOB", BR: "BRL",
-                             CO: "COP", CR: "CRC", EC: "USD", GT: "GTQ", ID: "IDR", MX: "MXN",
-                             MY: "MYR", PE: "PEN", PY: "PYG" }.freeze
+    include DlocalGo::EndpointGenerator
 
     def initialize
-      @api_key = DlocalGo.api_key
-      @api_secret = DlocalGo.api_secret
-      @base_url = DlocalGo.environment == "production" ? PRODUCTION_URL : SANDBOX_URL
-
-      raise DlocalGo::Error, "Dlocal Go api key is not set" if @api_key.nil?
-      raise DlocalGo::Error, "Dlocal Go api secret is not set" if @api_secret.nil?
+      raise DlocalGo::Error, "Dlocal Go api key is not set" if api_key.nil?
+      raise DlocalGo::Error, "Dlocal Go api secret is not set" if api_secret.nil?
     end
 
-    def create_payment(params = {})
-      raise DlocalGo::Error, "Unsupported country" unless supported_countries.include?(params[:country_code])
-
-      uri = "/v1/payments"
-      body = { amount: params[:amount], country: params[:country_code], notification_url: params[:notification_url],
-               currency: params[:currency] || CURRENCY_FOR_COUNTRY[params[:country_code].to_sym],
-               success_url: params[:success_url], back_url: params[:back_url] }
-
-      response = HTTP.auth(auth_header).headers(json_content_type).post(endpoint_url(uri), json: body)
-
-      raise DlocalGo::Error, "Error creating checkout #{response.parse}" unless response.status.success?
+    # Request body requirements for each endpoint: https://docs.dlocalgo.com/integration-api/welcome-to-dlocal-go-api/
 
-      DlocalGo::Responses::Payment.new(OpenStruct.new(response.parse))
-    end
-
-    def get_payment(payment_id)
-      uri = "/v1/payments/#{payment_id}"
-      response = HTTP.auth(auth_header).get(endpoint_url(uri))
+    # ===== USAGE =====
+    #
 
-      raise DlocalGo::Error, "Error getting payment: #{response.parse}" unless response.status.success?
+    # For get and delete requests, send the path variables as a hash, for example: client.get_payment(payment_id: "123") and it will get replaced automatically inside the uri
+    # Also for get and delete requests, query params are taken from the query_params hash key, for example: client.get_all_subscription_plans(query_params: { page: 2 })
+    # This is an example that uses query and path params: client.get_all_executions_by_subscription(subscription_id: "123", plan_id: "456", query_params: { page: 2 })
 
-      DlocalGo::Responses::Payment.new(OpenStruct.new(response.parse))
-    end
+    # For post and put/patch requests, the hash variables will be included in the body instead
 
-    def create_refund(params = {})
-      uri = "/v1/refunds"
-      body = { payment_id: params[:payment_id], currency: params[:currency], amount: params[:amount],
-               notification_url: params[:notification_url] }
+    #
+    # ===== USAGE =====
 
-      response = HTTP.auth(auth_header).headers(json_content_type).post(endpoint_url(uri), json: body)
+    # PAYMENTS
+    endpoint :create_payment, uri: "/v1/payments", verb: :post, dto_class: DlocalGo::Responses::Payment
+    endpoint :get_payment, uri: "/v1/payments/:payment_id", verb: :get, dto_class: DlocalGo::Responses::Payment
+    endpoint :create_refund, uri: "/v1/refunds", verb: :post, dto_class: DlocalGo::Responses::Refund
+    endpoint :get_refund, uri: "/v1/refunds/:refund_id", verb: :get, dto_class: DlocalGo::Responses::Refund
 
-      raise DlocalGo::Error, "Error creating refund: #{response.parse}" unless response.status.success?
+    # RECURRING PAYMENTS
+    endpoint :create_recurring_payment, uri: "/v1/recurring-payments", verb: :post, dto_class: DlocalGo::Responses::RecurringPayment
+    endpoint :get_recurring_payment, uri: "/v1/recurring-payments/:recurring_link_token", verb: :get, dto_class: DlocalGo::Responses::RecurringPayment
+    endpoint :get_all_recurring_payments, uri: "/v1/recurring-payments", verb: :get, dto_class: DlocalGo::Responses::RecurringPayment
 
-      DlocalGo::Responses::Refund.new(OpenStruct.new(response.parse))
-    end
+    # SUBSCRIPTIONS
+    endpoint :create_subscription_plan, uri: "/v1/subscription/plan", verb: :post, dto_class: DlocalGo::Responses::SubscriptionPlan
+    endpoint :update_subscription_plan, uri: "/v1/subscription/plan/:plan_id", verb: :patch, dto_class: DlocalGo::Responses::SubscriptionPlan
+    endpoint :get_all_subscription_plans, uri: "/v1/subscription/plan/all", verb: :get, dto_class: DlocalGo::Responses::SubscriptionPlan
+    endpoint :get_subscription_plan, uri: "/v1/subscription/plan/:plan_id", verb: :get, dto_class: DlocalGo::Responses::SubscriptionPlan
 
-    private
+    endpoint :get_subscriptions_by_plan, uri: "/v1/subscription/plan/:plan_id/subscription/all", verb: :get, dto_class: DlocalGo::Responses::Subscription
+    endpoint :get_all_executions_by_subscription, uri: "/v1/subscription/plan/:plan_id/subscription/:subscription_id/execution/all", verb: :get, dto_class: DlocalGo::Responses::SubscriptionExecution
+    endpoint :get_subscription_execution, uri: "/v1/subscription/:subscription_id/execution/:order_id", verb: :get, dto_class: DlocalGo::Responses::SubscriptionExecution
 
-    def auth_header
-      "Bearer #{@api_key}:#{@api_secret}"
-    end
-
-    def json_content_type
-      { 'content-type': "application/json" }
-    end
-
-    def endpoint_url(endpoint_url)
-      "#{@base_url}#{endpoint_url}"
-    end
-
-    def supported_countries
-      DlocalGo.supported_countries || DEFAULT_SUPPORTED_COUNTRIES
-    end
+    endpoint :cancel_plan, uri: "/v1/subscription/plan/:plan_id/deactivate", verb: :patch, dto_class: DlocalGo::Responses::SubscriptionPlan
+    endpoint :cancel_subscription, uri: "/v1/subscription/plan/:plan_id/subscription/:subscription_id/deactivate", verb: :patch, dto_class: DlocalGo::Responses::Subscription
   end
 end

data/lib/dlocal_go/constants.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DlocalGo
+  # Constants we'll use throughout the gem
+  module Constants
+    SANDBOX_URL = "https://api-sbx.dlocalgo.com"
+    PRODUCTION_URL = "https://api.dlocalgo.com"
+
+    SUBSCRIPTION_BASE_SANDBOX_URL = "https://checkout-sbx.dlocalgo.com/validate/subscription"
+    SUBSCRIPTION_BASE_PRODUCTION_URL = "https://checkout.dlocalgo.com/validate/subscription"
+
+    DEFAULT_SUPPORTED_COUNTRIES = %w[UY AR CL BO BR CO CR EC GT ID MX MY PE PY].freeze
+    CURRENCY_FOR_COUNTRY = { UY: "UYU", AR: "ARS", CL: "CLP", BO: "BOB", BR: "BRL",
+                             CO: "COP", CR: "CRC", EC: "USD", GT: "GTQ", ID: "IDR", MX: "MXN",
+                             MY: "MYR", PE: "PEN", PY: "PYG" }.freeze
+
+    def currency_for_country(country)
+      CURRENCY_FOR_COUNTRY[country.to_sym]
+    end
+
+    private
+
+    def api_key
+      @api_key ||= DlocalGo.api_key
+    end
+
+    def api_secret
+      @api_secret ||= DlocalGo.api_secret
+    end
+
+    def base_url
+      @base_url ||= DlocalGo.environment == "production" ? PRODUCTION_URL : SANDBOX_URL
+    end
+
+    def subscription_base_url
+      @subscription_base_url ||= DlocalGo.environment == "production" ? SUBSCRIPTION_BASE_PRODUCTION_URL : SUBSCRIPTION_BASE_SANDBOX_URL
+    end
+
+    def supported_countries
+      @supported_countries ||= DlocalGo.supported_countries || DEFAULT_SUPPORTED_COUNTRIES
+    end
+  end
+end

data/lib/dlocal_go/endpoint_generator.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "http"
+
+require_relative "constants"
+require_relative "responses/array"
+
+module DlocalGo
+  # Module that allows us to define endpoints in the DlocalGo::Client class just by calling the endpoint method
+  module EndpointGenerator
+    include Constants
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # "Define the DSL"
+    module ClassMethods
+      def endpoint(method, uri:, verb:, dto_class:)
+        define_method(method) do |params = {}|
+          if params[:country].present? && supported_countries.exclude?(params[:country])
+            raise DlocalGo::Error,
+                  "Unsupported country"
+          end
+
+          response = call_api(verb, uri, params)
+          parse_response(response, dto_class)
+        end
+      end
+    end
+
+    private
+
+    def call_api(http_method, uri, params)
+      parsed_uri, keys_to_remove = parse_uri(uri, params)
+      url = endpoint_url(parsed_uri)
+      args = [http_method, url]
+      needs_body = %i[post put patch].include?(http_method)
+
+      request_body = params.except(*keys_to_remove)
+      args << { json: request_body } if needs_body
+
+      HTTP.auth(auth_header).headers(json_content_type).send(*args)
+    end
+
+    # We grab the query_params from the params hash
+    # We also grab the path variables from the params hash and replace them in the uri
+    # We return the uri and the keys from the params hash that we used so we can remove them later and not include them in the json body
+    def parse_uri(uri, params)
+      parsed_uri = uri
+      keys_to_remove = %i[query_params]
+      query_params = params[:query_params] || {}
+
+      params.each do |key, value|
+        next unless uri.include?(":#{key}")
+
+        parsed_uri = parsed_uri.gsub(":#{key}", value.to_s)
+        keys_to_remove << key
+      end
+
+      ["#{parsed_uri}?#{query_params.to_query}", keys_to_remove]
+    end
+
+    def parse_response(response, dto_class)
+      response_body = response.parse
+      unless response.status.success?
+        raise DlocalGo::Error.new(response_body["message"],
+                                  error_code: response_body["code"])
+      end
+
+      parse_successful_response(response_body, dto_class)
+    end
+
+    def parse_successful_response(response_body, dto_class)
+      struct = OpenStruct.new(response_body)
+      array_response = response_body["data"].is_a?(Array)
+
+      array_response ? DlocalGo::Responses::Array.new(struct, { data_class: dto_class }) : dto_class.new(struct)
+    end
+
+    def auth_header
+      "Bearer #{api_key}:#{api_secret}"
+    end
+
+    def json_content_type
+      { 'content-type': "application/json" }
+    end
+
+    def endpoint_url(endpoint_url)
+      "#{base_url}#{endpoint_url}"
+    end
+  end
+end

data/lib/dlocal_go/errors.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
 module DlocalGo
-  class Error < StandardError; end
+  # Generic error class for all errors that occur in the gem
+  class Error < StandardError
+    attr_reader :error_code
+
+    def initialize(message, error_code: nil)
+      @error_code = error_code
+      super(message)
+    end
+  end
 end

data/lib/dlocal_go/responses/array.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module DlocalGo
+  module Responses
+    # Wrapper for Dlocal Go array responses
+    class Array < DlocalGo::Responses::Base
+      has_array_data_attribute :data
+
+      has_attributes %i[
+        total_elements
+        total_pages
+        page
+        number_of_elements
+        size
+      ]
+    end
+  end
+end

data/lib/dlocal_go/responses/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "response_parser"
+
+module DlocalGo
+  module Responses
+    class Base
+      include DlocalGo::Responses::ResponseParser
+    end
+  end
+end

data/lib/dlocal_go/responses/payment.rb

@@ -1,19 +1,28 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module DlocalGo
   module Responses
     # Class that represents Dlocal Go payment schema
-    class Payment
-      RESPONSE_ATTRIBUTES = %i[id amount currency country created_date status order_id success_url back_url
-                               redirect_url merchant_checkout_token direct].freeze
-
-      attr_reader(*RESPONSE_ATTRIBUTES)
-
-      def initialize(response)
-        RESPONSE_ATTRIBUTES.each do |attribute|
-          instance_variable_set("@#{attribute}", response.send(attribute))
-        end
-      end
+    class Payment < DlocalGo::Responses::Base
+      has_attributes %i[
+        id
+        amount
+        currency
+        country
+        created_date
+        status
+        order_id
+        success_url
+        back_url
+        redirect_url
+        notification_url
+        merchant_checkout_token
+        approved_date
+        description
+        direct
+      ]
     end
   end
 end

data/lib/dlocal_go/responses/recurring_payment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module DlocalGo
+  module Responses
+    # Class that represents Dlocal Go recurring payment schema
+    class RecurringPayment < DlocalGo::Responses::Base
+      has_attributes %i[
+        currency
+        amount
+        recurring_link_token
+        enabled
+      ]
+    end
+  end
+end

data/lib/dlocal_go/responses/refund.rb

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module DlocalGo
   module Responses
     # Class that represents Dlocal Go refund schema
-    class Refund
-      RESPONSE_ATTRIBUTES = %i[id amount status].freeze
-
-      attr_reader(*RESPONSE_ATTRIBUTES)
-
-      def initialize(response)
-        RESPONSE_ATTRIBUTES.each do |attribute|
-          instance_variable_set("@#{attribute}", response.send(attribute))
-        end
-      end
+    class Refund < DlocalGo::Responses::Base
+      has_attributes %i[
+        id
+        amount
+        status
+      ]
     end
   end
 end

data/lib/dlocal_go/responses/response_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module DlocalGo
+  module Responses
+    # Module that makes it easier for DTOs to define their schema
+    module ResponseParser
+      def self.included(base)
+        base.class_eval { class_attribute :response_attributes, :response_associations, :array_data_attribute }
+
+        base.extend(ClassMethods)
+
+        base.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def initialize(response, options = {})
+            extract_options(options)
+
+            assign_attributes(response)
+            assign_associations(response)
+          end
+        CODE
+      end
+
+      # "Define the DSL" for all the DTOs
+      module ClassMethods
+        # rubocop:disable Naming/PredicateName
+        def has_attributes(attributes)
+          self.response_attributes = attributes
+
+          class_eval { attr_reader(*attributes) }
+        end
+
+        def has_association(attribute, klass)
+          self.response_associations ||= {}
+          self.response_associations[attribute] = klass
+
+          class_eval { attr_reader attribute }
+        end
+
+        def has_array_data_attribute(attribute)
+          self.array_data_attribute = attribute
+        end
+        # rubocop:enable Naming/PredicateName
+      end
+
+      private
+
+      def extract_options(options)
+        return unless options[:data_class].present?
+
+        raise ArgumentError, "array_data_attribute is required" if array_data_attribute.blank?
+
+        class_eval { has_association(array_data_attribute, options[:data_class]) }
+      end
+
+      def assign_attributes(response)
+        return if response_attributes.nil?
+
+        response_attributes.each do |attribute|
+          instance_variable_set("@#{attribute}",
+                                response.send(attribute) || response.send(attribute.to_s.camelize(:lower)))
+        end
+      end
+
+      def assign_associations(response)
+        return if self.response_associations.nil?
+
+        self.response_associations.each do |attribute, klass|
+          response_data = response.send(attribute) || response.send(attribute.to_s.camelize(:lower))
+
+          if response_data.instance_of?(::Array)
+            mapped_data = response_data.map do |data|
+              struct = OpenStruct.new(data)
+              klass.new(struct)
+            end
+
+            instance_variable_set("@#{attribute}", mapped_data)
+          else
+            struct = OpenStruct.new(response_data)
+            instance_variable_set("@#{attribute}", klass.new(struct))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dlocal_go/responses/subscription.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+require_relative "subscription_plan"
+
+module DlocalGo
+  module Responses
+    # Class that represents Dlocal Go subscription schema
+    class Subscription < DlocalGo::Responses::Base
+      has_attributes %i[
+        id
+        country
+        subscription_token
+        status
+        language
+        scheduled_date
+        active
+        client_id
+        client_first_name
+        client_last_name
+        client_document_type
+        client_document
+        client_email
+        card_token
+        created_at
+        updated_at
+      ]
+
+      has_association :plan, DlocalGo::Responses::SubscriptionPlan
+    end
+  end
+end

data/lib/dlocal_go/responses/subscription_execution.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "subscription"
+
+module DlocalGo
+  module Responses
+    # Class that represents Dlocal Go subscription plan execution schema
+    class SubscriptionExecution < DlocalGo::Responses::Base
+      has_attributes %i[
+        id
+        status
+        order_id
+        merchant_checkout_id
+        currency
+        amount_paid
+        amount_received
+        checkout_currency
+        balance_currency
+        created_at
+        updated_at
+      ]
+
+      has_association :subscription, DlocalGo::Responses::Subscription
+    end
+  end
+end

data/lib/dlocal_go/responses/subscription_plan.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module DlocalGo
+  module Responses
+    # Class that represents Dlocal Go subscription plan schema
+    class SubscriptionPlan < DlocalGo::Responses::Base
+      has_attributes %i[
+        id
+        merchant_id
+        name
+        description
+        country
+        currency
+        amount
+        frequency_type
+        frequency_value
+        active
+        free_trial_days
+        plan_token
+        back_url
+        notification_url
+        success_url
+        error_url
+        created_at
+        updated_at
+      ]
+    end
+  end
+end

data/lib/dlocal_go/utilities.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module DlocalGo
+  # Utilities for using the Dlocal Go API
+  class Utilities
+    include Constants
+
+    class << self
+      def subscription_url(token:, email: nil)
+        new.subscription_url(token: token, email: email)
+      end
+    end
+
+    def subscription_url(token:, email: nil)
+      email.present? ? "#{subscription_base_url}/#{token}?email=#{email}" : "#{base_url}#{token}"
+    end
+  end
+end

data/lib/dlocal_go/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DlocalGo
-  VERSION = "0.1.1"
+  VERSION = "1.0"
 end

data/lib/dlocal_go.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require "active_support/all"
+
 require_relative "dlocal_go/version"
 require_relative "dlocal_go/errors"
 require_relative "dlocal_go/client"
+require_relative "dlocal_go/utilities"
 
 # Main module for Dlocal Go, it provides a way to configure the gem and imports the client
 module DlocalGo

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dlocal_go
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: '1.0'
 platform: ruby
 authors:
 - matiassalles99
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-05 00:00:00.000000000 Z
+date: 2024-04-24 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
@@ -39,17 +53,23 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- dlocal_go.gemspec
 - lib/dlocal_go.rb
 - lib/dlocal_go/client.rb
+- lib/dlocal_go/constants.rb
+- lib/dlocal_go/endpoint_generator.rb
 - lib/dlocal_go/errors.rb
+- lib/dlocal_go/responses/array.rb
+- lib/dlocal_go/responses/base.rb
 - lib/dlocal_go/responses/payment.rb
+- lib/dlocal_go/responses/recurring_payment.rb
 - lib/dlocal_go/responses/refund.rb
+- lib/dlocal_go/responses/response_parser.rb
+- lib/dlocal_go/responses/subscription.rb
+- lib/dlocal_go/responses/subscription_execution.rb
+- lib/dlocal_go/responses/subscription_plan.rb
+- lib/dlocal_go/utilities.rb
 - lib/dlocal_go/version.rb
 - sig/dlocal_go.rbs
-- sig/dlocal_go/client.rbs
-- sig/dlocal_go/responses/payment.rbs
-- sig/dlocal_go/responses/refund.rbs
 homepage: https://github.com/MetaLabs-inc/dlocal_go
 licenses:
 - MIT
@@ -72,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Dlocal Go client for ruby

data/dlocal_go.gemspec

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/dlocal_go/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "dlocal_go"
-  spec.version = DlocalGo::VERSION
-  spec.authors = ["matiassalles99"]
-  spec.email = ["matiassalles99@gmail.com"]
-
-  spec.summary = "Dlocal Go client for ruby"
-  spec.description = "Dlocal Go client written in ruby to interact with Dlocal Go's API"
-  spec.homepage = "https://github.com/MetaLabs-inc/dlocal_go"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/MetaLabs-inc/dlocal_go"
-  spec.metadata["changelog_uri"] = "https://github.com/MetaLabs-inc/dlocal_go/blob/main/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "http"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-end

data/sig/dlocal_go/client.rbs

@@ -1,26 +0,0 @@
-module DlocalGo
-  class Client
-    CURRENCY_FOR_COUNTRY: Hash[Symbol, String]
-    DEFAULT_SUPPORTED_COUNTRIES: Array[String]
-    SANDBOX_URL: String
-    PRODUCTION_URL: String
-
-    @api_key: String
-    @api_secret: String
-    @base_url: String
-
-    def create_payment: -> Responses::Payment
-    def get_payment: -> Responses::Payment
-    def create_refund: -> Responses::Refund
-
-    private
-
-    def auth_header: -> untyped
-
-    def endpoint_url: -> untyped
-
-    def json_content_type: -> untyped
-
-    def supported_countries: -> untyped
-  end
-end

data/sig/dlocal_go/responses/payment.rbs

@@ -1,7 +0,0 @@
-module DlocalGo
-  module Responses
-    class Payment
-      RESPONSE_ATTRIBUTES: Array[Symbol]
-    end
-  end
-end

data/sig/dlocal_go/responses/refund.rbs

@@ -1,7 +0,0 @@
-module DlocalGo
-  module Responses
-    class Refund
-      RESPONSE_ATTRIBUTES: Array[Symbol]
-    end
-  end
-end