foobara 0.0.115 → 0.0.116

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94baacc7205e4b750c59df65dede92b2c95f15053144ba8d8324c81eb80da770
-  data.tar.gz: 696db0d2d875c8f2c40ed9d916019518c3f2ffcc0829015a0333109c83a1e8ef
+  metadata.gz: fe51e6ab90aafb99246fd2872f0faa452004f71b0d37a7e68a2fc7e8027feff7
+  data.tar.gz: d9027059c2a75b268950b661e5c3bb3fd1d633f52afbbe6d302c8ba3351908bc
 SHA512:
-  metadata.gz: 5b5cd5e50eee5c8f652d24107027eaf9115128742b57f8964010667d0e12da2a5bc1087d87870c507c9bd0cc6016eaa0248e9707d567c96c4193794863bebb6a
-  data.tar.gz: 356150abc278d32b253ddc08ed1f4932ac4432a25f9ed4797518191b9a86fc01c06986df8e314aa5a6fc64b44441adc89946a6b6f49daac42d424a73d41e2589
+  metadata.gz: 3beecfb43803f74a01d9f1d6e36c6b6f10c5abbae6dc3eaf9bc9a62afe25d3413313ed6f65262ba4e4c165e8545bbb506f045cafbd3d7673a37d4b87e9202661
+  data.tar.gz: 34554e412fc605f453392d2432f59311abe65498ec0db28e1c617c61b4c7fb1ac4e1bd7140f1ee8064482355a6a90e800cefea7b2ea8f35e23ad00eed59cf674

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [0.0.116] - 2025-05-03
+
+- Add automatic transaction support to requests, cover in/out mutators/transformers
+  - This makes it so that authenticators and allowed rules can more cleanly be
+    expressed when they have the same entity bases needed by the transformed command
+- Move #authenticated_user from TransformedCommand to Request
+- Add a Request#authenticated_credential
+- Provide a way to skip validations for models
+- A type without sensitive types derived from an entity type will now be registered as a
+  detached entity
+- Fix model type re-registering bug
+
 # [0.0.115] - 2025-05-01
 
 - Make sure Authenticator#authenticate hits #applicable?

data/projects/command/src/command_pattern_implementation/concerns/transactions.rb

@@ -3,81 +3,22 @@ module Foobara
     module Concerns
       module Transactions
         include Concern
-
-        def transactions
-          @transactions ||= []
-        end
-
-        def opened_transactions
-          @opened_transactions ||= []
-        end
-
-        def auto_detect_current_transactions
-          bases = relevant_entity_classes.map(&:entity_base).uniq
-
-          bases.each do |base|
-            tx = base.current_transaction
-            transactions << tx if tx
-          end
-        end
+        include NestedTransactionable
 
         def relevant_entity_classes
-          @relevant_entity_classes ||= begin
-            entity_classes = if inputs_type
-                               Entity.construct_associations(
-                                 inputs_type
-                               ).values.uniq.map(&:target_class)
-                             else
-                               []
-                             end
-
-            if result_type
-              entity_classes += Entity.construct_associations(
-                result_type
-              ).values.uniq.map(&:target_class)
-
-              if result_type.extends?(BuiltinTypes[:entity])
-                entity_classes << result_type.target_class
-              end
-            end
+          return @relevant_entity_classes if defined?(@relevant_entity_classes)
 
-            entity_classes += entity_classes.uniq.map do |entity_class|
-              entity_class.deep_associations.values
-            end.flatten.uniq.map(&:target_class)
+          entity_classes = if inputs_type
+                             relevant_entity_classes_for_type(inputs_type)
+                           else
+                             []
+                           end
 
-            [*entity_classes, *self.class.depends_on_entities].uniq
+          if result_type
+            entity_classes += relevant_entity_classes_for_type(result_type)
           end
