starkcore 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 597f29968666f97ec42b8c6bef044896258eb166daf282d88a20bf1428f96a6e
+  data.tar.gz: f4ae2a817c7db41b8bd14f03600297e1439332804f4d7dcce75f49217f52b5c4
+SHA512:
+  metadata.gz: 1794d7632dcb540c513ff403643b9770d73e32610d7a5505157d3f63209873d65ec781f543a7b6e65d4a0cdc0ff463981c98fa36ed9afba6f4ace418b4b9717a
+  data.tar.gz: 28eb48e9984fe0fa24949f7785c7f87224c1f0912382e96f953400c53615bf170cc31585062dbd3416f38419bdc0c4dd9275ad6c742afcb443136d45f8eb9a1a

data/lib/environment.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module StarkCore
+  class Environment
+    PRODUCTION = 'production'
+    SANDBOX = 'sandbox'
+    
+    public_constant :PRODUCTION, :SANDBOX;
+  end
+end

data/lib/error.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require('json')
+
+module StarkCore
+  module Error
+    class StarkCoreError < StandardError
+      attr_reader :message
+      def initialize(message)
+        @message = message
+        super(message)
+      end
+    end
+
+    class Error < StarkCoreError
+      attr_reader :code, :message
+      def initialize(code, message)
+        @code = code
+        @message = message
+        super("#{code}: #{message}")
+      end
+    end
+
+    class InputErrors < StarkCoreError
+      attr_reader :errors
+      def initialize(content)
+        errors = []
+        content.each do |error|
+          errors << Error.new(error['code'], error['message'])
+        end
+        @errors = errors
+        super(content.to_json)
+      end
+    end
+
+    class InternalServerError < StarkCoreError
+      def initialize(message = 'Houston, we have a problem.')
+        super(message)
+      end
+    end
+
+    class UnknownError < StarkCoreError
+      def initialize(message)
+        super("Unknown exception encountered: #{message}")
+      end
+    end
+
+    class InvalidSignatureError < StarkCoreError
+    end
+  end
+end

data/lib/key.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require('fileutils')
+require('starkbank-ecdsa')
+
+module StarkCore
+  module Key
+    # # Generate a new key pair
+    # Generates a secp256k1 ECDSA private/public key pair to be used in the API
+    # authentications
+    #
+    # ## Parameters (optional):
+    # - path [string]: path to save the keys .pem files. No files will be saved if this parameter isn't provided
+    #
+    # ## Return:
+    # - private and public key pems
+    def self.create(path=nil)
+      private_key = EllipticCurve::PrivateKey.new
+      public_key = private_key.publicKey
+
+      private_key_pem = private_key.toPem
+      public_key_pem = public_key.toPem
+
+      unless path.nil?
+        FileUtils.mkdir_p(path)
+        File.write(File.join(path, 'private.pem'), private_key_pem)
+        File.write(File.join(path, 'public.pem'), public_key_pem)
+      end
+
+      [private_key_pem, public_key_pem]
+    end
+  end
+end

data/lib/starkcore.rb

@@ -0,0 +1,24 @@
+require_relative "user/organization"
+require_relative "user/project"
+require_relative "user/user"
+require_relative "utils/api"
+require_relative "utils/cache"
+require_relative "utils/case"
+require_relative "utils/checks"
+require_relative "utils/enum"
+require_relative "utils/host"
+require_relative "utils/parse"
+require_relative "utils/request"
+require_relative "utils/resource"
+require_relative "utils/rest"
+require_relative "utils/sub_resource"
+require_relative "utils/url"
+require_relative "environment"
+require_relative "error"
+require_relative "key"
+
+module StarkCore
+    @user = nil
+    @language = 'en-US'
+    class << self; attr_accessor :user, :language; end
+end

