ree_lib 1.0.49 → 1.0.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c09a8508f0d27f47f70238fbd1dad1c5627c6082f575d703c509a831c67385f
-  data.tar.gz: 297458d5b314777ce81af4d077e97fdcddc7985bf947ff0e33d7d07635a68718
+  metadata.gz: 4a53010ba7fdd43f86e011e0ee3f90675bb71e1b7f0c66d127736918ec89f6f0
+  data.tar.gz: 739eeb996f5ebfff231c613b5a6fd13022a4e91c5fa05716902dbd37d32f4d26
 SHA512:
-  metadata.gz: 7804922d52fc7d3d6b203d58cfbfa63b0d87df69655537edc85b70b01d1e4bba88ed73459bad71e0c1f10ebd6d5ffcbb6d5c86c231b0c817038ed5cb6eba48a3
-  data.tar.gz: ecd43b3975300c865644f617d7235f7d7868b945c9ca5a8f61e8bd2e939faa0214283d66aa883ad85bcba9ce365cfacd723a020eda31027991c74a4919e992b5
+  metadata.gz: f3a66d7108179a12e92fc5b36eb1adaaff37a733760f02e8867bcd949b9507b966161c4cb245da9d308de3d6066d8e6990ebd81b7a0d76a3e52e6fca02b75fd3
+  data.tar.gz: 5008628b066547548f69f3690d14e3103756b01573d3be8eb001450538c76a88c4adf3ebfec0ae36b5b47c13af9f598264d11a50c3a54f8eca0f3a630039563c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.49)
+    ree_lib (1.0.50)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -28,6 +28,8 @@ GEM
     crass (1.0.6)
     debug_inspector (1.1.0)
     diff-lcs (1.5.0)
+    faker (3.2.0)
+      i18n (>= 1.8.11, < 2)
     hashdiff (1.0.1)
     highline (2.0.3)
     i18n (1.12.0)
@@ -36,8 +38,6 @@ GEM
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     msgpack (1.6.0)
-    nokogiri (1.15.2-x86_64-darwin)
-      racc (~> 1.4)
     nokogiri (1.15.2-x86_64-linux)
       racc (~> 1.4)
     oj (3.13.23)
@@ -87,6 +87,7 @@ PLATFORMS
 
 DEPENDENCIES
   bootsnap
+  faker (~> 3.2)
   pg (~> 1.4.1)
   rack-test
   rake (~> 13.0)

data/lib/ree_lib/Packages.schema.json

@@ -78,6 +78,10 @@
       "name": "ree_routes",
       "schema": "packages/ree_routes/Package.schema.json"
     },
+    {
+      "name": "ree_std",
+      "schema": "packages/ree_std/Package.schema.json"
+    },
     {
       "name": "ree_string",
       "schema": "packages/ree_string/Package.schema.json"

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

@@ -150,23 +150,30 @@ RSpec.describe ReeActions::DSL, type: [:autoclean] do
           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)
-          }
+          Thread.new do
+            users_dao.put(ReeActionsTest::User.new(name: 'Alex', age: 33))
+          end.join
 
-          thr.join
+          Thread.new do
+            users_dao.put(ReeActionsTest::User.new(name: 'David', age: 21))
+
+            Thread.new do
+              users_dao.put(ReeActionsTest::User.new(name: 'Sam', age: 19))
+            end.join
+          end.join
           
-          $thread_group_cache = ReeDao::DaoCache.new.instance_variable_get(:@thread_groups)
-                                                   .dig(Thread.current.group.object_id, :users)
+          $thread_cache = ReeDao::DaoCache.new.instance_variable_get(:@threads)
+                                              .dig(Thread.current.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)
+    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)
   }
 end

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

@@ -16,6 +16,9 @@
     {
       "name": "ree_enum"
     },
+    {
+      "name": "ree_hash"
+    },
     {
       "name": "ree_mapper"
     },
@@ -93,6 +96,13 @@
         "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/aggregate_dsl.rb

