foobara 0.0.130 → 0.0.132

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dd322e7389be1e600f98133b9e92a177f1d14a1b2c0d4200e7b9630fd023983
-  data.tar.gz: 6518a4d6ac731b1973809640058b8e793ebcd9dc0d014827713fc2466fe209d9
+  metadata.gz: d4c8a877056c159be9d156cde81dececc246a1dda21e99c39d567603c4b99aca
+  data.tar.gz: 71f5c66811f399c7311b6a13fcd9562b7b11f1e6b3eb34e6cd0298cb6e2e548a
 SHA512:
-  metadata.gz: 96d8ca1ee65877ae7315052668cdff9c247ee778f5d285d4828145b3c69f06402fc97b4085744315f76b30dad36d5a9bd7f4a753108a1195950c4676c9cf16e1
-  data.tar.gz: a3ee1b0364e55f320ea2272b17f6a49d0a5e5a4d7406c3f9aa65fb8b04cdbf7b5c1169db6ae06adb3851edc62ae595614011a95b6b0ffa4767e672466f2c855c
+  metadata.gz: 97210eac20ace35283b2fdffe8ac36d924c3ac19336a34b914357a7c0cc7ab0a3097a867d78032898cbf8dc21ef57c6c605100919f96cfbbad15a3955cde4d2f
+  data.tar.gz: fb717c26f27f5fb6be91d77ddce128de252198523d4cc535d315fbe1029981951242a845b37460cee4cc3b6b0862a6220463750499e400d4a8d8426c62e776d4

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [0.0.132] - 2025-06-19
+
+- Add/improve the description for primary key types in EntityToPrimaryKeyInputsTransformer
+- Support model and tuple types in .has_associations?
+- Move EntityToPrimaryKeyInputsTransformer over from foobara-agent gem
+- Make sure EntitiesToPrimaryKeysSerializer recurses into models/detached entities
+- Fix bugs impacting use of multiple inputs transformers at a time and other issues with typed transformers
+
+# [0.0.131] - 2025-06-16
+
+- Extract InMemoryMinimal crud driver specs to foobara-crud-driver-spec-helpers gem
+- Better support for nested transactions
+- Fix buggy actions carried out when committing/rolling back transactions
+- Fix thread leaks in WeakObjectSet and test suite
+
 # [0.0.130] - 2025-06-06
 
 - Support using a proc as an attributes default for lazy evaluation of default values

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

@@ -14,10 +14,10 @@ module Foobara
             if detached_to_primary_key?
               object.primary_key
             else
-              object.attributes_with_delegates
+              serialize(object.attributes_with_delegates)
             end
           when Model
-            object.attributes_with_delegates
+            serialize(object.attributes_with_delegates)
           when ::Array
             object.map { |element| serialize(element) }
           when ::Hash

data/projects/command_connectors/src/transformed_command.rb

@@ -114,7 +114,9 @@ module Foobara
         inputs_type = command_class.inputs_type
 
         @inputs_transformers = transformers_to_processors(@inputs_transformers, inputs_type, direction: :to)
+        @inputs_transformers = @inputs_transformers.reverse
 
+        # TODO: this block looks pointless...
         @inputs_transformers.each do |transformer|
           if transformer.is_a?(TypeDeclarations::TypedTransformer)
             new_type = transformer.from_type
@@ -442,21 +444,18 @@ module Foobara
       def inputs_transformer
         return @inputs_transformer if defined?(@inputs_transformer)
 
-        if inputs_transformers.empty?
+        transformers = inputs_transformers
+
+        if transformers.empty?
           @inputs_transformer = nil
           return
         end
 
-        @inputs_transformer = begin
-          transformers = transformers_to_processors(inputs_transformers,
-                                                    command_class.inputs_type, direction: :to)
-
-          if transformers.size == 1
-            transformers.first
-          else
-            Value::Processor::Pipeline.new(processors: transformers)
-          end
-        end
+        @inputs_transformer = if transformers.size == 1
+                                transformers.first
+                              else
+                                Value::Processor::Pipeline.new(processors: transformers)
+                              end
       end
 
       def response_mutator

data/projects/command_connectors/src/transformers/entity_to_primary_key_inputs_transformer.rb