data/lib/user/organization.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative('user')
+
+module StarkCore
+  # # Organization object
+  # The Organization object is an authentication entity for the SDK that
+  # represents your entire Organization, being able to access any Workspace
+  # underneath it and even create new Workspaces. Only a legal representative
+  # of your organization can register or change the Organization credentials.
+  # All requests to the Stark Bank and Stark Infra API must be authenticated via an SDK user,
+  # which must have been previously created at the Stark Bank or Stark Infra websites
+  # [https://web.sandbox.starkbank.com] or [https://web.starkbank.com]
+  # before you can use it in this SDK. Organizations may be passed as the user parameter on
+  # each request or may be defined as the default user at the start (See README).
+  # If you are accessing a specific Workspace using Organization credentials, you should
+  # specify the workspace ID when building the Organization object or by request, using
+  # the Organization.replace(organization, workspace_id) method, which creates a copy of the organization
+  # object with the altered workspace ID. If you are listing or creating new Workspaces, the
+  # workspace_id should be nil.
+  #
+  # ## Parameters (required):
+  # - environment [string]: environment where the organization is being used. ex: 'sandbox' or 'production'
+  # - id [string]: unique id required to identify organization. ex: '5656565656565656'
+  # - private_key [string]: PEM string of the private key linked to the organization. ex: '-----BEGIN PUBLIC KEY-----\nMFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEyTIHK6jYuik6ktM9FIF3yCEYzpLjO5X/\ntqDioGM+R2RyW0QEo+1DG8BrUf4UXHSvCjtQ0yLppygz23z0yPZYfw==\n-----END PUBLIC KEY-----'
+  # - workspace_id [string]: unique id of the accessed Workspace, if any. ex: nil or '4848484848484848'
+  #
+  # ## Attributes (return-only):
+  # - pem [string]: private key in pem format. ex: '-----BEGIN PUBLIC KEY-----\nMFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEyTIHK6jYuik6ktM9FIF3yCEYzpLjO5X/\ntqDioGM+R2RyW0QEo+1DG8BrUf4UXHSvCjtQ0yLppygz23z0yPZYfw==\n-----END PUBLIC KEY-----'
+  class Organization < StarkCore::User
+    attr_reader :workspace_id
+    def initialize(id:, environment:, private_key:, workspace_id: nil)
+      super(environment, id, private_key)
+      @workspace_id = workspace_id
+    end
+
+    def access_id
+      return "organization/#{@id}/workspace/#{@workspace_id}" if @workspace_id
+
+      return "organization/#{@id}"
+    end
+
+    def self.replace(organization, workspace_id)
+      Organization.new(
+        environment: organization.environment,
+        id: organization.id,
+        private_key: organization.pem,
+        workspace_id: workspace_id
+      )
+    end
+  end
+end

data/lib/user/project.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative('user')
+
+module StarkCore
+  # # Project object
+  #
+  # The Project object is an authentication entity for the SDK that is permanently
+  # linked to a specific Workspace.
+  # All requests to the Stark Bank API must be authenticated via an SDK user,
+  # which must have been previously created at the Stark Bank website
+  # [https://web.sandbox.starkbank.com] or [https://web.starkbank.com]
+  # before you can use it in this SDK. Projects may be passed as the user parameter on
+  # each request or may be defined as the default user at the start (See README).
+  #
+  # ## Parameters (required):
+  # - id [string]: unique id required to identify project. ex: '5656565656565656'
+  # - private_key [string]: PEM string of the private key linked to the project. ex: '-----BEGIN PUBLIC KEY-----\nMFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEyTIHK6jYuik6ktM9FIF3yCEYzpLjO5X/\ntqDioGM+R2RyW0QEo+1DG8BrUf4UXHSvCjtQ0yLppygz23z0yPZYfw==\n-----END PUBLIC KEY-----'
+  # - environment [string]: environment where the project is being used. ex: 'sandbox' or 'production'
+  #
+  # ## Attributes (return-only):
+  # - name [string, default '']: project name. ex: 'MyProject'
+  # - allowed_ips [list of strings]: list containing the strings of the ips allowed to make requests on behalf of this project. ex: ['190.190.0.50']
+  # - pem [string]: private key in pem format. ex: '-----BEGIN PUBLIC KEY-----\nMFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEyTIHK6jYuik6ktM9FIF3yCEYzpLjO5X/\ntqDioGM+R2RyW0QEo+1DG8BrUf4UXHSvCjtQ0yLppygz23z0yPZYfw==\n-----END PUBLIC KEY-----'
+  class Project < StarkCore::User
+    attr_reader :name, :allowed_ips
+    def initialize(environment:, id:, private_key:, name: '', allowed_ips: nil)
+      super(environment, id, private_key)
+      @name = name
+      @allowed_ips = allowed_ips
+    end
+
+    def access_id
+      "project/#{@id}"
+    end
+  end
+end