-        end
-
-        def open_transaction
-          auto_detect_current_transactions
-
-          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.each do |entity_base|
-            transaction = entity_base.transaction
-            transaction.open!
-            opened_transactions << transaction
-            transactions << transaction
-          end
-        end
-
-        def rollback_transaction
-          opened_transactions.reverse.each do |transaction|
-            if transaction.currently_open?
-              # Hard to test this because halting and other exceptions rollback the transactions via
-              # block form but to be safe keeping this
-              # :nocov:
-              transaction.rollback!
-              # :nocov:
-            end
-          end
-        end
 
-        def commit_transaction
-          opened_transactions.reverse.each(&:commit!)
+          @relevant_entity_classes = [*entity_classes, *self.class.depends_on_entities].uniq
         end
       end
     end

data/projects/command_connectors/src/authenticator.rb

@@ -13,6 +13,10 @@ module Foobara
         @block = block
       end
 
+      def relevant_entity_classes(_request)
+        nil
+      end
+
       def symbol
         declaration_data[:symbol]
       end

data/projects/command_connectors/src/authenticator_selector.rb

@@ -24,6 +24,14 @@ module Foobara
       def authenticate(request)
         selector.process_value!(request)
       end
+
+      def relevant_entity_classes(request)
+        outcome = selector.processor_for(request)
+
+        if outcome.success?
+          outcome.result&.relevant_entity_classes(request)
+        end
+      end
     end
   end
 end

data/projects/command_connectors/src/command_connector/request.rb

@@ -2,9 +2,11 @@ module Foobara
   class CommandConnector
     class Request
       include TruncatedInspect
+      include NestedTransactionable
 
       # TODO: this feels like a smell of some sort...
       attr_accessor :command,
+                    :command_class,
                     :error,
                     :command_connector,
                     # Why aren't there serializers on the response?
@@ -12,9 +14,9 @@ module Foobara
                     :inputs,
                     :full_command_name,
                     :action,
-                    :response
-
-      attr_reader :command_class
+                    :response,
+                    :authenticated_user,
+                    :authenticated_credential
 
       def initialize(**opts)
         valid_keys = %i[inputs full_command_name action serializers]
@@ -33,8 +35,8 @@ module Foobara
         self.serializers = Util.array(opts[:serializers]) if opts.key?(:serializers)
       end
 
-      def command_class=(klass)
-        @command_class = klass
+      def mutate_request
+        return if error
 
         # TODO: we really need to revisit these interfaces. Something is wrong.
         if command_class.respond_to?(:mutate_request)
@@ -42,6 +44,25 @@ module Foobara
         end
       end
 
+      def authenticate
+        return if error
+        return unless command_class.respond_to?(:requires_authentication) && command_class.requires_authentication
+
+        authenticated_user, authenticated_credential = authenticator.authenticate(self)
+
+        # TODO: why are these on the command instead of the request??
+        self.authenticated_user = authenticated_user
+        self.authenticated_credential = authenticated_credential
+
+        unless authenticated_user
+          self.error = CommandConnector::UnauthenticatedError.new
+        end
+      end
+
+      def authenticator
+        command_class.authenticator
+      end
+
       def serializer
         return @serializer if defined?(@serializer)
 
@@ -77,12 +98,10 @@ module Foobara
       end
 
       def outcome
-        outcome = command&.outcome
-
-        if outcome
-          outcome
-        elsif error
+        if error
           Outcome.error(error)
+        else
+          command&.outcome
         end
       end
 
@@ -94,8 +113,34 @@ module Foobara
         outcome.error_collection
       end
 
+      def relevant_entity_classes
+        if command_class.is_a?(::Class) && command_class < TransformedCommand
+          entity_classes = authenticator&.relevant_entity_classes(self)
+          [*entity_classes, *relevant_entity_classes_from_inputs_transformer]
+        end || []
+      end
+
       private
 
