ree_lib 1.0.67 → 1.0.69

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adfdcee3c81364ab7af1c22fb56bd6b2d2f823b78f67264effce6b7e2af35852
-  data.tar.gz: 2991aa1e88c979c3b714bbf1da5facc68b52582a84001d43b8e1b304768125fb
+  metadata.gz: c746828c8b09f58c0406659649ef01ba7b7300f4b1f35f808f8e1f58a0dc4165
+  data.tar.gz: c03ddd00be42dbbe2ee2e2660a105a84912d19ccb5251fd882bd88d04e5bd781
 SHA512:
-  metadata.gz: e9d848d9321212758be3e7051b408eedef55bcfb3d712e647f598f9e82510ea1b09275e4944fe89e8e83bce4650b36c2f02b59fdfe01e37bf7e8703911102ac3
-  data.tar.gz: 3c62a965cd9c5aeb588b984d3e2b9d93ef80698fe24fc7dafa0595a214443ec5d29e2ba91d7f8a424ee6410f3921dda339eefbeb2a4510c3999bc13532662f5f
+  metadata.gz: 5fa6ca950b18d4e6678610f8dd1b1d3c239090e18d7c914be33643e75d846332e041109d8cb2f6d301398e9eafeeb6897320bfac688c2defb427bc2bec6a4e5c
+  data.tar.gz: 13405b30d0b4be4aba5e579f8bab5a410af29fe820a5aca37502ea6a7d356a5d5fdad315214fa70b8581927c7ee712607a101b191ec2d9fd383a4b4e1989f8a8

data/Gemfile.lock

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

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

@@ -147,8 +147,8 @@ RSpec.describe ReeActions::DSL, type: [:autoclean] do
 
         contract Any, Hash => Integer
         def call(user_access, attrs)
-          user = ReeActionsTest::User.new(name: 'John', age: 30)
-          users_dao.put(user)
+          $user = ReeActionsTest::User.new(name: 'John', age: 30)
+          users_dao.put($user)
 
           Thread.new do
             users_dao.put(ReeActionsTest::User.new(name: 'Alex', age: 33))
@@ -162,8 +162,7 @@ RSpec.describe ReeActions::DSL, type: [:autoclean] do
             end.join
           end.join
           
-          $thread_cache = ReeDao::DaoCache.new.instance_variable_get(:@threads)
-                                              .dig(Thread.current.object_id, :users)
+          $thread_cache = ReeDao::DaoCache.new.get(:users, $user.id)
 
           attrs[:user_id]
         end
@@ -173,7 +172,7 @@ RSpec.describe ReeActions::DSL, type: [:autoclean] do
     Thread.new do
       ReeActionsTest::TestAction3.new.call('user_access', {user_id: 1})
     end.join
-    expect($thread_cache.keys.count).to_not eq(0)
-    expect($thread_cache.keys.count).to eq(4)
+
+    expect($thread_cache).to eq($user.to_h)
   }
 end

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

@@ -33,6 +33,13 @@
 
   ],
   "objects": [
+    {
+      "name": "agg",
+      "schema": "packages/ree_dao/schemas/ree_dao/functions/agg.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
     {
       "name": "build_connection",
       "schema": "packages/ree_dao/schemas/ree_dao/functions/build_connection.schema.json",
@@ -96,13 +103,6 @@
         "fn"
       ]
     },
-    {
-      "name": "load_agg",
-      "schema": "packages/ree_dao/schemas/ree_dao/functions/load_agg.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/association.rb

@@ -1,18 +1,19 @@
 module ReeDao
   class Association
     include Ree::LinkDSL
+    include ReeDao::AssociationMethods
 
     link :demodulize, from: :ree_string
     link :group_by, from: :ree_array
     link :index_by, from: :ree_array
     link :underscore, from: :ree_string
 
-    attr_reader :parent, :parent_dao_name, :list, :global_opts
+    attr_reader :parent, :parent_dao, :list, :global_opts
 
-    contract(ReeDao::Associations, Symbol, Array, Ksplat[RestKeys => Any] => Any)
-    def initialize(parent, parent_dao_name, list, **global_opts)
+    contract(ReeDao::Associations, Sequel::Dataset, Array, Ksplat[RestKeys => Any] => Any)
+    def initialize(parent, parent_dao, list, **global_opts)
       @parent = parent
-      @parent_dao_name = parent_dao_name
+      @parent_dao = parent_dao
       @list = list
       @global_opts = global_opts
     end
@@ -35,7 +36,7 @@ module ReeDao
       Or[:belongs_to, :has_one, :has_many],
       Symbol,
       Ksplat[RestKeys => Any],
-      Optblock => Nilor[Array]
+      Optblock => Array
     )
     def load_association(assoc_type, assoc_name, **__opts, &block)
       __opts[:autoload_children] ||= false
@@ -46,21 +47,17 @@ module ReeDao
         **__opts
       )
 
