starkinfra 0.4.0 → 0.5.2

data/lib/starkinfra.rb

@@ -1,74 +1,82 @@
 # frozen_string_literal: true
 
-require_relative('key')
-require_relative('user/project')
-require_relative('user/organization')
-require_relative('brcodepreview/brcodepreview')
-require_relative('cardmethod/cardmethod')
-require_relative('creditnote/invoice/invoice')
-require_relative('creditnote/invoice/description')
-require_relative('creditnote/invoice/discount')
-require_relative('creditnote/creditnote')
-require_relative('creditnote/log')
-require_relative('creditnote/transfer')
-require_relative('creditholmes/creditholmes')
-require_relative('creditpreview/creditpreview')
-require_relative('creditpreview/creditnotepreview')
-require_relative('creditsigner/creditsigner')
-require_relative('dynamicbrcode/dynamicbrcode')
-require_relative('individualdocument/individualdocument')
-require_relative('individualdocument/log')
-require_relative('individualidentity/individualidentity')
-require_relative('individualidentity/log')
-require_relative('issuingbalance/issuingbalance')
-require_relative('issuingdesign/issuingdesign')
-require_relative('issuingembossingkit/issuingembossingkit')
-require_relative('issuingembossingrequest/issuingembossingrequest')
-require_relative('issuingembossingrequest/log')
-require_relative('issuingstock/issuingstock')
-require_relative('issuingstock/log')
-require_relative('issuingrestock/issuingrestock')
-require_relative('issuingrestock/log')
-require_relative('issuingcard/issuingcard')
-require_relative('issuingcard/log')
-require_relative('issuingholder/issuingholder')
-require_relative('issuingholder/log')
-require_relative('issuinginvoice/issuinginvoice')
-require_relative('issuinginvoice/log')
-require_relative('issuingproduct/issuingproduct')
-require_relative('issuingpurchase/issuingpurchase')
-require_relative('issuingpurchase/log')
-require_relative('issuingrule/issuingrule')
-require_relative('issuingtransaction/issuingtransaction')
-require_relative('issuingwithdrawal/issuingwithdrawal')
-require_relative('merchantcategory/merchantcategory')
-require_relative('merchantcountry/merchantcountry')
-require_relative('pixbalance/pixbalance')
-require_relative('pixchargeback/pixchargeback')
-require_relative('pixchargeback/log')
-require_relative('pixclaim/pixclaim')
-require_relative('pixclaim/log')
-require_relative('pixdirector/pixdirector')
-require_relative('pixdomain/pixdomain')
-require_relative('pixinfraction/pixinfraction')
-require_relative('pixinfraction/log')
-require_relative('pixkey/pixkey')
-require_relative('pixkey/log')
-require_relative('pixrequest/pixrequest')
-require_relative('pixrequest/log')
-require_relative('pixreversal/pixreversal')
-require_relative('pixreversal/log')
-require_relative('pixstatement/pixstatement')
-require_relative('staticbrcode/staticbrcode')
+require_relative('brcode_preview/brcode_preview')
+require_relative('card_method/card_method')
+require_relative('credit_note/invoice/invoice')
+require_relative('credit_note/invoice/description')
+require_relative('credit_note/invoice/discount')
+require_relative('credit_note/credit_note')
+require_relative('credit_note/log')
+require_relative('credit_note/transfer')
+require_relative('credit_holmes/credit_holmes')
+require_relative('credit_preview/credit_preview')
+require_relative('credit_preview/credit_note_preview')
+require_relative('credit_signer/credit_signer')
+require_relative('dynamic_brcode/dynamic_brcode')
+require_relative('individual_document/individual_document')
+require_relative('individual_document/log')
+require_relative('individual_identity/individual_identity')
+require_relative('individual_identity/log')
+require_relative('issuing_balance/issuing_balance')
+require_relative('issuing_design/issuing_design')
+require_relative('issuing_embossing_kit/issuing_embossing_kit')
+require_relative('issuing_embossing_request/issuing_embossing_request')
+require_relative('issuing_embossing_request/log')
+require_relative('issuing_stock/issuing_stock')
+require_relative('issuing_stock/log')
+require_relative('issuing_restock/issuing_restock')
+require_relative('issuing_restock/log')
+require_relative('issuing_card/issuing_card')
+require_relative('issuing_card/log')
+require_relative('issuing_holder/issuing_holder')
+require_relative('issuing_holder/log')
+require_relative('issuing_invoice/issuing_invoice')
+require_relative('issuing_invoice/log')
+require_relative('issuing_product/issuing_product')
+require_relative('issuing_purchase/issuing_purchase')
+require_relative('issuing_purchase/log')
+require_relative('issuing_rule/issuing_rule')
+require_relative('issuing_transaction/issuing_transaction')
+require_relative('issuing_withdrawal/issuing_withdrawal')
+require_relative('merchant_category/merchant_category')
+require_relative('merchant_country/merchant_country')
+require_relative('pix_balance/pix_balance')
+require_relative('pix_chargeback/pix_chargeback')
+require_relative('pix_chargeback/log')
+require_relative('pix_claim/pix_claim')
+require_relative('pix_claim/log')
+require_relative('pix_director/pix_director')
+require_relative('pix_domain/pix_domain')
+require_relative('pix_infraction/pix_infraction')
+require_relative('pix_infraction/log')
+require_relative('pix_key/pix_key')
+require_relative('pix_key/log')
+require_relative('pix_request/pix_request')
+require_relative('pix_request/log')
+require_relative('pix_reversal/pix_reversal')
+require_relative('pix_reversal/log')
+require_relative('pix_statement/pix_statement')
+require_relative('static_brcode/static_brcode')
 require_relative('webhook/webhook')
 require_relative('event/event')
 require_relative('event/attempt')
