foobara 0.0.119 → 0.0.120

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bcf730a4685cf72bb0af0b04cbf7cd7929faa672d64300444bc24f441e2f1d4
-  data.tar.gz: edfb3e4998d9adf25271075017167ed1b750ae4bccbdec17eb2196f5c9c9ab93
+  metadata.gz: df43aec79b46e3e71fd064c6482bdd5dd6e0af495987d6cea1cdf97311460e91
+  data.tar.gz: 800093b7a126bbca27fa300c4df50b568b329c762ad7a2c68925f4a3d5690090
 SHA512:
-  metadata.gz: 6484e4c0fe4d50946922b0dedf3cd0a443c89c21294d2b8c32f9eb1433a7ddaab6cbf68715a7ad926ab256822d2c6ef0a317036bab3d5a8879ec861ef7cdddc5
-  data.tar.gz: 9d17dfacde7d8ad2ac42635ccc11d4c2d2aed619c47ffe6d6ee5e4dfa40ba6eeb7820238fc642fa5324aa113985782e260f6d342289c760065759ddc8e7a04be
+  metadata.gz: 6305514bda86178efb70d09cd8ff8d46e404f0407b50189833b9939230cf716a80049afca17ea5071599bfb71f4cd45a660ade570b6bfcec063190e9b3a02096
+  data.tar.gz: 84705a7ff3bd306c13e7cdf5e81a3a960b0e769df51dacf38859a003da408926133c434d9d03ba2a58b70e57946b58d8355da338a0e780cab34f35a3e84df97c

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# [0.0.120] - 2025-05-11
+
+- Fix a race condition in persistence
+- Fix various problems preventing sensitive/private types from being properly removed
+  in exposed types
+
 # [0.0.119] - 2025-05-08
 
 - Make anonymous transformers more deterministic in manifests

data/projects/command_connectors/src/command_connector.rb

@@ -454,6 +454,13 @@ module Foobara
     end
 
     def foobara_manifest
+      Namespace.use command_registry do
+        foobara_manifest_in_current_namespace
+      end
+    end
+
+    # TODO: try to break this giant method up
+    def foobara_manifest_in_current_namespace
       process_delayed_connections
 
       to_include = Set.new
@@ -506,16 +513,20 @@ module Foobara
                 else
                   domain_name = o.foobara_domain.scoped_full_name
 
-                  unless command_registry.foobara_registered?(domain_name)
+                  unless command_registry.foobara_registered?(domain_name, mode: Namespace::LookupMode::ABSOLUTE)
                     command_registry.build_and_register_exposed_domain(domain_name)
 
                     # Since we don't know which other domains/orgs creating this domain might have created,
                     # we will just add them all to be included just in case
-                    command_registry.foobara_all_domain.each do |exposed_domain|
+                    command_registry.foobara_all_domain(
+                      mode: Namespace::LookupMode::ABSOLUTE
+                    ).each do |exposed_domain|
                       additional_to_include << exposed_domain
                     end
 
-                    command_registry.foobara_all_organization.each do |exposed_organization|
+                    command_registry.foobara_all_organization(
+                      mode: Namespace::LookupMode::ABSOLUTE
+                    ).each do |exposed_organization|
                       additional_to_include << exposed_organization
                     end
                   end
@@ -612,7 +623,7 @@ module Foobara
     def all_exposed_commands
       process_delayed_connections
 
-      command_registry.foobara_all_command
+      command_registry.foobara_all_command(mode: Namespace::LookupMode::ABSOLUTE)
     end
   end
 end

data/projects/command_connectors/src/command_registry.rb

@@ -24,6 +24,8 @@ module Foobara
       end
 
       foobara_add_category_for_instance_of(:command, ExposedCommand)
+
+      foobara_depends_on_namespaces << Namespace.global
     end
 
     def register(command_class, **)
@@ -32,7 +34,8 @@ module Foobara
 
     def create_exposed_command(command_class, **)
       full_domain_name = command_class.domain.scoped_full_name