@@ -0,0 +1,26 @@
+module ReeDao
+  module AggregateDSL
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.extended(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def aggregate(name, &proc)
+        dsl = Ree::ObjectDsl.new(
+          Ree.container.packages_facade, name, self, :fn
+        )
+
+        dsl.instance_exec(&proc) if block_given?
+        dsl.tags(["aggregate"])
+        dsl.freeze(false)
+        dsl.object.set_as_compiled(false)
+
+        Ree.container.compile(dsl.package, name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,311 @@
+module ReeDao
+  class Association
+    include Ree::LinkDSL
+
+    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, :list, :global_opts
+
+    contract(ReeDao::Associations, Array, Ksplat[RestKeys => Any] => Any)
+    def initialize(parent, list, **global_opts)
+      @parent = parent
+      @list = list
+      @global_opts = global_opts
+    end
+
+    contract(
+      Or[:belongs_to, :has_one, :has_many, :field],
+      Symbol,
+      Ksplat[RestKeys => Any],
+      Optblock => Array
+    )
+    def load(assoc_type, assoc_name, **opts, &block)
+      load_association(assoc_type, assoc_name, **opts, &block)
+    end
+
+    contract(
+      Or[:belongs_to, :has_one, :has_many, :field],
+      Symbol,
+      Ksplat[RestKeys => Any],
+      Optblock => Nilor[Array]
+    )
+    def load_association(assoc_type, assoc_name, **opts, &block)
+      assoc_index = load_association_by_type(
+        assoc_type,
+        assoc_name,
+        **opts
+      )
+
+      process_block(assoc_index, opts[:autoload_children] ||= false, &block) if block_given?
+
+      list
+    end
+
+    contract(
+      Or[:belongs_to, :has_one, :has_many, :field],
+      Symbol,
+      Ksplat[RestKeys => Any] => Any
+    )
+    def load_association_by_type(type, assoc_name, **opts)
+      case type
+      when :belongs_to
+        one_to_one(
+          assoc_name,
+          list,
+          scope: opts[:scope],
+          foreign_key: opts[:foreign_key],
+          setter: opts[:setter],
+          reverse: false
+        )
+      when :has_one
+        one_to_one(
+          assoc_name,
+          list,
+          scope: opts[:scope],
+          foreign_key: opts[:foreign_key],
+          setter: opts[:setter],
+          reverse: true
+        )
+      when :has_many
+        one_to_many(
+          assoc_name,
+          list,
+          scope: opts[:scope],
+          foreign_key: opts[:foreign_key],
+          setter: opts[:setter]
+        )
+      else
+        one_to_many(
+          assoc_name,
+          list,
+          scope: opts[:scope],
+          foreign_key: opts[:foreign_key],
+          setter: opts[:setter],
+          skip_dao: true
+        )
+      end
+    end
+
+    contract(Hash, Bool, Block => Any)
+    def process_block(assoc, autoload_children, &block)
+      assoc_list = assoc.values.flatten
+
+      if ReeDao::Associations.sync_mode?
+        ReeDao::Associations.new(
+          parent.agg_caller,
+          assoc_list,
+          parent.local_vars,
+          autoload_children,
+          **global_opts
+        ).instance_exec(assoc_list, &block)
+      else
+        ReeDao::Associations.new(
+          parent.agg_caller,
+          assoc_list,
+          parent.local_vars,
+          autoload_children,
+          **global_opts
+        ).instance_exec(assoc_list, &block).map(&:join)
+      end
+    end
+
+    contract(
+      Symbol,
+      Array,      
+      Kwargs[
+        foreign_key: Nilor[Symbol],
+        scope: Nilor[Sequel::Dataset],
+        setter: Nilor[Or[Symbol, Proc]],
+        reverse: Bool
+      ] => Hash
+    )
+    def one_to_one(
+      assoc_name,
+      list,
+      scope: nil,
+      foreign_key: nil,
+      setter: nil,
+      reverse: true
+    )
+      return {} if list.empty?
+
+      assoc_dao = find_dao(assoc_name, parent, scope)
+
+      if reverse
+        if !foreign_key
+          name = underscore(demodulize(list.first.class.name))
+          foreign_key = "#{name}_id".to_sym
+        end
+
+        root_ids = list.map(&:id).uniq
+      else
+        if !foreign_key
+          dto_class = assoc_dao
+            .opts[:schema_mapper]
+            .dto(:db_load)
+  
+          name = underscore(demodulize(dto_class.name))
+          
+          root_ids = list.map(&:"#{"#{name}_id".to_sym}").uniq
+          foreign_key = :id
+        else
+          root_ids = list.map(&:"#{foreign_key}")
+          foreign_key = :id
+        end
+      end
+
+      default_scope = assoc_dao&.where(foreign_key => root_ids)
+
+      items = add_scopes(default_scope, scope, global_opts[assoc_name])
+
+      assoc = index_by(items) { _1.send(foreign_key) }
+
+      populate_association(
+        list,
+        assoc,
+        assoc_name,
+        setter: setter,
+        reverse: reverse
+      )
+
+      assoc
+    end
+
+    contract(
+      Symbol,
+      Array,
+      Kwargs[
+        foreign_key: Nilor[Symbol],
+        scope: Nilor[Sequel::Dataset],
+        setter: Nilor[Or[Symbol, Proc]],
+        skip_dao: Bool
+      ] => Hash
+    )
+    def one_to_many(
+      assoc_name,
+      list,
+      foreign_key: nil,
+      scope: nil,
+      setter: nil,
+      skip_dao: false
+    )
+      return {} if list.empty?
+
+      assoc_dao = nil
+      assoc_dao = find_dao(assoc_name, parent, scope) if !skip_dao
+
+      foreign_key ||= "#{underscore(demodulize(list.first.class.name))}_id".to_sym
+
+      root_ids = list.map(&:id)
+
+      default_scope = assoc_dao&.where(foreign_key => root_ids)
+
+      items = add_scopes(default_scope, scope, global_opts[assoc_name])
+
+      assoc = group_by(items) { _1.send(foreign_key) }
+
+      populate_association(
+        list,
+        assoc,
+        assoc_name,
+        setter: setter
+      )
+
+      assoc
+    end
+
+    contract(
+      Array,
+      Hash,
+      Symbol,
+      Kwargs[
+        reverse: Nilor[Bool],
+        setter: Nilor[Or[Symbol, Proc]]
+      ] => Any
+    )
+    def populate_association(
+      list,
+      association_index,
+      assoc_name,
+      reverse: nil,
+      setter: nil
+    )
+      assoc_setter = if setter
+        setter
+      else
+        "set_#{assoc_name}"
+      end
+
+      list.each do |item|
+        if setter && setter.is_a?(Proc)
+          self.instance_exec(item, association_index, &assoc_setter)
+        else
+          key = if reverse.nil?
+            :id
+          else
+            reverse ? :id : "#{assoc_name}_id"
+          end
+          value = association_index[item.send(key)]
+          next if value.nil?
+
+          item.send(assoc_setter, value)
+        end
+      end
+    end
+
+    contract(Nilor[Sequel::Dataset], Nilor[Sequel::Dataset], Nilor[Proc] => Array)
+    def add_scopes(default_scope, scope, named_scope)
+      if default_scope && !scope
+        res = default_scope
+      end
+
+      if default_scope && scope
+        if scope == []
+          res = default_scope
+        else
+          res = merge_scopes(default_scope, scope)
+        end
+      end
+
+      if !default_scope && scope
+        return [] if scope.empty?
+
+        res = scope
+      end
+
+      if named_scope
+        res = named_scope.call(res)
+      end
+
+      res.all
+    end
+
+    def merge_scopes(s1, s2)
+      if s2.opts[:where]
+        s1 = s1.where(s2.opts[:where])
+      end
+
+      if s2.opts[:order]
+        s1 = s1.order(*s2.opts[:order])
+      end
+
+      s1
+    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?
+
+      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
+  end
+end

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

@@ -0,0 +1,148 @@
+module ReeDao
+  class Associations
+    include Ree::LinkDSL
+
+    attr_reader :agg_caller, :list, :local_vars, :only, :except, :autoload_children, :global_opts
+
+    def initialize(agg_caller, list, local_vars, autoload_children = false, **opts)
+      @agg_caller = agg_caller
+      @list = list
+      @local_vars = local_vars
+      @threads = [] if !self.class.sync_mode?
+      @global_opts = opts
+      @only = opts[:only] if opts[:only]
+      @except = opts[:except] if opts[:except]
+      @autoload_children = autoload_children
+
+      raise ArgumentError.new("you can't use both :only and :except arguments at the same time") if @only && @except
+
+      local_vars.each do |k, v|
+        instance_variable_set(k, v)
+
+        self.class.define_method k.to_s.gsub('@', '') do
+          v
+        end
+      end
+    end
+
+    def self.sync_mode?
+      ReeDao.load_sync_associations_enabled?
+    end
+
+    contract(
+      Symbol,
+      Ksplat[
+        scope?: Sequel::Dataset,
+        setter?: Or[Symbol, Proc],
+        foreign_key?: Symbol,
+        autoload_children?: Bool
+      ],
+      Optblock => Any
+    )
+    def belongs_to(assoc_name, **opts, &block)
+      association(__method__, assoc_name, **opts, &block)
+    end
+  
+    contract(
+      Symbol,
+      Ksplat[
+        scope?: Sequel::Dataset,
+        setter?: Or[Symbol, Proc],
+        foreign_key?: Symbol,
+        autoload_children?: Bool
+      ],
+      Optblock => Any
+    )
+    def has_one(assoc_name, **opts, &block)
+      association(__method__, assoc_name, **opts, &block)
+    end
+  
+    contract(
+      Symbol,
+      Ksplat[
+        scope?: Sequel::Dataset,
+        setter?: Or[Symbol, Proc],
+        foreign_key?: Symbol,
+        autoload_children?: Bool
+      ],
+      Optblock => Any
+    )
+    def has_many(assoc_name, **opts, &block)
+      association(__method__, assoc_name, **opts, &block)
+    end
+  
+    contract(
+      Symbol,
+      Ksplat[
+        scope?: Sequel::Dataset,
+        setter?: Or[Symbol, Proc],
+        foreign_key?: Symbol,
+        autoload_children?: Bool
+      ],
+      Optblock => Any
+    )
+    def field(assoc_name, **opts, &block)
+      association(__method__, assoc_name, **opts, &block)
+    end
+
+    private
+
+    contract(
+      Or[
+        :belongs_to,
+        :has_one,
+        :has_many,
+        :field
+      ],
+      Symbol,
+      Ksplat[
+        scope?: Sequel::Dataset,
+        setter?: Or[Symbol, Proc],
+        foreign_key?: Symbol,
+        autoload_children?: Bool
+      ],
+      Optblock => Any
+    )
+    def association(assoc_type, assoc_name, **assoc_opts, &block)
+      if self.class.sync_mode?
+        return if association_is_not_included?(assoc_name)
+
+        association = Association.new(self, list, **global_opts)
+        association.load(assoc_type, assoc_name, **assoc_opts, &block)
+      else
+        return @threads if association_is_not_included?(assoc_name)
+
+        @threads << Thread.new do
+          association = Association.new(self, list, **global_opts)
+          association.load(assoc_type, assoc_name, **assoc_opts, &block)
+        end
+      end
+    end
+
+    contract(Symbol => Bool)
+    def association_is_not_included?(assoc_name)
+      return false if !only && !except
+
+      if only
+        return false if only && only.include?(assoc_name)
+
+        if only && !only.include?(assoc_name)
+          return false if autoload_children
+          return true 
+        end
+      end
+
+      if except
+        return true if except && except.include?(assoc_name)
+        return false if except && !except.include?(assoc_name)
+      end
+    end
+
+    contract(Symbol, SplatOf[Any], Optblock => Any)
+    def method_missing(method, *args, &block)
+      return super if !agg_caller.private_methods(false).include?(method)
+
+      agg_caller.send(method, *args, &block)
+    end
+  end
+end

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

@@ -9,48 +9,69 @@ class ReeDao::DaoCache
   end
 
   def setup
-    @thread_groups = {}
+    @threads = {}
   end
 
-  def add_thread_group_cache(thread_group)
-    @thread_groups[thread_group.object_id] ||= {}
+  def add_thread_cache(thread)
+    @threads[get_thread_object_id(thread)] ||= {}
   end
 
-  def drop_thread_group_cache(thread_group)
-    @thread_groups.delete(thread_group.object_id)
+  def drop_thread_cache(thread)
+    @threads.delete(get_thread_object_id(thread))
   end
 
   def get(table_name, primary_key)
-    add_thread_group_cache(current_thread_group)
+    add_thread_cache(current_thread)
     add_table_name(table_name)
 
-    @thread_groups[current_thread_group.object_id][table_name][primary_key] 
+    @threads[current_thread_object_id][table_name][primary_key] 
   end
 
   def set(table_name, primary_key, data)
-    add_thread_group_cache(current_thread_group)
+    add_thread_cache(current_thread)
     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)
+    @threads[current_thread_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)
+  private
+
+  def get_thread_object_id(thread)
+    thread.parent == Thread.main ? thread.object_id : get_parent_thread(thread)
   end
 
-  private
+  def get_parent_thread(thread)
+    return thread.object_id if thread.parent == Thread.main || thread == Thread.main
+
+    get_parent_thread(thread.parent)
+  end
 
-  def current_thread_group
-    Thread.current.group
+  def current_thread
+    Thread.current
   end
 
-  def add_table_name(thread_group = Thread.current.group, table_name)
-    @thread_groups[thread_group.object_id][table_name] ||= {}
+  def current_thread_object_id
+    get_thread_object_id(current_thread)
   end
 
-  def add_primary_key(thread_group = Thread.current.group, table_name, primary_key)
-    @thread_groups[thread_group.object_id][table_name][primary_key] ||= {}
+  def add_table_name(table_name)
+    if !@threads[current_thread_object_id]
+      @threads[current_thread_object_id] ||= {}
+    end
+
+    @threads[current_thread_object_id][table_name] ||= {}
+  end
+
+  def add_primary_key(table_name, primary_key)
+    if !@threads[current_thread_object_id]
+      @threads[current_thread_object_id] ||= {}
+    end
+
+    if !@threads[current_thread_object_id][table_name]
+      @threads[current_thread_object_id][table_name] ||= {}
+    end
+
+    @threads[current_thread_object_id][table_name][primary_key] ||= {}
   end
 end