chalk_ruby 0.1.0

data/lib/chalk_ruby/client.rb

@@ -0,0 +1,192 @@
+require 'chalk_ruby/config/config'
+require 'chalk_ruby/logger_helper'
+require 'chalk_ruby/transport/transport'
+require 'chalk_ruby/http/response'
+
+module ChalkRuby
+  class Token
+    attr_accessor :token, :expires_at, :environment, :engines
+
+    # @param [Hash[String, untyped]] exchange_credentials_response
+    def initialize(exchange_credentials_response)
+      @token       = exchange_credentials_response[:access_token]
+      @expires_at  = DateTime.parse(exchange_credentials_response[:expires_at])
+      @environment = exchange_credentials_response[:primary_environment]
+      @engines     = exchange_credentials_response[:engines]
+    end
+
+    def expired?
+      DateTime.now.advance({ seconds: 60 }) > @expires_at
+    end
+  end
+
+  class Client
+    # Initializes the Personalization client
+    #
+    # @param chalk_config [ChalkRuby::Config] a ChalkRuby::Config object which contains your APP_ID and API_KEY
+    # @option adapter [Object] adapter object used for the connection
+    # @option logger [Object]
+    # @option http_requester [Object] http_requester object used for the connection
+    #
+    def initialize(chalk_config, opts = {})
+      @token       = nil
+      @config      = chalk_config
+      adapter      = opts[:adapter] || Defaults::ADAPTER
+      logger       = opts[:logger] || LoggerHelper.create
+      requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter: adapter, logger: logger)
+      @transporter = Transport::Transport.new(requester: requester)
+    end
+
+    # Create a new client providing only app ID and API key
+    #
+    # @param client_id [String] ChalkRuby application ID
+    # @param client_secret [String] ChalkRuby API key
+    # @param environment [String] ChalkRuby environment
+    # @param query_server [String] ChalkRuby query server
+    # @param api_server [String] ChalkRuby API server
+    #
+    # @return self
+    #
+    def self.create(
+      client_id,
+      client_secret,
+      environment = nil,
+      query_server = nil,
+      api_server = nil
+    )
+      config = Config.new(
+        client_id: client_id,
+        client_secret: client_secret,
+        environment: environment,
+        query_server: query_server,
+        api_server: api_server
+      )
+      create_with_config(config)
+    end
+
+    # Create a new client providing only a ChalkRuby::Config object
+    #
+    # @param config [ChalkRuby::Config]
+    #
+    # @return self
+    #
+    def self.create_with_config(config)
+      new(config)
+    end
+
+    # Compute features values using online resolvers.
+    # See https://docs.chalk.ai/docs/query-basics for more information.
+    #
+    # @param input [Hash[String, any]] The features for which there are known values, mapped to those values.
+    #
+    # @param output [[String]] Outputs are the features that you'd like to compute from the inputs.
+    #     For example, `['user.age', 'user.name', 'user.email']`.
+    #
+    #     If an empty sequence, the output will be set to all features on the namespace
+    #     of the query. For example, if you pass as input `{"user.id": 1234}`, then the query
+    #     is defined on the `User` namespace, and all features on the `User` namespace
+    #     (excluding has-one and has-many relationships) will be used as outputs.
+    #
+    #
+    # @return [Hash[Symbol, String]]
+    #
+    def query(
+      input:,
+      output:,
+      # now,
+      opts: {}
+      # _staleness
+    )
+      query_server_request(
+        method: :post,
+        path: 'v1/query/online',
+        body: {
+          inputs: input,
+          outputs: output
+          # now: now
+        },
+        headers: get_authenticated_headers
+      )
+    end
+
+    def get_token
+      response = api_server_request(
+        method: :post,
+        path: '/v1/oauth/token',
+        body: {
+          client_id: @config.client_id,
+          client_secret: @config.client_secret,
+          grant_type: 'client_credentials'
+        },
+        headers: get_unauthenticated_headers
+      )
+      Token.new(response)
+    end
+
+    private
+
+    def api_server_request(method:, path:, body:, headers:)
+      @transporter.request_simple(
+        method: method,
+        host: @config.api_server,
+        path: path,
+        timeout: @config.api_timeout,
+        connect_timeout: @config.connect_timeout,
+        body: body,
+        headers: headers
+      )
+    end
+
+    def query_server_request(method:, path:, body:, headers:)
+      @transporter.request_simple(
+        method: method,
+        host: query_server_host,
+        path: path,
+        timeout: @config.query_timeout,
+        connect_timeout: @config.connect_timeout,
+        body: body,
+        headers: headers
+      )
+    end
+
+    def get_authenticated_headers
+      t = valid_token
+      {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Authorization': 'Bearer ' + t.token,
+        'X-ChalkRuby-Environment': @config.environment || t.environment
+      }
+    end
+
+    def get_unauthenticated_headers
+      {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'X-ChalkRuby-Environment': @config.environment
+      }
+    end
+
+    def query_server_host
+      explicit = @config.query_server
+      if explicit.nil?
+        tok   = valid_token
+        found = @config.environment || tok.environment
+        found.nil? ? Defaults::QUERY_SERVER : tok.engines[found] || Defaults::QUERY_SERVER
+      else
+        explicit
+      end
+    end
+
+    def valid_token
+      if @token.nil? || @token.expired?
+        t      = get_token
+        @token = t
+        t
+      else
+        @token
+      end
+    end
+
+  end
+end

