starkbank 2.5.0 → 2.7.0

data/lib/transfer/transfer.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative('../utils/resource')
+require('starkcore')
 require_relative('../utils/rest')
-require_relative('../utils/checks')
+
 
 module StarkBank
   # # Transfer object
@@ -15,7 +15,7 @@ module StarkBank
   # - amount [integer]: amount in cents to be transferred. ex: 1234 (= R$ 12.34)
   # - name [string]: receiver full name. ex: 'Anthony Edward Stark'
   # - tax_id [string]: receiver tax ID (CPF or CNPJ) with or without formatting. ex: '01234567890' or '20.018.183/0001-80'
-  # - bank_code [string]: code of the receiver bank institution in Brazil. If an ISPB (8 digits) is informed, a PIX transfer will be created, else a TED will be issued. ex: '20018183' or '260'
+  # - bank_code [string]: code of the receiver bank institution in Brazil. If an ISPB (8 digits) is informed, a Pix transfer will be created, else a TED will be issued. ex: '20018183' or '260'
   # - branch_code [string]: receiver bank account branch. Use '-' in case there is a verifier digit. ex: '1357-9'
   # - account_number [string]: receiver bank account number. Use '-' before the verifier digit. ex: '876543-2'
   #
@@ -25,17 +25,18 @@ module StarkBank
   # - scheduled [string, default now]: datetime when the transfer will be processed. May be pushed to next business day if necessary. ex: DateTime.new(2020, 3, 11, 8, 13, 12, 11)
   # - description [string, default nil]: optional description to override default description to be shown in the bank statement. ex: 'Payment for service #1234'
   # - tags [list of strings]: list of strings for reference when searching for transfers. ex: ['employees', 'monthly']
+  # - rules [list of Transfer::Rules, default []]: list of Transfer::Rule objects for modifying transfer behavior. ex: [Transfer::Rule(key: "resendingLimit", value: 5)]
   #
   # ## Attributes (return-only):
-  # - id [string, default nil]: unique id returned when Transfer is created. ex: '5656565656565656'
-  # - fee [integer, default nil]: fee charged when transfer is created. ex: 200 (= R$ 2.00)
-  # - status [string, default nil]: current transfer status. ex: 'success' or 'failed'
-  # - transaction_ids [list of strings, default nil]: ledger transaction ids linked to this transfer (if there are two, second is the chargeback). ex: ['19827356981273']
-  # - created [DateTime, default nil]: creation datetime for the transfer. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
-  # - updated [DateTime, default nil]: latest update datetime for the transfer. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
-  class Transfer < StarkBank::Utils::Resource
-    attr_reader :amount, :name, :tax_id, :bank_code, :branch_code, :account_number, :account_type, :external_id, :scheduled, :description, :transaction_ids, :fee, :tags, :status, :id, :created, :updated
-    def initialize(amount:, name:, tax_id:, bank_code:, branch_code:, account_number:, account_type: nil, external_id: nil, scheduled: nil, description: nil, transaction_ids: nil, fee: nil, tags: nil, status: nil, id: nil, created: nil, updated: nil)
+  # - id [string]: unique id returned when Transfer is created. ex: '5656565656565656'
+  # - fee [integer]: fee charged when transfer is created. ex: 200 (= R$ 2.00)
+  # - status [string]: current transfer status. ex: 'success' or 'failed'
+  # - transaction_ids [list of strings]: ledger transaction ids linked to this transfer (if there are two, second is the chargeback). ex: ['19827356981273']
+  # - created [DateTime]: creation datetime for the transfer. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - updated [DateTime]: latest update datetime for the transfer. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class Transfer < StarkCore::Utils::Resource
+    attr_reader :amount, :name, :tax_id, :bank_code, :branch_code, :account_number, :account_type, :external_id, :scheduled, :description, :transaction_ids, :fee, :tags, :rules, :status, :id, :created, :updated
+    def initialize(amount:, name:, tax_id:, bank_code:, branch_code:, account_number:, account_type: nil, external_id: nil, scheduled: nil, description: nil, transaction_ids: nil, fee: nil, tags: nil, rules: nil, status: nil, id: nil, created: nil, updated: nil)
       super(id)
       @amount = amount
       @name = name
