ree_lib 1.0.35 → 1.0.37

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/float.rb

@@ -20,6 +20,8 @@ class ReeMapper::Float < ReeMapper::AbstractType
       rescue ArgumentError => e
         raise ReeMapper::CoercionError, "`#{name}` is invalid float"
       end
+    elsif defined?(BigDecimal) && value.is_a?(BigDecimal)
+      value.to_f
     else
       raise ReeMapper::TypeError, "`#{name}` should be a float"
     end

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

@@ -160,7 +160,7 @@ Create `mapper_factory.rb` file to declare `MapperFactory` class.
         build_mapper_strategy(method: :db_load,   dto: Object)
       ])
 
-      mapper_factory.register(:cart_user, user_caster)
+      mapper_factory.register_mapper(:cart_user, user_caster)
 
       mapper_factory
     end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_factory_spec.rb

@@ -5,35 +5,76 @@ RSpec.describe ReeMapper::MapperFactory do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
-  let(:mapper_factory) {
-    build_mapper_factory(strategies: [
-      build_mapper_strategy(method: :cast, dto: Hash)
-    ])
-  }
+  let(:cast_strategy) { build_mapper_strategy(method: :cast, dto: Hash) }
+  let(:serialize_strategy) { build_mapper_strategy(method: :serialize, dto: Hash) }
+  let(:mapper_factory) { build_mapper_factory(strategies: [cast_strategy, serialize_strategy]) }
+
+  describe '.register_type' do
+    let(:mapper_type) {
+      Class.new(ReeMapper::AbstractType) do
+        def cast(*); :value end
+        def serialize(*); end
+      end
+    }
 
-  describe '.register' do
     it {
-      mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
-      expect(mapper_factory.instance_methods).to include(:new_type)
+      mapper_factory.register_type(:new_type, mapper_type.new)
+      expect(
+        mapper_factory.call.use(:cast) { new_type :val }.cast({ val: :any })
+      ).to eq({ val: :value })
     }
 
-    it 'raise an error if the type is already registered' do
-      mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
+    it {
+      mapper_factory.register_type(:new_type, mapper_type.new, strategies: [cast_strategy])
+      expect(
+        mapper_factory.call.use(:cast) { new_type :val }.cast({ val: :any })
+      ).to eq({ val: :value })
+    }
+  end
+
+  describe '.register_mapper' do
+    let(:serializer) { mapper_factory.call.use(:serialize) { integer :id } }
+
+    it {
+      mapper_factory.register_mapper(:new_type, serializer)
+
+      expect(
+        mapper_factory.call.use(:serialize) { new_type :val }.serialize({ val: { id: 1 } })
+      ).to eq({ val: { id: 1 } })
+    }
+
+    it 'allow to register caster and serializer with same name' do
+      caster = mapper_factory.call.use(:cast) { string :name }
+
+      mapper_factory.register_mapper(:new_type, serializer)
+      mapper_factory.register_mapper(:new_type, caster)
+
+      expect(
+        mapper_factory.call.use(:serialize) { new_type :val }.serialize({ val: { id: 1 } })
+      ).to eq({ val: { id: 1 } })
+
+      expect(
+        mapper_factory.call.use(:cast) { new_type :val }.cast({ val: { name: '1' } })
+      ).to eq({ val: { name: '1' } })
+    end
+
+    it 'raise an error if the mapper is already registered' do
+      mapper_factory.register_mapper(:new_type, serializer)
 
       expect {
-        mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
-      }.to raise_error(ArgumentError, 'type :new_type already registered')
+        mapper_factory.register_mapper(:new_type, serializer)
+      }.to raise_error(ArgumentError, 'type :new_type with `serialize` strategy already registered')
     end
 
-    it 'raise an error if the type is ended by ?' do
+    it 'raise an error if the mapper name is ended by ?' do
       expect {
-        mapper_factory.register(:new_type?, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
-      }.to raise_error(ArgumentError)
+        mapper_factory.register_mapper(:new_type?, serializer)
+      }.to raise_error(ArgumentError, 'name of mapper type should not end with `?`')
     end
 
