magic-admin 0.0.0 → 0.1.0

data/bin/magic-console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "irb"
+require "irb/completion"
+require "byebug"
+require "#{::File.dirname(__FILE__)}/../lib/magic-admin"
+
+# Config IRB to enable --simple-prompt and auto indent
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+IRB.conf[:AUTO_INDENT] = true
+
+puts "Loaded gem 'magic-admin'"
+IRB.start

data/lib/magic-admin.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# Magic Ruby bindings
+require "etc"
+require "json"
+require "net/http"
+require "uri"
+require "base64"
+require "eth"
+
+# Version
+require "magic-admin/version"
+
+# Magic API Classes
+require "magic-admin/util"
+require "magic-admin/config"
+require "magic-admin/errors"
+
+# HTTP Classes
+require "magic-admin/http/client"
+require "magic-admin/http/request"
+require "magic-admin/http/response"
+
+# Magic Resource Classes
+require "magic-admin/resource/token"
+require "magic-admin/resource/user"
+
+# Magic Class to access resources
+class Magic
+  RETRIES = 3
+  TIMEOUT = 5
+  BACKOFF = 0.02
+
+  # attribute reader for magic api secret key
+  attr_reader :secret_key
+
+  # attribute reader for magic http client
+  attr_reader :http_client
+
+  # The constructor allows you to specify your own API secret key
+  # and HTTP request strategy when your application interacting
+  # with the Magic API.
+  #
+  # It will automatically configure required arguments
+  # using the following environment variables
+  #   MAGIC_API_SECRET_KEY
+  #   MAGIC_API_RETRIES
+  #   MAGIC_API_TIMEOUT
+  #   MAGIC_API_BACKOFF
+  #
+  # Arguments:
+  #   api_secret_key: Your API Secret Key retrieved from the Magic Dashboard.
+  #   retries: Total number of retries to allow.
+  #   timeout: A period of time the request is going to wait for a response.
+  #   backoff: A backoff factor to apply between retry attempts.
+  #
+  # Returns:
+  #   A Magic object that provides access to all the supported resources.
+  #
+  # Examples:
+  #
+  #   Magic.new
+  #   Magic.new api_secret_key: "SECRET_KEY>"
+  #   Magic.new api_secret_key: "SECRET_KEY>",
+  #             retries: 2,
+  #             timeout: 2,
+  #             backoff: 0.2
+  #
+  #
+
+  def initialize(api_secret_key: nil,
+                 retries: nil,
+                 timeout: nil,
+                 backoff: nil)
+    secret_key!(api_secret_key)
+    http_client!(retries, timeout, backoff)
+  end
+
+  # Description:
+  #   Method provides you User object
+  #   for interacting with the Magic API.
+  #
+  # Returns:
+  #   A User object that provides access to
+  #   all the supported resources.
+
+  def user
+    MagicAdmin::Resource::User.new(self)
+  end
+
+  # Description:
+  #   Method provides you Token object
+  #   for various utility methods of Token.
+  #
+  # Returns:
+  #   A Token object that provides access to
+  #   all the supported resources.
+
+  def token
+    MagicAdmin::Resource::Token.new
+  end
+
+  private
+
+  def secret_key?
+    !(secret_key.nil? || secret_key.empty?)
+  end
+
+  def secret_key!(api_secret_key)
+    @secret_key = api_secret_key || ENV["MAGIC_API_SECRET_KEY"]
+    message = "Magic api secret key was not found."
+
+    raise MagicAdmin::MagicError, message unless secret_key?
+  end
+
+  def configure_retries(retries)
+    retries || ENV["MAGIC_API_RETRIES"] || RETRIES
+  end
+
+  def configure_timeout(timeout)
+    timeout || ENV["MAGIC_API_TIMEOUT"] || TIMEOUT
+  end
+
+  def configure_backoff(backoff)
+    backoff || ENV["MAGIC_API_BACKOFF"] || BACKOFF
+  end
+
+  def http_client!(retries, timeout, backoff)
+    @http_client = MagicAdmin::Http::Client
+                   .new(MagicAdmin::Config.api_base,
+                        configure_retries(retries),
+                        configure_timeout(timeout),
+                        configure_backoff(backoff))
+  end
+end