@@ -0,0 +1,88 @@
+module Foobara
+  module CommandConnectors
+    module Transformers
+      class EntityToPrimaryKeyInputsTransformer < TypeDeclarations::TypedTransformer
+        def from_type_declaration
+          return nil unless to_type
+
+          if contains_associations_or_is_entity?(to_type)
+            if to_type.extends?(Foobara::BuiltinTypes[:attributes])
+              to_fix = {}
+
+              to_type.element_types.each_pair do |attribute_name, attribute_type|
+                if contains_associations_or_is_entity?(attribute_type)
+                  to_fix[attribute_name] = attribute_type
+                end
+              end
+
+              element_type_declarations = to_type.declaration_data[:element_type_declarations].dup
+
+              to_fix.each_pair do |attribute_name, attribute_type|
+                transformer = EntityToPrimaryKeyInputsTransformer.new(to: attribute_type)
+                element_type_declarations[attribute_name] = transformer.from_type_declaration
+              end
+
+              to_type.declaration_data.merge(element_type_declarations:)
+            elsif to_type.extends?(Foobara::BuiltinTypes[:tuple])
+              indexes_to_fix = []
+
+              to_type.element_types.each.with_index do |element_type, index|
+                if contains_associations_or_is_entity?(element_type)
+                  indexes_to_fix << index
+                end
+              end
+
+              element_type_declarations = to_type.declaration_data[:element_type_declarations].dup
+
+              indexes_to_fix.each do |index|
+                transformer = EntityToPrimaryKeyInputsTransformer.new(to: to_type.element_types[index])
+                element_type_declarations[index] = transformer.from_type_declaration
+              end
+
+              to_type.declaration_data.merge(element_type_declarations:)
+            elsif to_type.extends?(Foobara::BuiltinTypes[:array])
+              transformer = EntityToPrimaryKeyInputsTransformer.new(to: to_type.element_type)
+              element_type_declaration = transformer.from_type_declaration
+
+              to_type.declaration_data.merge(element_type_declaration:)
+            elsif to_type.extends?(Foobara::BuiltinTypes[:detached_entity])
+              declaration = to_type.target_class.primary_key_type.reference_or_declaration_data
+
+              description = "#{to_type.target_class.model_name} #{to_type.target_class.primary_key_attribute}"
+
+              unless to_type.extends_directly?(Foobara::BuiltinTypes[:detached_entity]) ||
+                     to_type.extends_directly?(Foobara::BuiltinTypes[:entity])
+                description = [
+                  description,
+                  to_type.description
+                ].join(" : ")
+              end
+              declaration[:description] = description
+
+              declaration
+            elsif to_type.extends?(Foobara::BuiltinTypes[:model])
+              attributes_type = to_type.target_class.attributes_type
+              EntityToPrimaryKeyInputsTransformer.new(to: attributes_type).from_type_declaration
+            else
+              # :nocov:
+              raise "Not sure how to handle #{to_type}"
+              # :nocov:
+            end
+          else
+            to_type
+          end
+        end
+
+        def transform(inputs)
+          inputs
+        end
+
+        private
+
+        def contains_associations_or_is_entity?(type)
+          DetachedEntity.contains_associations?(type) || type.extends?(Foobara::BuiltinTypes[:detached_entity])
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/concerns/associations.rb

@@ -221,19 +221,29 @@ module Foobara
 
             if type.extends?(BuiltinTypes[:detached_entity])
               if initial
-                element_types = type.element_types
-
-                if remove_sensitive
-                  # TODO: test this code path
-                  # :nocov:
-                  element_types = element_types&.reject(&:sensitive?)
-                  # :nocov:
-                end
-
-                contains_associations?(element_types, false)
+                contains_associations?(type.element_types, false)
               else
                 true
               end
+            elsif type.extends?(BuiltinTypes[:model])
+              element_types = type.element_types
+
+              if remove_sensitive
+                # TODO: test this code path
+                # :nocov:
+                element_types = element_types&.reject(&:sensitive?)
+                # :nocov:
+              end
+
+              contains_associations?(element_types, false)
+            elsif type.extends?(BuiltinTypes[:tuple])
+              element_types = type.element_types
+
+              element_types&.any? do |element_type|
+                if !remove_sensitive || !element_type.sensitive?
+                  contains_associations?(element_type, false)
+                end
+              end
             elsif type.extends?(BuiltinTypes[:array])
               # TODO: what to do about an associative array type?? Unclear how to make a key from that...
               # TODO: raise if associative array contains a non-persisted record to handle this edge case for now.

data/projects/in_memory_crud_driver_minimal/src/in_memory_minimal.rb

