ree_lib 1.0.42 → 1.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '029a676848df8b25ed6e8319749a9a563f779e65886e866c57e1a8834bf5614b'
-  data.tar.gz: 6bd0ff97e2bb2d6b10eb121c29e988fe63af07cd8759212c261a61abeefb89f9
+  metadata.gz: 1322fe618658e425a1614927faf1ed43252e3b49bc9c953d3ba10de162693217
+  data.tar.gz: 8843b92fb6f84cbd83b1966108ea2a541ae798067b6b1a379c1cb7a1baeebbfa
 SHA512:
-  metadata.gz: 2f009bab3a5897fafc59e3443577b19b10435b0fa74d8840d148d2b4151fae4c527d230dcb8218cde86d401ef955084a34c418124e4ae35ddb91845d2d44ff5e
-  data.tar.gz: ee04a53688b9c282b314440fc4da21943c30dcfbb5a73c209bfdca4605cabef1a6f74f8805f9a0fa76581f192dbb58ce82a50dbe7e6110277984ab6b95e93680
+  metadata.gz: 41693ec34aff5834b7aba142dd2fb9a9a10146ce178091a8404d7c143bc6a1bce54b106fdbacac896ccc19df3ef5ef87d41a5a88cf2ad27646362839151a04cc
+  data.tar.gz: eb691d0b59814c5fab063627c6bea39ab8dcfec2f48643e17249a6175d2738c5867ba342776b7967626008757244848ad4abd95dd290f57de119a772b3167d81

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.42)
+    ree_lib (1.0.43)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -49,7 +49,7 @@ GEM
       rack (>= 1.3)
     rainbow (3.1.1)
     rake (13.0.6)
-    ree (1.0.27)
+    ree (1.0.28)
       commander (~> 4.6.0)
     rexml (3.2.5)
     roda (3.58.0)

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

@@ -7,6 +7,9 @@
     "ree_actions"
   ],
   "depends_on": [
+    {
+      "name": "ree_dao"
+    },
     {
       "name": "ree_mapper"
     }

data/lib/ree_lib/packages/ree_actions/package/ree_actions/dsl.rb

@@ -3,11 +3,19 @@ module ReeActions
     def self.included(base)
       base.extend(ClassMethods)
       base.include(ReeMapper::DSL)
+      link_dao_cache(base)
     end
 
     def self.extended(base)
       base.extend(ClassMethods)
       base.include(ReeMapper::DSL)
+      link_dao_cache(base)
+    end
+
+    private_class_method def self.link_dao_cache(base)
+      base.include(Ree::LinkDSL)
+      base.link :drop_cache, as: :__ree_dao_drop_cache, from: :ree_dao
+      base.link :init_cache, as: :__ree_dao_init_cache, from: :ree_dao
     end
 
     module ClassMethods
@@ -40,6 +48,8 @@ module ReeActions
         alias_method(:__original_call, :call)
 
         define_method :call do |user_access, attrs|
+          __ree_dao_init_cache
+
           if self.class.const_defined?(:ActionCaster)
             caster = self.class.const_get(:ActionCaster)
 
@@ -51,6 +61,8 @@ module ReeActions
           else
             __original_call(user_access, attrs)
           end
+        ensure
+          __ree_dao_drop_cache
         end
 
         nil

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

@@ -5,6 +5,7 @@ module ReeActions
 
   package do
     depends_on :ree_mapper
+    depends_on :ree_dao
   end
 end
 

data/lib/ree_lib/packages/ree_actions/spec/ree_actions/dsl_spec.rb

@@ -1,6 +1,29 @@
 package_require("ree_actions/dsl")
 
 RSpec.describe ReeActions::DSL, type: [:autoclean] do
+  link :build_sqlite_connection, from: :ree_dao
+
+  before(:all) do
+    connection = build_sqlite_connection({database: 'sqlite_db'})
+
+    if connection.table_exists?(:users)
+      connection.drop_table(:users)
+    end
+
+    if connection.table_exists?(:products)
+      connection.drop_table(:products)
+    end
+
+    connection.create_table :users do
+      primary_key :id
+
+      column  :name, 'varchar(256)'
+      column  :age, :integer
+    end
+
+    connection.disconnect
+  end
+
   before do
     Ree.enable_irb_mode
   end
@@ -15,6 +38,7 @@ RSpec.describe ReeActions::DSL, type: [:autoclean] do
 
       package do
         depends_on :ree_mapper
+        depends_on :ree_dao
       end
 
       class TestAction
@@ -42,6 +66,8 @@ RSpec.describe ReeActions::DSL, type: [:autoclean] do
       include Ree::PackageDSL
 
       package do
+        depends_on :ree_mapper
+        depends_on :ree_dao
       end
 
       class TestAction2
@@ -59,4 +85,88 @@ RSpec.describe ReeActions::DSL, type: [:autoclean] do
     result = ReeActionsTest::TestAction2.new.call('user_access', {user_id: 1})
     expect(result).to eq(1)
   }
