fhakfjds 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94b60c7bdb7a68dd342852e2ec1848e6c0855daeef0b42627eb5b7259464d50f
-  data.tar.gz: bbe6581033970a8fae079b5d39a48f7fc811fdc410bc9516b3c2448e33e5e850
+  metadata.gz: 2a7eaec29175b7d5b1ea53b2188f5ca5fa0f1fe7dfd68962c8a76fea9a13cd13
+  data.tar.gz: d5e04816c9c2e993b05f8a2756fc8ecf71aa175f5b1f8b5a1b8637d2f6b495ac
 SHA512:
-  metadata.gz: 9c41327af4ffa948f8ea39b53e0cedd34c041e865dfbac5a3b1fc6b6206509b6df0c55c33bf33b3c4bfcfdd87cab11e38b1973ce6452de5900e43aa1e3436608
-  data.tar.gz: 533a38aef478a7d2e9d0c52fc3d1b9100c9f9b8702b15564bb75fad5c9721e612f3e7682169489533cf599997270049ee3dc47bf9645f631ac6f1ad1c1ec1a49
+  metadata.gz: 36e3b43236654ebcd083d34f60d77efd41e9066de3f9f7583471d46a05e9c39dfc3627e1726f4dca83eb6a12e370d04d0f5cb730f6d554eaf276d9273aa1b5a8
+  data.tar.gz: 753124a83f85521af130c17f242445fe99ba93776fa2743a2b8f6df75fbdb3ed80d940c59d005fec838f71564aaa8416e0ec6d5082559f508a6da3476ea42dbf

data/lib/environment.rb

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

data/lib/error.rb

@@ -0,0 +1,52 @@
+# 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/fhakfjds.rb

@@ -0,0 +1,17 @@
+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/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"

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/user/organization.rb

@@ -0,0 +1,54 @@
+# 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 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. 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
+      if @workspace_id
+        "organization/#{@id}/workspace/#{@workspace_id}"
+      else
+        "organization/#{@id}"
+      end
+    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,20 @@
+# 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)
+      require_relative('../utils/checks')
+      super(id)
+      @pem = StarkCore::Utils::Checks.check_private_key(private_key)
+      @environment = StarkCore::Utils::Checks.check_environment(environment)
+    end
+
+    def private_key
+      EllipticCurve::PrivateKey.fromPem(@pem)
+    end
+  end
+end

data/lib/utils/api.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative('case')
+
+module StarkCore
+	module Utils
+		module API
+			def self.build_entity_hash(entity)
+				return entity if entity.is_a?(Hash)
+
+				entity_hash = {}
+				entity.instance_variables.each do |key|
+					variable = entity.instance_variable_get(key)
+					entity_hash[key[1..-1]] = variable.is_a?(StarkCore::Utils::Resource) ? 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 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|
+					list << (v.is_a?(Hash) ? cast_json_to_api_format(v) : 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
+				return 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)
+				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 = StarkCore.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)
+                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,20 @@
+# 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,11 @@
+# frozen_string_literal: true
+
+module StarkCore
+    module Utils
+        class StarkHost < Enum
+            INFRA = "infra"
+            BANK = "bank"
+            SIGN = "sign"
+        end
+    end
+end

data/lib/utils/parse.rb

@@ -0,0 +1,54 @@
+# 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:, 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?
+
+        StarkCore::Utils::API.from_api_json(resource[:resource_maker], json)
+      end
+
+      def self.verify(content:, signature:, user: nil)
+        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, user: user)
+          return content
+        end
+
+        if verify_signature(content: content, signature: signature, user: user, refresh: true)
+          return content
+        end
+
+        raise(StarkCore::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 = StarkCore::Utils::Cache.starkinfra_public_key
+        if public_key.nil? || refresh
+          pem = get_public_key_pem(user)
+          public_key = EllipticCurve::PublicKey.fromPem(pem)
+          StarkCore::Utils::Cache.starkinfra_public_key = public_key
+        end
+        EllipticCurve::Ecdsa.verify(content, signature, public_key)
+      end
+
+      def self.get_public_key_pem(user)
+        StarkCore::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 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(method:, path:, payload: nil, query: nil, user: nil)
+        user = Checks.check_user(user)
+        language = Checks.check_language
+
+        base_url = {
+          Environment::PRODUCTION => 'https://api.starkbank.com/',
+          Environment::SANDBOX => 'https://sandbox.api.starkbank.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-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(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
+
+        response
+      end
+    end
+  end
+end

data/lib/utils/resource.rb

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

data/lib/utils/sub_resource.rb

@@ -0,0 +1,28 @@
+
+
+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 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 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
+        '?' + query_list.join('&')
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fhakfjds
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - xavier
@@ -71,7 +71,26 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/environment.rb
+- lib/error.rb
+- lib/fhakfjds.rb
+- lib/key.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: 
 licenses:
 - MIT