starkinfra 0.0.1

data/lib/utils/checks.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require('date')
+require('starkbank-ecdsa')
+require('starkbank')
+require_relative('environment')
+
+module StarkInfra
+  module Utils
+    class Checks
+      def self.check_user(user)
+        return user if user.is_a?(StarkBank::User)
+
+        user = user.nil? ? StarkInfra.user : user
+        raise(ArgumentError, 'A user is required to access our API. Check our README: https://github.com/starkinfra/sdk-ruby/') if user.nil?
+
+        user
+      end
+
+      def self.check_language
+        language = StarkInfra.language
+        accepted_languages = %w[en-US pt-BR]
+        raise(ArgumentError, "Select a valid language: #{accepted_languages.join(', ')}") unless accepted_languages.include?(language)
+
+        language
+      end
+
+      def self.check_environment(environment)
+        environments = StarkInfra::Utils::Environment.constants(false).map { |c| StarkInfra::Utils::Environment.const_get(c) }
+        raise(ArgumentError, "Select a valid environment: #{environments.join(', ')}") unless environments.include?(environment)
+
+        environment
+      end
+
+      def self.check_private_key(pem)
+        EllipticCurve::PrivateKey.fromPem(pem)
+        pem
+      rescue
+        raise(ArgumentError, 'Private-key must be a valid secp256k1 ECDSA string in pem format')
+      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)
+        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/environment.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module StarkInfra
+  module Utils
+    class Environment
+      PRODUCTION = 'production'
+      public_constant :PRODUCTION
+
+      SANDBOX = 'sandbox'
+      public_constant :SANDBOX
+
+    end
+  end
+end

data/lib/utils/parse.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require('json')
+require('starkbank-ecdsa')
+require_relative('api')
+require_relative('cache')
+require_relative('request')
+require_relative('../error')\
+
+
+module StarkInfra
+  module Utils
+    module Parse
+      def self.parse_and_verify(content:, signature:, user: nil, resource:, key: nil)
+        event = StarkInfra::Utils::API.from_api_json(resource[:resource_maker], JSON.parse(content))
+        if key != nil
+          event = StarkInfra::Utils::API.from_api_json(resource[:resource_maker], JSON.parse(content)[key])
+        end
+
+        begin
+          signature = EllipticCurve::Signature.fromBase64(signature)
+        rescue
+          raise(StarkInfra::Error::InvalidSignatureError, 'The provided signature is not valid')
+        end
+  
+        return event if verify_signature(content: content, signature: signature, user: user)
+  
+        return event if verify_signature(content: content, signature: signature, user: user, refresh: true)
+  
+        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']
+      end
+    end
+  end
+end
+
+

data/lib/utils/request.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require('json')
+require('starkbank-ecdsa')
+require('net/http')
+require_relative('url')
+require_relative('checks')
+require_relative('../error')
+
+module StarkInfra
+  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(method:, path:, payload: nil, query: nil, user: nil)
+        user = Checks.check_user(user)
+        language = Checks.check_language
+
+        base_url = {
+          Environment::PRODUCTION => 'https://api.starkinfra.com/',
+          Environment::SANDBOX => 'https://sandbox.api.starkinfra.com/',
+        }[user.environment] + 'v2'
+
+        url = "#{base_url}/#{path}#{StarkInfra::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-2.6.0"
+        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(StarkInfra::Error::InternalServerError) if response.status == 500
+        raise(StarkInfra::Error::InputErrors, response.json['errors']) if response.status == 400
+        raise(StarkInfra::Error::UnknownError, response.content) unless response.status == 200
+
+        response
+      end
+    end
+  end
+end

data/lib/utils/resource.rb

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

data/lib/utils/rest.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative('request')
+require_relative('api')
+
+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']
+      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
+      end
+
+      def self.get_id(resource_name:, resource_maker:, id:, user: nil)
+        json = StarkInfra::Utils::Request.fetch(
+          method: 'GET',
+          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)
+      end
+
+      def self.get_content(resource_name:, resource_maker:, sub_resource_name:, id:, user: nil, **query)
+        StarkInfra::Utils::Request.fetch(
+          method: 'GET',
+          path: "#{StarkInfra::Utils::API.endpoint(resource_name)}/#{id}/#{sub_resource_name}",
+          query: StarkInfra::Utils::API.cast_json_to_api_format(query),
+          user: user
+        ).content
+      end
+
+      def self.post(resource_name:, resource_maker:, entities:, user: nil)
+        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,
+          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
+      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)
+      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)
+      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)
+      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,
+          query: StarkInfra::Utils::API.cast_json_to_api_format(query)
+        ).json
+        entity = json[StarkInfra::Utils::API.last_name(sub_resource_name)]
+        StarkInfra::Utils::API.from_api_json(sub_resource_maker, entity)
+      end
+    end
+  end
+end

data/lib/utils/sub_resource.rb

@@ -0,0 +1,28 @@
+
+
+module StarkInfra
+    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 inspect
+                "#{class_name}[#{@id}]"
+            end
+        
+            private
+        
+            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 StarkInfra
+  module Utils
+    module URL
+      # generates query string from hash
+      def self.urlencode(params)
+        return '' if params.nil?
+
+        params = StarkInfra::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
+        '?' + query_list.join('&')
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: starkinfra
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- starkinfra
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: starkbank
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+- !ruby/object:Gem::Dependency
+  name: starkbank-ecdsa
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+- !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/error.rb
+- lib/event/event.rb
+- lib/key.rb
+- lib/pixbalance/pixbalance.rb
+- lib/pixrequest/log.rb
+- lib/pixrequest/pixrequest.rb
+- lib/pixreversal/log.rb
+- lib/pixreversal/pixreversal.rb
+- lib/pixstatement/pixstatement.rb
+- lib/starkinfra.rb
+- lib/utils/api.rb
+- lib/utils/cache.rb
+- lib/utils/case.rb
+- lib/utils/checks.rb
+- lib/utils/environment.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/sdk-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.1.4
+signing_key:
+specification_version: 4
+summary: SDK to facilitate Ruby integrations with Stark Infra
+test_files: []