+
+  it {
+    module ReeActionsTest
+      include Ree::PackageDSL
+
+      package do
+        depends_on :ree_mapper
+        depends_on :ree_dao
+      end
+
+      class 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 User
+        include ReeDto::EntityDSL
+
+        properties(
+          id: Nilor[Integer],
+          name: String,
+          age: Integer,
+        )
+
+        attr_accessor :name
+      end
+
+      class UsersDao
+        include ReeDao::DSL
+
+        dao :users_dao do
+          link :db
+        end
+
+        table :users
+
+        schema ReeActionsTest::User do
+          integer :id, null: true
+          string :name
+          integer :age
+        end
+      end
+
+      class TestAction3
+        include ReeActions::DSL
+
+        action :test_action3 do
+          link :users_dao
+        end
+
+        contract Any, Hash => Integer
+        def call(user_access, attrs)
+          user = ReeActionsTest::User.new(name: 'John', age: 30)
+          users_dao.put(user)
+
+          thr = Thread.new {
+            user2 = ReeActionsTest::User.new(name: 'Alex', age: 33)
+            users_dao.put(user2)
+          }
+
+          thr.join
+          
+          $thread_group_cache = ReeDao::DaoCache.new.instance_variable_get(:@thread_groups)
+                                                   .dig(Thread.current.group.object_id, :users)
+
+          attrs[:user_id]
+        end
+      end
+    end
+
+    ReeActionsTest::TestAction3.new.call('user_access', {user_id: 1})
+    expect($thread_group_cache.keys.count).to_not eq(0)
+    expect($thread_group_cache.keys.count).to eq(2)
+  }
 end

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

@@ -19,6 +19,9 @@
     {
       "name": "ree_mapper"
     },
+    {
+      "name": "ree_object"
+    },
     {
       "name": "ree_string"
     }
@@ -62,6 +65,34 @@
         "object"
       ]
     },