-      exposed_domain = foobara_lookup_domain(full_domain_name) || build_and_register_exposed_domain(full_domain_name)
+      exposed_domain = foobara_lookup_domain(full_domain_name, mode: Namespace::LookupMode::ABSOLUTE) ||
+                       build_and_register_exposed_domain(full_domain_name)
 
       exposed_command = create_exposed_command_without_domain(command_class, **)
 
@@ -75,8 +78,11 @@ module Foobara
                       end
 
       full_organization_name = domain_module.foobara_full_organization_name
-      exposed_organization = foobara_lookup_organization(full_organization_name) ||
-                             build_and_register_exposed_organization(full_organization_name)
+
+      exposed_organization = foobara_lookup_organization(
+        full_organization_name,
+        mode: Namespace::LookupMode::ABSOLUTE
+      ) || build_and_register_exposed_organization(full_organization_name)
 
       exposed_domain = Module.new
       exposed_domain.foobara_namespace!

data/projects/command_connectors/src/transformed_command.rb

@@ -3,12 +3,12 @@ module Foobara
   # TODO: move this to command connectors project
   class TransformedCommand
     class << self
+      # TODO: handle errors_transformers!
+      attr_writer :result_transformers, :inputs_transformers
       attr_accessor :command_class,
                     :command_name,
                     :full_command_name,
                     :capture_unknown_error,
-                    :inputs_transformers,
-                    :result_transformers,
                     :errors_transformers,
                     :pre_commit_transformers,
                     # TODO: get at least these serializers out of here...
@@ -20,7 +20,9 @@ module Foobara
                     :request_mutators,
                     :allowed_rule,
                     :requires_authentication,
-                    :authenticator
+                    :authenticator,
+                    :subclassed_in_namespace,
+                    :suffix
 
       def subclass(
         command_class,
@@ -40,28 +42,6 @@ module Foobara
         suffix: nil,
         capture_unknown_error: false
       )
-        result_type = command_class.result_type
-
-        if result_type&.has_sensitive_types?
-          remover_class = Foobara::TypeDeclarations.sensitive_value_remover_class_for_type(result_type)
-
-          remover = Namespace.use scoped_namespace do
-            transformed_result_type = result_type_from_transformers(result_type, result_transformers)
-
-            path = if transformed_result_type.scoped_path_set?
-                     transformed_result_type.scoped_full_path
-                   else
-                     [*command_class.scoped_path, *suffix, "Result"]
-                   end
-
-            remover_class.new(from: transformed_result_type).tap do |r|
-              r.scoped_path = ["SensitiveValueRemover", *path]
-            end
-          end
-
-          result_transformers = [*result_transformers, remover]
-        end
-
         Class.new(self).tap do |klass|
           klass.command_class = command_class
           klass.command_name = command_name
@@ -77,6 +57,8 @@ module Foobara
           klass.allowed_rule = allowed_rule
           klass.requires_authentication = requires_authentication
           klass.authenticator = authenticator
+          klass.subclassed_in_namespace = scoped_namespace
+          klass.suffix = suffix
         end
       end
 
@@ -85,51 +67,125 @@ module Foobara
                        :organization,
                        to: :command_class
 
-      def inputs_type
-        return @inputs_type if defined?(@inputs_type)
+      def result_transformers
+        return @result_transformers if @considered_sensitive_value_remover
 