+      def relevant_entity_classes_from_inputs_transformer(
+        object = [*command_class.inputs_transformer, *command_class.result_transformer]
+      )
+        case object
+        when TypeDeclarations::TypedTransformer
+          relevant_entity_classes_from_inputs_transformer([*object.from_type, *object.to_type])
+        when Types::Type
+          relevant_entity_classes_for_type(object)
+        when ::Array
+          object.map do |o|
+            relevant_entity_classes_from_inputs_transformer(o)
+          end.flatten
+        when Value::Processor::Pipeline
+          relevant_entity_classes_from_inputs_transformer(object.processors)
+        else
+          []
+        end
+      end
+
       def objects_to_serializers(objects)
         objects.map do |object|
           case object

data/projects/command_connectors/src/command_connector/response.rb

@@ -22,6 +22,10 @@ module Foobara
       def success?
         request.success?
       end
+
+      def outcome
+        request.outcome
+      end
     end
   end
 end

data/projects/command_connectors/src/command_connector.rb

@@ -154,15 +154,11 @@ module Foobara
       command_registry.foobara_lookup_command(name)
     end
 
-    # TODO: maybe instead connect commands with a shortcut_only: "describe" option
-    # in order to make this easier to extend and manage.
-    def request_to_command(request)
+    def request_to_command_class(request)
       action = request.action
-      inputs = nil
       full_command_name = request.full_command_name
 
-      case action
-      when "run"
+      if action == "run"
         transformed_command_class = transformed_command_from_name(full_command_name)
 
         unless transformed_command_class
@@ -171,9 +167,36 @@ module Foobara
           # :nocov:
         end
 
-        request.command_class = transformed_command_class
+        transformed_command_class
+      else
+        action = case action
+                 when "describe_type", "manifest", "describe_command"
+                   "describe"
+                 when "describe", "ping", "query_git_commit_info", "help"
+                   action
+                 when "list"
+                   "list_commands"
+                 else
+                   # :nocov:
+                   raise InvalidContextError.new(message: "Not sure what to do with #{action}")
+                   # :nocov:
+                 end
+
+        command_name = Util.classify(action)
+        command_class = find_builtin_command_class(command_name)
+        full_command_name = command_class.full_command_name
+
+        transformed_command_from_name(full_command_name) || transform_command_class(command_class)
+      end
+    end
+
+    def request_to_command_inputs(request)
+      action = request.action
+      full_command_name = request.full_command_name
 
-        inputs = request.inputs
+      case action
+      when "run"
+        request.inputs
       when "describe"
         manifestable = transformed_command_from_name(full_command_name) || type_from_name(full_command_name)
 
@@ -185,13 +208,7 @@ module Foobara
           # :nocov:
         end
 
-        command_class = find_builtin_command_class("Describe")
-        full_command_name = command_class.full_command_name
-
-        inputs = request.inputs.merge(manifestable:, request:)
-
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
+        request.inputs.merge(manifestable:, request:)
       when "describe_command"
         transformed_command_class = transformed_command_from_name(full_command_name)
 
@@ -201,12 +218,7 @@ module Foobara
           # :nocov:
         end
 
-        command_class = find_builtin_command_class("Describe")
-        full_command_name = command_class.full_command_name
-
-        inputs = request.inputs.merge(manifestable: transformed_command_class, request:)
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
+        request.inputs.merge(manifestable: transformed_command_class, request:)
       when "describe_type"
         type = type_from_name(full_command_name)
 
@@ -216,59 +228,30 @@ module Foobara
           # :nocov:
         end
 
-        command_class = find_builtin_command_class("Describe")
-        full_command_name = command_class.full_command_name
-
-        inputs = request.inputs.merge(manifestable: type, request:)
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
+        request.inputs.merge(manifestable: type, request:)
       when "manifest"
-        command_class = find_builtin_command_class("Describe")
-        full_command_name = command_class.full_command_name
-
-        inputs = request.inputs.merge(manifestable: self, request:)
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
-      when "ping"
-        command_class = find_builtin_command_class("Ping")
-        full_command_name = command_class.full_command_name
-
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
-      when "query_git_commit_info"
-        # TODO: this feels out of control... should just accomplish this through run I think instead. Same with ping.
-        command_class = find_builtin_command_class("QueryGitCommitInfo")
-        full_command_name = command_class.full_command_name
-
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
+        request.inputs.merge(manifestable: self, request:)
+      when "ping", "query_git_commit_info"
+        nil
       when "help"
