foobara 0.0.91 → 0.0.93

data/projects/namespace/src/is_namespace.rb

@@ -98,28 +98,29 @@ module Foobara
         path,
         filter: nil,
         mode: LookupMode::GENERAL,
-        visited: Set.new
+        visited: Set.new,
+        initial: true
       )
-        visited_key = [path, mode, self]
+        path = Namespace.to_registry_path(path)
+        visited_key = [path, mode, initial, self]
         return nil if visited.include?(visited_key)
 
         visited << visited_key
 
         LookupMode.validate!(mode)
 
-        path = Namespace.to_registry_path(path)
-
         if mode == LookupMode::RELAXED
           scoped = foobara_lookup(
             path,
             filter:,
             mode: LookupMode::GENERAL,
-            visited:
+            visited:,
+            initial: false
           )
           return scoped if scoped
 
           candidates = foobara_children.map do |namespace|
-            namespace.foobara_lookup(path, filter:, mode:, visited:)
+            namespace.foobara_lookup(path, filter:, mode:, visited:, initial: false)
           end.compact
 
           if candidates.size > 1
@@ -129,7 +130,8 @@ module Foobara
             # :nocov:
           end
 
-          return candidates.first || foobara_parent_namespace&.foobara_lookup(path, filter:, mode:, visited:)
+          return candidates.first ||
+                 foobara_parent_namespace&.foobara_lookup(path, filter:, mode:, visited:, initial: false)
         end
 
         if path[0] == ""
@@ -141,7 +143,7 @@ module Foobara
             path = path[(foobara_root_namespace.scoped_path.size + 1)..]
           end
 
-          return foobara_root_namespace.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE)
+          return foobara_root_namespace.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE, initial: true)
         end
 
         partial = foobara_registry.lookup(path, filter)
@@ -166,12 +168,16 @@ module Foobara
         return scoped if scoped
 
         if [LookupMode::GENERAL, LookupMode::STRICT].include?(mode) && foobara_parent_namespace
-          scoped = foobara_parent_namespace.foobara_lookup(path, filter:, mode: LookupMode::STRICT, visited:)
+          scoped = foobara_parent_namespace.foobara_lookup(
+            path, filter:, mode: LookupMode::STRICT, visited:, initial: false
+          )
           return scoped if scoped
         end
 
-        scoped = _lookup_in(path, foobara_depends_on_namespaces, filter:, visited:)
-        return scoped if scoped
+        if mode == LookupMode::GENERAL
+          scoped = _lookup_in(path, foobara_depends_on_namespaces, filter:, visited:)
+          return scoped if scoped
+        end
 
         to_consider = case mode
                       when LookupMode::GENERAL
@@ -181,7 +187,7 @@ module Foobara
                       end
 
         candidates = to_consider.map do |namespace|
-          namespace.foobara_lookup(path, filter:, mode:, visited:)
+          namespace.foobara_lookup(path, filter:, mode:, visited:, initial: false)
         end.compact
 
         if candidates.size > 1
@@ -190,7 +196,19 @@ module Foobara
           # :nocov:
         end
 
-        candidates.first || partial
+        scoped = candidates.first || partial
+        return scoped if scoped
+
+        # As a last resort we'll see if we're trying to fetch a builtin type from a different namespace
+        # TODO: these lookup modes are really confusing and were designed prior to having multiple root
+        # namespaces playing a role in command connectors.
+        if initial
+          scoped = Namespace.global.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE, visited:, initial: false)
+
+          if scoped.is_a?(Types::Type) && scoped.builtin?
+            scoped
+          end
+        end
       end
 
       def foobara_parent_namespace
@@ -330,14 +348,15 @@ module Foobara
             path[matching_child_score..],
             mode: LookupMode::ABSOLUTE,
             filter:,
-            visited:
+            visited:,
+            initial: false
           )
 
           return scoped if scoped
         end
 
         last_resort.uniq.each do |namespace|
-          scoped = namespace.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE, visited:)
+          scoped = namespace.foobara_lookup(path, filter:, mode: LookupMode::ABSOLUTE, visited:, initial: false)
           return scoped if scoped
         end
 

data/projects/persistence/src/entity_attributes_crud_driver.rb

@@ -155,7 +155,31 @@ module Foobara
         end
 
         def matches_attributes_filter?(attributes, attributes_filter)