-        @inputs_type = if inputs_transformer
-                         if inputs_transformer.is_a?(Value::Processor::Pipeline)
-                           inputs_transformer.processors.each do |transformer|
-                             if transformer.is_a?(TypeDeclarations::TypedTransformer)
-                               from_type = transformer.from_type
-                               if from_type
-                                 @inputs_type = from_type
-                                 return from_type
-                               end
-                             end
-                           end
-
-                           command_class.inputs_type
-                         else
-                           if inputs_transformer.is_a?(TypeDeclarations::TypedTransformer)
-                             inputs_transformer.from_type
-                           end || command_class.inputs_type
-                         end
-                       else
-                         command_class.inputs_type
-                       end
+        @considered_sensitive_value_remover = true
+
+        result_type = command_class.result_type
+
+        result_transformers.reverse.each do |transformer|
+          if transformer.is_a?(TypeDeclarations::TypedTransformer) ||
+             (transformer.is_a?(Class) && transformer < TypeDeclarations::TypedTransformer)
+            new_type = transformer.to_type
+            if new_type
+              result_type = new_type
+              break
+            end
+          end
+        end
+
+        if result_type&.has_sensitive_types?
+          remover_class = Foobara::TypeDeclarations.sensitive_value_remover_class_for_type(result_type)
+
+          remover = Namespace.use subclassed_in_namespace do
+            path = if result_type.scoped_path_set?
+                     result_type.scoped_full_path
+                   else
+                     [*command_class.scoped_path, *suffix, "Result"]
+                   end
+
+            remover_class.new(from: result_type).tap do |r|
+              r.scoped_path = ["SensitiveValueRemover", *path]
+            end
+          end
+
+          @result_transformers = [*@result_transformers, remover]
+        end
+
+        @result_transformers
+      end
+
+      def inputs_transformers
+        return @inputs_transformers if @considered_inputs_sensitive_value_remover
+
+        @considered_inputs_sensitive_value_remover = true
+
+        inputs_type = command_class.inputs_type
+
+        @inputs_transformers = transformers_to_processors(@inputs_transformers, inputs_type, direction: :to)
+
+        @inputs_transformers.each do |transformer|
+          if transformer.is_a?(TypeDeclarations::TypedTransformer)
+            new_type = transformer.from_type
+            if new_type
+              inputs_type = new_type
+              break
+            end
+          end
+        end
+
+        @inputs_transformers
       end
 
-      def result_type_from_transformers(result_type, transformers)
-        transformers.reverse.each do |transformer|
-          if transformer.is_a?(Class) && transformer < TypeDeclarations::TypedTransformer
+      def inputs_type_for_manifest
+        return @inputs_type_for_manifest if defined?(@inputs_type_for_manifest)
+
+        @inputs_type_for_manifest = if inputs_type&.has_sensitive_types?
+                                      remover_class = Foobara::TypeDeclarations.sensitive_value_remover_class_for_type(
+                                        inputs_type
+                                      )
+
+                                      Namespace.use subclassed_in_namespace do
+                                        remover_class.new(to: inputs_type).from_type
+                                      end
+                                    else
+                                      inputs_type
+                                    end
+      end
+
+      def inputs_type_from_transformers
+        return @inputs_type_from_transformers if defined?(@inputs_type_from_transformers)
+
+        @inputs_type_from_transformers = if inputs_transformer
+                                           if inputs_transformer.is_a?(Value::Processor::Pipeline)
+                                             inputs_transformer.processors.each do |transformer|
+                                               if transformer.is_a?(TypeDeclarations::TypedTransformer)
+                                                 from_type = transformer.from_type
+                                                 if from_type
+                                                   @inputs_type_from_transformers = from_type
+                                                   return from_type
+                                                 end
+                                               end
+                                             end
+
+                                             command_class.inputs_type
+                                           else
+                                             if inputs_transformer.is_a?(TypeDeclarations::TypedTransformer)
+                                               inputs_transformer.from_type
+                                             end || command_class.inputs_type
+                                           end
+                                         else
+                                           command_class.inputs_type
+                                         end
+      end
+
+      def result_type_from_transformers
+        result_transformers.reverse.each do |transformer|
+          if transformer.is_a?(TypeDeclarations::TypedTransformer) ||
+             (transformer.is_a?(Class) && transformer < TypeDeclarations::TypedTransformer)
             new_type = transformer.to_type
             return new_type if new_type
           end
         end
 
-        result_type
+        command_class.result_type
       end
 
       def result_type
-        result_type_from_transformers(command_class.result_type, result_transformers)
-      end
-
-      def result_type_for_manifest
-        return @result_type_for_manifest if defined?(@result_type_for_manifest)
+        return @result_type if defined?(@result_type)
 
-        mutated_result_type = result_type
+        mutated_result_type = result_type_from_transformers
 
         mutators = if response_mutators.size == 1
                      [response_mutator]
@@ -141,25 +197,25 @@ module Foobara
           mutated_result_type = mutator.result_type_from(mutated_result_type)
         end
 