@@ -20,7 +20,7 @@ module Foobara
           # TODO: all multiple record methods should return enumerators and code further up should only use
           # the lazy enumerator interface... to encourage that/catch bugs we will return lazy enumerators in these
           # built-in crud drivers
-          def all
+          def all(page_size: nil)
             records.each_value.lazy
           end
 

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

@@ -14,7 +14,7 @@ module Foobara
           end
 
           def applicable?(model_instance)
-            !model_instance.skip_validations
+            model_instance && !model_instance.skip_validations
           end
 
           def process_value(model_instance)

data/projects/persistence/src/entity_attributes_crud_driver.rb

@@ -4,6 +4,12 @@ module Foobara
     class EntityAttributesCrudDriver
       attr_accessor :raw_connection, :tables
 
+      class << self
+        def has_real_transactions?
+          false
+        end
+      end
+
       def initialize(connection_or_credentials = nil)
         self.raw_connection = open_connection(connection_or_credentials)
         self.tables = {}
@@ -31,7 +37,7 @@ module Foobara
       def rollback_transaction(_raw_tx)
       end
 
-      def close_transaction(_raw_tx)
+      def commit_transaction(_raw_tx)
       end
 
       def table_for(entity_class)
@@ -91,7 +97,7 @@ module Foobara
           # :nocov:
         end
 
-        def all
+        def all(page_size: nil)
           # :nocov:
           raise "subclass responsibility"
           # :nocov:
@@ -161,39 +167,22 @@ module Foobara
 
         def matches_attributes_filter?(attributes, attributes_filter)
           attributes_filter.all? do |attribute_name_or_path, value|
-            value = normalize_attribute_filter_value(value)
+            # get the model-free type?
+            attribute_type = entity_class.attributes_type.type_at_path(attribute_name_or_path)
+
+            value = restore_attributes(value, attribute_type)
 
             if attribute_name_or_path.is_a?(::Array)
               values = DataPath.values_at(attribute_name_or_path, attributes)
 
               values.any? do |attribute_value|
-                normalize_attribute_filter_value(attribute_value) == value
+                restore_attributes(attribute_value, attribute_type) == value
               end
             else
-              attribute_value = attributes[attribute_name_or_path]
-              normalize_attribute_filter_value(attribute_value) == value
-            end
-          end
-        end
-
-        def normalize_attribute_filter_value(value)
-          case value
-          when ::Array
-            value.map { |v| normalize_attribute_filter_value(v) }
-          when ::Hash
-            value.to_h do |k, v|
-              [normalize_attribute_filter_value(k), normalize_attribute_filter_value(v)]
-            end
-          when DetachedEntity
-            if value.persisted?
-              normalize_attribute_filter_value(value.primary_key)
-            else
-              value
+              attribute_value = DataPath.value_at(attribute_name_or_path, attributes)
+              attribute_value = restore_attributes(attribute_value, attribute_type)
+              attribute_value == value
             end
-          when Model
-            normalize_attribute_filter_value(value.attributes)
-          else
-            value
           end
         end
 
@@ -262,6 +251,50 @@ module Foobara
         def primary_key_attribute
           entity_class.primary_key_attribute
         end
+
+        def restore_attributes(object, type = entity_class.attributes_type)
+          if type.extends?(BuiltinTypes[:attributes])
+            object.to_h do |attribute_name, attribute_value|
+              attribute_type = type.type_at_path(attribute_name)
+              [attribute_name.to_sym, restore_attributes(attribute_value, attribute_type)]
+            end
+          elsif type.extends?(BuiltinTypes[:tuple])
+            # TODO: test this code path
+            # :nocov:
+            object.map.with_index do |value, index|
+              element_type = type.element_types[index]
+              restore_attributes(value, element_type)
+            end
+            # :nocov:
+          elsif type.extends?(BuiltinTypes[:array])
+            element_type = type.element_type
+            object.map { |value| restore_attributes(value, element_type) }
+          elsif type.extends?(BuiltinTypes[:entity])
+            if object.is_a?(Model)
+              if object.persisted?
+                object = object.primary_key
+                restore_attributes(object, type.target_class.primary_key_type)
+              else
+                object
+              end
+            else
+              restore_attributes(object, type.target_class.primary_key_type)
+            end
+          elsif type.extends?(BuiltinTypes[:model])
+            if object.is_a?(Model)
+              object = object.attributes
+            end
+            restore_attributes(object, type.element_types)
+          else
+            outcome = type.process_value(object)
+
+            if outcome.success?
+              outcome.result
+            else
+              object
+            end
+          end
+        end
       end
     end
   end

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