data/lib/user/user.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require('starkbank-ecdsa')
+require_relative('../utils/resource')
+
+module StarkCore
+  class User < StarkCore::Utils::Resource
+    attr_reader :pem, :environment
+    def initialize(environment, id, private_key)
+      super(id)
+      @pem = StarkCore::Utils::Checks.check_private_key(private_key)
+      @environment = StarkCore::Utils::Checks.check_environment(environment)
+    end
+
+    def private_key
+      return EllipticCurve::PrivateKey.fromPem(@pem)
+    end
+  end
+end

data/lib/utils/api.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative('case')
+
+module StarkCore
+  module Utils
+    module API
+      def self.build_entity_hash(entity)
+        entity_hash = {}
+        entity_hash = entity if entity.is_a?(Hash)
+
+        entity.instance_variables.each do |key|
+          variable = entity.instance_variable_get(key)
+          entity_hash[key[1..-1]] = variable.is_a?(StarkCore::Utils::SubResource) ? build_entity_hash(variable) : entity.instance_variable_get(key)
+        end
+        return entity_hash
+      end
+
+      def self.api_json(entity)
+        built_hash = build_entity_hash(entity)
+        cast_json_to_api_format(built_hash)
+      end
+
+      def self.cast_json_to_api_format(hash)
+        entity_hash = {}
+        hash.each do |key, value|
+          next if value.nil?
+          entity_hash[StarkCore::Utils::Case.snake_to_camel(key)] = parse_value(value)
+        end
+        return entity_hash
+      end
+
+      def self.parse_value(value)
+        return api_json(value) if value.is_a?(SubResource)
+        return value.strftime('%Y-%m-%d') if value.is_a?(Date)
+        return value.strftime('%Y-%m-%dT%H:%M:%S+00:00') if value.is_a?(DateTime) || value.is_a?(Time)
+        return cast_json_to_api_format(value) if value.is_a?(Hash)
+        return value unless value.is_a?(Array)
+
+        list = []
+        value.each do |v|
+          if v.is_a?(Hash)
+            list << cast_json_to_api_format(v)
+            next
+          end
+          if v.is_a?(SubResource)
+            list << api_json(v)
+            next
+          end
+          list << v
+        end
+        return list
+      end
+
+      def self.from_api_json(resource_maker, json)
+        snakes = {}
+        json.each do |key, value|
+          snakes[StarkCore::Utils::Case.camel_to_snake(key)] = value
+        end
+
+        resource_maker.call(snakes)
+      end
+
+      def self.endpoint(resource_name)
+        kebab = StarkCore::Utils::Case.camel_to_kebab(resource_name)
+        kebab.sub!('-log', '/log')
+        kebab.sub!('-attempt', '/attempt')
+        return kebab
+      end
+
+      def self.last_name_plural(resource_name)
+        base = last_name(resource_name)
+
+        return base if base[-1].eql?('s')
+        return "#{base}s" if base[-2..-1].eql?('ey')
+        return "#{base[0...-1]}ies" if base[-1].eql?('y')
+
+        return "#{base}s"
+      end
+
+      def self.last_name(resource_name)
+        return StarkCore::Utils::Case.camel_to_kebab(resource_name).split('-').last
+      end
+    end
+  end
+end

data/lib/utils/cache.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module StarkCore
+  module Utils
+    module Cache
+      @starkbank_public_key = nil
+      class << self; attr_accessor :starkbank_public_key; end
+    end
+  end
+end

data/lib/utils/case.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StarkCore
+  module Utils
+    module Case
+      def self.camel_to_snake(camel)
+        return camel.to_s.gsub(/([a-z])([A-Z\d])/, '\1_\2').downcase
+      end
+
+      def self.snake_to_camel(snake)
+        camel = snake.to_s.split('_').map(&:capitalize).join
+        camel[0] = camel[0].downcase
+        return camel
+      end
+
+      def self.camel_to_kebab(camel)
+        return camel_to_snake(camel).tr('_', '-')
+      end
+    end
+  end
+end