-    it 'raise an error if the type method is already registered' do
+    it 'raise an error if the mapper name is reserved' do
       expect {
-        mapper_factory.register(:array, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
+        mapper_factory.register_mapper(:array, serializer)
       }.to raise_error(ArgumentError, 'method :array already defined')
     end
   end
@@ -48,13 +89,17 @@ RSpec.describe ReeMapper::MapperFactory do
     }
 
     it {
-      mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
+      serializer = mapper_factory.call.use(:serialize) do
+        integer :my_field
+      end
+
+      mapper_factory.register_mapper(:new_type, serializer)
 
       expect {
         mapper_factory.call.use(:cast) do
           new_type :settings
         end
-      }.to raise_error(ReeMapper::UnsupportedTypeError)
+      }.to raise_error(ReeMapper::UnsupportedTypeError, 'type :new_type should implement `cast`')
     }
 
     it {
@@ -62,7 +107,9 @@ RSpec.describe ReeMapper::MapperFactory do
         integer :id
       end
 
-      expect(mapper_factory.instance_methods).to include(:user)
+      expect(
+        mapper_factory.call.use(:cast) { user :user }.cast({ user: { id: 1 } })
+      ).to eq({ user: { id: 1 } })
     }
 
     it {
@@ -80,4 +127,14 @@ RSpec.describe ReeMapper::MapperFactory do
       }.to raise_error(ReeMapper::ArgumentError, "mapper should contain at least one field")
     }
   end
+
+  describe '.find_strategy' do
+    it {
+      expect(mapper_factory.find_strategy(:cast)).to eq(cast_strategy)
+    }
+
+    it {
+      expect(mapper_factory.find_strategy(:unknown)).to be_nil
+    }
+  end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_spec.rb

@@ -92,7 +92,7 @@ RSpec.describe ReeMapper::Mapper do
       )
     }
 
-    it { 
+    it {
       expect(mapper.cast({ my_field: 1, hsh: { nested_field: 1 } })).to be_a(Struct)
     }
   end
@@ -166,4 +166,28 @@ RSpec.describe ReeMapper::Mapper do
       expect { mapper.dto(:db_dump) }.to raise_error(ArgumentError, "there is no :db_dump strategy")
     }
   end
+
+  describe '#find_strategy' do
+    let(:mapper_factory) {
+      build_mapper_factory(
+        strategies: [
+          build_mapper_strategy(method: :cast),
+          build_mapper_strategy(method: :serialize),
+        ]
+      )
+    }
+    let(:mapper) {
+      mapper_factory.call.use(:cast) do
+        integer :my_field
+      end
+    }
+
+    it {
+      expect(mapper.find_strategy(:cast)).to be_a(ReeMapper::MapperStrategy)
+    }
+
+    it {
+      expect(mapper.find_strategy(:serialize)).to be_nil
+    }
+  end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/float_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'bigdecimal'
 
 RSpec.describe 'ReeMapper::Float' do
   link :build_mapper_factory, from: :ree_mapper
@@ -30,6 +31,10 @@ RSpec.describe 'ReeMapper::Float' do
       expect(mapper.cast({ float: '1.1' })).to eq({ float: 1.1 })
     }
 
