ree_lib 1.0.66 → 1.0.68

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4afa1450a6827106e39ef7e907de9ce4f490a2cc323bbc59eca1c5cf7386b69
-  data.tar.gz: 2a7e3858a80590ad65ce462f77d61f1e5d87435fdf9b5528c626ed41a573cb5c
+  metadata.gz: a34603f1dd69c0e4eecca51ac58f30e000fd673da8f157901eb085671b7d9e04
+  data.tar.gz: ddd8255a1b09641a1d88869e8c664415b44c1a3e8669c907459fd14bcd709743
 SHA512:
-  metadata.gz: 6a2d3070cbe58af3289dd89da27004955d4689a2b32758b7dd123288e6fabcc1915571ee6b353cd8edd0beaef8402f9668bf8034742a7ab30359d26b1f7828a3
-  data.tar.gz: 3eb4943530aa4e658f091ce8d8314032b9b5381828ec04e82686ecea3ec2a6481d56783eb19a8d86a943d3108a846632ff0903ec2a28b164734792f9e20322ae
+  metadata.gz: 1e07c24f16571cbdadf18a7f5013a87d488d230663f89524d927dd1998835365293b83e42bce61e8ceac2871762b16102130efe26419e2ef5270bc5ee2597db7
+  data.tar.gz: 6ca2018732da00c6205c048bb1011738694174a8b76930973625567db74e6bca9ad86aea6764e503ddb4f915853ce603160e0bd194f229587c018ac7e98cd156

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.66)
+    ree_lib (1.0.68)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -37,10 +37,10 @@ GEM
     loofah (2.18.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
+    mini_portile2 (2.8.1)
     msgpack (1.6.0)
-    nokogiri (1.15.3-x86_64-darwin)
-      racc (~> 1.4)
-    nokogiri (1.15.3-x86_64-linux)
+    nokogiri (1.13.10)
+      mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
     oj (3.13.23)
     pg (1.4.6)
@@ -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,6 +1,7 @@
 module ReeDao
   class Association
     include Ree::LinkDSL
+    include ReeDao::AssociationMethods
 
     link :demodulize, from: :ree_string
     link :group_by, from: :ree_array
@@ -119,24 +120,21 @@ 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_name,
+        autoload_children,
+        **global_opts
+      )
+      parent_dao = find_dao(parent_dao_name, parent.agg_caller)
+
+      if dao_in_transaction?(parent_dao) || 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)
@@ -345,20 +343,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,33 @@
+module ReeDao
+  module AssociationMethods
+    def self.included(base)
+      base.include(InstanceMethods)
+    end
+
+    def self.extended(base)
+      base.include(Instance)
+    end
+
+    module InstanceMethods
+      def find_dao(assoc_name, parent_caller, scope = nil)
+        dao_from_name = parent_caller.instance_variable_get("@#{assoc_name}") || parent_caller.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_caller.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 dao_in_transaction?(dao)
+        return false if dao.nil?
+    
+        dao.db.in_transaction?
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 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
 
@@ -86,7 +87,9 @@ module ReeDao
       Optblock => Any
     )
     def association(assoc_type, assoc_name, __opts, &block)
-      if self.class.sync_mode?
+      parent_dao = find_dao(parent_dao_name, agg_caller)
+
+      if dao_in_transaction?(parent_dao) || self.class.sync_mode?
         return if association_is_not_included?(assoc_name) || list.empty?
 
         association = Association.new(self, parent_dao_name, list, **global_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,9 +1,10 @@
 # frozen_string_literal: true
 
-class ReeDao::LoadAgg
+class ReeDao::Agg
   include Ree::FnDSL
+  include ReeDao::AssociationMethods
 
-  fn :load_agg do
+  fn :agg do
     link :demodulize, from: :ree_string
     link :underscore, from: :ree_string
     link "ree_dao/associations", -> { Associations }
@@ -72,8 +73,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)
+    dao = find_dao(dao_name, agg_caller)
 
-    if ReeDao.load_sync_associations_enabled?
+    if dao_in_transaction?(dao) || 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/functions/build_connection.rb

@@ -68,7 +68,7 @@ class ReeDao::BuildConnection
     end
 
     if opts[:sql_log_level]