data/lib/utils/checks.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require('date')
+require('starkbank-ecdsa')
+require_relative('../environment')
+require_relative('../user/user')
+
+module StarkCore
+  module Utils
+    class Checks
+      def self.check_environment(environment)
+        environments = StarkCore::Environment.constants(false).map { |c| StarkCore::Environment.const_get(c) }
+        raise(ArgumentError, "Select a valid environment: #{environments.join(', ')}") unless environments.include?(environment)
+        return environment
+      end
+      
+      def self.check_private_key(pem)
+        EllipticCurve::PrivateKey.fromPem(pem)
+        return pem
+      rescue
+        raise(ArgumentError, 'Private-key must be a valid secp256k1 ECDSA string in pem format')
+      end
+
+      def self.check_user(user)
+        return user if user.is_a?(StarkCore::User)
+        user = user.nil? ? StarkCore.user : user
+        raise(ArgumentError, 'A user is required to access our API. Check our README: https://github.com/starkbank/sdk-ruby/') if user.nil?
+        return user
+      end
+
+      def self.check_language(language)
+        language = language.nil? ? StarkCore.language : language
+        accepted_languages = %w[en-US pt-BR]
+        raise(ArgumentError, "Select a valid language: #{accepted_languages.join(', ')}") unless accepted_languages.include?(language)
+        return language
+      end
+
+      def self.check_date_or_datetime(data)
+        return if data.nil?
+
+        return data if data.is_a?(Time) || data.is_a?(DateTime)
+
+        return data if data.is_a?(Date)
+
+        data, type = check_datetime_string(data)
+        type == 'date' ? Date.new(data.year, data.month, data.day) : data
+      end
+
+      def self.check_datetime(data)
+        return if data.nil?
+
+        return data if data.is_a?(Time) || data.is_a?(DateTime)
+
+        return Time.new(data.year, data.month, data.day) if data.is_a?(Date)
+
+        data, _type = check_datetime_string(data)
+        return data
+      end
+
+      def self.check_date(data)
+        return if data.nil?
+
+        return Date.new(data.year, data.month, data.day) if data.is_a?(Time) || data.is_a?(DateTime)
+
+        return data if data.is_a?(Date)
+
+        data, type = check_datetime_string(data)
+
+        type == 'date' ? Date.new(data.year, data.month, data.day) : data
+      end
+
+      class << self
+        private
+
+        def check_datetime_string(data)
+          data = data.to_s
+
+          begin
+            return [DateTime.strptime(data, '%Y-%m-%dT%H:%M:%S.%L+00:00'), 'datetime']
+            rescue ArgumentError
+          end
+
+          begin
+            return [DateTime.strptime(data, '%Y-%m-%dT%H:%M:%S+00:00'), 'datetime']
+            rescue ArgumentError
+          end
+
+          begin
+            return [DateTime.strptime(data, '%Y-%m-%d'), 'date']
+          rescue ArgumentError
+            raise(ArgumentError, 'invalid datetime string ' + data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/utils/enum.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StarkCore
+  module Utils
+    class Enum
+      def values
+        list = []
+        self.class.constants.each do |constant|
+          unless constant[0] == '_' and constant.respond_to?(:call)
+            list.push(self.class.const_get(constant))
+          end
+        end
+        return list
+      end
+
+      def is_valid
+        return values.include?(self)
+      end
+    end
+  end
+end

data/lib/utils/host.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module StarkCore
+  module Utils
+    class StarkHost < Enum
+      INFRA = "infra"
+      BANK = "bank"
+      SIGN = "sign"
+
+      public_constant :INFRA, :BANK, :SIGN
+    end
+  end
+end

data/lib/utils/parse.rb

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

data/lib/utils/request.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require('json')
+require('starkbank-ecdsa')
+require('net/http')
+require_relative('url')
+require_relative('checks')
+require_relative('../error')
+
+module StarkCore
+  module Utils
+    module Request
+      class Response
+        attr_reader :status, :content
+        def initialize(status, content)
+          @status = status
+          @content = content
+        end
+
+        def json
+          JSON.parse(@content)
+        end
+      end
+
+      def self.fetch(host:, sdk_version:, user:, method:, path:, payload: nil, query: nil, 
+                      api_version: "v2", language: "en-US", timeout: 15)
+        user = Checks.check_user(user)
+        language = Checks.check_language(language)
+
+        service = {
+          StarkCore::Utils::StarkHost::INFRA => "starkinfra",
+          StarkCore::Utils::StarkHost::BANK => "starkbank",
+          StarkCore::Utils::StarkHost::SIGN => "starksign",
+        }[host]
+
+        base_url = {
+          Environment::PRODUCTION => "https://api.#{service}.com/",
+          Environment::SANDBOX => "https://sandbox.api.#{service}.com/"
+        }[user.environment] + 'v2'
+
+        url = "#{base_url}/#{path}#{StarkCore::Utils::URL.urlencode(query)}"
+        uri = URI(url)
+
+        access_time = Time.now.to_i
+        body = payload.nil? ? '' : payload.to_json
+        message = "#{user.access_id}:#{access_time}:#{body}"
+        signature = EllipticCurve::Ecdsa.sign(message, user.private_key).toBase64
+
+        case method
+          when 'GET'
+            req = Net::HTTP::Get.new(uri)
+          when 'DELETE'
+            req = Net::HTTP::Delete.new(uri)
+          when 'POST'
+            req = Net::HTTP::Post.new(uri)
+            req.body = body
+          when 'PATCH'
+            req = Net::HTTP::Patch.new(uri)
+            req.body = body
+          when 'PUT'
+            req = Net::HTTP::Put.new(uri)
+            req.body = body
+          else
+            raise(ArgumentError, 'unknown HTTP method ' + method)
+        end
+
+        req['Access-Id'] = user.access_id
+        req['Access-Time'] = access_time
+        req['Access-Signature'] = signature
+        req['Content-Type'] = 'application/json'
+        req['User-Agent'] = "Ruby-#{RUBY_VERSION}-SDK-#{host}-#{sdk_version}"
+        req['Accept-Language'] = language
+
+        request = Net::HTTP.start(uri.hostname, use_ssl: true) { |http| http.request(req) }
+
+        response = Response.new(Integer(request.code, 10), request.body)
+
+        raise(StarkCore::Error::InternalServerError) if response.status == 500
+        raise(StarkCore::Error::InputErrors, response.json['errors']) if response.status == 400
+        raise(StarkCore::Error::UnknownError, response.content) unless response.status == 200
+
+        return response
+      end
+    end
+  end
+end

data/lib/utils/resource.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative("sub_resource")
+
+module StarkCore
+  module Utils
+    class Resource < StarkCore::Utils::SubResource
+      attr_reader :id
+      def initialize(id = nil)
+        @id = id
+      end
+    end
+  end
+end

data/lib/utils/rest.rb

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

data/lib/utils/sub_resource.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StarkCore
+  module Utils
+    class SubResource    
+      def to_s
+        string_vars = []
+        instance_variables.each do |key|
+          value = instance_variable_get(key).to_s.lines.map(&:chomp).join("\n  ")
+          string_vars << "#{key[1..-1]}: #{value}"
+        end
+        fields = string_vars.join(",\n  ")
+        "#{class_name}(\n  #{fields}\n)"
+      end
+      
+      def class_name
+        self.class.name.split('::').last.downcase
+      end
+    end
+  end
+end

data/lib/utils/url.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module StarkCore
+  module Utils
+    module URL
+      # generates query string from hash
+      def self.urlencode(params)
+        return '' if params.nil?
+
+        params = StarkCore::Utils::API.cast_json_to_api_format(params)
+        return '' if params.empty?
+
+        string_params = {}
+        params.each do |key, value|
+          string_params[key] = value.is_a?(Array) ? value.join(',') : value
+        end
+
+        query_list = []
+        string_params.each do |key, value|
+          query_list << "#{key}=#{ERB::Util.url_encode(value)}"
+        end
+        return '?' + query_list.join('&')
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: starkcore
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- starkinfra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: starkbank-ecdsa
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.81'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.81'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/environment.rb
+- lib/error.rb
+- lib/key.rb
+- lib/starkcore.rb
+- lib/user/organization.rb
+- lib/user/project.rb
+- lib/user/user.rb
+- lib/utils/api.rb
+- lib/utils/cache.rb
+- lib/utils/case.rb
+- lib/utils/checks.rb
+- lib/utils/enum.rb
+- lib/utils/host.rb
+- lib/utils/parse.rb
+- lib/utils/request.rb
+- lib/utils/resource.rb
+- lib/utils/rest.rb
+- lib/utils/sub_resource.rb
+- lib/utils/url.rb
+homepage: https://github.com/starkinfra/core-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Basic SDK functionalities for the starkbank and starkinfra SDKs
+test_files: []