data/lib/magic-admin/config.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module MagicAdmin
+
+  module Config
+
+    # Description:
+    #   Method provides you platform information
+    #
+    # Returns:
+    #   user platform information
+    def self.platform
+      RUBY_PLATFORM
+    end
+
+    # Description:
+    #   Method provides you sdk programming language
+    #
+    # Returns:
+    #   sdk programming language
+    def self.language
+      "ruby"
+    end
+
+    # Description:
+    #   Method provides you sdk programming language version
+    #
+    # Returns:
+    #   sdk programming language version
+    def self.language_version
+      RUBY_VERSION
+    end
+
+    # Description:
+    #   Method provides you installation machine user_name
+    #
+    # Returns:
+    #   installation machine user_name
+    def self.user_name
+      Etc.getpwnam(Etc.getlogin).gecos.split(/,/).first
+    end
+
+    # Description:
+    #   Method provides you sdk publisher name
+    #
+    # Returns:
+    #   sdk publisher name
+    def self.publisher
+      "MagicLabs"
+    end
+
+    # Description:
+    #   Method provides you api base url
+    #
+    # Returns:
+    #   api base url
+    def self.api_base
+      "https://api.magic.link"
+    end
+
+    # Description:
+    #   Method provides you nbf grace period
+    #
+    # Returns:
+    #   nbf grace period
+    def self.nbf_grace_period
+      300
+    end
+
+  end
+end

data/lib/magic-admin/errors.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module MagicAdmin
+
+  # MagicAdmin::MagicError class
+  class MagicError < StandardError
+
+    # attribute reader for error message
+    attr_reader :message
+
+    # Description:
+    #   The constructor allows you to specify error message
+    #
+    # Arguments:
+    #   message: error message.
+    def initialize(message)
+      @message = message
+    end
+  end
+
+  # MagicAdmin::MagicError class
+  class DIDTokenError < MagicError; end
+
+  # RequestError Class
+  class RequestError < MagicError
+    # attribute reader for http response status
+    attr_reader :http_status
+
+    # attribute reader for http response code
+    attr_reader :http_code
+
+    # attribute reader for http response
+    attr_reader :http_response
+
+    # attribute reader for http response message
+    attr_reader :http_message
+
+    # attribute reader for http response error code
+    attr_reader :http_error_code
+
+    # attribute reader for http request params
+    attr_reader :http_request_params
+
+    # attribute reader for http request data
+    attr_reader :http_request_data
+
+    # attribute reader for http request method
+    attr_reader :http_method
+
+    # Description:
+    #   The constructor allows you to specify error message
+    #   and HTTP request and response info
+    #
+    # Arguments:
+    #   message: request error message.
+    #   opt: hash of request and response info of following keys:
+    #     http_status
+    #     http_code
+    #     http_response
+    #     http_message
+    #     http_error_code
+    #     http_request_params
+    #     http_request_data
+    #     http_method
+    # Returns:
+    #   A Error object that provides additional error info for magic api call.
+    def initialize(message, opt = {})
+      super(message)
+      @http_status = opt[:http_status]
+      @http_code = opt[:http_code]
+      @http_response = opt[:http_response]
+      @http_message = opt[:http_message]
+      @http_error_code = opt[:http_error_code]
+      @http_request_params = opt[:http_request_params]
+      @http_request_data = opt[:http_request_data]
+      @http_method = opt[:http_method]
+    end
+  end
+
+  # MagicAdmin::MagicError class
+  class APIConnectionError < RequestError; end
+
+  # MagicAdmin::RateLimitingError class
+  class RateLimitingError < RequestError; end
+
+  # MagicAdmin::BadRequestError class
+  class BadRequestError < RequestError; end
+
+  # MagicAdmin::AuthenticationError class
+  class AuthenticationError < RequestError; end
+
+  # MagicAdmin::ForbiddenError class
+  class ForbiddenError < RequestError; end
+
+  # MagicAdmin::APIError class
+  class APIError < RequestError; end
+
+end

