starkinfra 0.4.0 → 0.5.0

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.language,
+          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.language
+        )
       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)

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: starkinfra
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - starkinfra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-20 00:00:00.000000000 Z
+date: 2024-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: starkbank-ecdsa
+  name: starkcore
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.2.2
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -113,7 +113,6 @@ files:
 - lib/issuingstock/log.rb
 - lib/issuingtransaction/issuingtransaction.rb
 - lib/issuingwithdrawal/issuingwithdrawal.rb
-- lib/key.rb
 - lib/merchantcategory/merchantcategory.rb
 - lib/merchantcountry/merchantcountry.rb
 - lib/pixbalance/pixbalance.rb
@@ -133,25 +132,11 @@ files:
 - lib/pixreversal/log.rb
 - lib/pixreversal/pixreversal.rb
 - lib/pixstatement/pixstatement.rb
+- lib/request/request.rb
 - lib/starkinfra.rb
 - lib/staticbrcode/staticbrcode.rb
-- lib/user/organization.rb
-- lib/user/project.rb
-- lib/user/user.rb
-- lib/utils/api.rb
-- lib/utils/bacenid.rb
-- lib/utils/cache.rb
-- lib/utils/case.rb
-- lib/utils/checks.rb
-- lib/utils/endtoendid.rb
-- lib/utils/environment.rb
 - lib/utils/parse.rb
-- lib/utils/request.rb
-- lib/utils/resource.rb
 - lib/utils/rest.rb
-- lib/utils/returnid.rb
-- lib/utils/sub_resource.rb
-- lib/utils/url.rb
 - lib/webhook/webhook.rb
 homepage: https://github.com/starkinfra/sdk-ruby
 licenses:

data/lib/key.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require('fileutils')
-require('starkbank-ecdsa')
-
-module StarkInfra
-  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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require_relative('user')
-
-module StarkInfra
-  # # 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 Infra API must be authenticated via an SDK user,
-  # which must have been previously created at the Stark Infra website
-  # [https://web.sandbox.starkinfra.com] or [https://web.starkinfra.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 < StarkInfra::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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require_relative('user')
-
-module StarkInfra
-  # # 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 Infra API must be authenticated via an SDK user,
-  # which must have been previously created at the Stark Infra website
-  # [https://web.sandbox.starkinfra.com] or [https://web.starkinfra.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 nil]: 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 < StarkInfra::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

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