ree_lib 1.0.0

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/build_request.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+class ReeHttp::BuildRequest
+  include Ree::FnDSL
+
+  fn :build_request do
+    link :to_json, from: :ree_json
+    link :slice, from: :ree_hash
+    link :not_blank, from: :ree_object
+
+    link 'ree_http/constants', -> {
+      HTTPS & HTTP & HTTPS_PORT & HTTP_PORT & DEFAULT_FORCE_SSL
+    }
+  end
+
+  DEFAULT_PROTOCOL_PORTS = [HTTPS_PORT, HTTP_PORT]
+
+  DEFAULTS = {
+    headers: {},
+    force_ssl: DEFAULT_FORCE_SSL,
+  }.freeze
+
+  doc(<<~DOC)
+    Builds Net::HTTPRequest with specified method, url, headers, body, form data,
+    query params, basic auth or bearer token. Forces SSL mode
+  DOC
+
+  contract(
+    Symbol,
+    String,
+    Ksplat[
+      headers?: HashOf[Or[String, Symbol], Or[String, Integer]],
+      body?: Or[HashOf[Or[Symbol, String], Or[Integer, Float, Bool, String, Hash, Array]], String, File],
+      form_data?: HashOf[Or[Symbol, String], Or[Integer, Float, Bool, String, Array, File]],
+      query_params?: HashOf[Or[String, Symbol], Or[String, Integer]],
+      force_ssl?: Bool,
+      basic_auth?: {
+        username: String,
+        password: String
+      },
+      bearer_token?: String,
+    ] => Net::HTTPRequest,
+    ).throws(ArgumentError)
+  def call(method, url, **opts)
+    unless opts[:body].nil?
+      unless  opts[:form_data].nil?
+        raise ArgumentError, "You can't use body argument with form_data argument"
+      end
+    end
+
+    opts = DEFAULTS.merge(opts)
+    uri = URI(url)
+
+    uri.scheme = opts[:force_ssl] ? HTTPS : uri.scheme
+
+    if DEFAULT_PROTOCOL_PORTS.include?(uri.port)
+      uri.port = opts[:force_ssl] ? HTTPS_PORT : uri.port
+    end
+
+    q_string = opts[:query_params] ? URI.encode_www_form(opts[:query_params]) : nil
+
+    uri.query = if uri.query.nil?
+      q_string
+    else
+      if not_blank(q_string)
+        uri.query + '&' + q_string.to_s
+      else
+        uri.query
+      end
+    end
+
+    request =
+      case method
+      when :get then Net::HTTP::Get.new(uri)
+      when :post then Net::HTTP::Post.new(uri)
+      when :put then Net::HTTP::Put.new(uri)
+      when :delete then Net::HTTP::Delete.new(uri)
+      when :patch then Net::HTTP::Patch.new(uri)
+      when :head then Net::HTTP::Head.new(uri)
+      when :options then Net::HTTP::Options.new(uri)
+      else
+        raise ArgumentError, "Unavailable rest method"
+      end
+
+    unless opts[:body].nil?
+      request.body =
+        case request[:body]
+        when Hash then to_json[opts[:body]]
+        when File then opts[:body].read
+        else
+          opts[:body]
+        end
+    end
+
+    unless opts[:form_data].nil?
+      request = add_form_data(request, opts[:form_data])
+    end
+
+    opts[:headers].each do |k, v|
+      request.add_field k, v
+    end
+
+    unless opts[:basic_auth].nil?
+      request.basic_auth(opts[:basic_auth][:username], opts[:basic_auth][:password])
+    end
+
+    unless opts[:bearer_token].nil?
+      request.add_field "Authorization", generate_bearer_auth(opts[:bearer_token])
+    end
+
+    request
+  end
+
+  private
+
+  def add_form_data(request, form_data)
+    array_form_data = []
+
+    form_data.each_pair do |k, v|
+      array_form_data << [k.to_s, v]
+    end
+
+    request.set_form([*array_form_data], "multipart/form-data", charset: "UTF-8")
+
+    request
+  end
+
+  def generate_bearer_auth(token)
+    "Bearer " + token.to_s
+  end
+end
+

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/build_request_executor.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class ReeHttp::BuildRequestExecutor
+  include Ree::FnDSL
+
+  fn :build_request_executor do
+    link 'ree_http/constants', -> {
+      DEFAULT_TIMEOUT & DEFAULT_WRITE_TIMEOUT & DEFAULT_FORCE_SSL
+    }
+  end
+
+  DEFAULTS = {
+    timeout: DEFAULT_TIMEOUT,
+    write_timeout: DEFAULT_WRITE_TIMEOUT,
+    force_ssl: DEFAULT_FORCE_SSL,
+    proxy: {}
+  }.freeze
+
+  doc(<<~DOC)
+    Builds Net::HTTP object that could be further used for execution
+  DOC
+
+  contract(
+    URI,
+    Ksplat[
+      timeout?: Integer,
+      write_timeout?: Integer,
+      force_ssl?: Bool,
+      ca_certs?: ArrayOf[File],
+      proxy?: {
+        address: String,
+        port?: Integer,
+        username?: String,
+        password?: String
+      }
+    ] => Net::HTTP
+  )
+  def call(uri, **opts)
+    opts = DEFAULTS.merge(opts)
+    proxy = opts[:proxy] || {}
+
+    request_executor = Net::HTTP.new(
+      uri.hostname, uri.port ,
+      proxy[:address], proxy[:port], proxy[:username], proxy[:password]
+    )
+
+    request_executor.write_timeout = opts[:write_timeout]
+    request_executor.read_timeout = opts[:timeout]
+
+    request_executor.use_ssl = opts[:force_ssl]
+
+    if opts[:ca_certs?]
+      request_executor = build_ca_certs(request_executor, opts[:ca_certs?])
+    end
+
+    request_executor
+  end
+
+  private
+
+  def build_ca_certs(request_executor, ca_files)
+    store = OpenSSL::X509::Store.new
+
+    ca_files.each do |ca_file|
+      store.add_cert(OpenSSL::X509::Certificate.new(ca_file.read))
+    end
+
+    request_executor.cert_store = store
+    request_executor
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/execute_request.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+class ReeHttp::ExecuteRequest
+  include Ree::FnDSL
+
+  fn :execute_request do
+    link :build_request_executor
+    link :slice, from: :ree_hash
+    link 'ree_http/http_exceptions', -> { HttpExceptions }
+
+    link 'ree_http/constants', -> {
+      DEFAULT_TIMEOUT & DEFAULT_WRITE_TIMEOUT & DEFAULT_FORCE_SSL
+    }
+  end
+
+  include HttpExceptions
+
+  REDIRECT_CODES = [300, 301, 302, 303, 307, 308].to_set.freeze
+  STRICT_SENSITIVE_CODES = [300, 301, 302].to_set.freeze
+  ALWAYS_GET_CODES = [303].to_set.freeze
+  METHOD_NOT_MODIFIED_CODES = [307, 308].to_set.freeze
+  UNSAFE_VERBS = %i[put delete post patch options].to_set.freeze
+  SEE_OTHER_ALLOWED_VERBS = %i[get head].to_set.freeze
+  MAX_REDIRECT_COUNT = 10
+
+  DEFAULTS = {
+    redirects_count: MAX_REDIRECT_COUNT,
+    strict_redirect_mode: true,
+    timeout: DEFAULT_TIMEOUT,
+    write_timeout: DEFAULT_WRITE_TIMEOUT,
+    force_ssl: DEFAULT_FORCE_SSL,
+  }.freeze
+
+  doc(<<~DOC)
+    Executes prepared Net::HTTPRequest.
+
+    Optional options:
+      strict_redirect_mode - raise RedirectMethodError if strict_redirect_mode=true (default)
+      otherwise redirects with GET method if response code in [300, 301, 302]
+
+      redirects_count - raise TooManyRedirectsError if we have more redirects than specified otherwise proceed redirects
+
+      timeout - wait response timeout (defaults to 60 seconds)
+
+      write_timeout - send request timeout (defaults to 30 seconds)
+
+      force_ssl - force SSL on
+
+      ca_certs - sets path of a CA certification files
+
+      proxy - set proxy server auth
+  DOC
+
+  contract(
+     Net::HTTPRequest,
+     Ksplat[
+       write_timeout?: Integer,
+       timeout?: Integer,
+       redirects_count?: Integer,
+       strict_redirect_mode?: Bool,
+       force_ssl?: Bool,
+       ca_certs?: ArrayOf[File],
+       proxy?: {
+         address: String,
+         port?: Integer,
+         username?: String,
+         password?: String
+       }
+     ],
+     Optblock => Net::HTTPResponse
+  ).throws(TooManyRedirectsError, RedirectMethodError)
+  def call(request, **opts, &block)
+    opts = DEFAULTS.merge(opts)
+
+    requester = build_request_executor(
+      request.uri,
+      **slice(opts, [:timeout, :force_ssl, :ca_certs, :proxy, :write_timeout])
+    )
+
+    ReeHttp.logger.debug(
+      "Sending #{request.method} request: URI #{request.uri}\n BODY: #{request.body}\n"
+    )
+
+    response = requester.start do |http|
+      http.request(request, &block)
+    end
+
+    ReeHttp.logger.debug(
+      "Got #{response.code} response on request URI #{request.uri}\n With BODY: #{response.body}\n"
+    )
+
+    process_redirect_response(response, request, opts, &block)
+
+    response
+  end
+
+  private
+
+  def process_redirect_response(response, request, opts, &block)
+    if response.is_a?(Net::HTTPRedirection)
+      if opts[:redirects_count] == 0
+        raise TooManyRedirectsError, "Got too match redirects, if you want more redirects, use redirects_count"
+      end
+
+      if opts[:strict_redirect_mode] && STRICT_SENSITIVE_CODES.include?(response.code.to_i) && UNSAFE_VERBS.include?(request.method.to_sym)
+        raise RedirectMethodError, "Got #{response.code.to_i} with strict_mode"
+      end
+
+      if (ALWAYS_GET_CODES.include?(response.code.to_i) || STRICT_SENSITIVE_CODES.include?(response.code.to_i)) && UNSAFE_VERBS.include?(request.method.downcase.to_sym)
+        request.instance_variable_set(:@method, 'GET')
+      end
+
+      request.instance_variable_set(:@uri, URI(response['Location']))
+      request.instance_variable_set(:@path, request.uri.path)
+
+      opts[:redirects_count] -= 1
+
+      return call(request, **opts, &block)
+    end
+
+    response
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_delete.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpDelete
+  include Ree::FnDSL
+
+  fn :http_delete do
+    link :http_exec, import: -> { OPTS_CONTRACT }
+  end
+
+  doc(<<~DOC)
+    Sends DELETE HTTP request to a specified destination.
+    See http_exec for usage examples.
+  DOC
+
+  contract(
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse
+  )
+  def call(url, **opts, &block)
+    http_exec(:delete, url, **opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_exec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpExec
+  include Ree::FnDSL
+
+  fn :http_exec do
+    link :build_request
+    link :execute_request
+    link :slice, from: :ree_hash
+
+    link 'ree_http/constants', -> {
+      DEFAULT_TIMEOUT & DEFAULT_WRITE_TIMEOUT & DEFAULT_FORCE_SSL
+    }
+  end
+
+  DEFAULTS = {
+    headers: {},
+    timeout: DEFAULT_TIMEOUT,
+    write_timeout: DEFAULT_WRITE_TIMEOUT,
+    force_ssl: DEFAULT_FORCE_SSL,
+  }.freeze
+
+  OPTS_CONTRACT = {
+    headers?: HashOf[Or[String, Symbol], Or[String, Integer]],
+    body?: Or[String, Hash, File],
+    form_data?: HashOf[Or[Symbol, String], Or[Integer, Float, Bool, String, Array, File]],
+    write_timeout?: Integer,
+    timeout?: Integer,
+    redirects_count?: Integer,
+    strict_redirect_mode?: Bool,
+    query_params?: HashOf[Or[String, Symbol], Any],
+    force_ssl?: Bool,
+    ca_certs?: ArrayOf[File],
+    basic_auth?: {
+      username: String,
+      password: String
+    },
+    bearer_token?: String,
+    proxy?: {
+      address: String,
+      port?: Integer,
+      username?: String,
+      password?: String
+    }
+  }
+
+  doc(<<~DOC)
+    Sends HTTP request to a specified destination.
+
+    Options:
+      method - request method (:get, :post, :delete, :put, :patch, :head, :options)
+      url - request URL
+      headers - request headers
+      body - request body (String, Hash or File). Should not be used together with form data
+      form_data - request form data. Files are being sent with corresponding filenames
+      query_params - request query string params
+      basic_auth - sets basic auth credentials
+      strict_redirect_mode - see build_request_executor
+      redirects_count - see build_request_executor
+      timeout - see build_request_executor
+      force_ssl - see build_request_executor
+      write_timeout - see build_request_executor
+      ca_certs - see build_request_executor
+      proxy - see build_request_executor
+
+    Examples usage:
+      http_exec('https://example.com', :get)
+      http_exec('https://example.com', :post, form_data: {name: 'John', file: file})
+      http_exec('https://example.com', :delete, basic_auth: {username: 'John', password: 'password'})
+      http_exec('http://example.com', :options, force_ssl: true)
+  DOC
+
+  contract(
+    Or[:get, :post, :put, :patch, :head, :options, :delete],
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse
+  )
+  def call(method, url, **opts, &block)
+    opts = DEFAULTS.merge(opts)
+
+    request = build_request(
+      method, url,
+      **slice(opts, [
+          :headers, :body, :form_data, :query_params,
+          :force_ssl, :ca_certs, :basic_auth, :bearer_token
+      ])
+    )
+
+    request_opts = slice(
+      opts, [
+        :timeout, :force_ssl, :ca_certs, :proxy, :write_timeout,
+        :redirects_count, :strict_redirect_mode
+      ]
+    )
+
+    execute_request(request, **request_opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_get.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpGet
+  include Ree::FnDSL
+
+  fn :http_get do
+    link :http_exec, import: -> { OPTS_CONTRACT }
+  end
+
+  doc(<<~DOC)
+    Sends GET HTTP request to a specified destination.
+    See http_exec for usage examples.
+  DOC
+
+  contract(
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse
+  )
+  def call(url, **opts, &block)
+    http_exec(:get, url, **opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_head.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpHead
+  include Ree::FnDSL
+
+  fn :http_head do
+    link :http_exec, import: -> { OPTS_CONTRACT }
+  end
+
+  doc(<<~DOC)
+    Sends HEAD HTTP request to a specified destination.
+    See http_exec for usage examples.
+  DOC
+
+  contract(
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse
+  )
+  def call(url, **opts, &block)
+    http_exec(:head, url, **opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpOptions
+  include Ree::FnDSL
+
+  fn :http_options do
+    link :http_exec, import: -> { OPTS_CONTRACT }
+  end
+
+  doc(<<~DOC)
+    Sends OPTIONS HTTP request to a specified destination.
+    See http_exec for usage examples.
+  DOC
+
+  contract(
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse,
+  )
+  def call(url, **opts, &block)
+    http_exec(:options, url, **opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_patch.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpPatch
+  include Ree::FnDSL
+
+  fn :http_patch do
+    link :http_exec, import: -> { OPTS_CONTRACT }
+  end
+
+  doc(<<~DOC)
+    Sends PATCH HTTP request to a specified destination.
+    See http_exec for usage examples.
+  DOC
+
+  contract(
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse
+  )
+  def call(url, **opts, &block)
+    http_exec(:patch, url, **opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_post.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpPost
+  include Ree::FnDSL
+
+  fn :http_post do
+    link :http_exec, import: -> { OPTS_CONTRACT }
+  end
+
+  doc(<<~DOC)
+    Sends POST HTTP request to a specified destination.
+    See http_exec for usage examples.
+  DOC
+
+  contract(
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse,
+  )
+  def call(url, **opts, &block)
+    http_exec(:post, url, **opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/functions/http_put.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeHttp::HttpPut
+  include Ree::FnDSL
+
+  fn :http_put do
+    link :http_exec, import: -> { OPTS_CONTRACT }
+  end
+
+  doc(<<~DOC)
+    Sends PUT HTTP request to a specified destination.
+    See http_exec for usage examples.
+  DOC
+
+  contract(
+    String,
+    Ksplat[**OPTS_CONTRACT],
+    Optblock => Net::HTTPResponse,
+  )
+  def call(url, **opts, &block)
+    http_exec(:put, url, **opts, &block)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http/http_exceptions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ReeHttp
+  module HttpExceptions
+    RedirectError = Class.new(StandardError)
+    TooManyRedirectsError = Class.new(RedirectError)
+    RedirectMethodError = Class.new(RedirectError)
+  end
+end

data/lib/ree_lib/packages/ree_http/package/ree_http.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'logger'
+
+module ReeHttp
+  include Ree::PackageDSL
+
+  package do
+    depends_on :ree_json
+    depends_on :ree_hash
+    depends_on :ree_object
+  end
+
+  class << self
+    def logger
+      @logger ||= begin
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::WARN
+        logger
+      end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+end

data/lib/ree_lib/packages/ree_http/schemas/ree_http/add_auth.schema.json

@@ -0,0 +1,31 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "add_auth",
+  "path": "packages/ree_http/package/ree_http/add_auth.rb",
+  "mount_as": "fn",
+  "class": "ReeHttp::AddAuth",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Any",
+      "args": [
+        {
+          "arg": "request",
+          "type": "Net::HTTPRequest"
+        },
+        {
+          "arg": "auth",
+          "type": "Hash"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_http/schemas/ree_http/basic_auth.schema.json

@@ -0,0 +1,15 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "basic_auth",
+  "path": "packages/ree_http/package/ree_http/basic_auth.rb",
+  "mount_as": "object",
+  "class": "ReeHttp::BasicAuth",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+
+  ]
+}