-        @result_type_for_manifest = mutated_result_type
+        @result_type = mutated_result_type
       end
 
-      def inputs_type_for_manifest
-        return @inputs_type_for_manifest if defined?(@inputs_type_for_manifest)
+      def inputs_type
+        return @inputs_type if defined?(@inputs_type)
 
-        mutated_inputs_type = inputs_type
+        mutated_inputs_type = inputs_type_from_transformers
 
         mutators = if request_mutators.size == 1
                      [request_mutator]
                    else
-                     request_mutator&.processors&.reverse
+                     request_mutator&.processors
                    end
 
         mutators&.each do |mutator|
           mutated_inputs_type = mutator.inputs_type_from(mutated_inputs_type)
         end
 
-        @inputs_type_for_manifest = mutated_inputs_type
+        @inputs_type = mutated_inputs_type
       end
 
       def error_context_type_map
@@ -211,12 +267,12 @@ module Foobara
 
       def inputs_types_depended_on
         TypeDeclarations.with_manifest_context(remove_sensitive: false) do
-          inputs_type_for_manifest&.types_depended_on || []
+          inputs_type&.types_depended_on || []
         end
       end
 
       def result_types_depended_on
-        type_proc = -> { result_type_for_manifest&.types_depended_on || [] }
+        type_proc = -> { result_type&.types_depended_on || [] }
 
         if TypeDeclarations.manifest_context_set?(:remove_sensitive)
           type_proc.call
@@ -231,21 +287,21 @@ module Foobara
         # TODO: memoize this
         # TODO: this should not delegate to command since transformers are in play
 
-        type = inputs_type
+        types_proc = proc do
+          type = inputs_type_for_manifest
 
-        if type
-          if type.registered?
-            # TODO: if we ever change from attributes-only inputs type
-            # then this will be handy
-            # :nocov:
-            types |= [type]
-            # :nocov:
-          end
+          if type
+            if type.registered?
+              # TODO: if we ever change from attributes-only inputs type
+              # then this will be handy
+              # :nocov:
+              types |= [type]
+              # :nocov:
+            end
 
-          types |= type.types_depended_on
-        end
+            types |= type.types_depended_on
+          end
 
-        types_proc = proc do
           type = result_type
 
           if type
@@ -319,17 +375,19 @@ module Foobara
         result_types_depended_on = self.result_types_depended_on.map(&:foobara_manifest_reference)
         result_types_depended_on = result_types_depended_on.sort
 
