kobana 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e38b461dc88bcecd8dde4c85c696b588239907f531eccad3f0e06e9a895f8a5
-  data.tar.gz: a8c09d5b98e20f982dffbbffec3b4ce50277d09a8dbf4d65055b3767ff4cf2d3
+  metadata.gz: 0e0b0639fe29a20f6f650718a0669a52a4a0ec26be7b4dfb2d3aed802d23de1d
+  data.tar.gz: a000e4c09633901fd7a379d4ba91251864bcfec4c78914b31a9c72fd28993f1d
 SHA512:
-  metadata.gz: f4ef8fb5d176a78645aa8fca88ce9be5208a51dee2f558107d3f274a446dbda056b47c8d67c0656f09fd1ca9571c30f1b98a2f3e27dc756ca47d4b34dc93ce4d
-  data.tar.gz: 1fd2fa615f8e353c17fc1bf949dd9ca7b2e03807f1819640eca8a3142fe67278dbc22edb34952d24a9959d5c97c7eea762d3ecb9ec6b99754e5620d11efc27e1
+  metadata.gz: '0194334668913ae15ec91ff9473e25407343094d405a81c71fd1651c69dacbc9af920a326f1b02ef628f247f8c7ec7b4222ec650a89df6b756dd8c339bf12d29'
+  data.tar.gz: 153fc2b9af819e1881140d25935f9b939de25a2a0c76edfe66fc73e8919825a79d845eccfcae4de756585e7a6dab23d0e338a93075a4836e5de6b4e2a8887d1d

data/README.md

@@ -40,32 +40,23 @@ Configure your API key by creating an initializer in your Rails project:
 
 `config/initializers/kobana.rb`
 
-```ruby
-Kobana.api_key = 'YOUR_API_KEY_HERE'
-```
-
-Replace `'YOUR_API_KEY_HERE'` with your actual API key.
-
-### Usage
-
-To use this gem:
-
-#### **Configuration**
-
 ```ruby
 Kobana.configure do |config|
-  config.api_token = 'YOUR_API_KEY'
+  config.api_token = 'YOUR_API_TOKEN'
   config.environment = :sandbox # you can specify the environment as :development, :sandbox, or :production
-  config.api_version = :v1 #or :v2
 end
 ```
 
+Replace `'YOUR_API_TOKEN'` with your actual API key from the corresponding environment.
+
+### Usage
+
 #### **Charges**
 
 ##### Creating a Charge
 
 ```ruby
-charge_data = {
+attributes = {
   'amount' => 100.50,
   'payer' => {
     'document_number' => '1234567890',
@@ -80,26 +71,35 @@ charge_data = {
   'custom_data' => '{"order_id": "12345"}'
 }
 
-charge = Kobana::Resources::Charge::Pix.new
-result = charge.create(charge_data)
-puts result
+pix = Kobana::Resources::Charge::Pix.create(attributes)
+pix.id # 1
+pix.new_record? false
+pix.created? # true
+pix.attributes # {}
+
+
+pix = Kobana::Resources::Charge::Pix.new(attributes)
+pix.id nil
+pix.new_record? # true
+pix.created? # false
+pix.attributes # {}
+
+pix.save
 ```
 
 ##### Fetching a Charge
 
 ```ruby
 charge_id = 1  # Replace with your charge ID
-charge = Kobana::Resources::Charge::Pix.new
-result = charge.find(charge_id)
-puts result
+pix = Kobana::Resources::Charge::Pix.find(charge_id)
+puts pix
 ```
 
 ##### Listing All Charges
 
 ```ruby
-charge = Kobana::Resources::Charge::Pix.new
 params = { status: ["opened", "overdue"], page: 2 }
-results = charge.index(params)
+results = Kobana::Resources::Charge::Pix.all(params)
 puts result
 ```
 