@@ -15,12 +15,20 @@ module Foobara
               end
             end
 
+            def open_nested!(outer_tx)
+              state_machine.open_nested! do
+                self.is_nested = true
+                self.raw_tx = outer_tx.raw_tx
+              end
+            end
+
             def flush!
               state_machine.flush! do
                 each_table(&:validate!)
                 each_table(&:flush_created!)
                 each_table(&:flush_updated_and_hard_deleted!)
               end
+              entity_attributes_crud_driver.flush_transaction(raw_tx)
             rescue => e
               # :nocov:
               rollback!(e)
@@ -34,6 +42,7 @@ module Foobara
               state_machine.revert! do
                 each_table(&:revert!)
               end
+              entity_attributes_crud_driver.revert_transaction(raw_tx)
             rescue => e
               # :nocov:
               rollback!(e)
@@ -42,11 +51,25 @@ module Foobara
             end
 
             def commit!
+              return commit_nested! if nested?
+
               state_machine.commit! do
-                each_table(&:validate!)
-                each_table(&:flush_created!)
-                each_table(&:flush_updated_and_hard_deleted!)
-                entity_attributes_crud_driver.close_transaction(raw_tx)
+                each_table(&:commit!)
+                entity_attributes_crud_driver.commit_transaction(raw_tx)
+                each_table(&:transaction_closed)
+              end
+            rescue => e
+              # :nocov:
+              rollback!(e)
+              raise
+              # :nocov:
+            end
+
+            def commit_nested!
+              state_machine.commit_nested! do
+                each_table(&:commit!)
+                entity_attributes_crud_driver.flush_transaction(raw_tx)
+                each_table(&:transaction_closed)
               end
             rescue => e
               # :nocov:
@@ -61,13 +84,32 @@ module Foobara
             end
 
             def rollback!(because_of = nil)
+              return rollback_nested!(because_of) if nested?
+
               state_machine.rollback! do
                 # TODO: raise error if already flushed and if crud_driver doesn't support true transactions
                 entity_attributes_crud_driver.rollback_transaction(raw_tx)
                 each_table(&:rollback!)
-                entity_attributes_crud_driver.close_transaction(raw_tx)
               end
 
+              each_table(&:transaction_closed)
+
+              if !because_of && (self == entity_base.current_transaction)
+                raise RolledBack, "intentionally rolled back"
+              end
+            rescue
+              state_machine.error! if state_machine.currently_open?
+              raise
+            end
+
+            def rollback_nested!(because_of = nil)
+              state_machine.rollback_nested! do
+                entity_attributes_crud_driver.revert_transaction(raw_tx)
+                each_table(&:revert!)
+              end
+
+              each_table(&:transaction_closed)
+
               if !because_of && (self == entity_base.current_transaction)
                 raise RolledBack, "intentionally rolled back"
               end

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

@@ -7,6 +7,7 @@ module Foobara
           set_transition_map({
                                unopened: {
                                  open: :open,
+                                 open_nested: :open,
                                  close: :closed
                                },
                                open: {
@@ -17,7 +18,9 @@ module Foobara
                                  # TODO: should we have intermediate states to quickly get out of the open state?
                                  rollback: :closed,
                                  commit: :closed,
-                                 error: :closed
+                                 error: :closed,
+                                 commit_nested: :closed,
+                                 rollback_nested: :closed
                                }
                              })
         end

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

@@ -6,7 +6,7 @@ module Foobara
         include Concerns::EntityCallbackHandling
         include Concerns::TransactionTracking
 
-        attr_accessor :state_machine, :entity_base, :raw_tx, :tables
+        attr_accessor :state_machine, :entity_base, :raw_tx, :tables, :is_nested
 
         def initialize(entity_base)
           self.entity_base = entity_base
@@ -162,6 +162,10 @@ module Foobara
         def perform(&)
           entity_base.using_transaction(self, &)
         end
+
+        def nested?
+          is_nested
+        end
       end
     end
   end

data/projects/persistence/src/entity_base/transaction_table/concerns/record_tracking.rb

@@ -83,10 +83,25 @@ module Foobara
             end
 
             def rolled_back
+              closed
+            end
+
+            def committed
+              closed
+            end
+
+            def closed
               marked_hard_deleted.clear
               marked_updated.clear
               marked_created.clear