-      dao = find_dao(assoc_name, parent, __opts[:scope])
-
-      dao_name = if dao
-        dao.first_source_table
-      elsif __opts[:scope].is_a?(Array)
-        name = underscore(demodulize(__opts[:scope].first.class.name))
+      scope = __opts[:scope]
 
-        if name.end_with?("s")
-          "#{name}es"
-        else
-          "#{name}s"
-        end
+      dao = if scope.is_a?(Array)
+        return [] if scope.empty?
+        name = underscore(demodulize(scope.first.class.name))
+        find_dao(name, parent, nil)
+      else
+        find_dao(assoc_name, parent, scope)
       end
 
-      process_block(assoc_index, __opts[:autoload_children], __opts[:to_dto], dao_name, &block) if block_given?
+      process_block(assoc_index, __opts[:autoload_children], __opts[:to_dto], dao, &block) if block_given?
 
       list
     end
@@ -74,7 +71,7 @@ module ReeDao
       case type
       when :belongs_to
         one_to_one(
-          parent_dao_name,
+          parent_dao,
           assoc_name,
           list,
           scope: __opts[:scope],
@@ -85,7 +82,7 @@ module ReeDao
         )
       when :has_one
         one_to_one(
-          parent_dao_name,
+          parent_dao,
           assoc_name,
           list,
           scope: __opts[:scope],
@@ -97,7 +94,7 @@ module ReeDao
         )
       when :has_many
         one_to_many(
-          parent_dao_name,
+          parent_dao,
           assoc_name,
           list,
           scope: __opts[:scope],
@@ -109,8 +106,8 @@ module ReeDao
       end
     end
 
-    contract(Or[Hash, Array], Bool, Nilor[Proc], Symbol, Block => Any)
-    def process_block(assoc, autoload_children, to_dto, parent_dao_name, &block)
+    contract(Or[Hash, Array], Bool, Nilor[Proc], Sequel::Dataset, Block => Any)
+    def process_block(assoc, autoload_children, to_dto, parent_dao, &block)
       assoc_list = assoc.is_a?(Array) ? assoc : assoc.values.flatten
 
       if to_dto
@@ -119,24 +116,20 @@ module ReeDao
         end
       end
 
-      if ReeDao::Associations.sync_mode?
-        ReeDao::Associations.new(
-          parent.agg_caller,
-          assoc_list,
-          parent.local_vars,
-          parent_dao_name,
-          autoload_children,
-          **global_opts
-        ).instance_exec(assoc_list, &block)
+      associations = ReeDao::Associations.new(
+        parent.agg_caller,
+        assoc_list,
+        parent.local_vars,
+        parent_dao,
+        autoload_children,
+        **global_opts
+      )
+
+      if parent_dao.db.in_transaction? || ReeDao::Associations.sync_mode?
+        associations.instance_exec(assoc_list, &block)
       else
-        threads = ReeDao::Associations.new(
-          parent.agg_caller,
-          assoc_list,
-          parent.local_vars,
-          parent_dao_name,
-          autoload_children,
-          **global_opts
-        ).instance_exec(assoc_list, &block)
+        threads = associations.instance_exec(assoc_list, &block)
+
         threads[:association_threads].map do |association, assoc_type, assoc_name, __opts, block|
           Thread.new do
             association.load(assoc_type, assoc_name, **__opts, &block)
@@ -152,7 +145,7 @@ module ReeDao
     end
 
     contract(
-      Symbol,
+      Sequel::Dataset,
       Symbol,
       Array,
       Kwargs[
@@ -164,7 +157,7 @@ module ReeDao
         reverse: Bool
       ] => Or[Hash, Array]
     )
-    def one_to_one(parent_assoc_name, assoc_name, list, scope: nil, primary_key: :id, foreign_key: nil, setter: nil, to_dto: nil, reverse: true)
+    def one_to_one(parent_dao, assoc_name, list, scope: nil, primary_key: :id, foreign_key: nil, setter: nil, to_dto: nil, reverse: true)
       return {} if list.empty?
 
       primary_key ||= :id
@@ -177,7 +170,7 @@ module ReeDao
         if reverse
           # has_one
           if !foreign_key
-            foreign_key = "#{parent_assoc_name.to_s.gsub(/s$/,'')}_id".to_sym
+            foreign_key = "#{parent_dao.first_source_table.to_s.gsub(/s$/,'')}_id".to_sym
           end
 
           root_ids = list.map(&:id).uniq
@@ -213,7 +206,7 @@ module ReeDao
     end
 
     contract(
-      Symbol,
+      Sequel::Dataset,
       Symbol,
       Array,
       Kwargs[
@@ -224,7 +217,7 @@ module ReeDao
         to_dto: Nilor[Proc]
       ] => Or[Hash, Array]
     )
-    def one_to_many(parent_assoc_name, assoc_name, list, primary_key: nil, foreign_key: nil, scope: nil, setter: nil, to_dto: nil)
+    def one_to_many(parent_dao, assoc_name, list, primary_key: nil, foreign_key: nil, scope: nil, setter: nil, to_dto: nil)
       return {} if list.empty?
 
       primary_key ||= :id
@@ -235,7 +228,7 @@ module ReeDao
         assoc_dao = nil
         assoc_dao = find_dao(assoc_name, parent, scope)
 
-        foreign_key ||= "#{parent_assoc_name.to_s.gsub(/s$/, '')}_id".to_sym
+        foreign_key ||= "#{parent_dao.first_source_table.to_s.gsub(/s$/, '')}_id".to_sym
 
         root_ids = list.map(&:"#{primary_key}")
 
@@ -345,20 +338,6 @@ module ReeDao
       res.all
     end
 
-    def find_dao(assoc_name, parent, scope)
-      dao_from_name = parent.instance_variable_get("@#{assoc_name}") || parent.instance_variable_get("@#{assoc_name}s")
-      return dao_from_name if dao_from_name
-
-      raise ArgumentError, "can't find DAO for :#{assoc_name}, provide correct scope or association name" if scope.nil?
-      return nil if scope.is_a?(Array)
-
-      table_name = scope.first_source_table
-      dao_from_scope = parent.instance_variable_get("@#{table_name}")
-      return dao_from_scope if dao_from_scope
-
-      raise ArgumentError, "can't find DAO for :#{assoc_name}, provide correct scope or association name"
-    end
-
     def method_missing(method, *args, &block)
       return super if !parent.agg_caller.private_methods(false).include?(method)
 

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

@@ -0,0 +1,28 @@
+module ReeDao
+  module AssociationMethods
+    def self.included(base)
+      base.include(InstanceMethods)
+    end
+
+    def self.extended(base)
+      base.include(Instance)
+    end
+
+    module InstanceMethods
+      SUFFIXES = ["", "s", "es", "dao", "s_dao", "es_dao"].freeze
+
+      def find_dao(assoc_name, parent_caller, scope = nil)
+        SUFFIXES.each do |suffix|
+          dao_from_name = parent_caller.instance_variable_get("@#{assoc_name}#{suffix}")
+          return dao_from_name if dao_from_name
+        end
+
+        if scope.is_a?(Sequel::Dataset)
+          return scope.unfiltered
+        end
+
+        raise ArgumentError, "can't find DAO for :#{assoc_name}, provide correct scope or association name"
+      end
+    end
+  end
+end

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

@@ -1,24 +1,25 @@
 module ReeDao
   class Associations
     include Ree::LinkDSL
+    include ReeDao::AssociationMethods
 
-    attr_reader :agg_caller, :list, :local_vars, :only, :except, :parent_dao_name, :autoload_children, :global_opts
+    attr_reader :agg_caller, :list, :local_vars, :only, :except, :parent_dao, :autoload_children, :global_opts
 
-    def initialize(agg_caller, list, local_vars, parent_dao_name, autoload_children = false, **opts)
+    def initialize(agg_caller, list, local_vars, parent_dao, autoload_children = false, **opts)
       @agg_caller = agg_caller
       @list = list
       @local_vars = local_vars
       @global_opts = opts || {}
       @only = opts[:only] if opts[:only]
       @except = opts[:except] if opts[:except]
-      @parent_dao_name = parent_dao_name
+      @parent_dao = parent_dao
       @autoload_children = autoload_children
 
       if @only && @except
         shared_keys = @only.intersection(@except)
 
         if shared_keys.size > 0
-          raise ArgumentError.new("you can't use both :only and :except for #{shared_keys.map { "\"#{_1}\"" }.join(", ")} keys") 
+          raise ArgumentError.new("you can't use both :only and :except for #{shared_keys.map { "\"#{_1}\"" }.join(", ")} keys")
         end
       end
 