@@ -108,26 +108,23 @@ puts result
 ##### Creating a Bank Billet
 
 ```ruby
-bank_billet_data = { ... }
+attributes = { ... }
 
-bank_billet = Kobana::Resources::BankBillet::BankBillet.new
-result = bank_billet.create(bank_billet_data)
-puts result
+bank_billet = Kobana::Resources::BankBillet::BankBillet.create(attributes)
+puts bank_billet
 ```
 
 ##### Fetching a Bank Billet
 
 ```ruby
 bank_billet_id = 1  # Replace with your charge ID
-bank_billet = Kobana::Resources::BankBillet::BankBillet.new
-result = bank_billet.find(bank_billet_id)
-puts result
+bank_billet = Kobana::Resources::BankBillet::BankBillet.find(bank_billet_id)
+puts bank_billet
 ```
 
 ##### Listing All Bank Billets
 
 ```ruby
-bank_billet = Kobana::Resources::BankBillet::BankBillet.new
-result = bank_billet.index
-puts result
+bank_billets = Kobana::Resources::BankBillet::BankBillet.all
+puts bank_billets
 ```

data/Rakefile

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
+require "bundler"
+Bundler.setup(:development)
+
+require "dotenv/load"
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
 require "rubocop/rake_task"
-
 RuboCop::RakeTask.new
 
+Dir.glob("lib/tasks/*.rake").each { |r| load r }
+
 task default: %i[spec rubocop]

data/lib/kobana/configuration.rb

@@ -2,11 +2,11 @@
 
 module Kobana
   class Configuration
-    attr_accessor :api_token, :environment, :custom_headers, :api_version, :debug
+    attr_accessor :api_token, :environment, :custom_headers, :debug
 
     def initialize
       @custom_headers = {}
-      @environment = :development
+      @environment = :sandbox
     end
   end
 end

data/lib/kobana/resources/admin/subaccount.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kobana
+  module Resources
+    module Admin
+      class Subaccount < Base
+        self.primary_key = :id
+      end
+    end
+  end
+end

data/lib/kobana/resources/base.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Kobana
+  module Resources
+    class Base
+      include Connection
+      include Operations
+
+      class << self
+        attr_accessor :primary_key, :api_version, :resource_endpoint, :errors, :default_attributes
+
+        def inherited(subclass)
+          super
+          subclass.resource_endpoint ||= infer_resource_endpoint(subclass)
+          subclass.primary_key ||= :uid
+          subclass.api_version ||= :v2
+          subclass.errors ||= []
+          subclass.default_attributes ||= {}
+        end
+
+        def infer_resource_endpoint(klass)
+          return resource_endpoint if resource_endpoint
+
+          return unless klass.name =~ /Kobana::Resources::(.*)$/
+
+          ::Regexp.last_match(1).underscore.pluralize
+        end
+
+        def uri(attributes = {})
+          "#{base_url}/#{interpolate(resource_endpoint, default_attributes.merge(attributes))}"
+        end
+
+        def interpolate(template, attributes)
+          template.gsub(/\{([^\}]+)\}/) do
+            key = Regexp.last_match(1)
+            begin
+              attributes[key.to_sym].to_s
+            rescue NameError
+              "{#{key}}" # Keep original if variable is undefined
+            end
+          end
+        end
+      end
+
+      attr_accessor :attributes, :errors
+
+      def initialize(attributes = {})
+        @attributes = attributes.deep_symbolize_keys
+        @errors = []
+      end
+
+      def [](key)
+        attributes[key.to_sym]
+      end
+
+      def method_missing(key, *args, &)
+        if key.to_s.end_with?("=")
+          key = key.to_s.chomp("=").to_sym
+          attributes[key] = args.first
+        else
+          return unless attributes.key?(key.to_sym)
+
+          attributes[key]
+        end
+      end
+
+      def respond_to_missing?(key, include_private = false)
+        attributes.key?(key.to_sym) || super
+      end
+
+      def uri
+        "#{self.class.uri(attributes)}/#{attributes[self.class.primary_key]}"
+      end
+
+      def request(*)
+        self.class.request(*)
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def created?
+        attributes[:created] || false
+      end
+
+      def updated?
+        attributes[:updated] || false
+      end
+
+      def new_record?
+        primary_key.nil? || primary_key.to_s.empty?
+      end
+
+      def primary_key
+        attributes[self.class.primary_key]
+      end
+    end
+  end
+end