+    it {
+      expect(mapper.db_load({ float: BigDecimal("1.1") })).to eq({ float: 1.1 })
+    }
+
     it {
       expect { mapper.cast({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }
@@ -88,6 +93,10 @@ RSpec.describe 'ReeMapper::Float' do
       expect(mapper.db_load({ float: '1.1' })).to eq({ float: 1.1 })
     }
 
+    it {
+      expect(mapper.db_load({ float: BigDecimal("1.1") })).to eq({ float: 1.1 })
+    }
+
     it {
       expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/to_hash.rb

@@ -6,7 +6,7 @@ class ReeObject::ToHash
   fn :to_hash do
     def_error { RecursiveObjectErr }
   end
-  
+
   BASIC_TYPES = [
     Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol,
     Module, Class
@@ -57,8 +57,8 @@ class ReeObject::ToHash
       raise RecursiveObjectErr, "Recursive object found: #{obj}"
     end
 
-    cache[obj.object_id] = acc
-    
+    cache[obj.object_id] = true
+
     obj.instance_variables.each do |var|
       key_name = var.to_s.delete("@")
       key_sym = key_name.to_sym
@@ -69,6 +69,8 @@ class ReeObject::ToHash
       acc[key] = recursively_convert(value, {}, cache)
     end
 
+    cache.delete(obj.object_id)
+
     acc
   end
 end

data/lib/ree_lib/packages/ree_object/spec/ree_object/functions/to_hash_spec.rb

@@ -167,6 +167,11 @@ RSpec.describe :to_hash do
           to_hash(obj)
         }.to raise_error(ReeObject::ToHash::RecursiveObjectErr, /Recursive object found: /)
       }
+
+      it {
+        obj = obj_klass.new
+        expect(to_hash([obj, obj])).to eq([{}, {}])
+      }
     end
   end
 end

data/lib/ree_lib/packages/ree_roda/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/ree_lib/packages/ree_roda/Package.schema.json

@@ -0,0 +1,58 @@
+{
+  "schema_type": "package",
+  "schema_version": "1.1",
+  "name": "ree_roda",
+  "entry_path": "packages/ree_roda/package/ree_roda.rb",
+  "tags": [
+    "ree_roda"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_actions"
+    },
+    {
+      "name": "ree_errors"
+    },
+    {
+      "name": "ree_hash"
+    },
+    {
+      "name": "ree_json"
+    },
+    {
+      "name": "ree_logger"
+    },
+    {
+      "name": "ree_object"
+    },
+    {
+      "name": "ree_swagger"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+    {
+      "name": "build_action_errors",
+      "schema": "packages/ree_roda/schemas/ree_roda/services/build_action_errors.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
+    {
+      "name": "build_swagger_from_actions",
+      "schema": "packages/ree_roda/schemas/ree_roda/services/build_swagger_from_actions.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
+    {
+      "name": "status_from_error",
+      "schema": "packages/ree_roda/schemas/ree_roda/services/status_from_error.schema.json",
+      "tags": [
+        "fn"
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_roda/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "ree"
+
+Ree.init(__dir__, irb: true)

data/lib/ree_lib/packages/ree_roda/package/ree_roda/app.rb

@@ -0,0 +1,46 @@
+package_require("ree_errors/error")
+package_require("ree_mapper/errors/type_error")
+
+class ReeRoda::App < Roda
+  include Ree::LinkDSL
+
+  link :logger, from: :ree_logger
+  link :status_from_error
+  link :to_json, from: :ree_json
+
+  plugin :error_handler
+  plugin :json_parser
+  plugin :type_routing, default_type: :json
+
+  error do |e|
+    response["Content-Type"] = "application/json"
+
+    if e.is_a?(ReeErrors::Error)
+      body = {
+        code: e.code,
+        message: e.message,
+        type: e.type,
+      }
+
+      response.status = status_from_error(e.type)
+      response.write(to_json(body))
+      response.finish
+    elsif e.is_a?(ReeMapper::TypeError) || e.is_a?(ReeMapper::CoercionError)
+      body = {
+        code: "param",
+        message: e.message,
+        type: :invalid_param,
+      }
+
+      response.status = 400
+      response.write(to_json(body))
+      response.finish
+    else
+      logger.error(e.message, {}, e)
+      response["Content-Type"] = "text/plain"
+      response.status = 500
+      response.write("unhandled server error")
+      response.finish
+    end
+  end
+end

data/lib/ree_lib/packages/ree_roda/package/ree_roda/plugins/ree_actions.rb

@@ -0,0 +1,150 @@
+class Roda
+  module RodaPlugins
+    module ReeActions
+      def self.load_dependencies(app, opts = {})
+        package_require("ree_roda/services/build_swagger_from_actions")
+        package_require("ree_json/functions/to_json")
+        package_require("ree_hash/functions/transform_values")
+        package_require("ree_object/functions/not_blank")
+
+        app.plugin :all_verbs
+      end
+
+      def self.configure(app, opts = {})
+        app.opts[:ree_actions_before] = opts[:before] if opts[:before]
+      end
+
+      module ClassMethods
+        def ree_actions(actions, swagger_title: "", swagger_description: "",
+                        swagger_version: "", swagger_url: "", api_url: "")
+          @ree_actions ||= []
+          @ree_actions += actions
+
+          opts[:ree_actions_swagger_title] = swagger_title
+          opts[:ree_actions_swagger_description] = swagger_description
+          opts[:ree_actions_swagger_version] = swagger_version
+          opts[:ree_actions_swagger_url] = swagger_url
+          opts[:ree_actions_api_url] = api_url
+
+          opts[:ree_actions_swagger] = ReeRoda::BuildSwaggerFromActions.new.call(
+            @ree_actions,
+            opts[:ree_actions_swagger_title],
+            opts[:ree_actions_swagger_description],
+            opts[:ree_actions_swagger_version],
+            opts[:ree_actions_api_url]
+          )
+
+          build_actions_proc
+          nil
+        end
+
+        private
+
+        def build_actions_proc
+          list = []
+          context = self
+
+          return list if @ree_actions.nil? || @ree_actions.empty?
+
+          if context.opts[:ree_actions_swagger_url]
+            list << Proc.new do |r|
+              r.get context.opts[:ree_actions_swagger_url] do
+                r.json do
+                  response.status = 200
+                  ReeJson::ToJson.new.call(context.opts[:ree_actions_swagger])
+                end
+              end
+            end
+          end
+
+          @ree_actions.each do |action|
+            route = []
+            route_args = []
+
+            action.path.split("/").each do |part|
+              if part.start_with?(":")
+                route << String
+                route_args << part.gsub(":", "")
+              else
+                route << part
+              end
+            end
+
+            list << Proc.new do |r|
+              r.send(action.request_method, *route) do |*args|
+                r.send(action.respond_to) do
+                  env["warden"].authenticate!(scope: action.warden_scope)
+
+                  if context.opts[:ree_actions_before]
+                    self.instance_exec(@_request, action.warden_scope, &scope.opts[:ree_actions_before])
+                  end
+
+                  # TODO: implement me when migration to roda DSL happens
+                  # if action.before; end
+
+                  route_args.each_with_index do |arg, index|
+                    r.params["#{arg}"] = args[index]
+                  end
+
+                  params = r.params
+
+                  if r.body
+                    body = begin
+                      JSON.parse(r.body.read)
+                    rescue => e
+                      {}
+                    end
+
+                    params = params.merge(body)
+                  end
+
+                  not_blank = ReeObject::NotBlank.new
+
+                  filtered_params = ReeHash::TransformValues.new.call(params) do |k, v|
+                    v.is_a?(Array) ? v.select { not_blank.call(_1) } : v
+                  end
+
+                  accessor = env["warden"].user(action.warden_scope)
+                  action_result = action.action.klass.new.call(accessor, filtered_params)
+
+                  if action.serializer
+                    serialized_result = action.serializer.klass.new.serialize(action_result)
+                  else
+                    serialized_result = {}
+                  end
+
+                  case action.request_method
+                  when :post
+                    response.status = 201
+                    ReeJson::ToJson.new.call(serialized_result)
+                  when :put, :delete, :patch
+                    response.status = 204
+                    ""
+                  else
+                    response.status = 200
+                    ReeJson::ToJson.new.call(serialized_result)
+                  end
+                end
+              end
+            end
+          end
+
+          opts[:ree_actions_proc]  = list
+        end
+      end
+
+      module RequestMethods
+        def ree_actions
+          if scope.opts[:ree_actions_proc]
+            scope.opts[:ree_actions_proc].each do |request_proc|
+              self.instance_exec(self, &request_proc)
+            end
+          end
+          nil
+        end
+      end
+    end
+
+    register_plugin(:ree_actions, Roda::RodaPlugins::ReeActions)
+  end
+end

data/lib/ree_lib/packages/ree_roda/package/ree_roda/plugins/ree_logger.rb

@@ -0,0 +1,66 @@
+package_require "ree_logger/beans/logger"
+
+class Roda
+  module RodaPlugins
+    # The ree_logger plugin adds ReeLogger support to Roda
+    #
+    # Example:
+    #
+    #   plugin :ree_logger
+    #   plugin :ree_logger, log_params: true, filter: -> { request.path.include?("health") }
+    module ReeLogger
+      REE_LOGGER_DEFAULTS = {
+        method: :info,
+        log_params: true
+      }
+
+      def self.configure(app, **opts)
+        opts = REE_LOGGER_DEFAULTS.merge(opts)
+        app.opts[:ree_logger] = ::ReeLogger::Logger.new
+        app.opts[:ree_logger_filter] = opts[:filter] if opts[:filter]
+        app.opts[:ree_logger_log_params] = !!opts[:log_params]
+      end
+
+      def self.start_timer
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      module InstanceMethods
+        private
+
+        # Log request/response information in common log format to logger.
+        def _roda_after_90__ree_logger(result)
+          return unless result && result[0] && result[1]
+
+          if opts[:ree_logger_filter]
+            return if self.instance_exec(&opts[:ree_logger_filter])
+          end
+
+          elapsed_time = if timer = @_request_timer
+            "%0.4f" % (ReeLogger.start_timer - timer)
+          else
+            "-"
+          end
+
+          env = @_request.env
+
+          message = <<~DOC
+            Request/Response details:
+              Request: #{env["REQUEST_METHOD"]} #{env["QUERY_STRING"] && !env["QUERY_STRING"].empty? ? env["SCRIPT_NAME"].to_s + env["PATH_INFO"] + "?#{env["QUERY_STRING"]}": env["SCRIPT_NAME"].to_s + env["PATH_INFO"]} #{opts[:ree_logger_log_params] ? "\n  Params: " + request.params.inspect : ""}
+              Response status: #{response.status || "-"}#{(400..499).include?(response.status) ? "\n  Response body: " + response.body[0] : ""}
+              Time Taken: #{elapsed_time}
+          DOC
+
+          opts[:ree_logger].info(message)
+        end
+
+        # Create timer instance used for timing
+        def _roda_before_05__ree_logger
+          @_request_timer = ReeLogger.start_timer
+        end
+      end
+    end
+
+    register_plugin(:ree_logger, ReeLogger)
+  end
+end

data/lib/ree_lib/packages/ree_roda/package/ree_roda/services/build_action_errors.rb

@@ -0,0 +1,76 @@
+class ReeRoda::BuildActionErrors
+  include Ree::FnDSL
+
+  fn :build_action_errors do
+    link "ree_swagger/dto/error_dto", -> { ErrorDto }
+  end
+
+  contract(ReeActions::Action => ArrayOf[ErrorDto])
+  def call(action)
+    ree_object = action.action
+    errors = recursively_extract_errors(ree_object)
+
+    errors
+      .select {
+        _1.ancestors.include?(ReeErrors::Error) && status_from_error(_1)
+      }
+      .map {
+        e = _1.new
+        description = "type: **#{e.type}**, code: **#{e.code}**, message: **#{e.message}**"
+
+        ErrorDto.new(
+          status: status_from_error(_1),
+          description: description
+        )
+      }
+      .uniq { [_1.status, _1.description] }
+  end
+
+  private
+
+  def recursively_extract_errors(ree_object)
+    errors = extract_errors(ree_object)
+
+    ree_object.links.each do |link|
+      obj = Ree.container.packages_facade.get_object(
+        link.package_name, link.object_name
+      )
+
+      if obj.fn?
+        errors += recursively_extract_errors(obj)
+      end
+    end
+
+    errors
+  end
+
+  def extract_errors(ree_object)
+    klass = ree_object.klass
+    return [] if ree_object.object?
+
+    method_decorator = Ree::Contracts.get_method_decorator(
+      klass, :call, scope: :instance
+    )
+
+    method_decorator&.errors || []
+  end
+
+  def status_from_error(error)
+    case error.instance_variable_get(:@type)
+    when :not_found
+      404
+    when :invalid_param
+      400
+    when :conflict
+      405
+    when :auth
+      401
+    when :permission
+      403
+    when :payment
+      402
+    when :validation
+      422
+    end
+  end
+end