@@ -45,14 +46,15 @@ module StarkBank
       @account_number = account_number
       @account_type = account_type
       @external_id = external_id
-      @scheduled = StarkBank::Utils::Checks.check_date_or_datetime(scheduled)
+      @scheduled = StarkCore::Utils::Checks.check_date_or_datetime(scheduled)
       @description = description
-      @transaction_ids = transaction_ids
-      @fee = fee
       @tags = tags
+      @rules = StarkBank::Transfer::Rule.parse_rules(rules)
+      @fee = fee
       @status = status
-      @created = StarkBank::Utils::Checks.check_datetime(created)
-      @updated = StarkBank::Utils::Checks.check_datetime(updated)
+      @transaction_ids = transaction_ids
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
     end
 
     # # Create Transfers
@@ -138,8 +140,8 @@ module StarkBank
     # ## Return:
     # - generator of Transfer objects with updated attributes
     def self.query(limit: nil, after: nil, before: nil, transaction_ids: nil, status: nil, tax_id: nil, sort: nil, tags: nil, ids: nil, user: nil)
-      after = StarkBank::Utils::Checks.check_date(after)
-      before = StarkBank::Utils::Checks.check_date(before)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
       StarkBank::Utils::Rest.get_stream(
         limit: limit,
         after: after,
@@ -173,8 +175,8 @@ module StarkBank
     # ## Return:
     # - list of Transfer objects with updated attributes and cursor to retrieve the next page of Transfer objects
     def self.page(cursor: nil, limit: nil, after: nil, before: nil, transaction_ids: nil, status: nil, tax_id: nil, sort: nil, tags: nil, ids: nil, user: nil)
-      after = StarkBank::Utils::Checks.check_date(after)
-      before = StarkBank::Utils::Checks.check_date(before)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
       return StarkBank::Utils::Rest.get_page(
         cursor: cursor,
         limit: limit,
@@ -196,7 +198,6 @@ module StarkBank
         resource_name: 'Transfer',
         resource_maker: proc { |json|
           Transfer.new(
-            id: json['id'],
             amount: json['amount'],
             name: json['name'],
             tax_id: json['tax_id'],
@@ -207,10 +208,12 @@ module StarkBank
             external_id: json['external_id'],
             scheduled: json['scheduled'],
             description: json['description'],
-            transaction_ids: json['transaction_ids'],
-            fee: json['fee'],
             tags: json['tags'],
+            rules: json['rules'],
+            id: json['id'],
+            fee: json['fee'],
             status: json['status'],
+            transaction_ids: json['transaction_ids'],
             created: json['created'],
             updated: json['updated']
           )

data/lib/utility_payment/log.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative('../utils/resource')
+require('starkcore')
 require_relative('../utils/rest')
-require_relative('../utils/checks')
 require_relative('utility_payment')
 
+
 module StarkBank
   class UtilityPayment
     # # UtilityPayment::Log object
@@ -13,20 +13,20 @@ module StarkBank
     # is generated for the entity. This log is never generated by the user, but it can
     # be retrieved to check additional information on the UtilityPayment.
     #
-    # ## Attributes:
+    # ## Attributes (return-only):
     # - id [string]: unique id returned when the log is created. ex: '5656565656565656'
     # - payment [UtilityPayment]: UtilityPayment entity to which the log refers to.
     # - errors [list of strings]: list of errors linked to this UtilityPayment event.
     # - type [string]: type of the UtilityPayment event which triggered the log creation. ex: 'processing' or 'success'
     # - created [DateTime]: creation datetime for the log. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
-    class Log < StarkBank::Utils::Resource
+    class Log < StarkCore::Utils::Resource
       attr_reader :id, :created, :type, :errors, :payment
       def initialize(id:, created:, type:, errors:, payment:)
         super(id)
         @type = type
         @errors = errors
         @payment = payment
-        @created = StarkBank::Utils::Checks.check_datetime(created)
+        @created = StarkCore::Utils::Checks.check_datetime(created)
       end
 
       # # Retrieve a specific Log
@@ -60,8 +60,8 @@ module StarkBank
       # ## Return:
       # - list of Log objects with updated attributes
       def self.query(limit: nil, after: nil, before: nil, types: nil, payment_ids: nil, user: nil)
-        after = StarkBank::Utils::Checks.check_date(after)
-        before = StarkBank::Utils::Checks.check_date(before)
+        after = StarkCore::Utils::Checks.check_date(after)
+        before = StarkCore::Utils::Checks.check_date(before)
         StarkBank::Utils::Rest.get_stream(
           limit: limit,
           after: after,
@@ -90,8 +90,8 @@ module StarkBank
       # ## Return:
       # - list of Log objects with updated attributes and cursor to retrieve the next page of Log objects
       def self.page(cursor: nil, limit: nil, after: nil, before: nil, types: nil, payment_ids: nil, user: nil)
-        after = StarkBank::Utils::Checks.check_date(after)
-        before = StarkBank::Utils::Checks.check_date(before)
+        after = StarkCore::Utils::Checks.check_date(after)
+        before = StarkCore::Utils::Checks.check_date(before)
         return StarkBank::Utils::Rest.get_page(
           cursor: cursor,
           limit: limit,
@@ -114,7 +114,7 @@ module StarkBank
               created: json['created'],
               type: json['type'],
               errors: json['errors'],
-              payment: StarkBank::Utils::API.from_api_json(payment_maker, json['payment'])
+              payment: StarkCore::Utils::API.from_api_json(payment_maker, json['payment'])
             )
           }
         }

data/lib/utility_payment/utility_payment.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative('../utils/resource')
+require('starkcore')
 require_relative('../utils/rest')
-require_relative('../utils/checks')
+
 
 module StarkBank
   # # UtilityPayment object
@@ -23,24 +23,30 @@ module StarkBank
   # - tags [list of strings]: list of strings for tagging
   #
   # ## Attributes (return-only):
-  # - id [string, default nil]: unique id returned when payment is created. ex: '5656565656565656'
-  # - status [string, default nil]: current payment status. ex: 'success' or 'failed'
-  # - amount [int, default nil]: amount automatically calculated from line or bar_code. ex: 23456 (= R$ 234.56)
-  # - fee [integer, default nil]: fee charged when utility payment is created. ex: 200 (= R$ 2.00)
-  # - created [DateTime, default nil]: creation datetime for the payment. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
-  class UtilityPayment < StarkBank::Utils::Resource
-    attr_reader :description, :line, :bar_code, :tags, :scheduled, :id, :amount, :fee, :status, :created
-    def initialize(description:, line: nil, bar_code: nil, tags: nil, scheduled: nil, id: nil, amount: nil, fee: nil, status: nil, created: nil)
+  # - id [string]: unique id returned when payment is created. ex: '5656565656565656'
+  # - status [string]: current payment status. ex: 'success' or 'failed'
+  # - amount [int]: amount automatically calculated from line or bar_code. ex: 23456 (= R$ 234.56)
+  # - fee [integer]: fee charged when utility payment is created. ex: 200 (= R$ 2.00)
+  # - type [string]: payment type. ex: "utility"
+  # - transaction_ids [list of strings]: ledger transaction ids linked to this UtilityPayment. ex: ["19827356981273"]
+  # - created [DateTime]: creation datetime for the payment. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - updated [DateTime]: latest update datetime for the payment. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class UtilityPayment < StarkCore::Utils::Resource
+    attr_reader :description, :line, :bar_code, :tags, :scheduled, :id, :amount, :fee, :type, :transaction_ids, :status, :created, :updated
+    def initialize(description:, line: nil, bar_code: nil, tags: nil, scheduled: nil, id: nil, amount: nil, fee: nil, type: nil, transaction_ids: nil, status: nil, created: nil, updated: nil)
       super(id)
       @description = description
       @line = line
       @bar_code = bar_code
       @tags = tags
-      @scheduled = StarkBank::Utils::Checks.check_date(scheduled)
+      @scheduled = StarkCore::Utils::Checks.check_date(scheduled)
       @amount = amount
       @fee = fee
       @status = status
-      @created = StarkBank::Utils::Checks.check_datetime(created)
+      @type = type
+      @transaction_ids = transaction_ids
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
     end
 
     # # Create UtilityPayments
@@ -108,8 +114,8 @@ module StarkBank
     # ## Return:
     # - generator of UtilityPayment objects with updated attributes
     def self.query(limit: nil, after: nil, before: nil, tags: nil, ids: nil, status: nil, user: nil)
-      after = StarkBank::Utils::Checks.check_date(after)
-      before = StarkBank::Utils::Checks.check_date(before)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
       StarkBank::Utils::Rest.get_stream(
         limit: limit,
         after: after,
@@ -140,8 +146,8 @@ module StarkBank
     # ## Return:
     # - list of UtilityPayment objects with updated attributes and cursor to retrieve the next page of UtilityPayment objects
     def self.page(cursor: nil, limit: nil, after: nil, before: nil, tags: nil, ids: nil, status: nil, user: nil)
-      after = StarkBank::Utils::Checks.check_date(after)
-      before = StarkBank::Utils::Checks.check_date(before)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
       return StarkBank::Utils::Rest.get_page(
         cursor: cursor,
         limit: limit,
@@ -184,8 +190,11 @@ module StarkBank
             scheduled: json['scheduled'],
             amount: json['amount'],
             fee: json['fee'],
+            type: json['type'],
+            transaction_ids: json['transaction_ids'],
             status: json['status'],
-            created: json['created']
+            created: json['created'],
+            updated: json['updated']
           )
         }
       }

data/lib/utils/parse.rb

@@ -0,0 +1,35 @@
+require('starkcore')
+
+module StarkBank
+  module Utils
+    module Parse
+      def self.parse_and_verify(content:, signature:, user: nil, resource:, key: nil)
+        return StarkCore::Utils::Parse.parse_and_verify(
+          content: content, 
+          signature: signature, 
+          sdk_version: StarkBank::SDK_VERSION,
+          api_version: StarkBank::API_VERSION,
+          host: StarkBank::HOST,
+          resource: resource,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.language,
+          key: key
+        )
+      end
+
+      def self.verify(content:, signature:, user: nil)
+        return StarkCore::Utils::Parse.verify(
+          content: content, 
+          signature: signature, 
+          sdk_version: StarkBank::SDK_VERSION,
+          api_version: StarkBank::API_VERSION,
+          host: StarkBank::HOST,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.language
+        )
+      end
+    end
+  end
+end

data/lib/utils/rest.rb

@@ -1,135 +1,158 @@
 # frozen_string_literal: true
 
-require_relative('request')
-require_relative('api')
+require('starkcore')
 
 module StarkBank
   module Utils
     module Rest
-      def self.get_page(resource_name:, resource_maker:, user: nil, **query)
-        json = StarkBank::Utils::Request.fetch(
-          method: 'GET',
-          path: StarkBank::Utils::API.endpoint(resource_name),
-          query: query,
-          user: user
-        ).json
-        entities = []
-        json[StarkBank::Utils::API.last_name_plural(resource_name)].each do |entity_json|
-          entities << StarkBank::Utils::API.from_api_json(resource_maker, entity_json)
-        end
-        return entities, json['cursor']
-      end
-
-      def self.get_stream(resource_name:, resource_maker:, user: nil, **query)
-        limit = query[:limit]
-        query[:limit] = limit.nil? ? limit : [limit, 100].min
-
-        Enumerator.new do |enum|
-          loop do
-            json = StarkBank::Utils::Request.fetch(
-              method: 'GET',
-              path: StarkBank::Utils::API.endpoint(resource_name),
-              query: query,
-              user: user
-            ).json
-            entities = json[StarkBank::Utils::API.last_name_plural(resource_name)]
 
-            entities.each do |entity|
-              enum << StarkBank::Utils::API.from_api_json(resource_maker, entity)
-            end
+      def self.get_page(resource_name:, resource_maker:, user:, **query)
+        return StarkCore::Utils::Rest.get_page(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          **query
+        )
+      end
 
-            unless limit.nil?
-              limit -= 100
-              query[:limit] = [limit, 100].min
-            end
+      def self.get_stream(resource_name:, resource_maker:, user:, **query)
+        return StarkCore::Utils::Rest.get_stream(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          **query
+        )
+      end
 
-            cursor = json['cursor']
-            query['cursor'] = cursor
-            break if cursor.nil? || cursor.empty? || (!limit.nil? && limit <= 0)
-          end
-        end
+      def self.get_id(resource_name:, resource_maker:, user:, id:, **query)
+        return StarkCore::Utils::Rest.get_id(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          id: id,
+          **query
+        )
       end
 
-      def self.get_id(resource_name:, resource_maker:, id:, user: nil)
-        json = StarkBank::Utils::Request.fetch(
-          method: 'GET',
-          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}",
-          user: user
-        ).json
-        entity = json[StarkBank::Utils::API.last_name(resource_name)]
-        StarkBank::Utils::API.from_api_json(resource_maker, entity)
+      def self.get_content(resource_name:, resource_maker:, user:, sub_resource_name:, id:, **query)
+        return StarkCore::Utils::Rest.get_content(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          sub_resource_name: sub_resource_name, 
+          id: id,
+          **query
+        )
       end
 