@@ -86,10 +87,10 @@ module ReeDao
       Optblock => Any
     )
     def association(assoc_type, assoc_name, __opts, &block)
-      if self.class.sync_mode?
+      if parent_dao.db.in_transaction? || self.class.sync_mode?
         return if association_is_not_included?(assoc_name) || list.empty?
 
-        association = Association.new(self, parent_dao_name, list, **global_opts)
+        association = Association.new(self, parent_dao, list, **global_opts)
 
         if assoc_type == :field
           association.handle_field(assoc_name, __opts)
@@ -101,7 +102,7 @@ module ReeDao
           return { association_threads: @assoc_threads, field_threads: @field_threads }
         end
 
-        association = Association.new(self, parent_dao_name, list, **global_opts)
+        association = Association.new(self, parent_dao, list, **global_opts)
 
         if assoc_type == :field
           field_proc = __opts

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

@@ -38,11 +38,11 @@ class ReeDao::DaoCache
   private
 
   def get_thread_object_id(thread)
-    thread.parent == Thread.main ? thread.object_id : get_parent_thread(thread)
+    thread == Thread.main ? thread.object_id : get_parent_thread(thread)
   end
 
   def get_parent_thread(thread)
-    return thread.object_id if thread.parent == Thread.main || thread == Thread.main
+    return thread.object_id if thread == Thread.main
 
     get_parent_thread(thread.parent)
   end