-              tracked_records.clear
+              marked_loading.clear
+            end
+
+            # We need to clear this one separately. That's because otherwise a different table
+            # might flush and create a thunk if it has an association to this table but we've stopped
+            # tracking the record.
+            def transaction_closed
+              tracked_records.close
             end
 
             def reverted

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

@@ -632,6 +632,14 @@ module Foobara
           rolled_back
         end
 
+        def commit!
+          validate!
+          flush_created!
+          flush_updated_and_hard_deleted!
+
+          committed
+        end
+
         def revert!
           # TODO: could pause record tracking while doing this as a performance boost
           marked_updated.each(&:restore_without_callbacks!)

data/projects/persistence/src/entity_base.rb

@@ -52,7 +52,31 @@ module Foobara
         Thread.inheritable_thread_local_var_set(transaction_key, transaction)
       end
 
-      VALID_MODES = [:use_existing, :open_nested, :open_new, nil].freeze
+      # What types of transaction scenarios are there?
+      # 1. If a transaction is already open, use it as a "nested transaction", otherwise, open a new one.
+      #    A nested transaction means that "rollback" is the same as "revert" and "commit" is the same as "flush".
+      #    For a true
+      # 2. If a transaction is already open, raise an error. otherwise, open a new one.
+      # 3. Open a new, independent transaction, no matter what.
+      # 4. If a transaction is already open, use it, otherwise, open a new one.
+      # 5. We are outside of a transaction but have a handle on one. We want to set it as the current transaction.
+      #    and do some work in that transaction.
+      # Which use cases do we probably need at the moment?
+      # 1. If we are running a command calling other commands, we will open transactions when needed but
+      #    inherit any already-open transactions. Commands don't commit or flush to the already-open transactions
+      #    that they inherit. So this feels like a "use existing" situation or a situation where we don't even
+      #    bother calling open_transaction at all.  This is the most important use-case.  It can be helpful to raise
+      #    in this situation because it is not expected that there's an existing transaction yet we're opening another.
+      # 2. We might have a situation where we are in one transaction but definitely want to open a new one and
+      #    commit it ourselves and have its results committed and visible independent of the current transaction.
+      #    So this feels like a "open new" situation where we don't want to raise an error if a transaction is
+      #    already open.
+      VALID_MODES = [
+        :use_existing,
+        :open_nested,
+        :open_new,
+        nil
+      ].freeze
 
       def using_transaction(existing_transaction, &)
         transaction(existing_transaction:, &)
@@ -67,18 +91,28 @@ module Foobara
 
         old_transaction = current_transaction
 
-        if old_transaction&.closed?
+        if old_transaction && !old_transaction.currently_open?
           old_transaction = nil
         end
 
-        if old_transaction&.currently_open?
+        open_nested = false
+
+        if old_transaction
           if mode == :use_existing || existing_transaction == old_transaction
             if block_given?
               return yield old_transaction
             else
               return old_transaction
             end
-          elsif mode != :open_nested && mode != :open_new
+          elsif mode == :open_nested
+            open_nested = true
+          elsif mode == :open_new
+            if existing_transaction
+              # :nocov:
+              raise ArgumentError, "Cannot use mode :open_new with existing_transaction:"
+              # :nocov:
+            end
+          else
             # :nocov:
             raise "Transaction already open. " \
                   "Use mode :use_existing if you want to make use of the existing transaction. " \
@@ -96,16 +130,27 @@ module Foobara
             tx = existing_transaction
           else
             tx = Transaction.new(self)
-            tx.open!
+
+            if open_nested
+              tx.open_nested!(old_transaction)
+            else
+              tx.open!
+            end
           end
 
           set_current_transaction(tx)
+
           result = yield tx
-          tx.commit! if tx.currently_open? && !existing_transaction
+
+          if tx.currently_open? && !existing_transaction
+            tx.commit!
+          end
           result
         rescue Foobara::Persistence::EntityBase::Transaction::RolledBack # rubocop:disable Lint/SuppressedException
         rescue => e
-          tx.rollback!(e) if tx.currently_open?
+          if tx.currently_open?
+            tx.rollback!(e)
+          end
           raise
         ensure
           set_current_transaction(old_transaction)

data/projects/type_declarations/src/typed_transformer.rb

@@ -22,6 +22,10 @@ module Foobara
         attr_reader :from_type, :to_type
       end
 
+      def always_applicable?
+        true
+      end
+
       def from_type_declaration
         nil
       end

data/projects/types/src/type.rb

@@ -232,6 +232,27 @@ module Foobara
         end
       end
 