data/lib/magic-admin/http/client.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module MagicAdmin
+
+  module Http
+
+    # Http Client and its methods are accessible
+    # on the Magic instance by the http_client attribute.
+    # It provides methods to interact with the http client.
+    class Client
+
+      # attribute reader for magic api max retries
+      attr_reader :retries
+
+      # attribute reader for magic api backoff factor
+      attr_reader :backoff
+
+      # attribute reader for magic api timeout
+      attr_reader :timeout
+
+      # attribute reader for magic api base api url
+      attr_reader :base_url
+
+      # attribute reader for magic http request class
+      attr_reader :http_request
+
+      # attribute reader for magic http response class
+      attr_reader :http_response
+
+      # The constructor allows you to configure HTTP request strategy
+      # when your application interacting with the Magic API
+      #
+      # Arguments:
+      #   api_base: api base url.
+      #   req_retries: Total number of retries to allow.
+      #   req_timeout: A period of time the request is going
+      #                to wait for a response.
+      #   req_backoff: A backoff factor to apply between retry attempts.
+      #
+      # Returns:
+      #   A Http Client object that provides access to
+      #   all the supported resources.
+      #
+      # Examples:
+      #   Client.new(<api_base>, <req_retries>, <req_timeout>, <req_backoff>)
+      def initialize(api_base, req_retries, req_timeout, req_backoff)
+        @retries = req_retries.to_i
+        @backoff = req_backoff.to_f
+        @timeout = req_timeout.to_f
+        @base_url = api_base
+        @http_request = Request
+        @http_response = Response
+      end
+
+      # Description:
+      #   call create http request and provide response
+      #
+      # Arguments:
+      #   method: http method
+      #   path: api path
+      #   options: a hash contains params and headers for request
+      #
+      # Returns:
+      #   A response object
+      def call(method, path, options)
+        url = URI("#{base_url}#{path}")
+        req = http_request.request(method, url, options)
+        resp = backoff_retries(retries, backoff) do
+          base_client(url, req, timeout)
+        end
+        http_response.from_net_http(resp, req)
+      end
+
+      private
+
+      # Description:
+      #   backoff_retries implementations of retries strategy
+      #   with backoff factor
+      #
+      # Arguments:
+      #   max_retries: max retries count
+      #   backoff_factor: backoff factor for configure delay in retries
+      #   block: block of code that uses retries backoff strategy
+      #
+      # Returns:
+      #   it returns, block return object
+      def backoff_retries(max_retries, backoff_factor, &block)
+        attempts = 0
+        begin
+          attempts += 1
+          block.call
+        rescue StandardError => e
+          raise e if attempts >= max_retries
+
+          sleep_seconds = backoff_factor * (2**(attempts - 1))
+          sleep sleep_seconds
+          retry
+        end
+      end
+
+      # Description:
+      #   use_ssl? provide true if url uses https protocol otherwise false
+      #
+      # Arguments:
+      #   url: max retries count
+      #
+      # Returns:
+      #   boolean value
+      def use_ssl?(url)
+        url.scheme == "https"
+      end
+
+      # Description:
+      #   base_client is base http request/response mechanism
+      #
+      # Arguments:
+      #   url: request url
+      #   request: request object
+      #   read_timeout: read_timeout for request
+      #
+      # Returns:
+      #   response
+      def base_client(url, request, read_timeout)
+        begin
+          Net::HTTP.start(url.host, url.port, use_ssl: use_ssl?(url)) do |http|
+            http.read_timeout = read_timeout
+            http.request(request)
+          end
+        rescue SocketError => e
+          raise APIConnectionError.new(e.message)
+        end
+      end
+
+    end
+  end
+end