@@ -56,22 +56,26 @@ class ReeDao::DaoCache
   end
 
   def add_table_name(table_name)
-    if !@threads[current_thread_object_id]
-      @threads[current_thread_object_id] ||= {}
+    current_thr_obj_id = current_thread_object_id
+
+    if !@threads[current_thr_obj_id]
+      @threads[current_thr_obj_id] ||= {}
     end
 
-    @threads[current_thread_object_id][table_name] ||= {}
+    @threads[current_thr_obj_id][table_name] ||= {}
   end
 
   def add_primary_key(table_name, primary_key)
-    if !@threads[current_thread_object_id]
-      @threads[current_thread_object_id] ||= {}
+    current_thr_obj_id = current_thread_object_id
+
+    if !@threads[current_thr_obj_id]
+      @threads[current_thr_obj_id] ||= {}
     end
 
-    if !@threads[current_thread_object_id][table_name]
-      @threads[current_thread_object_id][table_name] ||= {}
+    if !@threads[current_thr_obj_id][table_name]
+      @threads[current_thr_obj_id][table_name] ||= {}
     end
 
-    @threads[current_thread_object_id][table_name][primary_key] ||= {}
+    @threads[current_thr_obj_id][table_name][primary_key] ||= {}
   end
 end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/{load_agg.rb → agg.rb}

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
-class ReeDao::LoadAgg
+class ReeDao::Agg
   include Ree::FnDSL
 
-  fn :load_agg do
-    link :demodulize, from: :ree_string
-    link :underscore, from: :ree_string
+  fn :agg do
     link "ree_dao/associations", -> { Associations }
     link "ree_dao/contract/dao_dataset_contract", -> { DaoDatasetContract }
     link "ree_dao/contract/entity_contract", -> { EntityContract }
   end
 
   contract(
-    Nilor[DaoDatasetContract],
+    DaoDatasetContract,
     Or[Sequel::Dataset, ArrayOf[Integer], ArrayOf[EntityContract], Integer],
     Ksplat[
       only?: ArrayOf[Symbol],
@@ -22,26 +20,16 @@ class ReeDao::LoadAgg
     ],
     Optblock => ArrayOf[Any]
   )