-        # TODO: Do NOT defer to command_class.foobara_manifest because it might process types that
-        # might not have an exposed command and might not need one due to transformers/mutators/remove_sensitive flag
-        command_class.foobara_manifest.merge(
+        bit_bucket = Set.new
+        manifest = TypeDeclarations.with_manifest_context(to_include: bit_bucket) do
+          command_class.foobara_manifest
+        end
+
+        # TODO: handle errors_types_depended_on!
+        manifest.merge(
           Util.remove_blank(
             inputs_types_depended_on:,
             result_types_depended_on:,
             types_depended_on: types,
-            inputs_type: TypeDeclarations.with_manifest_context(remove_sensitive: false) do
-              inputs_type_for_manifest&.reference_or_declaration_data
-            end,
-            result_type: result_type_for_manifest&.reference_or_declaration_data,
+            inputs_type: inputs_type_for_manifest&.reference_or_declaration_data,
+            result_type: result_type&.reference_or_declaration_data,
             possible_errors: possible_errors_manifest,
             capture_unknown_error:,
             inputs_transformers:,
@@ -404,13 +462,16 @@ module Foobara
       def response_mutator
         return @response_mutator if defined?(@response_mutator)
 
+        # A hack: this will give the SensitiveValueRemover a chance to be injected
+        result_transformers
+
         if response_mutators.empty?
           @response_mutator = nil
           return
         end
 
         @response_mutator = begin
-          transformers = transformers_to_processors(response_mutators, result_type, direction: :from)
+          transformers = transformers_to_processors(response_mutators, result_type_from_transformers, direction: :from)
 
           if transformers.size == 1
             transformers.first
@@ -423,13 +484,16 @@ module Foobara
       def request_mutator
         return @request_mutator if defined?(@request_mutator)
 
+        # HACK: to give SensitiveValueRemover a chance to be injected
+        inputs_transformer
+
         if request_mutators.empty?
           @request_mutator = nil
           return
         end
 
         @request_mutator = begin
-          transformers = transformers_to_processors(request_mutators, result_type, direction: :to)
+          transformers = transformers_to_processors(request_mutators, inputs_type_from_transformers, direction: :to)
 
           if transformers.size == 1
             transformers.first

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

@@ -114,6 +114,7 @@ module Foobara
 
                 Entity.after_initialized_created do |record:, **|
                   transaction = Persistence.current_transaction(record)
+
                   unless transaction
                     raise NoCurrentTransactionError,
                           "Cannot initialize #{record} because there's no current transaction"
@@ -131,6 +132,7 @@ module Foobara
 
                 Entity.after_initialized_thunk do |record:, **|
                   transaction = Persistence.current_transaction(record)
+
                   unless transaction
                     # :nocov:
                     raise NoCurrentTransactionError,

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

@@ -21,9 +21,8 @@ module Foobara
                   attributes = normalize_attributes(attributes)
                   primary_key = primary_key_for_attributes(attributes)
 
-                  if tracked_records.include_key?(primary_key)
-                    record = tracked_records.find_by_key(primary_key)
-
+                  record = tracked_records.find_by_key(primary_key)
+                  if record
                     next if record.hard_deleted?
                     next if created?(record)
 

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

@@ -34,7 +34,7 @@ module Foobara
             end
 
             def created(record)
-              tracked_records << record
+              tracked(record)
               mark_created(record)
             end
 
@@ -64,7 +64,7 @@ module Foobara
             end
 
             def updated(record)
-              tracked_records << record
+              tracked(record)
 
               # TODO: is this check redundant? Maybe have the entity explode directly instead?
               if hard_deleted?(record)

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

@@ -65,16 +65,29 @@ module Foobara
         end
 
         def load(entity_or_record_id)
-          if entity_or_record_id.is_a?(Entity)
-            if entity_or_record_id.loaded?
-              # :nocov:
-              raise "#{entity_or_record_id} is already loaded!"
-              # :nocov:
-            end
-
-            entity = tracked_records[entity_or_record_id]
+          if entity_or_record_id.nil?
+            # :nocov:
+            raise "Expected a record or record primary key but received nil"
+            # :nocov:
+          end
 
-            if entity && !entity.equal?(entity_or_record_id)
+          if entity_or_record_id.is_a?(Entity)
+            entity = if entity_or_record_id.persisted?
+                       unless entity_or_record_id.primary_key
+                         # :nocov:
+                         raise "Did not expect a record to be persisted but have no primary key"
+                         # :nocov:
+                       end
+
+                       tracked_records.find_by_key(entity_or_record_id.primary_key)
+                     else
+                       # :nocov:
+                       raise "Cannot load an unpersisted record!"
+                       # :nocov:
+                     end
+
+            if entity &&
+               (!entity.equal?(entity_or_record_id) || entity.object_id != entity_or_record_id.object_id)
               # :nocov:
               raise "This transaction is already tracking a different entity with the same primary key." \
                     "Try passing in the primary key instead of constructing an unloaded entity to pass in."
@@ -151,7 +164,19 @@ module Foobara
                 next
               end
 
-              entity = tracked_records[entity_or_record_id]
+              entity = if entity_or_record_id.persisted?
+                         unless entity_or_record_id.primary_key
+                           # :nocov:
+                           raise "Did not expect a record to be persisted but have no primary key"
+                           # :nocov:
+                         end
+
+                         tracked_records.find_by_key(entity_or_record_id.primary_key)
+                       else
+                         # :nocov:
+                         raise "Cannot load an unpersisted record!"
+                         # :nocov:
+                       end
 
               if entity && !entity.equal?(entity_or_record_id)
                 # :nocov:
@@ -440,7 +465,7 @@ module Foobara
         end
 
         def track_loaded(entity)
-          tracked_records << entity
+          tracked(entity)
         end
 
         def hard_delete_all!
@@ -527,7 +552,7 @@ module Foobara
 
             # we need to update finding the tracked object by key and removing/reading it seems to be the simplest
             # way to accomplish that at the moment
-            tracked_records << record
+            tracked(record)
 
             record.is_persisted = record.is_loaded = true
             record.is_created = false
@@ -547,7 +572,7 @@ module Foobara
 
           # we need to update finding the tracked object by key and removing/reading it seems to be the simplest
           # way to accomplish that at the moment
-          tracked_records << record
+          tracked(record)
 
           record.is_persisted = record.is_loaded = true
           record.is_created = false

data/projects/type_declarations/src/attributes_transformers.rb

@@ -0,0 +1,11 @@
+module Foobara
+  class AttributesTransformers < TypeDeclarations::TypedTransformer
+    def initialize(...)
+      super
+
+      unless scoped_path_set?
+        self.scoped_path = self.class.scoped_path
+      end
+    end
+  end
+end

data/projects/type_declarations/src/remove_sensitive_values_transformer.rb

@@ -5,20 +5,30 @@ module Foobara
     class RemoveSensitiveValuesTransformer < TypedTransformer
       def from(...)
         super.tap do
-          associations = Foobara::DetachedEntity.construct_deep_associations(from_type)
+          create_all_association_types_in_current_namespace(from_type)
+        end
+      end
+
+      def to(...)
+        super.tap do
+          create_all_association_types_in_current_namespace(to_type)
+        end
+      end
 
-          associations&.values&.reverse&.each do |entity_type|
-            next if entity_type.sensitive?
-            next unless entity_type.has_sensitive_types?
+      def create_all_association_types_in_current_namespace(type)
+        associations = Foobara::DetachedEntity.construct_deep_associations(type)
 
-            declaration = entity_type.declaration_data
-            sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
+        associations&.values&.reverse&.each do |entity_type|
+          next if entity_type.sensitive?
+          next unless entity_type.has_sensitive_types?
 
-            # We want to make sure that any types that change due to having sensitive types
-            # has a corresponding registered type in the command registry domain if needed
-            # TODO: this all feels so messy and brittle.
-            Domain.current.foobara_type_from_declaration(sanitized_type_declaration)
-          end
+          declaration = entity_type.declaration_data
+          sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
+
+          # We want to make sure that any types that change due to having sensitive types
+          # has a corresponding registered type in the command registry domain if needed
+          # TODO: this all feels so messy and brittle.
+          Domain.current.foobara_type_from_declaration(sanitized_type_declaration)
         end
       end
 
@@ -26,6 +36,10 @@ module Foobara
         TypeDeclarations.remove_sensitive_types(from_type.declaration_data)
       end
 
+      def from_type_declaration
+        TypeDeclarations.remove_sensitive_types(to_type.declaration_data)
+      end
+
       def transform(_value)
         # :nocov:
         raise "subclass responsibility"

data/projects/type_declarations/src/typed_transformer.rb

@@ -73,7 +73,7 @@ module Foobara
           self.to to
         end
 
-        # we want to force these to be created now in the current name space if they are declarations
+        # we want to force these to be created now in the current namespace if they are declarations
         from_type
         to_type
       end

data/projects/value/src/processor.rb

@@ -324,6 +324,12 @@ module Foobara
       def foobara_manifest
         to_include = TypeDeclarations.foobara_manifest_context_to_include
 
+        unless scoped_path_set?
+          if self.class.scoped_path_set?
+            self.scoped_path = self.class.scoped_path
+          end
+        end
+
         possible_errors = self.possible_errors.map do |possible_error|
           [possible_error.key.to_s, possible_error.foobara_manifest]
         end

data/projects/weak_object_set/src/weak_object_set.rb

@@ -1,52 +1,98 @@
+require "monitor"
+
 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
-      def initialize(objects, key_to_object_id = nil, object_id_to_key = nil)
-        @objects = objects
-        @key_to_object_id = key_to_object_id
-        @object_id_to_key = object_id_to_key
-      end
+      attr_accessor :weak_object_set, :deactivated, :queue, :cleanup_thread
 
-      def cleanup_proc
-        @cleanup_proc ||= ->(object_id) {
-          unless @deactivated
-            @objects.delete(object_id)
+      def initialize(weak_object_set, queue)
+        self.queue = queue
+        self.weak_object_set = weak_object_set
 
-            key = @object_id_to_key&.delete(object_id)
+        start_cleanup_thread
+      end
 
-            if key
-              @key_to_object_id.delete(key)
+      def cleanup_proc
+        @cleanup_proc ||= begin
+          queue = self.queue
+
+          ->(object_id) do
+            unless deactivated?
+              begin
+                queue.push(object_id)
+              rescue ClosedQueueError
+                # :nocov:
+                deactivate
+                # :nocov:
+              end
             end
           end
-        }
+        end
       end
 
-      def track(object)
-        if @deactivated
-          # :nocov:
-          raise "Cannot track anymore objects since we have been deactivated"
-          # :nocov:
+      def start_cleanup_thread
+        self.cleanup_thread = Thread.new do
+          loop do
+            object_id = queue.pop
+            if object_id
+              weak_object_set.delete(object_id)
+            elsif queue.closed?
+              self.queue = nil
+              break
+            else
+              # :nocov:
+              raise "Unexpected nil value in the queue"
+              # :nocov:
+            end
+          end
         end
+      end
 
+      def track(object)
         ObjectSpace.define_finalizer(object, cleanup_proc)
       end
 
       def deactivate
-        @deactivated = true
+        self.deactivated = true
+        queue.close
+        cleanup_thread.join # just doing this for test suite/simplecov
+      end
+
+      def deactivated?
+        deactivated
       end
     end
 
     include Enumerable
 
+    attr_accessor :monitor, :key_method, :key_to_object_id, :object_id_to_key, :objects
+    attr_writer :garbage_cleaner
+
     def initialize(key_method = nil)
-      @key_method = key_method
+      self.key_method = key_method
+      self.monitor = Monitor.new
+      clear
     end
 
     def [](object_or_object_id)
-      ref = ref_for(object_or_object_id)
+      monitor.synchronize do
+        ref = ref_for(object_or_object_id)
 
-      if ref&.weakref_alive?
-        ref.__getobj__
+        object = begin
+          ref&.__getobj__
+        rescue WeakRef::RefError
+          # :nocov:
+          nil
+          # :nocov:
+        end
+
+        if ref&.weakref_alive?
+          object
+        end
       end
     end
 
@@ -61,121 +107,146 @@ module Foobara
     end
 
     def each
-      objects.each_value do |ref|
-        if ref.weakref_alive?
-          yield ref.__getobj__
+      monitor.synchronize do
+        objects.each_value do |ref|
+          object = begin
+            ref.__getobj__
+          rescue WeakRef::RefError
+            nil
+          end
+
+          if ref.weakref_alive?
+            yield object
+          end
         end
       end
     end
 
-    def objects
-      @objects ||= {}
-    end
-
     def size
       count
     end
 
     def empty?
-      objects.empty? || objects.values.none?(&:weakref_alive?)
+      monitor.synchronize do
+        objects.empty? || objects.values.none?(&:weakref_alive?)
+      end
     end
 
-    def key_to_object_id
-      @key_to_object_id ||= {}
-    end
+    def garbage_cleaner
+      @garbage_cleaner ||= begin
+        queue = Queue.new
 
-    def object_id_to_key
-      @object_id_to_key ||= {}
-    end
+        gc = GarbageCleaner.new(self, queue)
 
-    def garbage_cleaner
-      @garbage_cleaner ||= if @key_method
-                             GarbageCleaner.new(objects, key_to_object_id, object_id_to_key)
-                           else
-                             GarbageCleaner.new(objects)
-                           end
+        ObjectSpace.define_finalizer gc do
+          # :nocov:
+          queue.close
+          # :nocov:
+        end
+
+        gc
+      end
     end
 
     def <<(object)
       object_id = object.object_id
 
-      if include?(object)
-        if @key_method
-          key = object.send(@key_method)
-          old_key = object_id_to_key[object_id]
+      monitor.synchronize do
+        existing_object = self[object_id]
+
+        if existing_object
+          if key_method
+            key = object.send(key_method)
+            old_key = object_id_to_key[object_id]
 
-          if key != old_key
-            key_to_object_id.delete(old_key)
+            if key != old_key
+              key_to_object_id.delete(old_key)
+
+              if key
+                key_to_object_id[key] = object_id
+                object_id_to_key[object_id] = key
+              else
+                object_id_to_key.delete(object_id)
+              end
+            end
+          end
+        else
+          garbage_cleaner.track(object)
+
+          if key_method
+            key = object.send(key_method)
 
             if key
+              existing_record_object_id = key_to_object_id[key]
+
+              if existing_record_object_id
+                # Sometimes this path is hit in the test suite and sometimes not, depending on
+                # non-deterministic behavior of the garbage collector
+                # :nocov:
+                delete(existing_record_object_id)
+                # :nocov:
+              end
+
               key_to_object_id[key] = object_id
               object_id_to_key[object_id] = key
-            else
-              object_id_to_key.delete(object_id)
             end
           end
-        end
-      else
-        garbage_cleaner.track(object)
-
-        objects[object_id] = WeakRef.new(object)
 
-        if @key_method
-          key = object.send(@key_method)
+          objects[object_id] = WeakRef.new(object)
 
-          if key
-            key_to_object_id[key] = object_id
-            object_id_to_key[object_id] = key
-          end
+          object
         end
-
-        object
       end
     end
 
-    def include?(object_or_object_id)
-      ref_for(object_or_object_id)&.weakref_alive?
-    end
+    def delete(object_or_object_id)
+      object_id = if object_or_object_id.is_a?(::Integer)
+                    object_or_object_id
+                  else
+                    object_or_object_id.object_id
+                  end
 
-    def delete(object)
-      if @key_method
-        key = @object_id_to_key&.delete(object.object_id)
+      monitor.synchronize do
+        if key_method
+          key = object_id_to_key.delete(object_id)
 
-        if key
-          @key_to_object_id.delete(key)
+          if key
+            key_to_object_id.delete(key)
+          end
         end
-      end
-
-      objects.delete(object)
-    end
 
-    def include_key?(key)
-      unless @key_method
-        # :nocov:
-        raise "Cannot check by key if there was no key_method given."
-        # :nocov:
+        objects.delete(object_id)
       end
-
-      objects[key_to_object_id[key]]&.weakref_alive?
     end
 
     def find_by_key(key)
-      unless @key_method
-        # :nocov:
-        raise "Cannot find by key if there was no key_method given."
-        # :nocov:
-      end
+      monitor.synchronize do
+        unless key_method
+          # :nocov:
+          raise "Cannot find by key if there was no key_method given."
+          # :nocov:
+        end
 
-      object = objects[key_to_object_id[key]]
+        object_id = key_to_object_id[key]
 
-      if object&.weakref_alive?
-        object.__getobj__
+        if object_id
+          self[object_id]
+        end
       end
     end
 
     def clear
-      @garbage_cleaner&.deactivate
-      @key_to_object_id = @object_id_to_key = @objects = @garbage_cleaner = nil
+      monitor.synchronize do
+        garbage_cleaner.deactivate
+
+        self.garbage_cleaner = nil
+        self.objects = {}
+
+        if key_method
+          self.key_to_object_id = {}
+          self.object_id_to_key = {}
+        end
+      end
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.119
+  version: 0.0.120
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-05-08 00:00:00.000000000 Z
+date: 2025-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -396,6 +396,7 @@ files:
 - projects/state_machine/src/validations.rb
 - projects/type_declarations/lib/foobara/type_declarations.rb
 - projects/type_declarations/src/attributes.rb
+- projects/type_declarations/src/attributes_transformers.rb
 - projects/type_declarations/src/attributes_transformers/only.rb
 - projects/type_declarations/src/attributes_transformers/reject.rb
 - projects/type_declarations/src/caster.rb