-require_relative('utils/endtoendid')
-require_relative('utils/returnid')
+require_relative('request/request')
 
 # SDK to facilitate Ruby integrations with Stark Infra
 module StarkInfra
+
+  API_VERSION = 'v2'
+  SDK_VERSION = '0.5.2'
+  HOST = "infra"
+  public_constant :API_VERSION, :SDK_VERSION, :HOST;
+
   @user = nil
   @language = 'en-US'
-  class << self; attr_accessor :user, :language; end
+  @timeout = 15
+  class << self; attr_accessor :user, :language, :timeout; end
+
+  Project = StarkCore::Project
+  Organization = StarkCore::Organization
+  Key = StarkCore::Key
+
 end

data/lib/{staticbrcode/staticbrcode.rb → static_brcode/static_brcode.rb}

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
+require('starkcore')
 require_relative('../utils/rest')
 require_relative('../utils/parse')
-require_relative('../utils/checks')
-require_relative('../utils/resource')
 
 module StarkInfra
   # # StaticBrcode object
@@ -33,7 +32,7 @@ module StarkInfra
   # - url [string]: url link to the BR Code image. ex: 'https://brcode-h.development.starkinfra.com/static-qrcode/97756273400d42ce9086404fe10ea0d6.png'
   # - created [DateTime]: creation datetime for the StaticBrcode. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
   # - updated [DateTime]: latest update datetime for the StaticBrcode. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