-      def self.get_content(resource_name:, resource_maker:, sub_resource_name:, id:, user: nil, **query)
-        StarkBank::Utils::Request.fetch(
-          method: 'GET',
-          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}/#{sub_resource_name}",
-          query: StarkBank::Utils::API.cast_json_to_api_format(query),
-          user: user
-        ).content
+      def self.get_sub_resource(resource_name:, sub_resource_maker:, sub_resource_name:, user:, id:, **query)
+        return StarkCore::Utils::Rest.get_sub_resource(
+          resource_name: resource_name,
+          sub_resource_maker: sub_resource_maker, 
+          sub_resource_name: sub_resource_name, 
+          sdk_version: StarkBank::SDK_VERSION, 
+          host: StarkBank::HOST, 
+          api_version: StarkBank::API_VERSION, 
+          user: user ? user : StarkBank.user, 
+          language: StarkBank.language, 
+          timeout: StarkBank.timeout, 
+          id: id, 
+          **query
+        )
       end
 
-      def self.post(resource_name:, resource_maker:, entities:, user: nil)
-        jsons = []
-        entities.each do |entity|
-          jsons << StarkBank::Utils::API.api_json(entity)
-        end
-        payload = { StarkBank::Utils::API.last_name_plural(resource_name) => jsons }
-        json = StarkBank::Utils::Request.fetch(
-          method: 'POST',
-          path: StarkBank::Utils::API.endpoint(resource_name),
-          payload: payload,
-          user: user
-        ).json
-        returned_jsons = json[StarkBank::Utils::API.last_name_plural(resource_name)]
-        entities = []
-        returned_jsons.each do |returned_json|
-          entities << StarkBank::Utils::API.from_api_json(resource_maker, returned_json)
-        end
-        entities
+      def self.get_sub_resources(resource_name:, sub_resource_maker:, sub_resource_name:, user:, id:, **query)
+        return StarkCore::Utils::Rest.get_sub_resource(
+          resource_name: resource_name,
+          sub_resource_maker: sub_resource_maker, 
+          sub_resource_name: sub_resource_name, 
+          sdk_version: StarkBank::SDK_VERSION, 
+          host: StarkBank::HOST, 
+          api_version: StarkBank::API_VERSION, 
+          user: user ? user : StarkBank.user, 
+          language: StarkBank.language, 
+          timeout: StarkBank.timeout, 
+          id: id, 
+          **query
+        )
       end
 