-        command_class = find_builtin_command_class("Help")
-        full_command_name = command_class.full_command_name
-
-        inputs = { request: }
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
+        { request: }
       when "list"
-        command_class = find_builtin_command_class("ListCommands")
-
-        full_command_name = command_class.full_command_name
-
-        request.command_class = command_class
-        inputs = request.inputs.merge(request:)
-
-        transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                    transform_command_class(command_class)
+        request.inputs.merge(request:)
       else
         # :nocov:
         raise InvalidContextError.new(message: "Not sure what to do with #{action}")
         # :nocov:
       end
+    end
+
+    def request_to_command_instance(request)
+      command_class = request.command_class
+      inputs = request.inputs
 
       if inputs && !inputs.empty?
-        transformed_command_class.new(inputs)
+        command_class.new(inputs)
       else
-        transformed_command_class.new
+        command_class.new
       end
     end
 
@@ -305,6 +288,7 @@ module Foobara
       command = response.command
 
       if command.respond_to?(:serialize_result)
+        # TODO: Get serialization off of the command instance!!
         response.body = command.serialize_result(response.body)
       end
     end
@@ -383,18 +367,40 @@ module Foobara
     end
 
     def run_request(request)
-      command = build_command(request)
-
-      if command.respond_to?(:requires_authentication?) && command.requires_authentication?
-        authenticate(request)
-      end
-
-      if command
-        run_command(request)
-        # :nocov:
-      elsif !request.error
-        raise "No command returned from #request_to_command"
-        # :nocov:
+      command_class = determine_command_class(request)
+      request.command_class = command_class
+
+      return build_response(request) unless command_class
+
+      begin
+        request.open_transaction
+        request.use_transaction do
+          request.authenticate
+          request.mutate_request
+
+          inputs = request_to_command_inputs(request)
+          request.inputs = inputs
+          command = build_command_instance(request)
+          request.command = command
+
+          unless request.error
+            if command
+              run_command(request)
+              # :nocov:
+            else
+              raise "No command returned from #request_to_command"
+              # :nocov:
+            end
+          end
+        end
+      ensure
+        request.use_transaction do
+          if (request.response || request).outcome&.success?
+            request.commit_transaction_if_open
+          else
+            request.rollback_transaction
+          end
+        end
       end
 
       build_response(request)
@@ -414,33 +420,22 @@ module Foobara
       end
     end
 
-    def authenticate(request)
-      request_command = request.command
-      authenticator = request_command.authenticator || self.authenticator
-
-      request_command.after_load_records do |command:, **|
-        authenticated_user, authenticated_credential = authenticator.authenticate(request)
-
-        # TODO: why are these on the command instead of the request??
-        request_command.authenticated_user = authenticated_user
-        request_command.authenticated_credential = authenticated_credential
-
-        unless authenticated_user
-          request_command.outcome = Outcome.error(CommandConnector::UnauthenticatedError.new)
-
-          command.state_machine.error!
-          command.halt!
-        end
+    def build_command_instance(request)
+      command = request_to_command_instance(request)
+      request.command = command
+      if command.is_a?(TransformedCommand)
+        # This allows the command to access the authenticated_user
+        command.request = request
       end
+
+      command
     end
 
-    def build_command(request)
+    def determine_command_class(request)
       unless request.error
-        command = request_to_command(request)
-        request.command = command
+        command_class = request_to_command_class(request)
+        request.command_class = command_class
       end
-
-      command
     end
 
     def build_response(request)

data/projects/command_connectors/src/serializers/entities_to_primary_keys_serializer.rb

@@ -11,7 +11,7 @@ module Foobara
             # Is there maybe prior art for this in the associations stuff?
             object.primary_key
           when DetachedEntity
-            if declaration_data[:detached_to_primary_key]
+            if detached_to_primary_key?
               object.primary_key
             else
               object.attributes