-      connection.sql_log_level = opts[:sql_log_level] 
+      connection.sql_log_level = opts[:sql_log_level]
     end
 
     Timeout::timeout(timeout) do

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": [
     {

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/load_agg/{load_agg_benchmark_spec.rb → agg_benchmark_spec.rb}

@@ -2,9 +2,9 @@
 require 'faker'
 require 'benchmark'
 
-RSpec.describe :load_agg do
+RSpec.describe :agg do
+  link :agg, from: :ree_dao
   link :build_pg_connection, from: :ree_dao
-  link :load_agg, from: :ree_dao
 
   NUM_OF_USERS = 100
   ASSOC_COUNT = 10
@@ -14,7 +14,7 @@ RSpec.describe :load_agg do
   end
 
   before :all do
-    connection = build_pg_connection(ReeDaoLoadAggTest::Db::DB_CONFIG)
+    connection = build_pg_connection(ReeDaoAggTest::Db::DB_CONFIG)
 
     connection.drop_table(:organizations, cascade: true) if connection.table_exists?(:organizations)
     connection.drop_table(:users, cascade: true) if connection.table_exists?(:users)
@@ -108,28 +108,28 @@ RSpec.describe :load_agg do
     connection.disconnect
   end
 
-  require_relative 'ree_dao_load_agg_test'
+  require_relative 'ree_dao_agg_test'
 
-  class ReeDaoLoadAggTest::UsersAggBenchmark
+  class ReeDaoAggTest::AggUsersBenchmark
     include ReeDao::AggregateDSL
 
-    aggregate :users_agg_benchmark do
-      link :users, from: :ree_dao_load_agg_test
-      link :organizations, from: :ree_dao_load_agg_test
-      link :user_passports, from: :ree_dao_load_agg_test
-      link :books, from: :ree_dao_load_agg_test
-      link :movies, from: :ree_dao_load_agg_test
-      link :videogames, from: :ree_dao_load_agg_test
-      link :hobbies, from: :ree_dao_load_agg_test
-      link :vinyls, from: :ree_dao_load_agg_test
-      link :pets, from: :ree_dao_load_agg_test
-      link :skills, from: :ree_dao_load_agg_test
-      link :dreams, from: :ree_dao_load_agg_test
-      link :load_agg, from: :ree_dao
+    aggregate :agg_users_benchmark do
+      link :users, from: :ree_dao_agg_test
+      link :organizations, from: :ree_dao_agg_test
+      link :user_passports, from: :ree_dao_agg_test
+      link :books, from: :ree_dao_agg_test
+      link :movies, from: :ree_dao_agg_test
+      link :videogames, from: :ree_dao_agg_test
+      link :hobbies, from: :ree_dao_agg_test
+      link :vinyls, from: :ree_dao_agg_test
+      link :pets, from: :ree_dao_agg_test
+      link :skills, from: :ree_dao_agg_test
+      link :dreams, from: :ree_dao_agg_test
+      link :agg, from: :ree_dao
     end
 
     def call(ids_or_scope)
-      load_agg(users, ids_or_scope) do
+      agg(users, ids_or_scope) do
         belongs_to :organization
 
         has_many :books
@@ -146,21 +146,21 @@ RSpec.describe :load_agg do
     end
   end
 
-  class ReeDaoLoadAggTest::UsersSyncFetcher
+  class ReeDaoAggTest::UsersSyncFetcher
     include Ree::FnDSL
 
     fn :users_sync_fetcher do
-      link :users, from: :ree_dao_load_agg_test
-      link :organizations, from: :ree_dao_load_agg_test
-      link :user_passports, from: :ree_dao_load_agg_test
-      link :books, from: :ree_dao_load_agg_test
-      link :movies, from: :ree_dao_load_agg_test
-      link :videogames, from: :ree_dao_load_agg_test
-      link :hobbies, from: :ree_dao_load_agg_test
-      link :vinyls, from: :ree_dao_load_agg_test
-      link :pets, from: :ree_dao_load_agg_test
-      link :skills, from: :ree_dao_load_agg_test
-      link :dreams, from: :ree_dao_load_agg_test
+      link :users, from: :ree_dao_agg_test
+      link :organizations, from: :ree_dao_agg_test
+      link :user_passports, from: :ree_dao_agg_test
+      link :books, from: :ree_dao_agg_test
+      link :movies, from: :ree_dao_agg_test
+      link :videogames, from: :ree_dao_agg_test
+      link :hobbies, from: :ree_dao_agg_test
+      link :vinyls, from: :ree_dao_agg_test
+      link :pets, from: :ree_dao_agg_test
+      link :skills, from: :ree_dao_agg_test
+      link :dreams, from: :ree_dao_agg_test
       link :one_to_many, from: :ree_dao
       link :one_to_one, from: :ree_dao
     end
@@ -169,7 +169,7 @@ RSpec.describe :load_agg do
       Or[Sequel::Dataset, ArrayOf[Integer]],
       Kwargs[
         include: ArrayOf[Symbol]
-      ] => ArrayOf[ReeDaoLoadAggTest::User]
+      ] => ArrayOf[ReeDaoAggTest::User]
     )
     def call(ids_or_scope, include: [])
       scope = if ids_or_scope.is_a?(Array)
@@ -230,23 +230,23 @@ RSpec.describe :load_agg do
     end
   end
 
