foobara 0.1.16 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b5f241d83e9591db56a0c1021eb2544bf701ba2ddb0c0a47f257fa6797bafbf
-  data.tar.gz: 98f0be44ed8abf5b4af0ef24da0e9c4e095956b24038726dabf369ad2051860a
+  metadata.gz: d6975f14259f6fa733c19dc1877d1868ef90b2f72a6408ba49cf1d0706ca69fe
+  data.tar.gz: ab1c0f032c8f653c2b6f5d2b24aa1eded6a5cec1ec6994ee905e90d87edcb157
 SHA512:
-  metadata.gz: '08de40d305155c09dab3a0e513fa53bc06e11cd7c848a21104ff5dae158d4b09d13957ce1c697fec98291d98e9ef1db4b88e497d04c60664010edbf3ca0a8180'
-  data.tar.gz: 7b781e2547614126578f134adf0aab7465a0ecc79fa27b1cd34fbe54716019ec740327f94044861478d13c5e2bcf39fa0ebcb68a736a2b56ec0aa636364bbdbd
+  metadata.gz: ff85faf59d67f5d1cfeab25f3520633df1747025aa760428af91c0b6e100893ff722f9a5dcac86246009842a0b2a0930ae18be26baabedaba42b46aa94f36472
+  data.tar.gz: 13ca3101da2f61f2d181a10a751e5e299722195cfdf1057a4216cf4bbf592728a2ec0cbbbfdc315827e74b6d579ba6e57fc5d31bdd7ab84323c48cffd6ba238b

data/.ruby-version

@@ -1 +1 @@
-3.4.6
+3.4.7

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# [0.2.1] - 2025-10-21
+
+- Rename EntityBase#initialize prefix: to table_prefix: to avoid collision with redis-crud-driver
+
+# [0.2.0] - 2025-10-21
+
+- Support setting an entity base for a domain
+- Add TransactionGroup
+- Properly sort and nest bases/transactions/entities to fix some multi-base transaction bugs
+
 # [0.1.16] - 2025-10-15
 
 - Improve manifest processing performance by memoizing ManifestBase#hash

data/projects/entity/src/concerns/persistence.rb

@@ -11,7 +11,7 @@ module Foobara
 
         module ClassMethods
           def entity_base
-            @entity_base ||= Foobara::Persistence.base_for_entity_class_name(full_entity_name)
+            @entity_base ||= Foobara::Persistence.base_for_entity_class(self)
           end
         end
 

data/projects/entity/src/extensions/domain/domain_module_extension.rb

@@ -0,0 +1,15 @@
+module Foobara
+  module Domain
+    module DomainModuleExtension
+      module ClassMethods
+        attr_reader :foobara_default_entity_base
+
+        def foobara_set_entity_base(*, name: nil, table_prefix: nil)
+          name ||= Util.underscore(scoped_full_name).gsub("::", "_")
+          base = Persistence.register_base(*, name:, table_prefix:)
+          @foobara_default_entity_base = base
+        end
+      end
+    end
+  end
+end

data/projects/nested_transactionable/lib/foobara/nested_transactionable.rb

@@ -19,30 +19,13 @@ module Foobara
       end
 
       def with_needed_transactions_for_type(type, &)
-        relevant_entity_classes = relevant_entity_classes_for_type(type)
+        entity_classes = relevant_entity_classes_for_type(type)
 
-        if relevant_entity_classes.empty?
+        if entity_classes.empty?
           return yield
         end
 
-        tx_class = Class.new
-        tx_class.include NestedTransactionable
-
-        tx_class.define_method(:relevant_entity_classes) do
-          relevant_entity_classes
-        end
-
-        tx_instance = tx_class.new
-
-        begin
-          tx_instance.open_transaction
-          result = Persistence::EntityBase.using_transactions(tx_instance.transactions, &)
-          tx_instance.commit_transaction
-          result
-        rescue
-          tx_instance.rollback_transaction
-          raise
-        end
+        TransactionGroup.run(entity_classes:, &)
       end
     end
 
@@ -62,13 +45,26 @@ module Foobara
 
     def opened_transactions
       @opened_transactions ||= []
+      Persistence.sort_transactions(@opened_transactions)
     end
 
     def auto_detect_current_transactions
-      classes = relevant_entity_classes
-      return if classes.nil? || classes.empty?
+      bases = nil
+
+      if respond_to?(:relevant_entity_bases)
+        bases = relevant_entity_bases
+
+        unless bases.nil?
+          return if bases.empty?
+        end
+      end
+
+      unless bases
+        classes = relevant_entity_classes
+        return if classes.nil? || classes.empty?
 
