ree_lib 1.3.9 → 1.3.11

data/lib/ree_lib/packages/ree_audit/spec/ree_audit/functions/filter_params_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+package_require('ree_audit/functions/filter_params')
+
+RSpec.describe :filter_params do
+  link :filter_params, from: :ree_audit
+
+  it "leaves a plain payload untouched" do
+    expect(filter_params({page: 1, per_page: 25})).to eq({page: 1, per_page: 25})
+  end
+
+  it "filters a secret sitting at the top level" do
+    expect(filter_params({password: "hunter2", page: 1})).to eq(
+      {password: 'FILTERED', page: 1}
+    )
+  end
+
+  it "filters a secret nested three levels deep" do
+    result = filter_params({user: {profile: {user_password: "hunter2", name: "Ann"}}})
+
+    expect(result).to eq(
+      {user: {profile: {user_password: 'FILTERED', name: "Ann"}}}
+    )
+  end
+
+  it "filters inside an array of hashes" do
+    result = filter_params({items: [{auth_token: "t"}, {name: "ok"}]})
+
+    expect(result).to eq({items: [{auth_token: 'FILTERED'}, {name: "ok"}]})
+  end
+
+  it "matches filter words on string keys as well" do
+    expect(filter_params({"Authorization" => "Bearer x"})).to eq(
+      {"Authorization" => 'FILTERED'}
+    )
+  end
+
+  it "cuts everything deeper than the configured depth" do
+    result = filter_params({a: {b: {c: {d: {e: 1}}}}})
+
+    expect(result).to eq({a: {b: {c: {d: '[TRUNCATED_DEPTH]'}}}})
+  end
+
+  it "replaces an oversized payload with its size" do
+    result = filter_params({blob: "x" * 5000})
+
+    expect(result[:truncated]).to eq(true)
+    expect(result[:size]).to be > 4096
+    expect(result[:blob]).to be_nil
+  end
+
+  it "keeps a payload that fits the size limit" do
+    result = filter_params({blob: "x" * 100})
+
+    expect(result[:truncated]).to be_nil
+    expect(result[:blob]).to eq("x" * 100)
+  end
+end

data/lib/ree_lib/packages/ree_audit/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+RSpec.configure do |config|
+  config.extend Ree::RSpecLinkDSL
+end
+
+ENV['AUDIT_ENABLED'] = 'true'
+ENV['AUDIT_MAX_PARAMS_BYTES'] = '4096'
+ENV['AUDIT_MAX_PARAMS_DEPTH'] = '4'
+
+# The audit bean links a logger; keep it silent — the specs assert on the
+# logger object itself, not on its output.
+ENV['LOG_FILE_PATH'] = '/tmp/ree_audit.log'
+ENV['LOG_LEVEL_FILE'] = ''
+ENV['LOG_LEVEL_STDOUT'] = ''

data/lib/ree_lib/packages/ree_dao/package/ree_dao/dataset_extensions.rb

@@ -183,21 +183,23 @@ module ReeDao
       end
 
       def with_mapper(mapper)