-      def self.post_single(resource_name:, resource_maker:, entity:, user: nil)
-        json = StarkBank::Utils::Request.fetch(
-          method: 'POST',
-          path: StarkBank::Utils::API.endpoint(resource_name),
-          payload: StarkBank::Utils::API.api_json(entity),
-          user: user
-        ).json
-        entity_json = json[StarkBank::Utils::API.last_name(resource_name)]
-        StarkBank::Utils::API.from_api_json(resource_maker, entity_json)
+      def self.post(resource_name:, resource_maker:, user:, entities:, **query)
+        return StarkCore::Utils::Rest.post(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          entities: entities,
+          **query
+        )
       end
 
-      def self.delete_id(resource_name:, resource_maker:, id:, user: nil)
-        json = StarkBank::Utils::Request.fetch(
-          method: 'DELETE',
-          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}",
-          user: user
-        ).json
-        entity = json[StarkBank::Utils::API.last_name(resource_name)]
-        StarkBank::Utils::API.from_api_json(resource_maker, entity)
+      def self.post_single(resource_name:, resource_maker:, user:, entity:)
+        return StarkCore::Utils::Rest.post_single(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          entity: entity
+        )
       end
 
-      def self.patch_id(resource_name:, resource_maker:, id:, user: nil, **payload)
-        json = StarkBank::Utils::Request.fetch(
-          method: 'PATCH',
-          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}",
-          user: user,
-          payload: StarkBank::Utils::API.cast_json_to_api_format(payload)
-        ).json
-        entity = json[StarkBank::Utils::API.last_name(resource_name)]
-        StarkBank::Utils::API.from_api_json(resource_maker, entity)
+      def self.delete_id(resource_name:, resource_maker:, user:, id:)
+        return StarkCore::Utils::Rest.delete_id(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          id: id
+        )
       end
 