-  class StaticBrcode < StarkInfra::Utils::Resource
+  class StaticBrcode < StarkCore::Utils::Resource
     attr_reader :name, :key_id, :city, :amount, :cashier_bank_code, :description, :reconciliation_id, :id, :tags, :uuid, :url, :created, :updated
     def initialize(
       name:, key_id:, city:, amount:, cashier_bank_code: nil, description: nil, reconciliation_id: nil, id: nil, tags:nil, uuid: nil, url: nil, created: nil, updated: nil
@@ -49,8 +48,8 @@ module StarkInfra
       @tags = tags
       @uuid = uuid
       @url = url
-      @created = StarkInfra::Utils::Checks.check_datetime(created)
-      @updated = StarkInfra::Utils::Checks.check_datetime(updated)
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
     end
 
     # # Create StaticBrcodes
@@ -100,8 +99,8 @@ module StarkInfra
     # ## Return:
     # - generator of StaticBrcode objects with updated attributes
     def self.query(limit: nil, after: nil, before: nil, uuids: nil, tags: nil, user: nil)
-      after = StarkInfra::Utils::Checks.check_date(after)
-      before = StarkInfra::Utils::Checks.check_date(before)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
       StarkInfra::Utils::Rest.get_stream(
         limit: limit,
         after: after,
@@ -130,8 +129,8 @@ module StarkInfra
     # - list of StaticBrcode objects with updated attributes
     # - cursor to retrieve the next page of StaticBrcode objects
     def self.page(cursor: nil, limit: nil, after: nil, before: nil, tags: nil, uuids: nil, user: nil)
-      after = StarkInfra::Utils::Checks.check_date(after)
-      before = StarkInfra::Utils::Checks.check_date(before)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
       StarkInfra::Utils::Rest.get_page(
         cursor: cursor,
         limit: limit,

data/lib/utils/parse.rb

@@ -1,53 +1,34 @@
-# frozen_string_literal: true
-
-require('json')
-require('starkbank-ecdsa')
-require_relative('api')
-require_relative('cache')
-require_relative('request')
-require_relative('../error')
+require('starkcore')
 
 module StarkInfra
   module Utils
     module Parse
       def self.parse_and_verify(content:, signature:, user: nil, resource:, key: nil)
-        content = verify(content:content, signature: signature, user: user)
-        json = JSON.parse(content)
-        json = JSON.parse(content)[key] unless key.nil?
-
-        StarkInfra::Utils::API.from_api_json(resource[:resource_maker], json)
+        return StarkCore::Utils::Parse.parse_and_verify(
+          content: content, 
+          signature: signature, 
+          sdk_version: StarkInfra::SDK_VERSION,
+          api_version: StarkInfra::API_VERSION,
+          host: StarkInfra::HOST,
+          resource: resource,
+          user: user ? user : StarkInfra.user,
+          language: StarkInfra.language,
+          timeout: StarkInfra.timeout,
+          key: key
+        )
       end
 
       def self.verify(content:, signature:, user: nil)
-        begin
-          signature = EllipticCurve::Signature.fromBase64(signature)
-        rescue
-          raise(StarkInfra::Error::InvalidSignatureError, 'The provided signature is not valid')
-        end
-
-        if verify_signature(content: content, signature: signature, user: user)
-          return content
-        end
-
-        if verify_signature(content: content, signature: signature, user: user, refresh: true)
-          return content
-        end
-
-        raise(StarkInfra::Error::InvalidSignatureError, 'The provided signature and content do not match the Stark Infra public key')
-      end
-
-      def self.verify_signature(content:, signature:, user:, refresh: false)
-        public_key = StarkInfra::Utils::Cache.starkinfra_public_key
-        if public_key.nil? || refresh
-          pem = get_public_key_pem(user)
-          public_key = EllipticCurve::PublicKey.fromPem(pem)
-          StarkInfra::Utils::Cache.starkinfra_public_key = public_key
-        end
-        EllipticCurve::Ecdsa.verify(content, signature, public_key)
-      end
-
-      def self.get_public_key_pem(user)
-        StarkInfra::Utils::Request.fetch(method: 'GET', path: 'public-key', query: { limit: 1 }, user: user).json['publicKeys'][0]['content']
+        return StarkCore::Utils::Parse.verify(
+          content: content, 
+          signature: signature, 
+          sdk_version: StarkInfra::SDK_VERSION,
+          api_version: StarkInfra::API_VERSION,
+          host: StarkInfra::HOST,
+          user: user ? user : StarkInfra.user,
+          language: StarkInfra.language,
+          timeout: StarkInfra.timeout
+        )
       end
     end
   end

data/lib/utils/rest.rb

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

data/lib/webhook/webhook.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
+require('starkcore')
 require_relative('../utils/rest')
-require_relative('../utils/checks')
-require_relative('../utils/resource')
 
 module StarkInfra
   # # Webhook object
@@ -16,7 +15,7 @@ module StarkInfra
   #
   # ## Attributes (return-only):
   # - id [string]: unique id returned when the webhook is created. ex: '5656565656565656'
-  class Webhook < StarkInfra::Utils::Resource
+  class Webhook < StarkCore::Utils::Resource
     attr_reader :url, :subscriptions, :id
     def initialize(url:, subscriptions:, id: nil)
       super(id)