-        clone(
-          schema_mapper: mapper || opts[:schema_mapper],
-        ).with_row_proc(
+        m = mapper || opts[:schema_mapper]
+
+        row_proc = if m.nil?
+          Proc.new { |hash| hash }
+        elsif (dto = m.find_strategy(:db_load)&.dto) && dto.include?(ReeDto::DSL)
+          # ree_dto entities skip set_persistence_state anyway; avoid the
+          # per-row ancestor walk entirely
+          Proc.new { |hash| m.db_load(hash) }
+        else
           Proc.new { |hash|
-            m = mapper || opts[:schema_mapper]
-
-            if m
-              entity = m.db_load(hash)
-              self.set_persistence_state(entity, hash)
-              entity
-            else
-              hash
-            end
+            entity = m.db_load(hash)
+            self.set_persistence_state(entity, hash)
+            entity
           }
-        )
+        end
+
+        clone(schema_mapper: m).with_row_proc(row_proc)
       end
 
       private

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/db_load_performance_mode_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+package_require('ree_dao')
+package_require('ree_dto/entity_dsl')
+package_require('ree_dto/dsl')
+
+RSpec.describe "db_load performance mode (dao integration)" do
+  link :build_sqlite_connection, from: :ree_dao
+
+  after do
+    Ree.disable_irb_mode
+    Ree.disable_db_load_performance_mode
+  end
+
+  before :all do
+    connection = build_sqlite_connection({database: 'sqlite_db'})
+
+    if connection.table_exists?(:perf_mode_users)
+      connection.drop_table(:perf_mode_users)
+    end
+
+    connection.create_table :perf_mode_users do
+      primary_key :id
+
+      column :name, 'varchar(256)'
+      column :age, :integer
+    end
+
+    connection.disconnect
+  end
+
+  Ree.enable_irb_mode
+
+  module ReeDaoPerfModeTest
+    include Ree::PackageDSL
+
+    package do
+      depends_on :ree_dao
+    end
+  end
+
+  class ReeDaoPerfModeTest::Db
+    include Ree::BeanDSL
+
+    bean :db do
+      singleton
+      factory :build
+
+      link :build_sqlite_connection, from: :ree_dao
+    end
+
+    def build
+      build_sqlite_connection({database: 'sqlite_db'})
+    end
+  end
+
+  class ReeDaoPerfModeTest::User
+    include ReeDto::EntityDSL
+
+    properties(
+      id: Nilor[Integer],
+      name: String,
+      age: Integer,
+    )
+
+    attr_accessor :name
+  end
+
+  class ReeDaoPerfModeTest::UserDto
+    include ReeDto::DSL
+
+    build_dto do
+      field :id, Nilor[Integer]
+      field :name, String
+      field :age, Integer
+    end
+  end
+
+  # mappers are built at class definition time, so the flag state around each
+  # class body decides which db_load implementation the dao gets
+  Ree.enable_db_load_performance_mode
+
+  class ReeDaoPerfModeTest::CompiledUsersDao
+    include ReeDao::DSL
+
+    dao :compiled_users_dao do
+      link :db
+    end
+
+    table :perf_mode_users
+
+    schema ReeDaoPerfModeTest::User do
+      integer :id, null: true
+      string :name
+      integer :age
+    end
+  end
+
+  class ReeDaoPerfModeTest::CompiledDtoDao
+    include ReeDao::DSL
+
+    dao :compiled_dto_dao do
+      link :db
+    end
+
+    table :perf_mode_users
+
+    schema ReeDaoPerfModeTest::UserDto do
+      integer :id, null: true
+      string :name
+      integer :age
+    end
+  end
+
+  Ree.disable_db_load_performance_mode
+
+  class ReeDaoPerfModeTest::GenericUsersDao
+    include ReeDao::DSL
+
+    dao :generic_users_dao do
+      link :db
+    end
+
+    table :perf_mode_users
+
+    schema ReeDaoPerfModeTest::User do
+      integer :id, null: true
+      string :name
+      integer :age
+    end
+  end
+
+  let(:compiled_dao) { ReeDaoPerfModeTest::CompiledUsersDao.new }
+  let(:compiled_dto_dao) { ReeDaoPerfModeTest::CompiledDtoDao.new }
+  let(:generic_dao) { ReeDaoPerfModeTest::GenericUsersDao.new }
+
+  it "compiles the schema mapper of daos defined with the mode on" do
+    compiled_mapper = ReeDaoPerfModeTest::CompiledUsersDao.instance_variable_get(:@schema_mapper)
+    generic_mapper = ReeDaoPerfModeTest::GenericUsersDao.instance_variable_get(:@schema_mapper)
+
+    expect(compiled_mapper.class.method_defined?(:__generic_db_load, false)).to be true
+    expect(generic_mapper.class.method_defined?(:__generic_db_load, false)).to be false
+  end
+
+  it "reads identical entities through compiled and generic daos" do
+    generic_dao.delete_all
+
+    user = ReeDaoPerfModeTest::User.new(name: 'John', age: 30)
+    generic_dao.put(user)
+
+    from_generic = generic_dao.find(user.id)
+    from_compiled = compiled_dao.find(user.id)
+
+    expect(from_compiled.id).to eq(from_generic.id)
+    expect(from_compiled.name).to eq(from_generic.name)
+    expect(from_compiled.age).to eq(from_generic.age)
+
+    expect(compiled_dao.all.map(&:id)).to eq(generic_dao.all.map(&:id))
+  end
+
+  it "keeps the update round-trip working for entity_dsl entities" do
+    generic_dao.delete_all
+
+    user = ReeDaoPerfModeTest::User.new(name: 'John', age: 30)
+    compiled_dao.put(user)
+
+    loaded = compiled_dao.find(user.id)
+    loaded.name = 'Doe'
+    compiled_dao.update(loaded)
+
+    expect(generic_dao.find(user.id).name).to eq('Doe')
+  end
+
+  it "loads and updates ree_dto entities through the compiled dao" do
+    compiled_dto_dao.delete_all
+
+    dto = ReeDaoPerfModeTest::UserDto.build(id: nil, name: 'Jane', age: 25)
+    compiled_dto_dao.put(dto)
+
+    loaded = compiled_dto_dao.find(dto.id)
+    expect(loaded).to be_a(ReeDaoPerfModeTest::UserDto)
+    expect(loaded.name).to eq('Jane')
+
+    loaded.name = 'Janet'
+    expect(loaded.changed_fields).to eq([:name])
+    compiled_dto_dao.update(loaded)
+
+    expect(compiled_dto_dao.find(dto.id).name).to eq('Janet')
+  end
+end