data/lib/kobana/resources/charge/bank_billet.rb

@@ -4,19 +4,21 @@ module Kobana
   module Resources
     module Charge
       class BankBillet < Base
-        include ResourceOperations
+        self.primary_key = :id
+        self.api_version = :v1
+        self.resource_endpoint = "bank_billets"
 
-        @resource_endpoint = "bank_billets"
-
-        class << self
-          attr_reader :resource_endpoint
-        end
-
-        def cancel(resource_id)
-          url = "#{base_url}/#{endpoint}/#{resource_id}/cancel"
-          response = connection.put(url)
-          { status: response.status, data: {} }
+        # rubocop:disable Naming/PredicateMethod
+        def cancel
+          response = request(:put, "#{uri}/cancel")
+          case response[:status]
+          when 204
+            true
+          else
+            false
+          end
         end
+        # rubocop:enable Naming/PredicateMethod
       end
     end
   end

data/lib/kobana/resources/charge/pix.rb

@@ -4,13 +4,7 @@ module Kobana
   module Resources
     module Charge
       class Pix < Base
-        include ResourceOperations
-
-        @resource_endpoint = "charge/pix"
-
-        class << self
-          attr_reader :resource_endpoint
-        end
+        self.resource_endpoint = "charge/pix"
       end
     end
   end

data/lib/kobana/resources/connection.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Kobana
+  module Resources
+    module Connection
+      BASE_URI = {
+        v2: {
+          sandbox: "https://api-sandbox.kobana.com.br/v2",
+          production: "https://api.kobana.com.br/v2",
+          development: "http://localhost:5000/api/v2"
+        },
+        v1: {
+          sandbox: "https://api-sandbox.kobana.com.br/v1",
+          production: "https://api.kobana.com.br/v1",
+          development: "http://localhost:5000/api/v1"
+        }
+      }.freeze
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def headers
+          {
+            "Authorization" => "Bearer #{Kobana.configuration.api_token}",
+            "Content-Type" => "application/json"
+          }.merge(Kobana.configuration.custom_headers)
+        end
+
+        def connection
+          Faraday.new(url: base_url) do |faraday|
+            faraday.request :url_encoded
+            faraday.request :json
+            faraday.adapter Faraday.default_adapter
+            faraday.headers = headers
+            faraday.response :logger, logger if Kobana.configuration.debug
+          end
+        end
+
+        def multipart_connection
+          Faraday.new(url: base_url) do |faraday|
+            faraday.request :multipart
+            faraday.request :url_encoded
+            faraday.adapter :net_http
+            faraday.headers = headers.merge(
+              "Content-Type" => "multipart/form-data"
+            )
+            faraday.response :logger, logger if Kobana.configuration.debug
+          end
+        end
+
+        def logger
+          logger = Logger.new($stdout)
+          logger.formatter = proc do |severity, datetime, _progname, msg|
+            redacted_msg = msg.gsub(/(Bearer|Token)\s+[A-Za-z0-9\-_\.]+/, '\1 [REDACTED]')
+            "#{severity} #{datetime}: #{redacted_msg}\n"
+          end
+          logger
+        end
+
+        def request(method, url, params_or_body = nil, options = {})
+          self.errors = []
+          response = if options[:multipart]
+                       multipart_connection.send(method, url, params_or_body)
+                     else
+                       connection.send(method, url, params_or_body)
+                     end
+          parse_response(response)
+        end
+
+        def parse_response(response)
+          body_parsed = begin
+            JSON.parse(response.body, symbolize_names: true)
+          rescue JSON::ParserError
+            response.body
+          end
+
+          if body_parsed.is_a?(String) || body_parsed.is_a?(Array) || !body_parsed.key?(:data)
+            { status: response.status, data: body_parsed }
+          else
+            body_parsed
+          end
+        end
+
+        def base_url
+          @base_url ||= BASE_URI[api_version&.to_sym][Kobana.configuration.environment&.to_sym]
+        end
+      end
+    end
+  end
+end