-          attributes_filter.all? { |attribute_name, value| attributes[attribute_name] == value }
+          attributes_filter.all? do |attribute_name_or_path, value|
+            type = nil
+
+            if attribute_name_or_path.is_a?(::Array)
+              values = DataPath.values_at(attribute_name_or_path, attributes)
+
+              if values.include?(value)
+                true
+              else
+                type ||= entity_class.model_type.type_at_path(attribute_name_or_path)
+                if type.extends?(:detached_entity)
+                  values.any? do |v|
+                    value.primary_key == v
+                  end
+                end
+              end
+            elsif attributes[attribute_name_or_path] == value
+              true
+            else
+              type ||= entity_class.model_type.type_at_path(attribute_name_or_path)
+              if type.extends?(:detached_entity)
+                value.primary_key == attributes[attribute_name_or_path]
+              end
+            end
+          end
         end
 
         def insert(_attributes)

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

@@ -225,8 +225,8 @@ module Foobara
           find_by(attribute_name => value)
         end
 
-        def find_all_by_attribute(attribute_name, value)
-          find_many_by(attribute_name => value)
+        def find_all_by_attribute(attribute_name_or_path, value)
+          find_many_by(attribute_name_or_path => value)
         end
 
         def find_by_attribute_containing(attribute_name, value)
@@ -283,13 +283,38 @@ module Foobara
 
         def find_many_by(attributes_filter)
           find_by_type = entity_class.domain.foobara_type_from_declaration(entity_class.attributes_for_find_by)
-          attributes_filter = find_by_type.process_value!(attributes_filter)
+
+          path_filters = {}
+          regular_filters = {}
+
+          attributes_filter.each_pair do |attribute_name_or_path, value|
+            case attribute_name_or_path
+            when ::Symbol, ::String
+              regular_filters[attribute_name_or_path] = value
+            when ::Array, Value::DataPath
+              path_filters[attribute_name_or_path] = value
+            else
+              # :nocov:
+              raise "Unexpected filter type: #{attribute_name_or_path.class}"
+              # :nocov:
+            end
+          end
+
+          regular_filters = find_by_type.process_value!(regular_filters)
+
+          path_filters.keys.each do |path|
+            type = entity_class.deep_associations[DataPath.for(path).to_s]
+            path_filters[path] = type.process_value!(path_filters[path])
+          end
+
+          attributes_filter = regular_filters.merge(path_filters)
 
           yielded_ids = Set.new
 
           Enumerator.new do |yielder|
             tracked_records.each do |record|
               next if hard_deleted?(record)
+              next unless record.loaded? || record.built? || record.created?
 
               if entity_attributes_crud_driver_table.matches_attributes_filter?(record.attributes, attributes_filter)
                 yielded_ids << record.primary_key

data/projects/type_declarations/src/desugarizer.rb

@@ -10,7 +10,7 @@ module Foobara
           false
         end
 
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
           # :nocov:
           super.merge(processor_type: :desugarizer)
           # :nocov:

data/projects/type_declarations/src/remove_sensitive_values_transformer.rb

@@ -8,9 +8,15 @@ module Foobara
           associations = Foobara::DetachedEntity.construct_deep_associations(from_type)
 
           associations&.values&.reverse&.each do |entity_type|
+            next if entity_type.sensitive?
+            next unless entity_type.has_sensitive_types?
+
             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

data/projects/type_declarations/src/type_builder.rb

@@ -2,6 +2,46 @@ require "foobara/lru_cache"
 
 module Foobara
   module TypeDeclarations
+    class << self
+      # TODO: relocate these to a different file
+      def args_to_type_declaration(*args, &block)
+        if block
+          unless args.empty?
+            # :nocov:
+            raise ArgumentError, "Cannot provide both block and declaration"
+            # :nocov:
+          end
+
+          block
+        else
+          case args.size
+          when 0
+            # :nocov:
+            raise ArgumentError, "expected 1 argument or a block but got 0 arguments and no block"
+            # :nocov:
+          when 1
+            args.first
+          else
+            type, *symbolic_processors, processor_data = args
+
+            if !symbolic_processors.empty?
+              symbolic_processors = symbolic_processors.to_h { |symbol| [symbol, true] }
+
+              if processor_data.is_a?(::Hash) && !processor_data.empty?
+                processor_data.merge(symbolic_processors)
+              else
+                symbolic_processors
+              end
+            elsif processor_data.is_a?(::Hash)
+              processor_data
+            else
+              { processor_data.to_sym => true }
+            end.merge(type:)
+          end
+        end
+      end
+    end
+
     class TypeBuilder
       class NoTypeDeclarationHandlerFoundError < StandardError; end
 