data/lib/ree_lib/packages/ree_dto/package/ree_dto/dto/dto_class_methods.rb

@@ -32,6 +32,20 @@ module ReeDto::DtoClassMethods
     dto_obj
   end
 
+  # Fast-path constructor used by compiled db_load: takes ownership of attrs
+  # (it becomes @_attrs without copying), so callers must not reuse the hash.
+  # Reads @fields_with_default directly: the contract-wrapped reader would
+  # revalidate the array on every row.
+  def build_from_attrs(attrs)
+    (@fields_with_default || []).each do |field|
+      attrs[field.name] = field.default unless attrs.key?(field.name)
+    end
+
+    dto_obj = allocate
+    dto_obj.instance_variable_set(:@_attrs, attrs)
+    dto_obj
+  end
+
   private
 
   def set_fields(v)

data/lib/ree_lib/packages/ree_dto/spec/ree_dto/build_from_attrs_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+package_require("ree_dto/dsl")
+
+RSpec.describe "ReeDto build_from_attrs" do
+  class ReeDto::BuildFromAttrsDto
+    include ReeDto::DSL
+
+    build_dto do
+      field :id, Integer
+      field :name, Nilor[String]
+      field :with_default, Nilor[Integer], default: 7
+    end
+  end
+
+  it "takes ownership of the attrs hash without copying" do
+    attrs = { id: 1, name: "n" }
+    dto = ReeDto::BuildFromAttrsDto.build_from_attrs(attrs)
+
+    expect(dto.attrs).to equal(attrs)
+    expect(dto.id).to eq(1)
+    expect(dto.name).to eq("n")
+  end
+
+  it "fills defaults only for absent keys" do
+    dto = ReeDto::BuildFromAttrsDto.build_from_attrs({ id: 1 })
+    expect(dto.with_default).to eq(7)
+
+    dto = ReeDto::BuildFromAttrsDto.build_from_attrs({ id: 1, with_default: nil })
+    expect(dto.get_value(:with_default)).to eq(nil)
+  end
+
+  it "matches build for identical inputs" do
+    built = ReeDto::BuildFromAttrsDto.build({ id: 1, name: "n" })
+    fast = ReeDto::BuildFromAttrsDto.build_from_attrs({ id: 1, name: "n" })
+
+    expect(fast.attrs).to eq(built.attrs)
+    expect(fast).to eq(built)
+  end
+
+  it "produces a fully functional dto" do
+    dto = ReeDto::BuildFromAttrsDto.build_from_attrs({ id: 1 })
+
+    dto.name = "x"
+    expect(dto.changed_fields).to eq([:name])
+    expect(dto.has_value?(:name)).to be true
+    expect(dto.to_h).to eq({ id: 1, name: "x", with_default: 7 })
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+# Compiles a specialized :db_load for composite mappers when
+# Ree.db_load_performance_mode? is on at mapper build time.
+#
+# The compiled method handles the hot call shape `db_load(hash)` with no
+# role/filters as straight-line per-field code: values of primitive types
+# skip casting behind a cheap type guard (see AbstractType#db_load_trusted_check),
+# non-trusted types (custom, enums, pg wrappers, nested mappers) are cast as
+# usual, and dto construction goes through a single attrs hash instead of
+# build-then-copy. Every other call shape falls back to the untouched generic
+# method, kept as __generic_db_load.
+#
+# Codegen targets the mapper's anonymous class (each Mapper.build creates
+# one), never the instance: registered mappers are frozen.
+class ReeMapper::DbLoadCompiler
+  class << self
+    def compile(mapper)
+      return if mapper.type # leaf mappers keep their generic delegation
+
+      strategy = mapper.find_strategy(:db_load)
+      return unless strategy
+
+      case (output = strategy.output)
+      when ReeMapper::ReeDtoOutput
+        builder  = "acc = {}"
+        finisher = "DB_LOAD_DTO.build_from_attrs(acc)"
+      when ReeMapper::HashOutput
+        return unless strategy.dto == ::Hash # OpenStruct keeps the generic path
+        builder  = "acc = {}"
+        finisher = "acc"
+      when ReeMapper::ObjectOutput
+        builder  = "acc = DB_LOAD_DTO.allocate"
+        finisher = "acc"
+      else
+        return # StructOutput and unknown outputs keep the generic path
+      end
+
+      klass = mapper.class
+      return if klass.method_defined?(:__generic_db_load, false) # already compiled
+
+      fields = mapper.fields.values
+
+      set_const(klass, :DB_LOAD_FIELDS, fields.freeze)
+      set_const(klass, :DB_LOAD_DTO, strategy.dto)
+      set_const(
+        klass,
+        :DB_LOAD_NESTED_FILTERS,
+        fields.map { _1.fields_filter ? [_1.fields_filter].freeze : nil }.freeze
+      )
+
+      body = fields.each_with_index.filter_map { |field, idx|
+        # the generic loop skips role-scoped fields when role is nil; calls
+        # with an actual role go through the generic fallback
+        next unless field.roles.empty?
+        field_code(field, idx, output, strategy.always_optional)
+      }.join("\n")
+
+      klass.send(:alias_method, :__generic_db_load, :db_load)
+
+      klass.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def db_load(obj, role: nil, only: nil, except: nil, fields_filters: nil)
+          if role || only || except || fields_filters || !obj.is_a?(::Hash)
+            return __generic_db_load(obj, role: role, only: only, except: except, fields_filters: fields_filters)
+          end
+
+          #{builder}
+          #{body}
+          #{finisher}
+        end
+      RUBY
+
+      # keep the generated source inspectable for debugging
+      klass.instance_variable_set(:@compiled_db_load_source, body)
+
+      nil
+    end
+
+    private
+
+    def field_code(field, idx, output, always_optional)
+      cast_expr = "__dbl_cast(DB_LOAD_FIELDS[#{idx}], v, DB_LOAD_NESTED_FILTERS[#{idx}])"
+      guard = field.type.db_load_trusted_check("v")
+
+      value_expr = if guard == "true"
+        # identity type (any): nil also passes through unchanged, as in the
+        # generic loop where Any#db_load(nil) returns nil
+        "v"
+      elsif guard
+        if field.null
+          "v.nil? ? nil : (#{guard} ? v : #{cast_expr})"
+        else
+          "#{guard} ? v : #{cast_expr}"
+        end
+      else
+        if field.null
+          "v.nil? ? nil : #{cast_expr}"
+        else
+          cast_expr
+        end
+      end
+
+      sym_key = field.from.inspect
+      str_key = field.from_as_str.inspect
+
+      missing_code = if field.optional || always_optional
+        assign(field, output, "DB_LOAD_FIELDS[#{idx}].default") if field.has_default?
+      else
+        <<~RUBY.chomp
+          raise ReeMapper::TypeError.new(
+            "is missing (required field)", DB_LOAD_FIELDS[#{idx}].location, [#{str_key}]
+          )
+        RUBY
+      end
+
+      code = +<<~RUBY
+        if obj.key?(#{sym_key})
+          v = obj[#{sym_key}]
+          #{assign(field, output, value_expr)}
+        elsif obj.key?(#{str_key})
+          v = obj[#{str_key}]
+          #{assign(field, output, value_expr)}
+      RUBY
+
+      if missing_code
+        code << "else\n  #{missing_code}\n"
+      end
+
+      code << "end\n"
+    end
+
+    def assign(field, output, value_expr)
+      if output.is_a?(ReeMapper::ObjectOutput)
+        "acc.instance_variable_set(#{field.name_as_instance_var_name.inspect}, #{value_expr})"
+      else
+        "acc[#{field.name.inspect}] = #{value_expr}"
+      end
+    end
+
+    def set_const(klass, name, value)
+      klass.send(:remove_const, name) if klass.const_defined?(name, false)
+      klass.const_set(name, value)
+    end
+  end
+end

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

@@ -139,9 +139,34 @@ class ReeMapper::Mapper
   def prepare_dto
     raise ReeMapper::ArgumentError, "mapper should contain at least one field" if fields.empty?
     strategies.each { _1.prepare_dto(fields.keys) }
+
+    if ReeMapper.db_load_performance_mode? && find_strategy(:db_load)
+      ReeMapper::DbLoadCompiler.compile(self)
+    end
+
     nil
   end
 
+  # DbLoadCompiler helpers below are deliberately contract-free: they run
+  # per field per row on the hot path.
+
+  # Guard expression for the wrapped type, or nil when this mapper's db_load
+  # must always be called (composite mappers, wrappers, custom types)
+  def db_load_trusted_check(var)
+    return nil if @type.nil?
+    @type.respond_to?(:db_load_trusted_check) ? @type.db_load_trusted_check(var) : nil
+  end
+
+  # Slow path of compiled db_load: full cast with the same error decoration
+  # as the generic per-field loop
+  def __dbl_cast(field, value, nested_filters)
+    field.type.db_load(value, role: nil, fields_filters: nested_filters)
+  rescue ReeMapper::ErrorWithLocation => e
+    e.prepend_field_name(field.name_as_str)
+    e.location ||= field.location
+    raise e
+  end
+
   contract(Symbol => Nilor[ReeMapper::MapperStrategy])
   def find_strategy(strategy_method)
     strategies.detect { _1.method == strategy_method }

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class ReeMapper::MapperStrategy
-  attr_reader :method, :always_optional
+  attr_reader :method, :always_optional, :output
 
   contract(Symbol, Class, Bool => Any)
   def initialize(method:, dto:, always_optional:)
@@ -61,8 +61,6 @@ class ReeMapper::MapperStrategy
 
   private
 
-  attr_reader :output
-
   def build_output(dto)
     if dto == Hash || (defined?(OpenStruct) && dto == OpenStruct)
       ReeMapper::HashOutput.new(dto)

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

@@ -1,4 +1,13 @@
 class ReeMapper::AbstractType
+  # Ruby expression (as source string) checking that `var` already holds a
+  # correctly-typed DB value, so db_load may return it as-is. Types that
+  # cannot be skipped (custom types, enums, pg wrappers) return nil. The
+  # expression must accept exactly the values for which this type's db_load
+  # is an identity, or db_load semantics change in performance mode.
+  def db_load_trusted_check(var)
+    nil
+  end
+
   private
 
   def truncate(str, limit = 180)

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class ReeMapper::Any < ReeMapper::AbstractType
+  def db_load_trusted_check(var)
+    "true"
+  end
+
   contract(Any => Any)
   def serialize(value)
     value

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

@@ -4,6 +4,10 @@ class ReeMapper::Bool < ReeMapper::AbstractType
   TRUE_CAST_VALUES = ['1', 'true', 'on', 1, true].freeze
   FALSE_CAST_VALUES = ['0', 'false', 'off', 0, false].freeze
 
+  def db_load_trusted_check(var)
+    "(true.equal?(#{var}) || false.equal?(#{var}))"
+  end
+
   contract(Any => Bool).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.is_a?(TrueClass) || value.is_a?(FalseClass)

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

@@ -3,6 +3,11 @@
 require 'date'
 
 class ReeMapper::Date < ReeMapper::AbstractType
+  # instance_of?, not is_a?: DateTime < Date, and cast converts DateTime
+  def db_load_trusted_check(var)
+    "#{var}.instance_of?(::Date)"
+  end
+
   contract(Any => Date).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.class == Date

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

@@ -3,6 +3,10 @@
 require 'date'
 
 class ReeMapper::DateTime < ReeMapper::AbstractType
+  def db_load_trusted_check(var)
+    "#{var}.instance_of?(::DateTime)"
+  end
+
   contract(Any => DateTime).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.class == DateTime

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class ReeMapper::Float < ReeMapper::AbstractType
+  def db_load_trusted_check(var)
+    "#{var}.is_a?(::Float)"
+  end
+
   contract(Any => Float).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.is_a?(Float)

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class ReeMapper::Integer < ReeMapper::AbstractType
+  def db_load_trusted_check(var)
+    "#{var}.is_a?(::Integer)"
+  end
+
   contract(Any => Integer).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.is_a? Integer

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class ReeMapper::Rational < ReeMapper::AbstractType
+  def db_load_trusted_check(var)
+    "#{var}.is_a?(::Rational)"
+  end
+
   contract(Any => Rational).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.is_a?(Rational)

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class ReeMapper::String < ReeMapper::AbstractType
+  def db_load_trusted_check(var)
+    "#{var}.is_a?(::String)"
+  end
+
   contract(Any => String).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.is_a? String

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

@@ -3,6 +3,11 @@
 require 'time'
 
 class ReeMapper::Time < ReeMapper::AbstractType
+  # instance_of?: cast accepts subclasses (e.g. Sequel::SQLTime) only via parse paths
+  def db_load_trusted_check(var)
+    "#{var}.instance_of?(::Time)"
+  end
+
   contract(Any => Time).throws(ReeMapper::TypeError)
   def serialize(value)
     if value.class == Time