data/lib/chalk_ruby/config/config.rb

@@ -0,0 +1,39 @@
+require 'faraday'
+require 'chalk_ruby/defaults'
+
+module ChalkRuby
+  class Config
+    attr_accessor :client_id,
+                  :client_secret,
+                  :query_server,
+                  :api_server,
+                  :environment,
+                  :query_timeout,
+                  :api_timeout,
+                  :connect_timeout
+
+    #
+    # @option options [String] :client_id
+    # @option options [String] :client_secret
+    # @option options [String] :query_host
+    # @option options [String] :api_host
+    # @option options [Integer] :read_timeout
+    # @option options [Integer] :write_timeout
+    # @option options [Integer] :connect_timeout
+    #
+    def initialize(opts = {})
+      @client_id       = opts[:client_id] || ENV['CHALK_CLIENT_ID']
+      @client_secret   = opts[:client_secret] || ENV['CHALK_CLIENT_SECRET']
+      @environment     = opts[:environment] || ENV['CHALK_ACTIVE_ENVIRONMENT']
+      @query_server    = opts[:query_server] || ENV['CHALK_QUERY_SERVER'] || Defaults::QUERY_SERVER
+      @api_server      = opts[:api_server] || ENV['CHALK_API_SERVER'] || Defaults::API_SERVER
+      @query_timeout   = opts[:query_timeout] || Defaults::API_TIMEOUT
+      @api_timeout     = opts[:api_timeout] || Defaults::QUERY_TIMEOUT
+      @connect_timeout = opts[:connect_timeout] || Defaults::CONNECT_TIMEOUT
+
+      raise ChalkError, 'No Client ID provided, please set :client_id' if @client_id.nil?
+      raise ChalkError, 'No Client Secret provided, please set :client_secret' if @client_secret.nil?
+    end
+
+  end
+end

data/lib/chalk_ruby/defaults.rb

@@ -0,0 +1,36 @@
+require 'chalk_ruby/http/http_requester'
+
+module ChalkRuby
+  module Defaults
+    REQUESTER_CLASS = ChalkRuby::Http::HttpRequester
+    ADAPTER         = 'net_http_persistent'
+
+    # HTTP Headers
+    # ----------------------------------------
+    HEADER_CLIENT_ID     = 'X-ChalkRuby-Client-Id'.freeze
+    HEADER_CLIENT_SECRET = 'X-ChalkRuby-Client-Secret'.freeze
+    HEADER_ENVIRONMENT   = 'X-ChalkRuby-Env-Id'.freeze
+    AUTHORIZATION_HEADER = 'Authorization'.freeze
+    USER_AGENT           = "ChalkRuby Ruby (#{ChalkRuby::VERSION}), Ruby (#{RUBY_VERSION})"
+
+    # API Servers
+    # ----------------------------------------
+    QUERY_SERVER = 'https://api.prod.chalk.ai'.freeze
+    API_SERVER   = 'https://api.prod.chalk.ai'.freeze
+
+    # HTTP ERROR CODES
+    # ----------------------------------------
+    ERROR_BAD_REQUEST = 400
+    ERROR_FORBIDDEN   = 403
+    ERROR_NOT_FOUND   = 404
+    ERROR_TIMED_OUT   = 408
+
+    # HTTP TIMEOUTS
+    # ----------------------------------------
+    CONNECT_TIMEOUT = 2
+    API_TIMEOUT     = 10
+    QUERY_TIMEOUT   = 120
+
+    WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY = 100
+  end
+end