+      def extends_directly?(type)
+        case type
+        when Type
+          base_type == type
+        when Symbol, String
+          concrete_type = created_in_namespace.foobara_lookup_type(type)
+
+          if concrete_type.nil?
+            # :nocov:
+            raise "No type found for #{type}"
+            # :nocov:
+          end
+
+          extends_directly?(concrete_type)
+        else
+          # :nocov:
+          raise ArgumentError, "Expected a Type or a Symbol/String, but got #{type.inspect}"
+          # :nocov:
+        end
+      end
+
       def extends_type?(type)
         return true if self == type
 

data/projects/weak_object_set/src/weak_object_set.rb

@@ -4,8 +4,6 @@ module Foobara
   # TODO: a possible optimization: have a certain number of records before the Weakref approach kicks in
   # that way we don't just immediately clear out useful information without any actual memory burden
   class WeakObjectSet
-    class InvalidWtf < StandardError; end
-
     class GarbageCleaner
       attr_accessor :weak_object_set, :deactivated, :queue, :cleanup_thread
 
@@ -17,6 +15,12 @@ module Foobara
       end
 
       def cleanup_proc
+        if deactivated?
+          # :nocov:
+          raise "GarbageCleaner has been deactivated"
+          # :nocov:
+        end
+
         @cleanup_proc ||= begin
           queue = self.queue
 
@@ -35,6 +39,8 @@ module Foobara
       end
 
       def start_cleanup_thread
+        queue = self.queue
+
         self.cleanup_thread = Thread.new do
           loop do
             object_id = queue.pop
@@ -57,9 +63,16 @@ module Foobara
       end
 
       def deactivate
+        raise if deactivated?
+
         self.deactivated = true
         queue.close
+        # TODO: don't bother to join here outside of test suite
         cleanup_thread.join # just doing this for test suite/simplecov
+        @cleanup_proc = nil
+        @queue = nil
+        @weak_object_set = nil
+        @cleanup_thread = nil
       end
 
       def deactivated?
@@ -69,7 +82,7 @@ module Foobara
 
     include Enumerable
 
-    attr_accessor :monitor, :key_method, :key_to_object_id, :object_id_to_key, :objects
+    attr_accessor :monitor, :key_method, :key_to_object_id, :object_id_to_key, :objects, :closed
     attr_writer :garbage_cleaner
 
     def initialize(key_method = nil)
@@ -136,19 +149,17 @@ module Foobara
       @garbage_cleaner ||= begin
         queue = Queue.new
 
-        gc = GarbageCleaner.new(self, queue)
-
-        ObjectSpace.define_finalizer gc do
-          # :nocov:
-          queue.close
-          # :nocov:
-        end
-
-        gc
+        GarbageCleaner.new(self, queue)
       end
     end
 
     def <<(object)
+      if closed?
+        # :nocov:
+        raise "Cannot add objects to a closed WeakObjectSet"
+        # :nocov:
+      end
+
       object_id = object.object_id
 
       monitor.synchronize do
@@ -235,11 +246,30 @@ module Foobara
       end
     end
 
+    def close
+      raise if closed?
+
+      self.closed = true
+      stop_garbage_cleaner
+    end
+
+    def stop_garbage_cleaner
+      gc = nil
+
+      monitor.synchronize do
+        if @garbage_cleaner
+          gc = garbage_cleaner
+          self.garbage_cleaner = nil
+        end
+      end
+
+      gc&.deactivate
+    end
+
     def clear
       monitor.synchronize do
-        garbage_cleaner.deactivate
+        stop_garbage_cleaner
 
-        self.garbage_cleaner = nil
         self.objects = {}
 
         if key_method
@@ -248,5 +278,9 @@ module Foobara
         end
       end
     end
+
+    def closed?
+      closed
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.130
+  version: 0.0.132
 platform: ruby
 authors:
 - Miles Georgi
@@ -229,6 +229,7 @@ files:
 - 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/entity_to_primary_key_inputs_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
 - projects/common/lib/foobara/common.rb
@@ -486,8 +487,8 @@ licenses:
 - MPL-2.0
 metadata:
   homepage_uri: https://foobara.com
-  source_code_uri: https://foobara.com
-  changelog_uri: https://foobara.com/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/foobara/foobara
+  changelog_uri: https://github.com/foobara/foobara/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -529,7 +530,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A command-centric and discoverable software framework with a focus on domain
   concepts and abstracting away integration code