@@ -70,27 +110,8 @@ module Foobara
         end
       end
 
-      def type_for_declaration_without_cache(*type_declaration_bits, &block)
-        type_declaration = if block
-                             unless type_declaration_bits.empty?
-                               # :nocov:
-                               raise ArgumentError, "Cannot provide both block and declaration"
-                               # :nocov:
-                             end
-
-                             block
-                           else
-                             case type_declaration_bits.size
-                             when 0
-                               # :nocov:
-                               raise ArgumentError, "expected 1 argument or a block but got 0 arguments and no block"
-                               # :nocov:
-                             when 1
-                               type_declaration_bits.first
-                             else
-                               type_declaration_bits_to_type_declaration(type_declaration_bits)
-                             end
-                           end
+      def type_for_declaration_without_cache(*type_declaration_bits, &)
+        type_declaration = TypeDeclarations.args_to_type_declaration(*type_declaration_bits, &)
 
         handler = type_declaration_handler_for(type_declaration)
         handler.process_value!(type_declaration)
@@ -107,24 +128,6 @@ module Foobara
       def lru_cache
         @lru_cache ||= Foobara::LruCache.new(100)
       end
-
-      def type_declaration_bits_to_type_declaration(type_declaration_bits)
-        type, *symbolic_processors, processor_data = type_declaration_bits
-
-        if !symbolic_processors.empty?
-          symbolic_processors = symbolic_processors.to_h { |symbol| [symbol, true] }
-
-          if processor_data.is_a?(::Hash) && !processor_data.empty?
-            processor_data.merge(symbolic_processors)
-          else
-            symbolic_processors
-          end
-        elsif processor_data.is_a?(::Hash)
-          processor_data
-        else
-          { processor_data.to_sym => true }
-        end.merge(type:)
-      end
     end
   end
 end

data/projects/type_declarations/src/type_declaration_handler.rb

@@ -4,7 +4,7 @@ module Foobara
   module TypeDeclarations
     class TypeDeclarationHandler < Value::Processor::Pipeline
       class << self
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
           # :nocov:
           super.merge(processor_type: :type_declaration_handler)
           # :nocov:

data/projects/type_declarations/src/type_declaration_handler_registry.rb

@@ -2,7 +2,7 @@ module Foobara
   module TypeDeclarations
     class TypeDeclarationHandlerRegistry < Value::Processor::Selection
       class << self
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
           # :nocov:
           super.merge(processor_type: :type_declaration_handler_registry)
           # :nocov:

data/projects/type_declarations/src/type_declaration_validator.rb

@@ -4,7 +4,7 @@ module Foobara
       include WithRegistries
 
       class << self
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
           # :nocov:
           super.merge(processor_type: :type_declaration_validator)
           # :nocov:

data/projects/type_declarations/src/type_declarations.rb

@@ -68,22 +68,17 @@ module Foobara
         using_mode(Mode::STRICT_STRINGIFIED, &)
       end
 
-      def using_mode(new_mode)
-        old_mode = Thread.foobara_var_get(:foobara_type_declarations_mode)
-        begin
-          Thread.foobara_var_set(:foobara_type_declarations_mode, new_mode)
-          yield
-        ensure
-          Thread.foobara_var_set(:foobara_type_declarations_mode, old_mode)
-        end
+      # TODO: use manifest context instead
+      def using_mode(new_mode, &)
+        with_manifest_context(mode: new_mode, &)
       end
 
       def strict?
-        Thread.foobara_var_get(:foobara_type_declarations_mode) == Mode::STRICT
+        foobara_manifest_context_mode == Mode::STRICT
       end
 
       def strict_stringified?
-        Thread.foobara_var_get(:foobara_type_declarations_mode) == Mode::STRICT_STRINGIFIED
+        foobara_manifest_context_mode == Mode::STRICT_STRINGIFIED
       end
 
       # TODO: we should desugarize these but can't because of a bug where desugarizing entities results in creating the
@@ -94,6 +89,40 @@ module Foobara
 
         declaration1 == declaration2
       end