data/lib/chalk_ruby/error.rb

@@ -0,0 +1,22 @@
+module ChalkRuby
+  # Base exception class for errors thrown by the ChalkRuby
+  # client library. ChalkError will be raised by any
+  # network operation if ChalkRuby.init() has not been called.
+  #
+  class ChalkError < StandardError
+  end
+
+  # An exception class raised when the REST API returns an error.
+  # The error code and message will be parsed out of the HTTP response,
+  # which is also included in the response attribute.
+  #
+  class ChalkHttpError < ChalkError
+    attr_accessor :code, :message
+
+    def initialize(code:, message:)
+      self.code    = code
+      self.message = message
+      super("#{self.code}: #{self.message}")
+    end
+  end
+end

data/lib/chalk_ruby/helpers.rb

@@ -0,0 +1,45 @@
+require 'multi_json'
+
+module ChalkRuby
+  module Helpers
+    # Convert an Hash to json
+    #
+    def to_json(body:)
+      body.is_a?(String) ? body : MultiJson.dump(body)
+    end
+
+    # Converts each key of a hash to symbols
+    #
+    def symbolize_hash(hash:)
+      hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    end
+
+    # Convert a json object to an hash
+    #
+    def json_to_hash(json:, symbolize_keys:)
+      MultiJson.load(json, symbolize_keys: symbolize_keys)
+    end
+
+    # Retrieve the given value associated with a key, in string or symbol format
+    #
+    def get_option(hash:, key:)
+      hash[key.to_sym] || hash[key] || nil
+    end
+
+    # Build a path with the given arguments
+    #
+    def path_encode(path, *args)
+      arguments = []
+      args.each do |arg|
+        arguments.push(CGI.escape(arg.to_s))
+      end
+
+      format(path, *arguments)
+    end
+
+    def self.included(base)
+      base.extend(Helpers)
+    end
+
+  end
+end

data/lib/chalk_ruby/http/http_requester.rb

@@ -0,0 +1,94 @@
+require 'chalk_ruby/helpers'
+require 'chalk_ruby/http/response'
+
+module ChalkRuby
+  module Http
+    class HttpRequester
+      include Helpers
+      attr_accessor :adapter, :logger
+
+      #
+      # @param adapter [Net::Http] adapter used to make requests. Defaults to Net::Http
+      # @param logger [Logger] logger used to log requests. Defaults to ChalkRuby::LoggerHelper
+      #
+      def initialize(adapter:, logger:)
+        @adapter     = adapter
+        @logger      = logger
+        @connections = {}
+      end
+
+      # Sends a request
+      #
+      # @param host [String]
+      # @param method [Symbol]
+      # @param path [String]
+      # @param body [String]
+      # @param headers [Hash]
+      # @param timeout [Integer]
+      # @param connect_timeout [Integer]
+      #
+      # @return [Http::Response]
+      #
+      def send_request(
+        host:,
+        method:,
+        path:,
+        body:,
+        headers:,
+        timeout:,
+        connect_timeout:
+      )
+        connection                      = connection(host)
+        connection.options.timeout      = timeout
+        connection.options.open_timeout = connect_timeout
+
+        if ENV['CHALK_DEBUG']
+          @logger.info("Sending #{method.to_s.upcase!} request to #{path} with body #{body}")
+        end
+
+        response = connection.run_request(
+          method,
+          path,
+          body,
+          headers
+        )
+
+        if response.success?
+          if ENV['CHALK_DEBUG']
+            @logger.info("Request succeeded. Response status: #{response.status}, body: #{response.body}")
+          end
+          return Http::Response.new(status: response.status, body: response.body, headers: response.headers)
+        end
+
+        if ENV['CHALK_DEBUG']
+          @logger.info("Request failed. Response status: #{response.status}, error: #{response.body}")
+        end
+        Http::Response.new(status: response.status, error: response.body, headers: response.headers)
+      rescue Faraday::TimeoutError => e
+        if ENV['CHALK_DEBUG']
+          @logger.info("Request timed out. Error: #{e.message}")
+        end
+        Http::Response.new(error: e.message, has_timed_out: true)
+      rescue ::StandardError => e
+        if ENV['CHALK_DEBUG']
+          @logger.info("Request failed. Error: #{e.message}")
+        end
+        Http::Response.new(error: e.message, network_failure: true)
+
+      end
+
+      # Retrieve the connection from the @connections
+      #
+      # @param host [String]
+      #
+      # @return [Faraday::Connection]
+      #
+      def connection(host)
+        @connections[host] ||= Faraday.new(host) do |f|
+          f.adapter @adapter.to_sym
+        end
+      end
+
+    end
+  end
+end