@@ -28,6 +28,13 @@ module Foobara
             object
           end
         end
+
+        def detached_to_primary_key?
+          return true unless declaration_data.is_a?(::Hash)
+          return true unless declaration_data.key?(:detached_to_primary_key)
+
+          declaration_data[:detached_to_primary_key]
+        end
       end
     end
   end

data/projects/{command → command_connectors}/src/transformed_command.rb

@@ -95,7 +95,9 @@ module Foobara
 
                            command_class.inputs_type
                          else
-                           inputs_transformer.from_type || command_class.inputs_type
+                           if inputs_transformer.is_a?(TypeDeclarations::TypedTransformer)
+                             inputs_transformer.from_type
+                           end || command_class.inputs_type
                          end
                        else
                          command_class.inputs_type
@@ -479,8 +481,7 @@ module Foobara
       end
     end
 
-    attr_accessor :command, :untransformed_inputs, :transformed_inputs, :outcome, :authenticated_user,
-                  :authenticated_credential
+    attr_accessor :command, :untransformed_inputs, :transformed_inputs, :outcome, :request
 
     def initialize(untransformed_inputs = {})
       self.untransformed_inputs = untransformed_inputs || {}
@@ -499,7 +500,6 @@ module Foobara
                      :errors_transformers,
                      :pre_commit_transformers,
                      :serializers,
-                     :requires_authentication,
                      :allowed_rule,
                      :authenticator,
                      to: :class
@@ -508,14 +508,19 @@ module Foobara
       apply_allowed_rule
       apply_pre_commit_transformers
       run_command
-      # TODO: do this within the transaction!!!
+      # this gives us primary keys
+      flush_transactions
       transform_outcome
 
       outcome
     end
 
-    def requires_authentication?
-      !!requires_authentication
+    def authenticated_user
+      request.authenticated_user
+    end
+
+    def authenticated_credential
+      request.authenticated_credential
     end
 
     def transform_inputs
@@ -669,6 +674,10 @@ module Foobara
       outcome.errors
     end
 
+    def flush_transactions
+      request.opened_transactions&.reverse&.each(&:flush!)
+    end
+
     def transform_outcome
       if outcome.success?
         # can we do this while still in the transaction of the command???

data/projects/entity/src/sensitive_type_removers/entity.rb

@@ -2,6 +2,21 @@ module Foobara
   class Entity < DetachedEntity
     module SensitiveTypeRemovers
       class Entity < DetachedEntity::SensitiveTypeRemovers::DetachedEntity
+        def transform(strict_type_declaration)
+          new_type_declaration = super
+
+          if strict_type_declaration != new_type_declaration
+            if new_type_declaration[:type] == :entity
+              new_type_declaration[:type] = :detached_entity
+
+              if new_type_declaration[:model_base_class] == "Foobara::Entity"
+                new_type_declaration[:model_base_class] = "Foobara::DetachedEntity"
+              end
+            end
+          end
+
+          new_type_declaration
+        end
       end
     end
   end

data/projects/entity/src/sensitive_value_removers/entity.rb

@@ -4,22 +4,15 @@ module Foobara
       class Entity < DetachedEntity::SensitiveValueRemovers::DetachedEntity
         def transform(record)
           if record.loaded? || record.created?
-            sanitized_record = super
-
-            sanitized_record.is_loaded = record.loaded?
-            sanitized_record.is_persisted = record.persisted?
-
-            sanitized_record
+            super
           elsif record.persisted?
             # We will assume that we do not need to clean up the primary key itself as
             # we will assume we don't allow sensitive primary keys for now.
-            sanitized_record = to_type.target_class.build(record.class.primary_key_attribute => record.primary_key)
-
-            sanitized_record.is_persisted = true
-            sanitized_record.is_loaded = false
-            sanitized_record.is_built = false
-
-            sanitized_record
+            # We use .new because the target_class should be a detached entity
+            to_type.target_class.new(
+              { record.class.primary_key_attribute => record.primary_key },
+              { mutable: false, skip_validations: true }
+            )
           else
             # :nocov:
             raise "Not sure what to do with a record that isn't loaded, created, or persisted"
