foobara 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e4070c29eb1592791d290da7b5f142d7439d9c2df2164bdaa5567e15e32ae0f
-  data.tar.gz: 8162d30f3f304115550cdceeca48b678e086e092e36e1ef4e9fe847cbfa85b44
+  metadata.gz: 1261fd639b27af7af53e6a9be2225216d27ac77a83bddf4d78d645102473bff6
+  data.tar.gz: 8d1c16370a2adfdbd9eb47126d1ab830b502c2b7dfa885ed9099d0851a9bcd60
 SHA512:
-  metadata.gz: c5aa9b51a1897a8286e99c0abe82e329d9c2b5610fabca460f3058241d33e2b821b166202ac2da74ab3e41cd5cc56a1982535013be38e77d10103d44e637d277
-  data.tar.gz: 7869e4a448079699c99f5ed20c61ec30f17637eed0a033637c7a31a105b89a3032a39d8c600c8eba2a2ceca56586fd9bc77a93fa1bfb6ac3aabb851beda493ad
+  metadata.gz: b5a6ef53e71864b9d756447f8eaae461e798d243c23121e041a12a6e0c4ecaa87b624c593d185549b2714569b965913447fa747e5df7922d8a538d1a60061b94
+  data.tar.gz: 5a45569f70560c505b4c61a44fc91a0145e9d362c1f07ecacc2fb7cdbc3bbf12b9bc1f35ea51996f6138d060ed09b236483ed88fe12886609d3e241624db451a

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.1.13] - 2025-09-27
+
+- Fix various bugs resulting in values missing from connector manifest or included when they should not be
+- Type creation performance improvements
+- Fix bugs revolving around incorreclty making use of unregistered types
+- Fix bug with deleting entries from an AmbiguousRegistry
+
 # [0.1.12] - 2025-09-24
 
 - Fix bug where a hard-deleted, non-persisted record cannot be cast

data/projects/builtin_types/src/builtin_types.rb

@@ -90,8 +90,7 @@ module Foobara
 
         # TODO: really need to encapsulate this somehow...
         type.type_symbol = type_symbol
-        type.foobara_parent_namespace ||= GlobalDomain
-        type.foobara_parent_namespace.foobara_register(type)
+        (type.foobara_parent_namespace || GlobalDomain).foobara_register(type)
 
         supported_casters_module = Util.constant_value(builtin_type_module, :SupportedCasters)
         supported_caster_classes = if supported_casters_module
@@ -151,7 +150,6 @@ module Foobara
             parent = scoped.scoped_namespace
 
             if parent.nil? || parent == Foobara || parent == Namespace.global || parent == GlobalDomain
-              scoped.foobara_parent_namespace = type
               type.foobara_register(scoped)
             end
           end

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

@@ -48,6 +48,16 @@ module Foobara
           def full_command_symbol
             @full_command_symbol ||= Util.underscore_sym(full_command_name)
           end
+
+          def handle_reregistered_types!
+            if inputs_type
+              inputs inputs_type.reference_or_declaration_data
+            end
+
+            if result_type
+              result result_type.reference_or_declaration_data
+            end
+          end
         end
 
         foobara_delegate :type_for_declaration, to: :class

data/projects/command_connectors/src/command_connector.rb

@@ -504,11 +504,12 @@ module Foobara
       to_include << command_registry.global_organization
       to_include << command_registry.global_domain
 
-      command_registry.foobara_each(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) do |exposed_whatever|
-        to_include << exposed_whatever
+      command_registry.foobara_each_command(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) do |exposed_command|
+        to_include << exposed_command
       end
 
       included = Set.new