data/lib/chalk_ruby/http/response.rb

@@ -0,0 +1,23 @@
+module ChalkRuby
+  module Http
+    class Response
+      attr_reader :status, :body, :error, :headers, :has_timed_out, :network_failure
+
+      #
+      # @option status    [String]  Response status
+      # @option body    [String]  Response body
+      # @option error    [String]  Response error or caught error
+      # @option headers    [String]  Response headers
+      # @option has_timed_out    [String]  If the request has timed out
+      #
+      def initialize(opts = {})
+        @status          = opts[:status]
+        @body            = opts[:body] || ''
+        @error           = opts[:error] || ''
+        @headers         = opts[:headers] || ''
+        @has_timed_out   = opts[:has_timed_out] || false
+        @network_failure = opts[:network_failure] || false
+      end
+    end
+  end
+end

data/lib/chalk_ruby/logger_helper.rb

@@ -0,0 +1,14 @@
+require 'logger'
+
+module ChalkRuby
+  class LoggerHelper
+    # @param debug_file [nil|String] file used to output the logs
+    #
+    def self.create(debug_file = nil)
+      file              = debug_file || (ENV['CHALK_DEBUG'] ? File.new('debug.log') : $stderr)
+      instance          = ::Logger.new file
+      instance.progname = 'chalk'
+      instance
+    end
+  end
+end

data/lib/chalk_ruby/transport/transport.rb

@@ -0,0 +1,54 @@
+require 'faraday'
+# Default adapter needs to be required to be registered
+require 'faraday/net_http_persistent' unless Faraday::VERSION < '1'
+require 'chalk_ruby/error'
+
+module ChalkRuby
+  module Transport
+    class Transport
+      include Helpers
+
+      # @param requester [ChalkRuby::Http::HttpRequester] requester used for sending requests.
+      #
+      def initialize(requester:)
+        @http_requester = requester
+      end
+
+      def request_simple(method:, host:, path:, timeout:, connect_timeout:, headers:, body:)
+        response = @http_requester.send_request(
+          host: host,
+          method: method,
+          path: path,
+          body: body && to_json(body: body),
+          headers: headers,
+          timeout: timeout,
+          connect_timeout: connect_timeout
+        )
+
+        if response.has_timed_out
+          raise ChalkHttpError.new(code: Defaults::ERROR_TIMED_OUT, message: 'Request timed out')
+        end
+
+        if response.network_failure
+          raise ChalkHttpError.new(code: 502, message: 'Network failure')
+        end
+
+        unless success?(http_response_code: response.status)
+          decoded_error = json_to_hash(json: response.error, symbolize_keys: true)
+          raise ChalkHttpError.new(
+            code: get_option(hash: decoded_error, key: 'status'),
+            message: get_option(hash: decoded_error, key: 'message')
+          )
+        end
+        json_to_hash(json: response.body, symbolize_keys: true)
+      end
+
+      private
+
+      def success?(http_response_code:)
+        !http_response_code.nil? && (http_response_code.to_i / 100).floor == 2
+      end
+
+    end
+  end
+end

data/lib/chalk_ruby/version.rb

@@ -0,0 +1,3 @@
+module ChalkRuby
+  VERSION = '0.1.0'.freeze
+end

data/lib/chalk_ruby.rb

@@ -0,0 +1,13 @@
+# ChalkRuby module
+module ChalkRuby
+  require 'chalk_ruby/version'
+  require 'chalk_ruby/helpers'
+  require 'chalk_ruby/http/http_requester'
+  require 'chalk_ruby/defaults'
+  require 'chalk_ruby/config/config'
+  require 'chalk_ruby/http/response'
+  require 'chalk_ruby/transport/transport'
+  require 'chalk_ruby/client'
+  require 'chalk_ruby/error'
+  require 'chalk_ruby/logger_helper'
+end