@@ -28,7 +21,14 @@ module Foobara
         end
 
         def build_method
-          :build
+          if to_type.extends?(:entity)
+            # TODO: test this code path
+            # :nocov:
+            :build
+            # :nocov:
+          else
+            :new
+          end
         end
       end
     end

data/projects/foobara/lib/foobara/all.rb

@@ -30,9 +30,10 @@ module Foobara
              "detached_entity",
              "entity",
              "model_attribute_helpers",
+             "nested_transactionable",
              "command",
              "domain_mapper",
-             "persistence",
+             "persistence", # Feels like this would be loaded before command?
              "in_memory_crud_driver_minimal",
              "in_memory_crud_driver",
              "manifest"

data/projects/model/src/concerns/types.rb

@@ -64,8 +64,9 @@ module Foobara
 
               if model_type
                 unless Foobara::TypeDeclarations.declarations_equal?(declaration, model_type.declaration_data)
+                  type_domain = domain
                   self.model_type = nil
-                  domain.foobara_type_from_declaration(declaration)
+                  type_domain.foobara_type_from_declaration(declaration)
                 end
               else
                 domain.foobara_type_from_declaration(declaration)

data/projects/model/src/extensions/builtin_types/model/validators/model_instance_is_valid.rb

@@ -13,8 +13,8 @@ module Foobara
             end
           end
 
-          def always_applicable?
-            true
+          def applicable?(model_instance)
+            !model_instance.skip_validations
           end
 
           def process_value(model_instance)

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/model_class_desugarizer.rb

@@ -17,6 +17,8 @@ module Foobara
 
           # TODO: consider splitting this up into multiple desugarizers
           def desugarize(strictish_type_declaration)
+            strictish_type_declaration = strictish_type_declaration.dup
+
             if strictish_type_declaration.key?(:model_module)
               model_module = strictish_type_declaration[:model_module]
 
@@ -47,7 +49,7 @@ module Foobara
                                      end
                                    end
 
-                                   strictish_type_declaration[:model_base_class] = model_class.superclass.name
+                                   strictish_type_declaration[:model_base_class] ||= model_class.superclass.name
 
                                    model_class.name
                                  elsif klass.is_a?(::String)

data/projects/model/src/model.rb

@@ -169,10 +169,10 @@ module Foobara
 
     abstract
 
-    attr_accessor :mutable
+    attr_accessor :mutable, :skip_validations
 
     def initialize(attributes = nil, options = {})
-      allowed_options = %i[validate mutable ignore_unexpected_attributes]
+      allowed_options = %i[validate mutable ignore_unexpected_attributes skip_validations]
       invalid_options = options.keys - allowed_options
 
       unless invalid_options.empty?
@@ -181,6 +181,8 @@ module Foobara
         # :nocov:
       end
 
+      self.skip_validations = options[:skip_validations]
+
       if options[:ignore_unexpected_attributes]
         Thread.with_inheritable_thread_local_var(:foobara_ignore_unexpected_attributes, true) do
           initialize(attributes, options.except(:ignore_unexpected_attributes))
@@ -226,7 +228,7 @@ module Foobara
                        mutable
                      end
 
-      validate! if validate
+      validate! if validate # TODO: test this code path
     end
 
     foobara_delegate :model_name, :valid_attribute_name?, :validate_attribute_name!, to: :class

data/projects/monorepo/lib/foobara/monorepo/project.rb

@@ -26,7 +26,10 @@ module Foobara
 
       def load
         require require_path
-        Util.require_directory("#{project_path}/src")
+        src_dir = "#{project_path}/src"
+        if Dir.exist?(src_dir)
+          Util.require_directory(src_dir)
+        end
       end
 
       def install!

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