data/lib/kobana/resources/financial/account.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kobana
+  module Resources
+    module Financial
+      class Account < Base
+      end
+    end
+  end
+end

data/lib/kobana/resources/financial/account_balance.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kobana
+  module Resources
+    module Financial
+      class AccountBalance < Base
+        self.resource_endpoint = "financial/accounts/{financial_account_uid}/balances"
+      end
+    end
+  end
+end

data/lib/kobana/resources/financial/statement_transactions_import.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kobana
+  module Resources
+    module Financial
+      class StatementTransactionsImport < Base
+        self.resource_endpoint = "financial/accounts/{financial_account_uid}/statement_transactions/imports"
+
+        def self.create(attributes = {})
+          require "faraday/multipart"
+
+          if attributes[:source].is_a?(String) && File.exist?(attributes[:source])
+            attributes[:source] = Faraday::UploadIO.new(
+              attributes[:source],
+              attributes.delete(:source_mime_type) || "application/octet-stream",
+              attributes.delete(:source_filename) || File.basename(attributes[:source])
+            )
+          end
+          super(attributes, multipart: true)
+        end
+      end
+    end
+  end
+end

data/lib/kobana/resources/operations.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Kobana
+  module Resources
+    module Operations
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def all(params = {})
+          response = request(:get, uri(params), params)
+          case response[:status]
+          when 200
+            response[:data].map { |data| new(data) }
+          else
+            handle_error_response(response)
+            []
+          end
+        end
+
+        def find_by(params = {}, options = {})
+          result = all(params)
+          return nil if result.empty? || (result.size > 1 && options[:ignore_multiple])
+
+          match = params.all? do |key, value|
+            result.first[key] == value
+          end
+          return unless match
+
+          result.first
+        end
+
+        def create(attributes = {}, options = {})
+          response = request(:post, uri(attributes), attributes, options)
+          case response[:status]
+          when 201
+            new(response[:data].merge(created: true))
+          else
+            handle_error_response(response)
+            resource = new(attributes.merge(created: false))
+            resource.errors = @errors
+            resource
+          end
+        end
+
+        def find(resource_id, params = {})
+          response = request(:get, "#{uri(params)}/#{resource_id}", params)
+          case response[:status]
+          when 200
+            new(response[:data])
+          else
+            handle_error_response(response)
+            nil
+          end
+        end
+
+        def find_or_create_by(params, attributes = {}, options = {})
+          options = { ignore_multiple: false, find_by_id: false, find_params: nil }.merge(options)
+          if options[:find_by_id]
+            find(params, options[:find_params]) || create(attributes)
+          else
+            find_by(params, options) || create(attributes.merge(params.deep_symbolize_keys))
+          end
+        end
+
+        def handle_error_response(response)
+          return unless response[:data].is_a?(Hash)
+
+          @errors = response[:data][:errors] if response[:data].key?(:errors)
+          @errors = [title: response[:data][:error]] if response[:data].key?(:error)
+        end
+      end
+
+      def update(new_attributes = {})
+        return if new_attributes.empty?
+
+        data = attributes.merge(new_attributes.deep_symbolize_keys)
+        response = request(:put, uri, data.to_json)
+        case response[:status]
+        when 200..204
+          new(response[:data].merge(updated: true))
+        else
+          handle_error_response(response)
+          resource = new(attributes.merge(updated: false))
+          resource.errors = @errors
+          resource
+        end
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def delete
+        response = request(:delete, uri)
+        case response[:status]
+        when 204
+          true
+        else
+          handle_error_response(response)
+          false
+        end
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      def list_commands(params = {})
+        response = request(:get, "#{uri}/commands", params)
+        case response[:status]
+        when 200
+          # response[:data].map { |command| Kobana::Resources::Command.new(command) }
+          response[:data].map { |command| command }
+        else
+          handle_error_response(response)
+          []
+        end
+      end
+
+      def find_command(command_id)
+        raise ArgumentError, "Command ID cannot be nil" if command_id.nil?
+
+        response = request(:get, "#{uri}/commands/#{command_id}")
+        case response[:status]
+        when 200
+          # response[:data].map { |command| Kobana::Resources::Command.new(command) }
+          response[:data].map { |command| command }
+        else
+          handle_error_response(response)
+          nil
+        end
+      end
+
+      def handle_error_response(response)
+        self.class.handle_error_response(response)
+        @errors = self.class.errors
+      end
+    end
+  end
+end