data/renovate.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "config:base"
+  ]
+}

data/sig/chalk_ruby/client.rbs

@@ -0,0 +1,43 @@
+module ChalkRuby
+  class Client
+    @config: Config
+    @token: Token?
+    @transporter: Transport::Transport
+
+    def self.create: -> Client
+
+    def self.create_with_config: -> Client
+
+    def get_token: -> Token
+
+    def query: (
+        ::Hash[Symbol|String, untyped] input,
+        [String] output,
+        Time? now,
+        ?::Hash[String, String] staleness
+      ) -> Hash[Symbol, untyped]
+
+    private
+
+    def get_authenticated_headers: -> Hash[Symbol, String | nil]
+    def get_unauthenticated_headers: -> Hash[Symbol, String | nil]
+
+    def query_server_host: -> String
+
+    def query_server_request: (
+        Symbol method,
+        String path,
+        Hash[Symbol, String] body,
+        Hash[String, String] headers
+      ) -> Hash[Symbol, untyped]
+
+    def api_server_request: (
+        Symbol method,
+        String path,
+        Hash[Symbol, String] body,
+        Hash[String, String] headers
+      ) -> Hash[Symbol, untyped]
+
+    def valid_token: -> Token
+  end
+end

data/sig/chalk_ruby/config/config.rbs

@@ -0,0 +1,31 @@
+module ChalkRuby
+  class Config
+    attr_accessor client_id: String
+    attr_accessor client_secret: String
+
+    attr_accessor api_server: String
+    attr_accessor api_timeout: Integer
+
+    attr_accessor query_server: String
+    attr_accessor query_timeout: Integer
+
+    attr_accessor environment: String
+
+    attr_accessor connect_timeout: Integer
+
+    type options = {
+        client_id: String,
+        client_secret: String,
+        environment: String,
+        api_server: String,
+        query_server: String,
+        query_timeout: Integer,
+        api_timeout: Integer,
+        connect_timeout: Integer,
+        compression_type: String
+      }
+
+    def initialize: (options opts) -> void
+
+  end
+end

data/sig/chalk_ruby/defaults.rbs

@@ -0,0 +1,35 @@
+module ChalkRuby
+  module Defaults
+    REQUESTER_CLASS : Http::HttpRequester
+    ADAPTER         : String
+
+    # HTTP Headers
+    # ----------------------------------------
+    HEADER_CLIENT_ID     : String
+    HEADER_CLIENT_SECRET : String
+    HEADER_ENVIRONMENT   : String
+    AUTHORIZATION_HEADER : String
+    USER_AGENT           : String
+
+    # API Servers
+    # ----------------------------------------
+    QUERY_SERVER : String
+    API_SERVER   : String
+
+    # HTTP ERROR CODES
+    # ----------------------------------------
+    ERROR_BAD_REQUEST : Integer
+    ERROR_FORBIDDEN   : Integer
+    ERROR_NOT_FOUND   : Integer
+    ERROR_TIMED_OUT   : Integer
+
+    # HTTP TIMEOUTS
+    # ----------------------------------------
+    CONNECT_TIMEOUT : Integer
+    API_TIMEOUT     : Integer
+    QUERY_TIMEOUT   : Integer
+
+
+    WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY : Integer
+  end
+end

data/sig/chalk_ruby/error.rbs

@@ -0,0 +1,6 @@
+module ChalkRuby
+  class ChalkHttpError
+    attr_accessor code: Integer
+    attr_accessor message: String
+  end
+end

data/sig/chalk_ruby/helpers.rbs

@@ -0,0 +1,15 @@
+module ChalkRuby
+  module Helpers
+    def to_json: (String | Hash[Symbol, String] body) -> String
+
+    def symbolize_hash: (Hash[Symbol | String, untyped] hash) -> Hash[Symbol, untyped]
+
+    def json_to_hash: (String json, bool symbolize_keys) -> Hash[Symbol, String]
+
+    def get_option: ([Symbol | String, String] hash, String key) -> (String | [String])
+
+    def path_encode: (String path, *String args) -> String
+
+    def self.included: (self base) -> self
+  end
+end