-      def self.get_sub_resource(resource_name:, sub_resource_maker:, sub_resource_name:, id:, user: nil, **query)
-        json = StarkBank::Utils::Request.fetch(
-          method: 'GET',
-          path: "#{StarkBank::Utils::API.endpoint(resource_name)}/#{id}/#{StarkBank::Utils::API.endpoint(sub_resource_name)}",
-          user: user,
-          query: StarkBank::Utils::API.cast_json_to_api_format(query)
-        ).json
-        entity = json[StarkBank::Utils::API.last_name(sub_resource_name)]
-        StarkBank::Utils::API.from_api_json(sub_resource_maker, entity)
+      def self.patch_id(resource_name:, resource_maker:, user:, id:, **payload)
+        return StarkCore::Utils::Rest.patch_id(
+          resource_name: resource_name,
+          resource_maker: resource_maker,
+          sdk_version: StarkBank::SDK_VERSION,
+          host: StarkBank::HOST,
+          api_version: StarkBank::API_VERSION,
+          user: user ? user : StarkBank.user,
+          language: StarkBank.language,
+          timeout: StarkBank.timeout,
+          id: id,
+          **payload
+        )
       end
     end
   end

data/lib/webhook/webhook.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative('../utils/resource')
+require('starkcore')
 require_relative('../utils/rest')
-require_relative('../utils/checks')
+
 
 module StarkBank
   # # Webhook subscription object
@@ -15,9 +15,9 @@ module StarkBank
   # - url [string]: Url that will be notified when an event occurs.
   # - subscriptions [list of strings]: list of any non-empty combination of the available services. ex: ['transfer', 'deposit']
   #
-  # ## Attributes:
-  # - id [string, default nil]: unique id returned when the webhook is created. ex: '5656565656565656'
-  class Webhook < StarkBank::Utils::Resource
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the webhook is created. ex: '5656565656565656'
+  class Webhook < StarkCore::Utils::Resource
     attr_reader :url, :subscriptions, :id
     def initialize(url:, subscriptions:, id: nil)
       super(id)