-      bases = classes.map(&:entity_base).uniq
+        bases = classes.map(&:entity_base).uniq
+      end
 
       bases.each do |base|
         tx = base.current_transaction
@@ -84,12 +80,35 @@ module Foobara
 
       bases_not_needing_transaction = transactions.map(&:entity_base)
 
-      bases_needing_transaction = relevant_entity_classes.map(&:entity_base).uniq - bases_not_needing_transaction
+      bases_needing_transaction = nil
+
+      if respond_to?(:relevant_entity_bases)
+        bases_needing_transaction = relevant_entity_bases
+
+        unless bases_needing_transaction.nil?
+          return if bases_needing_transaction.empty?
+        end
+      end
+
+      unless bases_needing_transaction
+        classes = relevant_entity_classes
+        return if classes.nil? || classes.empty?
+
+        bases_needing_transaction = relevant_entity_classes.map(&:entity_base).uniq - bases_not_needing_transaction
+      end
+
+      bases_needing_transaction = Persistence.sort_bases(bases_needing_transaction)
 
       bases_needing_transaction.each do |entity_base|
-        transaction = entity_base.transaction
-        transaction.open!
-        opened_transactions << transaction
+        transaction_mode = if respond_to?(:transaction_mode)
+                             self.transaction_mode
+                           end
+        transaction = entity_base.transaction(transaction_mode)
+        unless transaction.currently_open?
+          transaction.open!
+          @opened_transactions ||= []
+          @opened_transactions << transaction
+        end
         transactions << transaction
       end
     end
@@ -122,4 +141,36 @@ module Foobara
       Persistence::EntityBase.using_transactions(transactions, &)
     end
   end
+
+  class TransactionGroup
+    include NestedTransactionable
+
+    class << self
+      def run(mode: nil, entity_classes: nil, bases: nil, &)
+        new(
+          transaction_mode: mode,
+          relevant_entity_classes: entity_classes,
+          relevant_entity_bases: bases
+        ).run(&)
+      end
+    end
+
+    attr_accessor :relevant_entity_classes, :relevant_entity_bases, :transaction_mode
+
+    def initialize(transaction_mode: nil, relevant_entity_classes: nil, relevant_entity_bases: nil)
+      self.relevant_entity_classes = relevant_entity_classes
+      self.relevant_entity_bases = relevant_entity_bases
+      self.transaction_mode = transaction_mode
+    end
+
+    def run(&)
+      open_transaction
+      result = Persistence::EntityBase.using_transactions(transactions, &)
+      commit_transaction
+      result
+    rescue
+      rollback_transaction
+      raise
+    end
+  end
 end

data/projects/persistence/src/entity_attributes_crud_driver.rb

@@ -2,7 +2,7 @@ module Foobara
   # Might be best to rename this to CrudDrivers or CrudDriver instead of Persistence?
   module Persistence
     class EntityAttributesCrudDriver
-      attr_accessor :raw_connection, :tables
+      attr_accessor :raw_connection, :tables, :table_prefix
 
       class << self
         def has_real_transactions?
@@ -10,7 +10,8 @@ module Foobara
         end
       end
 
-      def initialize(connection_or_credentials = nil)
+      def initialize(connection_or_credentials = nil, table_prefix: nil)
+        self.table_prefix = table_prefix
         self.raw_connection = open_connection(connection_or_credentials)
         self.tables = {}
       end
@@ -43,7 +44,26 @@ module Foobara
       def table_for(entity_class)
         key = entity_class.full_entity_name
 
-        tables[key] ||= self.class::Table.new(entity_class, self)
+        tables[key] ||= begin
+          if table_prefix
+            table_name = entity_class.entity_name
+            table_name.gsub!(/^Types::/, "")
+
+            table_name = Util.underscore(entity_class.entity_name)
+
+            table_name = if table_prefix == true
+                           "#{Util.underscore(entity_class.domain.scoped_full_name)}_#{table_name}"
+                         else
+                           "#{table_prefix}_#{table_name}"
+                         end
+
+            table_name.gsub!("::", "_")
+          end
+
+          # TODO: this seems like a smell
+          Persistence.bases_need_sorting!
+          self.class::Table.new(entity_class, self, table_name)
+        end
       end
 
       # TODO: relocate this to another file?