data/lib/kobana/version.rb

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

data/lib/kobana.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+$LOAD_PATH.unshift(File.expand_path(".", __dir__))
+
 require "faraday"
 require "json"
+require "support/string"
+require "support/hash"
 require "kobana/configuration"
 
 module Kobana
@@ -17,14 +21,25 @@ module Kobana
     end
   end
 
-  autoload :Base, "kobana/base"
   autoload :Version, "kobana/version"
 
   module Resources
-    autoload :ResourceOperations, "kobana/resources/resource_operations"
+    autoload :Base, "kobana/resources/base"
+    autoload :Connection, "kobana/resources/connection"
+    autoload :Operations, "kobana/resources/operations"
     module Charge
       autoload :Pix, "kobana/resources/charge/pix"
       autoload :BankBillet, "kobana/resources/charge/bank_billet"
     end
+
+    module Financial
+      autoload :Account, "kobana/resources/financial/account"
+      autoload :AccountBalance, "kobana/resources/financial/account_balance"
+      autoload :StatementTransactionsImport, "kobana/resources/financial/statement_transactions_import"
+    end
+
+    module Admin
+      autoload :Subaccount, "kobana/resources/admin/subaccount"
+    end
   end
 end

data/lib/support/hash.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Hash
+  def deep_symbolize_keys
+    result = {}
+    each do |key, value|
+      sym_key = key.respond_to?(:to_sym) ? key.to_sym : key
+      result[sym_key] =
+        case value
+        when Hash
+          value.deep_symbolize_keys
+        when Array
+          value.map { |v| v.is_a?(Hash) ? v.deep_symbolize_keys : v }
+        else
+          value
+        end
+    end
+    result
+  end
+  # rubocop:enable Metrics/MethodLength
+end

data/lib/support/string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class String
+  def pluralize
+    if end_with?("y") && !%w[a e i o u].include?(self[-2].downcase)
+      "#{self[0..-2]}ies"
+    elsif end_with?("s", "sh", "ch", "x", "z")
+      "#{self}es"
+    else
+      "#{self}s"
+    end
+  end
+
+  def underscore
+    word = gsub("::", "/")
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    word.tr!("-", "_")
+    word.downcase
+  end
+end

data/lib/tasks/development.rake

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+desc "Start an interactive console"
+task :console do
+  require "irb"
+
+  # Load the application environment if needed
+  require File.expand_path("../kobana.rb", __dir__)
+  require File.expand_path("../../spec/support/1password.rb", __dir__)
+
+  # Start the IRB session
+  IRB.start
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kobana
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Kivanio Barbosa
-autorequire:
+- Rafael Lima
 bindir: bin
 cert_chain: []
-date: 2025-01-03 00:00:00.000000000 Z
+date: 2025-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -30,6 +30,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  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: json
   requirement: !ruby/object:Gem::Requirement