+    {
+      "name": "dao_cache",
+      "schema": "packages/ree_dao/schemas/ree_dao/beans/dao_cache.schema.json",
+      "tags": [
+        "object"
+      ]
+    },
+    {
+      "name": "drop_cache",
+      "schema": "packages/ree_dao/schemas/ree_dao/functions/drop_cache.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
+    {
+      "name": "extract_changes",
+      "schema": "packages/ree_dao/schemas/ree_dao/functions/extract_changes.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
+    {
+      "name": "init_cache",
+      "schema": "packages/ree_dao/schemas/ree_dao/functions/init_cache.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
     {
       "name": "one_to_many",
       "schema": "packages/ree_dao/schemas/ree_dao/functions/one_to_many.schema.json",

data/lib/ree_lib/packages/ree_dao/package/ree_dao/beans/dao_cache.rb

@@ -0,0 +1,56 @@
+class ReeDao::DaoCache
+  include Ree::BeanDSL
+
+  bean :dao_cache do
+    link :deep_dup, from: :ree_object
+
+    singleton
+    after_init :setup
+  end
+
+  def setup
+    @thread_groups = {}
+  end
+
+  def add_thread_group_cache(thread_group)
+    @thread_groups[thread_group.object_id] ||= {}
+  end
+
+  def drop_thread_group_cache(thread_group)
+    @thread_groups.delete(thread_group.object_id)
+  end
+
+  def get(table_name, primary_key)
+    add_thread_group_cache(current_thread_group)
+    add_table_name(table_name)
+
+    @thread_groups[current_thread_group.object_id][table_name][primary_key] 
+  end
+
+  def set(table_name, primary_key, data)
+    add_thread_group_cache(current_thread_group)
+    add_table_name(table_name)
+    add_primary_key(table_name, primary_key)
+   
+    @thread_groups[current_thread_group.object_id][table_name][primary_key] = deep_dup(data)
+  end
+
+  def drop_table_cache(table_name)
+    add_thread_group_cache(current_thread_group)
+    @thread_groups[current_thread_group.object_id].delete(table_name)
+  end
+
+  private
+
+  def current_thread_group
+    Thread.current.group
+  end
+
+  def add_table_name(thread_group = Thread.current.group, table_name)
+    @thread_groups[thread_group.object_id][table_name] ||= {}
+  end
+
+  def add_primary_key(thread_group = Thread.current.group, table_name, primary_key)
+    @thread_groups[thread_group.object_id][table_name][primary_key] ||= {}
+  end
+end

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

@@ -19,24 +19,25 @@ module ReeDao
     end
 
     module InstanceMethods
-      PERSISTENCE_STATE_VARIABLE = :@persistence_state
       IMPORT_BATCH_SIZE = 1000
 
+      package_require("ree_dao/functions/extract_changes")
+
       # override methods
-      def find(id, mode = :write, mapper: nil)
-        where(primary_key => id).first(mode, mapper: mapper)
+      def find(id, mapper: nil)
+        where(primary_key => id).first(mapper: mapper)
       end
 
-      def first(mode = :write, mapper: nil)
-        with_mapper(mode, mapper).__original_first
+      def first(mapper: nil)
+        with_mapper(mapper).__original_first
       end
 
-      def last(mode = :write, mapper: nil)
-        with_mapper(mode, mapper).__original_last
+      def last(mapper: nil)
+        with_mapper(mapper).__original_last
       end
 
-      def all(mode = :write, mapper: nil)
-        with_mapper(mode, mapper).__original_all
+      def all(mapper: nil)
+        with_mapper(mapper).__original_all
       end
 
       def delete_all
@@ -49,7 +50,7 @@ module ReeDao
         key = insert(raw)
 
         set_entity_primary_key(entity, raw, key)
-        set_persistence_state(entity, raw)
+        set_entity_cache(entity, raw)
 
         entity
       end
@@ -73,7 +74,7 @@ module ReeDao
         key = insert_conflict(conflict_opts).insert(raw)
 
         set_entity_primary_key(entity, raw, key)
-        set_persistence_state(entity, raw)
+        set_entity_cache(entity, raw)
 
         where(primary_key => key).first
       end
@@ -104,7 +105,7 @@ module ReeDao
           raw_data = raw[entity]
 
           set_entity_primary_key(entity, raw_data, id)
-          set_persistence_state(entity, raw_data)
+          set_entity_cache(entity, raw_data)
         end
 
         nil
@@ -115,10 +116,10 @@ module ReeDao
         return __original_update(hash_or_entity) if hash_or_entity.is_a?(Hash)
 
         raw = opts[:schema_mapper].db_dump(hash_or_entity)
-        raw = extract_changes(hash_or_entity, raw)
+        raw = ReeDao::ExtractChanges.new.call(table_name, extract_primary_key(hash_or_entity), raw)
 
         unless raw.empty?
-          update_persistence_state(hash_or_entity, raw)
+          update_entity_cache(hash_or_entity, raw)
           key_condition = prepare_key_condition_from_entity(hash_or_entity)
           where(key_condition).__original_update(raw)
         end
@@ -148,10 +149,18 @@ module ReeDao
 
       private
 
+      def __ree_dao_cache
+        ReeDao::DaoCache.new
+      end
+
       def primary_key
         opts[:primary_key] || :id
       end
 
+      def table_name
+        first_source_table
+      end
+
       def remove_null_primary_key(raw)
         return if primary_key.is_a?(Array)
 
@@ -166,9 +175,9 @@ module ReeDao
         end
       end
 
-      def with_mapper(mode, mapper)
+      def with_mapper(mapper)
         clone(
-          mode: mode, schema_mapper: mapper || opts[:schema_mapper],
+          schema_mapper: mapper || opts[:schema_mapper],
         ).with_row_proc(
           Proc.new { |hash|
             m = mapper || opts[:schema_mapper]
@@ -176,9 +185,7 @@ module ReeDao
             if m
               entity = m.db_load(hash)
 
-              if mode == :write
-                self.set_persistence_state(entity, hash)
-              end
+              self.set_entity_cache(entity, hash)
 
               entity
             else
@@ -188,34 +195,27 @@ module ReeDao
         )
       end
 
-      def extract_changes(entity, hash)
-        return hash unless entity.instance_variable_defined?(PERSISTENCE_STATE_VARIABLE)
-        changes = {}
-
-        persistence_state = entity.instance_variable_get(PERSISTENCE_STATE_VARIABLE)
-
-        hash.each do |column, value|
-          previous_column_value = persistence_state[column]
-
-          if persistence_state.has_key?(column) && previous_column_value != value
-            changes[column] = value
-          end
+      def extract_primary_key(entity)
+        if primary_key.is_a?(Array)
+          primary_key.map do |key|
+            entity.send(key)
+          end.join("_")
+        else
+          entity.send(primary_key)
         end
-
-        changes
       end
 
-      def set_persistence_state(entity, raw)
+      def set_entity_cache(entity, raw)
         if !entity.is_a?(Integer) && !entity.is_a?(Symbol)
-          entity.instance_variable_set(PERSISTENCE_STATE_VARIABLE, raw)
+          __ree_dao_cache.set(table_name, extract_primary_key(entity), raw)
         end
       end
 
-      def update_persistence_state(entity, raw)
-        persistence_state = entity.instance_variable_get(PERSISTENCE_STATE_VARIABLE)
+      def update_entity_cache(entity, raw)
+        cache = __ree_dao_cache.get(table_name, extract_primary_key(entity))
 
-        if persistence_state
-          persistence_state.merge!(raw)
+        if cache
+          __ree_dao_cache.set(table_name, extract_primary_key(entity), cache.merge(raw))
         end
       end
 

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_pg_connection.rb

@@ -16,7 +16,7 @@ class ReeDao::BuildPgConnection
       user?: String,
       password?: String,
       host?: String,
-      port?: String,
+      port?: Or[String, Integer],
       convert_infinite_timestamps?: Or[:string, :nil, :float],
       connect_timeout?: Integer,
       driver_options?: Hash,

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/drop_cache.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ReeDao::DropCache
+  include Ree::FnDSL
+
+  fn :drop_cache do
+    link :dao_cache
+  end
+
+  contract(None => nil)
+  def call
+    dao_cache.drop_thread_group_cache(Thread.current.group)
+    nil
+  end
+end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/extract_changes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class ReeDao::ExtractChanges
+  include Ree::FnDSL
+
+  fn :extract_changes do
+    link :dao_cache, as: :__ree_dao_cache
+  end
+
+  contract(Symbol, Any, Hash => Hash)
+  def call(table_name, primary_key, hash)
+    cached = __ree_dao_cache.get(table_name, primary_key)
+    return hash unless cached
+    changes = {}
+
+    hash.each do |column, value|
+      previous_column_value = cached[column]
+
+      if cached.has_key?(column) && previous_column_value != value
+        changes[column] = value
+      end
+    end
+
+    changes
+  end
+end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/init_cache.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ReeDao::InitCache
+  include Ree::FnDSL
+
+  fn :init_cache do
+    link :dao_cache
+  end
+
+  contract(None => nil)
+  def call
+    dao_cache.add_thread_group_cache(Thread.current.group)
+    nil
+  end
+end

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

@@ -11,7 +11,16 @@ module ReeDao
     depends_on :ree_enum
     depends_on :ree_mapper
     depends_on :ree_string
+    depends_on :ree_object
   end
 
   require_relative "./ree_dao/dsl"
+
+  def self.init_cache(thread)
+    ReeDao::Cache.init_cache(thread)
+  end
+
+  def self.drop_cache(thread)
+    ReeDao::Cache.delete_cache(thread)
+  end
 end

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/beans/dao_cache.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "dao_cache",
+  "path": "packages/ree_dao/package/ree_dao/beans/dao_cache.rb",
+  "mount_as": "object",
+  "class": "ReeDao::DaoCache",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "deep_dup",
+      "package_name": "ree_object",
+      "as": "deep_dup",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/build_pg_connection.schema.json

@@ -17,7 +17,7 @@
         {
           "arg": "conn_opts",
           "arg_type": "req",
-          "type": "{:conn_str? => String, :adapter => String, :database? => String, :encoding? => String, :user? => String, :password? => String, :host? => String, :port? => String, :convert_infinite_timestamps? => Or[string, nil, float], :connect_timeout? => Integer, :driver_options? => Hash, :notice_receiver? => Proc, :sslmode? => Or[disable, allow, prefer, require, verify-ca, verify-full...], :sslrootcert? => String, :search_path? => String, :use_iso_date_format? => Bool, :max_connections? => Integer}"
+          "type": "{:conn_str? => String, :adapter => String, :database? => String, :encoding? => String, :user? => String, :password? => String, :host? => String, :port? => Or[String, Integer], :convert_infinite_timestamps? => Or[string, nil, float], :connect_timeout? => Integer, :driver_options? => Hash, :notice_receiver? => Proc, :sslmode? => Or[disable, allow, prefer, require, verify-ca, verify-full...], :sslrootcert? => String, :search_path? => String, :use_iso_date_format? => Bool, :max_connections? => Integer}"
         },
         {
           "arg": "opts",

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/drop_cache.schema.json

@@ -0,0 +1,31 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "drop_cache",
+  "path": "packages/ree_dao/package/ree_dao/functions/drop_cache.rb",
+  "mount_as": "fn",
+  "class": "ReeDao::DropCache",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Any",
+      "args": [
+
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "dao_cache",
+      "package_name": "ree_dao",
+      "as": "dao_cache",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/extract_changes.schema.json

@@ -0,0 +1,45 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "extract_changes",
+  "path": "packages/ree_dao/package/ree_dao/functions/extract_changes.rb",
+  "mount_as": "fn",
+  "class": "ReeDao::ExtractChanges",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Hash",
+      "args": [
+        {
+          "arg": "table_name",
+          "arg_type": "req",
+          "type": "Symbol"
+        },
+        {
+          "arg": "primary_key",
+          "arg_type": "req",
+          "type": "Any"
+        },
+        {
+          "arg": "hash",
+          "arg_type": "req",
+          "type": "Hash"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "dao_cache",
+      "package_name": "ree_dao",
+      "as": "__ree_dao_cache",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/init_cache.schema.json

@@ -0,0 +1,31 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "init_cache",
+  "path": "packages/ree_dao/package/ree_dao/functions/init_cache.rb",
+  "mount_as": "fn",
+  "class": "ReeDao::InitCache",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Any",
+      "args": [
+
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "dao_cache",
+      "package_name": "ree_dao",
+      "as": "dao_cache",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/build_pg_connection_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+package_require("ree_dao/wrappers/pg_jsonb")
+package_require("ree_dao/wrappers/pg_array")
+
+RSpec.describe :build_pg_connection do
+  link :build_pg_connection, from: :ree_dao
+
+  DB_CONFIG = {
+    host: "localhost",
+    user: "postgres",
+    database: "postgres",
+    password: "password",
+    adapter: "postgres"
+  }.freeze
+
+  after do
+    Ree.disable_irb_mode
+  end
+
+  before :all do
+    connection = build_pg_connection(
+      DB_CONFIG,
+      **{extensions: [:pg_array, :pg_json]}
+    )
+
+    if connection.table_exists?(:products)
+      connection.drop_table(:products)
+    end
+
+    connection.create_table :products do
+      primary_key :id
+
+      column  :title, 'varchar(256)'
+      column  :info, :jsonb
+      column  :labels, :"varchar(30)[]"
+    end
+
+    connection.disconnect
+  end
+
+  Ree.enable_irb_mode
+
+  module ReeDaoTestPg
+    include Ree::PackageDSL
+
+    package do
+      depends_on :ree_dao
+      depends_on :ree_mapper
+    end
+  end
+
+  class ReeDaoTestPg::MapperFactory
+    include Ree::BeanDSL
+
+    bean :mapper_factory do
+      factory :build
+      singleton
+
+      link :build_mapper_factory, from: :ree_mapper
+      link :build_mapper_strategy, from: :ree_mapper
+    end
+
+    def build
+      factory = build_mapper_factory(strategies: [
+        build_mapper_strategy(method: :cast, dto: Hash),
+        build_mapper_strategy(method: :serialize, dto: Hash),
+        build_mapper_strategy(method: :db_dump, dto: Hash),
+        build_mapper_strategy(method: :db_load, dto: Object, always_optional: true)
+      ])
+
+      factory
+        .register_wrapper(:pg_jsonb, ReeDao::PgJsonb)
+        .register_wrapper(:pg_array, ReeDao::PgArray)
+
+      factory
+    end
+  end
+
+  require "sequel/extensions/pg_json_ops"
+  require "sequel/extensions/pg_array_ops"
+
+  class ReeDaoTestPg::Db
+    include Ree::BeanDSL
+
+    bean :db do
+      singleton
+      factory :build
+
+      link :build_pg_connection, from: :ree_dao
+    end
+
+    def build
+      Sequel.extension :pg_json_ops
+      Sequel.extension :pg_array_ops
+
+      build_pg_connection(
+        DB_CONFIG,
+        **{extensions: [:pg_array, :pg_json]}
+      )
+    end
+  end
+
+  class ReeDaoTestPg::Product
+    include ReeDto::EntityDSL
+
+    properties(
+      id: Nilor[Integer],
+      title: String,
+      info: Hash,
+      labels: ArrayOf[String]
+    )
+
+    attr_accessor :title, :info
+  end
+
+  class ReeDaoTestPg::ProductsDao
+    include ReeDao::DSL
+
+    dao :products_dao do
+      link :db
+    end
+
+    schema ReeDaoTestPg::Product do
+      integer :id, null: true
+      string :title
+      pg_jsonb :info, any
+      pg_array :labels, string
+    end
+  end
+
+  let(:products_dao) { ReeDaoTestPg::ProductsDao.new }
+
+  it {
+    products_dao.delete_all
+
+    product = ReeDaoTestPg::Product.new(title: "Product", info: { price: 1337, count: 200 }, labels: ["Sale"])
+    products_dao.put(product)
+
+    product.info[:price] = 1440
+    product.labels << "New"
+
+    products_dao.update(product)
+
+    product = products_dao.find(product.id)
+    expect(product.title).to eq("Product")
+    expect(product.info[:price]).to eq(1440)
+    expect(product.labels).to eq(["Sale", "New"])
+  }
+end

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/build_sqlite_connection_spec.rb

@@ -5,6 +5,7 @@ package_require('ree_dto/entity_dsl')
 
 RSpec.describe :build_sqlite_connection do
   link :build_sqlite_connection, from: :ree_dao
+  link :dao_cache, from: :ree_dao
 
   after do
     Ree.disable_irb_mode
@@ -140,7 +141,7 @@ RSpec.describe :build_sqlite_connection do
 
     expect(u).to be_a(ReeDaoTest::User)
 
-    state = u.instance_variable_get(:@persistence_state)
+    state = dao_cache.get(:users, u.id)
 
     expect(state).to be_a(Hash)
     expect(state[:id]).to eq(user.id)
@@ -154,16 +155,16 @@ RSpec.describe :build_sqlite_connection do
     user = ReeDaoTest::User.new(name: 'John', age: 30)
     dao.put(user)
 
-    u = dao.find(user.id, :read)
+    u = dao.find(user.id)
     expect(u).to be_a(ReeDaoTest::User)
-    expect(u.instance_variable_get(:@persistence_state)).to eq(nil)
+    expect(dao_cache.get(:users, u.id)).to_not eq(nil)
 
     all = dao.all
     expect(all.size).to eq(1)
     u = all.first
 
     expect(u).to be_a(ReeDaoTest::User)
-    expect(u.instance_variable_get(:@persistence_state)).to be_a(Hash)
+    expect(dao_cache.get(:users, u.id)).to be_a(Hash)
   }
 
   it {
@@ -246,7 +247,7 @@ RSpec.describe :build_sqlite_connection do
     }
   end
 
-  context "uodate by entity" do
+  context "update by entity" do
     it {
       dao.delete_all
 

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

@@ -82,6 +82,10 @@ module ReeMapper
     pckg_name = ReeString::Underscore.new.call(mod.name)
     factory_path = "#{pckg_name}/mapper_factory"
 
+    if Ree.irb_mode? && Object.const_defined?("#{mod.name}::MapperFactory") && mod != self
+      return Object.const_get("#{mod.name}::MapperFactory").new
+    end
+
     mapper_factory_klass = if package_file_exists?(factory_path) && mod != self
       package_require(factory_path)
       Object.const_get("#{mod.name}::MapperFactory")

data/lib/ree_lib/packages/ree_roda/spec/ree_roda/app_spec.rb

@@ -16,7 +16,10 @@ RSpec.describe ReeRoda::App do
     module ReeRodaTest
       include Ree::PackageDSL
 
-      package
+      package do
+        depends_on :ree_actions
+        depends_on :ree_dao
+      end
     end
 
     class ReeRodaTest::Cmd

data/lib/ree_lib/packages/ree_roda/spec/ree_roda/services/build_routing_tree_spec.rb

@@ -11,7 +11,10 @@ RSpec.describe :build_routing_tree do
     module ReeRodaTestTree
       include Ree::PackageDSL
 
-      package
+      package do
+        depends_on :ree_actions
+        depends_on :ree_dao
+      end
     end
 
     class ReeRodaTestTree::Cmd

data/lib/ree_lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.42"
+  VERSION = "1.0.43"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.42
+  version: 1.0.43
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-23 00:00:00.000000000 Z
+date: 2023-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -293,26 +293,35 @@ files:
 - lib/ree_lib/packages/ree_dao/bin/console
 - lib/ree_lib/packages/ree_dao/package/ree_dao.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/beans/connections.rb
+- lib/ree_lib/packages/ree_dao/package/ree_dao/beans/dao_cache.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/dataset_extensions.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/dsl.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_connection.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_dao.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_pg_connection.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_sqlite_connection.rb
+- lib/ree_lib/packages/ree_dao/package/ree_dao/functions/drop_cache.rb
+- lib/ree_lib/packages/ree_dao/package/ree_dao/functions/extract_changes.rb
+- lib/ree_lib/packages/ree_dao/package/ree_dao/functions/init_cache.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/functions/one_to_many.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/functions/one_to_one.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/functions/persist_assoc.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/wrappers/pg_array.rb
 - lib/ree_lib/packages/ree_dao/package/ree_dao/wrappers/pg_jsonb.rb
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/beans/connections.schema.json
+- lib/ree_lib/packages/ree_dao/schemas/ree_dao/beans/dao_cache.schema.json
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/build_connection.schema.json
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/build_dao.schema.json
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/build_pg_connection.schema.json
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/build_sqlite_connection.schema.json
+- lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/drop_cache.schema.json
+- lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/extract_changes.schema.json
+- lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/init_cache.schema.json
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/one_to_many.schema.json
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/one_to_one.schema.json
 - lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/persist_assoc.schema.json
 - lib/ree_lib/packages/ree_dao/spec/package_schema_spec.rb
+- lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/build_pg_connection_spec.rb
 - lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/build_sqlite_connection/max_connections_spec.rb
 - lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/build_sqlite_connection_spec.rb
 - lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/one_to_many_spec.rb