@@ -0,0 +1,95 @@
+module Foobara
+  module NestedTransactionable
+    include Concern
+
+    class << self
+      def relevant_entity_classes_for_type(type)
+        entity_classes = []
+        entity_classes += Entity.construct_associations(type).values.map(&:target_class)
+
+        if type.extends?(BuiltinTypes[:entity])
+          entity_classes << type.target_class
+        end
+
+        entity_classes.uniq.each do |entity_class|
+          entity_classes += entity_class.deep_associations.values.map(&:target_class)
+        end
+
+        entity_classes.uniq
+      end
+    end
+
+    def relevant_entity_classes_for_type(type)
+      NestedTransactionable.relevant_entity_classes_for_type(type)
+    end
+
+    def relevant_entity_classes
+      # :nocov:
+      raise "subclass responsibility"
+      # :nocov:
+    end
+
+    def transactions
+      @transactions ||= []
+    end
+
+    def opened_transactions
+      @opened_transactions ||= []
+    end
+
+    def auto_detect_current_transactions
+      classes = relevant_entity_classes
+      return if classes.nil? || classes.empty?
+
+      bases = classes.map(&:entity_base).uniq
+
+      bases.each do |base|
+        tx = base.current_transaction
+        transactions << tx if tx
+      end
+    end
+
+    def open_transaction
+      auto_detect_current_transactions
+
+      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.each do |entity_base|
+        transaction = entity_base.transaction
+        transaction.open!
+        opened_transactions << transaction
+        transactions << transaction
+      end
+    end
+
+    def rollback_transaction
+      opened_transactions.reverse.each do |transaction|
+        if transaction.currently_open?
+          # Hard to test this because halting and other exceptions rollback the transactions via
+          # block form but to be safe keeping this
+          # :nocov:
+          transaction.rollback!
+          # :nocov:
+        end
+      end
+    end
+
+    def commit_transaction
+      opened_transactions.reverse.each(&:commit!)
+    end
+
+    def commit_transaction_if_open
+      opened_transactions.reverse.each do |tx|
+        if tx.currently_open?
+          tx.commit!
+        end
+      end
+    end
+
+    def use_transaction(&)
+      Persistence::EntityBase.using_transactions(transactions, &)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.115
+  version: 0.0.116
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2025-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -179,7 +179,6 @@ files:
 - projects/command/src/command_pattern_implementation/concerns/subcommands.rb
 - projects/command/src/command_pattern_implementation/concerns/transactions.rb
 - projects/command/src/state_machine.rb
-- projects/command/src/transformed_command.rb
 - projects/command_connectors/lib/foobara/command_connectors.rb
 - projects/command_connectors/src/authenticator.rb
 - projects/command_connectors/src/authenticator_selector.rb
@@ -216,6 +215,7 @@ files:
 - projects/command_connectors/src/serializers/record_store_serializer.rb
 - projects/command_connectors/src/serializers/success_serializer.rb
 - projects/command_connectors/src/serializers/yaml_serializer.rb
+- projects/command_connectors/src/transformed_command.rb
 - projects/command_connectors/src/transformers/auth_errors_transformer.rb
 - projects/command_connectors/src/transformers/load_aggregates_pre_commit_transformer.rb
 - projects/command_connectors/src/transformers/load_delegated_attributes_entities_pre_commit_transformer.rb
@@ -369,6 +369,7 @@ files:
 - projects/namespace/src/prefixless_registry.rb
 - projects/namespace/src/scoped.rb
 - projects/namespace/src/unambiguous_registry.rb
+- projects/nested_transactionable/lib/foobara/nested_transactionable.rb
 - projects/persistence/lib/foobara/persistence.rb
 - projects/persistence/src/entity_attributes_crud_driver.rb
 - projects/persistence/src/entity_base.rb
@@ -492,6 +493,7 @@ require_paths:
 - "./projects/model_attribute_helpers/lib"
 - "./projects/monorepo/lib"
 - "./projects/namespace/lib"
+- "./projects/nested_transactionable/lib"
 - "./projects/persistence/lib"
 - "./projects/state_machine/lib"
 - "./projects/type_declarations/lib"