-  def call(dao = nil, ids_or_scope, **opts, &block)
+  def call(dao, ids_or_scope, **opts, &block)
     scope = if ids_or_scope.is_a?(Array) && ids_or_scope.any? { _1.is_a?(Integer) }
-      raise ArgumentError.new("Dao should be provided") if dao.nil?
       return [] if ids_or_scope.empty?
-
       dao.where(id: ids_or_scope)
     elsif ids_or_scope.is_a?(Integer)
-      raise ArgumentError.new("Dao should be provided") if dao.nil?
-
       dao.where(id: ids_or_scope)
     else
       ids_or_scope
     end
 
-    if dao
-      dao_name = dao.first_source_table
-    else
-      dao_name = underscore(demodulize(scope.first.class.name)).to_sym
-    end
-
     list = scope.is_a?(Sequel::Dataset) ? scope.all : scope
 
     if opts[:to_dto]
@@ -50,7 +38,7 @@ class ReeDao::LoadAgg
       end
     end
 
-    load_associations(dao_name, list, **opts, &block) if block_given?
+    load_associations(dao.unfiltered, list, **opts, &block) if block_given?
 
     if ids_or_scope.is_a?(Array)
       list.sort_by { ids_or_scope.index(_1.id) }
@@ -61,7 +49,7 @@ class ReeDao::LoadAgg
 
   private
 
-  def load_associations(dao_name, list, **opts, &block)
+  def load_associations(dao, list, **opts, &block)
     return if list.empty?
 
     local_vars = block.binding.eval(<<-CODE, __FILE__, __LINE__ + 1)
@@ -71,9 +59,9 @@ class ReeDao::LoadAgg
 
     agg_caller = block.binding.eval("self")
 
-    associations = Associations.new(agg_caller, list, local_vars, dao_name, **opts).instance_exec(list, &block)
+    associations = Associations.new(agg_caller, list, local_vars, dao, **opts).instance_exec(list, &block)
 
-    if ReeDao.load_sync_associations_enabled?
+    if dao.db.in_transaction? || ReeDao.load_sync_associations_enabled?
       associations
     else
       associations[:association_threads].map do |association, assoc_type, assoc_name, opts, block|

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

@@ -18,17 +18,10 @@ module ReeDao
   require_relative "./ree_dao/dsl"
   require_relative "./ree_dao/thread_parents"
   require_relative "./ree_dao/aggregate_dsl"
+  require_relative "./ree_dao/association_methods"
   require_relative "./ree_dao/associations"
   require_relative "./ree_dao/association"
 
-  def self.init_cache(thread)
-    ReeDao::Cache.init_cache(thread)
-  end
-
-  def self.drop_cache(thread)
-    ReeDao::Cache.delete_cache(thread)
-  end
-
   def self.load_sync_associations_enabled?
     ENV.has_key?("REE_DAO_SYNC_ASSOCIATIONS") && ENV["REE_DAO_SYNC_ASSOCIATIONS"] == "true"
   end

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/{load_agg.schema.json → agg.schema.json}

@@ -1,10 +1,10 @@
 {
   "schema_type": "object",
   "schema_version": "1.1",
-  "name": "load_agg",
-  "path": "packages/ree_dao/package/ree_dao/functions/load_agg.rb",
+  "name": "agg",
+  "path": "packages/ree_dao/package/ree_dao/functions/agg.rb",
   "mount_as": "fn",
-  "class": "ReeDao::LoadAgg",
+  "class": "ReeDao::Agg",
   "factory": null,
   "methods": [
     {
@@ -16,8 +16,8 @@
       "args": [
         {
           "arg": "dao",
-          "arg_type": "opt",
-          "type": "Nilor[PackageName::DaoName::Dao: \"SELECT * FROM `table`\"]"
+          "arg_type": "req",
+          "type": "PackageName::DaoName::Dao: \"SELECT * FROM `table`\""
         },
         {
           "arg": "ids_or_scope",
@@ -38,21 +38,6 @@
     }
   ],
   "links": [
-    {
-      "target": "demodulize",
-      "package_name": "ree_string",
-      "as": "demodulize",
-      "imports": [
 
-      ]
-    },
-    {
-      "target": "underscore",
-      "package_name": "ree_string",
-      "as": "underscore",
-      "imports": [
-
-      ]
-    }
   ]
 }