@@ -47,6 +61,7 @@ dependencies:
 description: Kobana API Client
 email:
 - kivanio@gmail.com
+- rafael.lima@kobana.com.br
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -56,14 +71,23 @@ files:
 - README.md
 - Rakefile
 - lib/kobana.rb
-- lib/kobana/base.rb
 - lib/kobana/configuration.rb
+- lib/kobana/resources/admin/subaccount.rb
+- lib/kobana/resources/base.rb
 - lib/kobana/resources/charge/bank_billet.rb
 - lib/kobana/resources/charge/pix.rb
-- lib/kobana/resources/resource_operations.rb
+- lib/kobana/resources/connection.rb
+- lib/kobana/resources/financial/account.rb
+- lib/kobana/resources/financial/account_balance.rb
+- lib/kobana/resources/financial/statement_transactions_import.rb
+- lib/kobana/resources/operations.rb
 - lib/kobana/version.rb
+- lib/support/hash.rb
+- lib/support/string.rb
+- lib/tasks/development.rake
 homepage: https://www.kobana.com.br/
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://github.com/universokobana/kobana-ruby-client
   changelog_uri: https://github.com/universokobana/kobana-ruby-client/releases
@@ -71,7 +95,6 @@ metadata:
   bug_tracker_uri: https://github.com/universokobana/kobana-ruby-client/issues
   documentation_uri: https://github.com/universokobana/kobana-ruby-client/wiki
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 3.6.1
 specification_version: 4
 summary: Kobana API Client
 test_files: []

data/lib/kobana/base.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "json"
-
-module Kobana
-  class Base
-    attr_reader :base_url, :custom_headers
-
-    BASE_URI = {
-      v2: {
-        sandbox: "https://api-sandbox.kobana.com.br/v2",
-        production: "https://api.kobana.com.br/v2",
-        development: "http://localhost:5000/api/v2"
-      },
-      v1: {
-        sandbox: "https://api-sandbox.kobana.com.br/v1",
-        production: "https://api.kobana.com.br/v1",
-        development: "http://localhost:5000/api/v1"
-      }
-    }.freeze
-
-    def initialize
-      config = Kobana.configuration
-
-      @api_key = config.api_token
-      @base_url = BASE_URI[config.api_version][config.environment]
-      @custom_headers = config.custom_headers
-      @debug = config.debug
-    end
-
-    private
-
-    def default_headers
-      {
-        "Authorization" => "Bearer #{@api_key}",
-        "Content-Type" => "application/json"
-      }
-    end
-
-    def connection
-      headers = default_headers.merge(@custom_headers)
-      Faraday.new(url: @base_url) do |faraday|
-        faraday.request :url_encoded
-        faraday.adapter Faraday.default_adapter
-        faraday.headers = headers
-        faraday.response :logger if @debug
-      end
-    end
-
-    def parse_response(response)
-      body_parsed = JSON.parse(response.body, symbolize_names: true)
-
-      if body_parsed.is_a?(Array) || !body_parsed.key?(:data)
-        { status: response.status, data: body_parsed }
-      else
-        body_parsed
-      end
-    end
-  end
-end

data/lib/kobana/resources/resource_operations.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Kobana
-  module Resources
-    module ResourceOperations
-      def index(params = {})
-        url = "#{base_url}/#{endpoint}"
-        response = connection.get(url, params)
-        parse_response(response)
-      end
-
-      def create(data)
-        url = "#{base_url}/#{endpoint}"
-        response = connection.post(url, data.to_json)
-        parse_response(response)
-      end
-
-      def find(resource_id)
-        url = "#{base_url}/#{endpoint}/#{resource_id}"
-        response = connection.get(url)
-        parse_response(response)
-      end
-
-      private
-
-      def endpoint
-        self.class.resource_endpoint
-      end
-    end
-  end
-end