@@ -82,7 +102,13 @@ module Foobara
 
         attr_accessor :table_name, :entity_class, :raw_connection, :crud_driver
 
-        def initialize(entity_class, crud_driver, table_name = Util.underscore(entity_class.entity_name))
+        def initialize(entity_class, crud_driver, table_name = nil)
+          if table_name.nil?
+            table_name = Util.underscore(entity_class.entity_name)
+            table_name.gsub!(/^types::/, "")
+            table_name.gsub!("::", "_")
+          end
+
           self.crud_driver = crud_driver
           self.entity_class = entity_class
           # what is this used for?

data/projects/persistence/src/entity_base/table.rb

@@ -1,6 +1,7 @@
 module Foobara
   module Persistence
     class EntityBase
+      # TODO: this class seems useless and confusing since we have two other Table classes
       class Table
         attr_accessor :table_name, :entity_base
 

data/projects/persistence/src/entity_base/transaction.rb

@@ -57,7 +57,6 @@ module Foobara
             entity_class = entity_class.class
           end
 
-          # TODO: so much passing self around...
           unless entity_base == entity_class.entity_base
             # :nocov:
             raise "#{entity_class} is from a different entity base! Cannot proceed."

data/projects/persistence/src/entity_base.rb

@@ -22,6 +22,7 @@ module Foobara
           end
         end
 
+        # returns the entities such that ones on the right are allowed to depend on ones on the left
         def order_entity_classes(entity_classes)
           return entity_classes if entity_classes.size <= 1
 
@@ -66,7 +67,6 @@ module Foobara
         self.entity_attributes_crud_driver = entity_attributes_crud_driver
         self.tables = {}
         self.name = name
-        # TODO: a smell?
       end
 
       def register_entity_class(entity_class, table_name: entity_class.full_entity_name)
@@ -79,6 +79,10 @@ module Foobara
         tables[table.table_name] = table
       end
 
+      def entity_classes
+        entity_attributes_crud_driver.tables.values.map(&:entity_class)
+      end
+
       def transaction_key
         @transaction_key ||= "foobara:tx:#{name}"
       end

data/projects/persistence/src/persistence.rb

@@ -28,8 +28,7 @@ module Foobara
 
       # TODO: automatically order these by dependency...
       # TODO: also, consider automatically opening transactions for dependent entities automatically...
-      def transaction(*objects, mode: nil, &block)
-        # def transaction(mode = nil, existing_transaction: nil)
+      def transaction(*objects, mode: nil, &)
         bases = objects_to_bases(objects)
 
         if bases.empty?
@@ -39,13 +38,9 @@ module Foobara
         end
 
         if bases.size == 1
-          bases.first.transaction(mode, &block)
+          bases.first.transaction(mode, &)
         else
-          bases.inject(block) do |nested_proc, base|
-            proc do
-              base.transaction(mode, &nested_proc)
-            end
-          end.call
+          Foobara::TransactionGroup.run(bases:, mode:, &)
         end
       end
 
@@ -99,13 +94,15 @@ module Foobara
       end
 
       def objects_to_bases(objects)
-        if objects.size > 1 && objects.all? { |o| o.is_a?(::Class) && o < Entity }
-          objects = EntityBase.order_entity_classes(objects)
-        end
-
-        objects.map do |object|
+        unsorted = objects.map do |object|
           object_to_base(object)
         end.uniq
+
+        if bases_need_sorting?
+          sort_bases!
+        end
+
+        bases.values & unsorted
       end
 
       def object_to_base(object)
@@ -131,22 +128,23 @@ module Foobara
         @bases ||= {}
       end
 
-      def base_for_entity_class_name(entity_class_name)
-        table_for_entity_class_name(entity_class_name).entity_base
-      end
-
       def base_for_entity_class(entity_class)
-        table_for_entity_class_name(entity_class.full_entity_name).entity_base
+        table_for_entity_class(entity_class).entity_base
       end
 
-      def table_for_entity_class_name(entity_class_name)
+      def table_for_entity_class(entity_class)
+        entity_class_name = entity_class.full_entity_name
         table = tables_for_entity_class_name[entity_class_name]
 
         return table if table
 
-        if default_base
-          table = EntityBase::Table.new(entity_class_name, default_base)
-          default_base.register_table(table)
+        domain = entity_class.domain
+
+        base = domain.foobara_default_entity_base || default_base
+
+        if base
+          table = EntityBase::Table.new(entity_class_name, base)
+          base.register_table(table)
           tables_for_entity_class_name[entity_class_name] = table
         else
           # :nocov:
@@ -156,11 +154,120 @@ module Foobara
         end
       end
 
-      def register_base(base)
-        # TODO: add some validations here
+      def register_base(*args, name: nil, table_prefix: nil)
+        base = case args
+               in [EntityBase]
+                 args.first
+               in [Class => crud_driver_class, *rest] if crud_driver_class < EntityAttributesCrudDriver
+                 unless name
+                   # :nocov:
+                   raise ArgumentError, "Must provide name: when registering a base with a crud driver class"
+                   # :nocov:
+                 end
+
+                 crud_args, opts = case rest
+                                   in [Hash]
+                                     # TODO: test this code path
+                                     # :nocov:
+                                     [[], rest]
+                                     # :nocov:
+                                   in [] | [Array] | [Array, Hash]
+                                     rest
+                                   end
+
+                 crud_driver = crud_driver_class.new(*crud_args, **opts, table_prefix:)
+                 EntityBase.new(name, entity_attributes_crud_driver: crud_driver)
+               end
+
+        bases_need_sorting!
         bases[base.name] = base
       end
 
+      def sort_bases(bases)
+        return bases.dup if bases.size <= 1
+
+        if bases_need_sorting?
+          sort_bases!
+        end
+
+        sorted_bases = self.bases.values & bases
+
+        missing = bases - sorted_bases
+
+        unless missing.empty?
+          # :nocov:
+          raise ArgumentError, "Missing bases: #{missing} are the not registered or something?"
+          # :nocov:
+          # sorted_bases = [*missing, *sorted_bases]
+        end
+
+        sorted_bases
+      end
+
+      def sort_transactions(transactions)
+        return transactions.dup if transactions.size <= 1
+
+        if bases_need_sorting?
+          sort_bases!
+        end
+
+        sorted_bases = bases.values & transactions.map(&:entity_base)
+
+        sorted_bases.map do |base|
+          transactions.find { |tx| tx.entity_base == base }
+        end
+      end
+
+      # TODO: make this private
+      # TODO: add a callback so objects that are sensitive to this order can update when needed
+      def sort_bases!
+        return if bases.size <= 1
+
+        old_bases = bases.values
+
+        entity_classes = []
+
+        old_bases.each do |base|
+          entity_classes += base.entity_classes
+        end
+
+        return if entity_classes.size <= 1
+
+        entity_classes.select!(&:contains_associations?)
+
+        return if entity_classes.size <= 1
+
+        entity_classes = EntityBase.order_entity_classes(entity_classes)
+
+        new_bases = entity_classes.map(&:entity_base)
+        new_bases.reverse!
+        new_bases.uniq!
+
+        missing = old_bases - new_bases
+
+        unless missing.empty?
+          new_bases = [*new_bases, *missing]
+        end
+
+        @bases_need_sorting = false
+
+        self.last_table_count = table_count
+
+        @bases = new_bases.to_h do |base|
+          [base.name, base]
+        end
+      end
+
+      def bases_need_sorting!
+        @bases_need_sorting = true
+      end
+
+      def bases_need_sorting?
+        return true if @bases_need_sorting
+
+        @bases_need_sorting = table_count != last_table_count
+      end
+
       def register_entity(base, entity_class, table_name: entity_class.full_entity_name)
         base = to_base(base)
 
@@ -171,6 +278,14 @@ module Foobara
       def tables_for_entity_class_name
         @tables_for_entity_class_name ||= {}
       end
+
+      private
+
+      attr_accessor :last_table_count
+
+      def table_count
+        bases.values.map { |v| v.entity_attributes_crud_driver.tables.size }.sum
+      end
     end
   end
 end

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.1.16".freeze
+    VERSION = "0.2.1".freeze
     MINIMUM_RUBY_VERSION = ">= 3.4.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.2.1
 platform: ruby
 authors:
 - Miles Georgi
@@ -306,6 +306,7 @@ files:
 - projects/entity/src/extensions/builtin_types/entity/casters/record_from_closed_transaction.rb
 - projects/entity/src/extensions/builtin_types/entity/casters/record_from_current_transaction.rb
 - projects/entity/src/extensions/builtin_types/entity/validators/model_instance_is_valid.rb
+- projects/entity/src/extensions/domain/domain_module_extension.rb
 - projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration.rb
 - projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/attributes_handler_desugarizer.rb
 - projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/hash_desugarizer.rb