+
+      def foobara_manifest_context
+        Thread.foobara_var_get("foobara_manifest_context")
+      end
+
+      allowed_context_keys = %i[detached to_include mode remove_sensitive]
+      booleans = %i[detached remove_sensitive]
+
+      booleans.each do |context_item|
+        define_method "foobara_manifest_context_#{context_item}?" do
+          !!foobara_manifest_context&.[](context_item)
+        end
+      end
+
+      (allowed_context_keys - booleans).each do |context_item|
+        define_method "foobara_manifest_context_#{context_item}" do
+          foobara_manifest_context&.[](context_item)
+        end
+      end
+
+      def manifest_context_set?(context_item)
+        foobara_manifest_context&.key?(context_item)
+      end
+
+      def with_manifest_context(context)
+        old_context = foobara_manifest_context
+        begin
+          new_context = (old_context || {}).merge(context)
+          Thread.foobara_var_set("foobara_manifest_context", new_context)
+          yield
+        ensure
+          Thread.foobara_var_set("foobara_manifest_context", old_context)
+        end
+      end
     end
   end
 end

data/projects/types/src/extensions/error.rb

@@ -1,13 +1,13 @@
 module Foobara
   class Error
     class << self
-      def types_depended_on(*args, remove_sensitive: false)
+      def types_depended_on(*args)
         if args.size == 1
-          context_type.types_depended_on(args.first, remove_sensitive:)
+          context_type.types_depended_on(args.first)
         elsif args.empty?
           begin
             if context_type
-              context_type.types_depended_on(remove_sensitive:)
+              context_type.types_depended_on
             else
               raise Foobara::TypeDeclarations::ErrorExtension::NoContextTypeSetError
             end

data/projects/types/src/type/concerns/reflection.rb

@@ -6,7 +6,9 @@ module Foobara
           include Concern
 
           # as soon as we hit a registered type, don't go further down that path
-          def types_depended_on(result = nil, remove_sensitive: false)
+          def types_depended_on(result = nil)
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             start = result.nil?
             result ||= Set.new
             return if result.include?(self)
@@ -15,7 +17,7 @@ module Foobara
 
             return if !start && registered?
 
-            to_process = types_to_add_to_manifest(remove_sensitive:)
+            to_process = types_to_add_to_manifest
 
             if element_types
               to_process += case element_types
@@ -48,7 +50,7 @@ module Foobara
             end
 
             to_process.each do |type|
-              type.types_depended_on(result, remove_sensitive:)
+              type.types_depended_on(result)
             end
 
             if start
@@ -58,7 +60,9 @@ module Foobara
             result
           end
 
-          def types_to_add_to_manifest(remove_sensitive: false)
+          def types_to_add_to_manifest
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             types = [*base_type, *possible_errors.map(&:error_class)]
 
             if element_type && (!remove_sensitive || !element_type.sensitive?)
@@ -86,6 +90,77 @@ module Foobara
             result.select(&:registered?)
           end
 
+          def type_at_path(data_path)
+            path_parts = DataPath.for(data_path).path
+
+            path_part, *path_parts = path_parts
+
+            next_type = case path_part
+                        when :"#"
+                          unless element_type
+                            # :nocov:
+                            raise "Expected element_type to be set but is not"
+                            # :nocov:
+                          end
+
+                          element_type
+                        when Symbol
+                          case element_types
+                          when ::Hash
+                            unless element_types.key?(path_part)
+                              # :nocov:
+                              raise "Expected element type to have key #{path_part} but does not"
+                              # :nocov:
+                            end
+
+                            element_types[path_part]
+                          when Types::Type
+                            unless element_types.extends?(BuiltinTypes[:attributes])
+                              # :nocov:
+                              raise "Expected element type to be a Type but is not"
+                              # :nocov:
+                            end
+
+                            # TODO: We assume it's attributes here but maybe we should assert that
+                            element_types.element_types[path_part]
+                          when nil
+                            # :nocov:
+                            raise "Expected element_types to be set but is not"
+                            # :nocov:
+                          else
+                            # :nocov:
+                            raise "Unsure how to handle path part #{path_part}"
+                            # :nocov:
+                          end
+                        when Integer
+                          if extends?(BuiltinTypes[:tuple])
+                            element_types[path_part]
+                          elsif extends?(BuiltinTypes[:array])
+                            element_type
+                          else
+                            # :nocov:
+                            raise "Unsure how to handle path part #{path_part}"
+                            # :nocov:
+                          end
+                        else
+                          # :nocov:
+                          raise "Bad path part #{path_part}"
+                          # :nocov:
+                        end
+
+            unless next_type
+              # :nocov:
+              raise "Expected to find a type at #{path_part}"
+              # :nocov:
+            end
+
+            if path_parts.empty?
+              next_type
+            else
+              next_type.type_at_path(path_parts)
+            end
+          end
+
           def inspect
             # :nocov:
             name = if scoped_path_set?