+
       additional_to_include = Set.new
 
       h = {
@@ -551,23 +552,22 @@ module Foobara
                         "Make sure these are not included."
                 # :nocov:
                 else
+
                   mode = Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
                   domain_name = o.foobara_domain.scoped_full_name
 
                   exposed_domain = command_registry.foobara_lookup_domain(domain_name, mode:)
 
-                  unless exposed_domain
-                    exposed_domain = command_registry.build_and_register_exposed_domain(domain_name)
+                  exposed_domain ||= 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(mode:).each do |exposed_domain|
-                      additional_to_include << exposed_domain
-                    end
+                  # 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(mode:).each do |exposed_domain|
+                    additional_to_include << exposed_domain
+                  end
 
-                    command_registry.foobara_all_organization(mode:).each do |exposed_organization|
-                      additional_to_include << exposed_organization
-                    end
+                  command_registry.foobara_all_organization(mode:).each do |exposed_organization|
+                    additional_to_include << exposed_organization
                   end
                 end
               end

data/projects/command_connectors/src/command_registry/exposed_command.rb

@@ -17,8 +17,7 @@ module Foobara
                     :allowed_rule,
                     :requires_authentication,
                     :authenticator,
-                    :scoped_path,
-                    :scoped_namespace
+                    :scoped_path
 
       def initialize(
         command_class,

data/projects/command_connectors/src/command_registry.rb

@@ -94,7 +94,6 @@ module Foobara
       exposed_domain.foobara_depends_on domain_module
 
       exposed_organization.foobara_register(exposed_domain)
-      exposed_domain.foobara_parent_namespace = exposed_organization
 
       domain_module.foobara_depends_on.each do |domain_name|
         # TODO: test this code path!!
@@ -135,7 +134,6 @@ module Foobara
       exposed_organization.unexposed_organization = org
 
       foobara_register(exposed_organization)
-      exposed_organization.foobara_parent_namespace = self
 
       exposed_organization
     end

data/projects/domain/src/domain_module_extension.rb

@@ -264,18 +264,54 @@ module Foobara
                    foobara_type_from_declaration(*type_declaration_bits, &block)
                  end
 
-          if type_symbol.is_a?(::Array)
-            type.scoped_path = type_symbol
-            type.type_symbol = type_symbol.join("::")
+          new_scoped_path, new_type_symbol = if type_symbol.is_a?(::Array)
+                                               [type_symbol, type_symbol.join("::").to_sym]
+                                             else
+                                               type_symbol = type_symbol.to_s if type_symbol.is_a?(::Symbol)
+
+                                               [type_symbol.split("::"), type_symbol.to_sym]
+                                             end
+
+          if type.scoped_path_set? && type.registered? && foobara_registered?(type, mode: Namespace::LookupMode::DIRECT)
+            old_symbol = type.type_symbol
+            old_type = foobara_lookup_type(old_symbol, mode: Namespace::LookupMode::DIRECT)
+
+            if old_symbol != new_type_symbol
+              foobara_unregister(type)
+
+              type.scoped_path = new_scoped_path
+              type.type_symbol = new_type_symbol
+
+              foobara_register(type)
+              # :nocov:
+            elsif old_type != type
+              # TODO: delete this check if it's not really helping
+
+              raise "Didn't expect to find an old type"
+              # :nocov:
+            end
           else
-            type_symbol = type_symbol.to_s if type_symbol.is_a?(::Symbol)
+            type.scoped_path = new_scoped_path
+            type.type_symbol = new_type_symbol
 
-            type.scoped_path = type_symbol.split("::")
-            type.type_symbol = type_symbol.to_sym
-          end
+            old_type = foobara_lookup_type(new_type_symbol, mode: Namespace::LookupMode::DIRECT)
 
-          type.foobara_parent_namespace ||= self
-          foobara_register(type)
+            if old_type && old_type != type
+              # TODO: delete this check if it's not really helping
+              # :nocov:
+              raise "Didn't expect to find an old type"
+              # :nocov:
+            end
+
+            if foobara_registered?(type, mode: Namespace::LookupMode::DIRECT)
+              # TODO: delete this check if it's not really helping
+              # :nocov:
+              raise "Already registered: #{type.inspect}"
+              # :nocov:
+            end
+
+            foobara_register(type)
+          end
 
           _set_type_constant(type)
 
@@ -299,7 +335,6 @@ module Foobara
           end
 
           foobara_register(type)
-          type.foobara_parent_namespace = self
 
           type.target_class
         end

data/projects/domain/src/global_domain.rb

@@ -3,7 +3,6 @@ require_relative "global_organization"
 module Foobara
   module GlobalDomain
     foobara_namespace!(scoped_path: [])
-    self.foobara_parent_namespace = GlobalOrganization
     GlobalOrganization.foobara_register(self)
 
     foobara_domain!

data/projects/domain/src/global_organization.rb

@@ -3,8 +3,7 @@ require_relative "module_extension"
 module Foobara
   module GlobalOrganization
     foobara_namespace!(scoped_path: [])
-    self.foobara_parent_namespace = Namespace.global
-    foobara_parent_namespace.foobara_register(self)
+    Namespace.global.foobara_register(self)
 
     foobara_organization!
     self.foobara_manifest_reference = self.foobara_organization_name = "global_organization"

data/projects/domain/src/module_extension.rb

@@ -20,10 +20,7 @@ module Foobara
           foobara_autoset_namespace!(default_namespace: Foobara::GlobalOrganization)
           foobara_autoset_scoped_path!
 
-          # TODO: wow this is awkward. We should find a cleaner way to set children on namespaces.
-          parent = foobara_parent_namespace
-          parent.foobara_register(self)
-          self.foobara_parent_namespace = parent
+          foobara_parent_namespace.foobara_register(self)
         end
 
         include(DomainModuleExtension)
@@ -99,10 +96,7 @@ module Foobara
           self.scoped_namespace = Namespace.global
           foobara_autoset_scoped_path!(make_top_level: true)
 
-          # TODO: wow this is awkward. We should find a cleaner way to set children on namespaces.
-          parent = foobara_parent_namespace
-          parent.foobara_register(self)
-          self.foobara_parent_namespace = parent
+          foobara_parent_namespace.foobara_register(self)
         end
       end
 

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

@@ -98,15 +98,26 @@ module Foobara
                   domain = root_namespace.foobara_lookup_domain(domain_name)
 
                   type_symbol = type.declaration_data[:name]
-                  type.type_symbol = type_symbol.to_sym
-
-                  model_class.description type.declaration_data[:description]
 
                   if domain.foobara_type_registered?(type_symbol, mode: Namespace::LookupMode::DIRECT)
                     existing_type = domain.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::DIRECT)
+
+                    if existing_type.created_in_namespace == type.created_in_namespace &&
+                       existing_type.type_symbol == type_symbol.to_sym &&
+                       existing_type.declaration_data == type.declaration_data
+                      # There's nothing different about this new model type. Let's just return the old one
+                      # to reduce burdens on clearing caches.
+                      existing_type.clear_caches
+                      return Outcome.success(existing_type)
+                    end
+
                     domain.foobara_unregister(existing_type)
                   end
 
+                  type.type_symbol = type_symbol.to_sym
+
+                  model_class.description type.declaration_data[:description]
+
                   domain.foobara_register_model(model_class)
 
                   if type.declaration_data[:delegates]

data/projects/namespace/src/ambiguous_registry.rb

@@ -21,15 +21,7 @@ module Foobara
           # :nocov:
         end
 
-        registered = lookup([short_name])
-
-        unless registered
-          # :nocov:
-          raise NotRegisteredError, "Not registered: #{short_name.inspect}"
-          # :nocov:
-        end
-
-        unless entry.delete(registered)
+        unless entry.delete(scoped)
           # :nocov:
           raise NotRegisteredError, "Not registered: #{short_name.inspect}"
           # :nocov:

data/projects/namespace/src/is_namespace.rb

@@ -3,18 +3,6 @@ require_relative "scoped"
 module Foobara
   class Namespace
     module IsNamespace
-      class << self
-        def lru_cache
-          @lru_cache ||= Foobara::LruCache.new(200)
-        end
-
-        def clear_lru_cache!
-          if @lru_cache
-            lru_cache.reset!
-          end
-        end
-      end
-
       include Scoped
 
       def scoped_clear_caches
@@ -35,7 +23,16 @@ module Foobara
 
       def foobara_parent_namespace=(namespace)
         self.scoped_namespace = namespace
-        scoped_namespace.foobara_children << self if namespace
+
+        if namespace
+          if namespace.foobara_children.include?(self)
+            # :nocov:
+            raise "Already registered on parent"
+            # :nocov:
+          end
+
+          namespace.foobara_children << self
+        end
       end
 
       def foobara_add_category(symbol, &block)
@@ -102,13 +99,24 @@ module Foobara
 
       # TODO: make this thread-safe
       def foobara_register(scoped)
+        if scoped.scoped_unregistered?
+          scoped.scoped_reregistering!
+        end
+
         foobara_registry.register(scoped)
 
+        if scoped.is_a?(Namespace::IsNamespace)
+          scoped.foobara_parent_namespace = self
+        else
+          scoped.scoped_namespace = self
+        end
+
         # TODO: do we really need to clear the whole cache? Why not just the possible
         # impacted keys based on scoped.scoped_path ?
-        IsNamespace.clear_lru_cache!
-        # awkward??
-        scoped.scoped_namespace = self
+        Namespace.clear_lru_cache!
+        if scoped.unregistered_foobara_manifest_reference
+          scoped.unregistered_foobara_manifest_reference = nil
+        end
 
         if scoped.respond_to?(:foobara_on_register)
           scoped.foobara_on_register
@@ -124,9 +132,13 @@ module Foobara
 
         foobara_registry.unregister(scoped)
         foobara_children.delete(scoped)
+
+        scoped.unregistered_foobara_manifest_reference = scoped.foobara_manifest_reference
+
         scoped.scoped_namespace = nil
+        scoped.scoped_unregistered!
 
-        IsNamespace.clear_lru_cache!
+        Namespace.clear_lru_cache!
       end
 
       def foobara_unregister_all
@@ -136,7 +148,7 @@ module Foobara
       end
 
       def lru_cache
-        IsNamespace.lru_cache
+        Namespace.lru_cache
       end
 
       def foobara_lookup(path, filter: nil, mode: LookupMode::GENERAL)

data/projects/namespace/src/namespace.rb

@@ -49,6 +49,16 @@ module Foobara
           # :nocov:
         end
       end
+
+      def lru_cache
+        @lru_cache ||= Foobara::LruCache.new(1000)
+      end
+
+      def clear_lru_cache!
+        if @lru_cache
+          lru_cache.reset!
+        end
+      end
     end
 
     class NotFoundError < StandardError; end

data/projects/namespace/src/namespace_helpers.rb

@@ -47,13 +47,7 @@ module Foobara
             NamespaceHelpers.foobara_autoset_namespace(subclass, default_namespace: scoped_default_namespace)
             NamespaceHelpers.foobara_autoset_scoped_path(subclass)
 
-            if subclass.scoped_namespace
-              if subclass.is_a?(Foobara::Namespace::IsNamespace)
-                subclass.foobara_parent_namespace = subclass.scoped_namespace
-              end
-
-              subclass.scoped_namespace.foobara_register(subclass)
-            end
+            subclass.scoped_namespace&.foobara_register(subclass)
           end
         end
       end
@@ -262,11 +256,6 @@ module Foobara
 
                 mod.foobara_register(scoped)
 
-                if scoped.is_a?(Namespace::IsNamespace)
-                  scoped.foobara_parent_namespace = mod
-                else
-                  scoped.scoped_namespace = mod
-                end
               end
             end
           end

data/projects/namespace/src/scoped.rb

@@ -3,8 +3,16 @@ module Foobara
     class NoScopedPathSetError < StandardError; end
 
     attr_reader :scoped_namespace
+    attr_accessor :unregistered_foobara_manifest_reference
 
     def scoped_path
+      if scoped_unregistered?
+        # TODO: can probably delete this defensive check
+        # :nocov:
+        raise "Cannot use unregistered Scoped object"
+        # :nocov:
+      end
+
       unless defined?(@scoped_path)
         # :nocov:
         raise NoScopedPathSetError, "No scoped path set. Explicitly set it to nil if that's what you want."
@@ -22,11 +30,13 @@ module Foobara
 
     def scoped_clear_caches
       [
-        "@scoped_absolute_name",
-        "@scoped_name",
-        "@scoped_prefix",
-        "@scoped_full_name",
-        "@scoped_full_path"
+        :@scoped_absolute_name,
+        :@scoped_name,
+        :@scoped_prefix,
+        :@scoped_full_name,
+        :@scoped_full_path,
+        :@scoped_short_name,
+        :@scoped_short_path
       ].each do |variable|
         remove_instance_variable(variable) if instance_variable_defined?(variable)
       end
@@ -78,6 +88,13 @@ module Foobara
     attr_writer :foobara_manifest_reference
 
     def foobara_manifest_reference
+      if scoped_unregistered?
+        # TODO: can probably delete this defensive check
+        # :nocov:
+        raise "Cannot use unregistered Scoped object"
+        # :nocov:
+      end
+
       @foobara_manifest_reference ||= scoped_full_name
     end
 
@@ -109,5 +126,17 @@ module Foobara
     def scoped_category
       @scoped_category ||= Namespace.global.foobara_category_symbol_for(self)
     end
+
+    def scoped_unregistered!
+      @scoped_unregistered = true
+    end
+
+    def scoped_unregistered?
+      @scoped_unregistered
+    end
+
+    def scoped_reregistering!
+      @scoped_unregistered = nil
+    end
   end
 end

data/projects/type_declarations/lib/foobara/type_declarations.rb

@@ -59,7 +59,6 @@ module Foobara
           Namespace.global.foobara_children << child
         end
 
-        GlobalDomain.foobara_parent_namespace = GlobalOrganization
         GlobalOrganization.foobara_register(GlobalDomain)
 
         register_type_declaration(Handlers::RegisteredTypeDeclaration.new)

data/projects/type_declarations/src/attributes_transformers/from_yaml.rb

@@ -18,7 +18,6 @@ module Foobara
         transformer_class.from_yaml_attributes = attribute_names
 
         Namespace::NamespaceHelpers.foobara_autoset_scoped_path(transformer_class, set_namespace: true)
-        transformer_class.foobara_parent_namespace = transformer_class.scoped_namespace
         transformer_class.scoped_namespace.foobara_register(transformer_class)
 
         transformer_class

data/projects/type_declarations/src/attributes_transformers/only.rb

@@ -19,7 +19,6 @@ module Foobara
         transformer_class.only_attributes = attribute_names
 
         Namespace::NamespaceHelpers.foobara_autoset_scoped_path(transformer_class, set_namespace: true)
-        transformer_class.foobara_parent_namespace = transformer_class.scoped_namespace
         transformer_class.scoped_namespace.foobara_register(transformer_class)
 
         transformer_class

data/projects/type_declarations/src/attributes_transformers/reject.rb

@@ -17,7 +17,6 @@ module Foobara
         transformer_class.reject_attributes = attribute_names
 
         Namespace::NamespaceHelpers.foobara_autoset_scoped_path(transformer_class, set_namespace: true)
-        transformer_class.foobara_parent_namespace = transformer_class.scoped_namespace
         transformer_class.scoped_namespace.foobara_register(transformer_class)
 
         transformer_class

data/projects/type_declarations/src/remove_sensitive_values_transformer.rb

@@ -16,19 +16,49 @@ module Foobara
       end
 
       def create_all_association_types_in_current_namespace(type)
+        already_sanitized = Set.new
+
         associations = Foobara::DetachedEntity.construct_deep_associations(type)
 
         associations&.values&.reverse&.each do |entity_type|
+          next if already_sanitized.include?(entity_type)
+
           next if entity_type.sensitive?
-          next unless entity_type.has_sensitive_types?
+
+          unless entity_type.has_sensitive_types?
+            already_sanitized << entity_type
+            next
+          end
+
+          ns = Namespace.current
 
           declaration = entity_type.declaration_data
           sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
 
+          existing_type = ns.foobara_lookup(
+            entity_type.full_type_symbol,
+            mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+          )
+
+          if existing_type
+            if existing_type.declaration_data == sanitized_type_declaration
+              already_sanitized << entity_type
+              already_sanitized << existing_type
+              next
+            else
+              # :nocov:
+              raise "Did not expect to be re-sanitizing #{entity_type.full_type_symbol}"
+              # :nocov:
+            end
+
+          end
+
           # 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)
+
+          already_sanitized << entity_type
         end
       end
 

data/projects/type_declarations/src/type_builder.rb

@@ -155,7 +155,7 @@ module Foobara
       private
 
       def lru_cache
-        Namespace::IsNamespace.lru_cache
+        Namespace.lru_cache
       end
     end
   end

data/projects/types/src/type.rb

@@ -481,7 +481,11 @@ module Foobara
 
         if registered?
           # TODO: we should just use the symbol and nothing else in this context instead of a hash with 1 element.
-          foobara_manifest_reference.to_sym
+          if scoped_unregistered?
+            unregistered_foobara_manifest_reference.to_sym
+          else
+            foobara_manifest_reference.to_sym
+          end
         elsif remove_sensitive
           TypeDeclarations.remove_sensitive_types(declaration_data)
         else

data/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Miles Georgi