-  let(:users_agg) { ReeDaoLoadAggTest::UsersAggBenchmark.new }
-  let(:users_sync_fetcher) { ReeDaoLoadAggTest::UsersSyncFetcher.new }
-
-  let(:organizations) { ReeDaoLoadAggTest::Organizations.new }
-  let(:users) { ReeDaoLoadAggTest::Users.new }
-  let(:user_passports) { ReeDaoLoadAggTest::UserPassports.new }
-  let(:books) { ReeDaoLoadAggTest::Books.new }
-  let(:movies) { ReeDaoLoadAggTest::Movies.new }
-  let(:videogames) { ReeDaoLoadAggTest::Videogames.new }
-  let(:hobbies) { ReeDaoLoadAggTest::Hobbies.new }
-  let(:vinyls) { ReeDaoLoadAggTest::Vinyls.new }
-  let(:pets) { ReeDaoLoadAggTest::Pets.new }
-  let(:skills) { ReeDaoLoadAggTest::Skills.new }
-  let(:dreams) { ReeDaoLoadAggTest::Dreams.new }
+  let(:agg_users) { ReeDaoAggTest::AggUsersBenchmark.new }
+  let(:users_sync_fetcher) { ReeDaoAggTest::UsersSyncFetcher.new }
+
+  let(:organizations) { ReeDaoAggTest::Organizations.new }
+  let(:users) { ReeDaoAggTest::Users.new }
+  let(:user_passports) { ReeDaoAggTest::UserPassports.new }
+  let(:books) { ReeDaoAggTest::Books.new }
+  let(:movies) { ReeDaoAggTest::Movies.new }
+  let(:videogames) { ReeDaoAggTest::Videogames.new }
+  let(:hobbies) { ReeDaoAggTest::Hobbies.new }
+  let(:vinyls) { ReeDaoAggTest::Vinyls.new }
+  let(:pets) { ReeDaoAggTest::Pets.new }
+  let(:skills) { ReeDaoAggTest::Skills.new }
+  let(:dreams) { ReeDaoAggTest::Dreams.new }
 
   before(:each) do
-    organization = ReeDaoLoadAggTest::Organization.new(name: "Test Org")
+    organization = ReeDaoAggTest::Organization.new(name: "Test Org")
     organizations.put(organization)
 
     _users = []
@@ -255,7 +255,7 @@ RSpec.describe :load_agg do
     puts "Seeding #{NUM_OF_USERS} users..."
 
     NUM_OF_USERS.times do
-      u = ReeDaoLoadAggTest::User.new(
+      u = ReeDaoAggTest::User.new(
         name: Faker::Name.name,
         age: rand(18..50),
         organization_id: organization.id
@@ -268,7 +268,7 @@ RSpec.describe :load_agg do
     _users.each do |user|
       ASSOC_COUNT.times do
         books.put(
-          ReeDaoLoadAggTest::Book.new(
+          ReeDaoAggTest::Book.new(
             title: Faker::Book.title,
             user_id: user.id
           )
@@ -277,7 +277,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         movies.put(
-          ReeDaoLoadAggTest::Movie.new(
+          ReeDaoAggTest::Movie.new(
             user_id: user.id,
             title: Faker::Movie.title
           )
@@ -286,7 +286,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         videogames.put(
-          ReeDaoLoadAggTest::Videogame.new(
+          ReeDaoAggTest::Videogame.new(
             user_id: user.id,
             title: Faker::Game.title
           )
@@ -295,7 +295,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         hobbies.put(
-          ReeDaoLoadAggTest::Hobby.new(
+          ReeDaoAggTest::Hobby.new(
             user_id: user.id,
             title: Faker::Hobby.activity
           )
@@ -304,7 +304,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         vinyls.put(
-          ReeDaoLoadAggTest::Vinyl.new(
+          ReeDaoAggTest::Vinyl.new(
             user_id: user.id,
             title: Faker::Music.band
           )
@@ -313,7 +313,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         pets.put(
-          ReeDaoLoadAggTest::Pet.new(
+          ReeDaoAggTest::Pet.new(
             user_id: user.id,
             name: Faker::Creature::Animal.name
           )
@@ -322,7 +322,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         skills.put(
-          ReeDaoLoadAggTest::Skill.new(
+          ReeDaoAggTest::Skill.new(
             user_id: user.id,
             title: Faker::Job.key_skill
           )
@@ -331,7 +331,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         dreams.put(
-          ReeDaoLoadAggTest::Dream.new(
+          ReeDaoAggTest::Dream.new(
             user_id: user.id,
             description: Faker::ChuckNorris.fact
           )
@@ -340,7 +340,7 @@ RSpec.describe :load_agg do
 
       ASSOC_COUNT.times do
         user_passports.put(
-          ReeDaoLoadAggTest::UserPassport.new(
+          ReeDaoAggTest::UserPassport.new(
             user_id: user.id,
             info: "Passport info #{user.id}"
           )
@@ -358,12 +358,12 @@ RSpec.describe :load_agg do
 
     benchmark_res = Benchmark.bm do |x|
       x.report("async_load_agg") do
-        res1 = users_agg.call(users.all.map(&:id))
+        res1 = agg_users.call(users.all.map(&:id))
       end
 
       x.report("sync_load_agg ") do
         ENV['REE_DAO_SYNC_ASSOCIATIONS'] = "true"
-        res2 = users_agg.call(users.all.map(&:id))
+        res2 = agg_users.call(users.all.map(&:id))
         ENV.delete('REE_DAO_SYNC_ASSOCIATIONS')
       end