foobara 0.0.92 → 0.0.94

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

@@ -9,10 +9,17 @@ module Foobara
       end
 
       # TODO: unable to address types here so it is handled as a hack higher up...
-      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
-        to_include << foobara_organization
+      def foobara_manifest
+        to_include = TypeDeclarations.foobara_manifest_context_to_include
+
+        if to_include
+          to_include << foobara_organization
+        end
+
+        domain_manifest = TypeDeclarations.with_manifest_context(to_include: Set.new) do
+          unexposed_domain.foobara_manifest
+        end
 
-        domain_manifest = unexposed_domain.foobara_manifest(to_include: Set.new, remove_sensitive:)
         mode = Foobara::Namespace::LookupMode::DIRECT
         commands = foobara_all_command(mode:).map(&:foobara_manifest_reference).sort
 

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

@@ -9,8 +9,8 @@ module Foobara
       end
 
       # TODO: unable to address types here so it is handled as a hack higher up...
-      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
-        organization_manifest = unexposed_organization.foobara_manifest(to_include: Set.new, remove_sensitive:)
+      def foobara_manifest
+        organization_manifest = unexposed_organization.foobara_manifest
         mode = Foobara::Namespace::LookupMode::DIRECT
         domains = foobara_all_domain(mode:).map(&:foobara_manifest_reference).sort
 

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

@@ -8,7 +8,7 @@ module Foobara
               object.class.load(object)
             end
 
-            object = object.attributes
+            object = object.attributes_with_delegates
           end
 
           entities_to_primary_keys_serializer.serialize(object)

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

@@ -4,8 +4,10 @@ module Foobara
   module CommandConnectors
     module Serializers
       class ErrorsSerializer < Serializer
-        def always_applicable?
-          !request.outcome.success?
+        def applicable?(error_collection)
+          if request.outcome.nil? || !request.outcome.success?
+            error_collection.has_errors?
+          end
         end
 
         def serialize(error_collection)

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

@@ -0,0 +1,40 @@
+module Foobara
+  module CommandConnectors
+    module Transformers
+      # TODO: Should be a mutator instead
+      class LoadDelegatedAttributesEntitiesPreCommitTransformer < Value::Transformer
+        def applicable?(request)
+          request.command.outcome.success?
+        end
+
+        def transform(request)
+          result = request.command.outcome.result
+          load_delegated_attribute_entities(result)
+
+          request
+        end
+
+        def load_delegated_attribute_entities(object)
+          case object
+          when Entity
+            object.class.delegates.each_key do |delegated_attribute_name|
+              object.send(delegated_attribute_name)
+            end
+          when Array
+            object.each do |element|
+              load_delegated_attribute_entities(element)
+            end
+          when Hash
+            object.each_key do |key|
+              load_delegated_attribute_entities(key)
+            end
+
+            object.each_value do |value|
+              load_delegated_attribute_entities(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/common/src/data_path.rb

@@ -76,6 +76,14 @@ module Foobara
       def parse(key_string)
         new(key_string)
       end
+
+      def for(object)
+        if object.is_a?(DataPath)
+          object
+        else
+          new(object)
+        end
+      end
     end
 
     attr_reader :path
@@ -204,6 +212,14 @@ module Foobara
       self.class == other.class && path == other.path
     end
 
+    def last
+      path.last
+    end
+
+    def empty?
+      path.empty?
+    end
+
     private
 
     def normalize_all(key_parts)

data/projects/common/src/error.rb

@@ -102,9 +102,13 @@ module Foobara
         }
       end
 
-      def foobara_manifest(to_include: Set.new, remove_sensitive: false)
-        types = types_depended_on(remove_sensitive:).map do |t|
-          to_include << t
+      def foobara_manifest
+        to_include = TypeDeclarations.foobara_manifest_context_to_include
+
+        types = types_depended_on.map do |t|
+          if to_include
+            to_include << t
+          end
           t.foobara_manifest_reference
         end
 
@@ -112,7 +116,9 @@ module Foobara
         # don't bother including these core errors
         unless superclass == Foobara::Error
           base = superclass
-          to_include << base
+          if to_include
+            to_include << base
+          end
         end
 
         manifest = super

data/projects/common/src/possible_error.rb

@@ -46,12 +46,18 @@ module Foobara
     end
 
     # TODO: technically does not belong in this project but maybe it should
-    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
-      to_include << error_class
+    def foobara_manifest
+      to_include = TypeDeclarations.foobara_manifest_context_to_include
+
+      if to_include
+        to_include << error_class
+      end
 
       if processor
         processor_class = processor.class
-        to_include << processor_class
+        if to_include
+          to_include << processor_class
+        end
 
         if processor.scoped_path_set?
           # Unclear why nothing in the test suite passes through here.

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

@@ -5,18 +5,22 @@ module Foobara
         include Concern
 
         module ClassMethods
-          def foobara_associations(remove_sensitive: false)
+          def foobara_associations
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@foobara_associations) && @foobara_associations.key?(remove_sensitive)
               return @foobara_associations[remove_sensitive]
             end
 
             @foobara_associations ||= {}
-            @foobara_associations[remove_sensitive] = construct_associations(remove_sensitive:)
+            @foobara_associations[remove_sensitive] = construct_associations
           end
 
           alias associations foobara_associations
 
-          def foobara_deep_associations(remove_sensitive: false)
+          def foobara_deep_associations
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@foobara_deep_associations) && @foobara_deep_associations.key?(remove_sensitive)
               return @foobara_deep_associations[remove_sensitive]
             end
@@ -30,7 +34,7 @@ module Foobara
 
                 entity_class = type.target_class
 
-                entity_class.deep_associations(remove_sensitive:).each_pair do |sub_data_path, sub_type|
+                entity_class.deep_associations.each_pair do |sub_data_path, sub_type|
                   deep["#{data_path}.#{sub_data_path}"] = sub_type
                 end
               end
@@ -126,10 +130,9 @@ module Foobara
           def construct_deep_associations(
             type = attributes_type,
             path = DataPath.new,
-            result = {},
-            remove_sensitive: false
+            result = {}
           )
-            associations = construct_associations(type, path, result, remove_sensitive:)
+            associations = construct_associations(type, path, result)
 
             deep = {}
 
@@ -138,7 +141,7 @@ module Foobara
 
               entity_class = association_type.target_class
 
-              entity_class.deep_associations(remove_sensitive:).each_pair do |sub_data_path, sub_type|
+              entity_class.deep_associations.each_pair do |sub_data_path, sub_type|
                 deep["#{data_path}.#{sub_data_path}"] = sub_type
               end
             end
@@ -151,9 +154,10 @@ module Foobara
           def construct_associations(
             type = attributes_type,
             path = DataPath.new,
-            result = {},
-            remove_sensitive: false
+            result = {}
           )
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if type.extends?(BuiltinTypes[:entity])
               result[path.to_s] = type
             elsif type.extends?(BuiltinTypes[:tuple])
@@ -167,7 +171,7 @@ module Foobara
               end
 
               element_types&.each&.with_index do |element_type, index|
-                construct_associations(element_type, path.append(index), result, remove_sensitive:)
+                construct_associations(element_type, path.append(index), result)
               end
             elsif type.extends?(BuiltinTypes[:array])
               # TODO: what to do about an associative array type?? Unclear how to make a key from that...
@@ -175,7 +179,7 @@ module Foobara
               element_type = type.element_type
 
               if element_type && (!remove_sensitive || !element_type.sensitive?)
-                construct_associations(element_type, path.append(:"#"), result, remove_sensitive:)
+                construct_associations(element_type, path.append(:"#"), result)
               end
             elsif type.extends?(BuiltinTypes[:attributes]) # TODO: matches attributes itself instead of only subtypes
               type.element_types.each_pair do |attribute_name, element_type|
@@ -183,7 +187,7 @@ module Foobara
                   next
                 end
 
-                construct_associations(element_type, path.append(attribute_name), result, remove_sensitive:)
+                construct_associations(element_type, path.append(attribute_name), result)
               end
             elsif type.extends?(BuiltinTypes[:model])
               target_class = type.target_class
@@ -192,12 +196,12 @@ module Foobara
               attributes_type = target_class.send(method)
 
               if !remove_sensitive || !attributes_type.sensitive?
-                construct_associations(attributes_type, path, result, remove_sensitive:)
+                construct_associations(attributes_type, path, result)
               end
             elsif type.extends?(BuiltinTypes[:associative_array])
               # not going to bother testing this for now
               # :nocov:
-              if contains_associations?(type, remove_sensitive:)
+              if contains_associations?(type)
                 raise "Associative array types with associations in them are not currently supported. " \
                       "Use attributes type if you can or set the key_type and/or value_type to duck type"
               end
@@ -207,7 +211,9 @@ module Foobara
             result
           end
 
-          def contains_associations?(type = entity_type, initial = true, remove_sensitive: false)
+          def contains_associations?(type = entity_type, initial = true)
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if type.extends?(BuiltinTypes[:detached_entity])
               if initial
                 element_types = type.element_types
@@ -219,7 +225,7 @@ module Foobara
                   # :nocov:
                 end
 
-                contains_associations?(element_types, false, remove_sensitive:)
+                contains_associations?(element_types, false)
               else
                 true
               end
@@ -229,12 +235,12 @@ module Foobara
               element_type = type.element_type
 
               if element_type && (!remove_sensitive || !element_type.sensitive?)
-                contains_associations?(element_type, false, remove_sensitive:)
+                contains_associations?(element_type, false)
               end
             elsif type.extends?(BuiltinTypes[:attributes])
               type.element_types.values.any? do |element_type|
                 if !remove_sensitive || !element_type.sensitive?
-                  contains_associations?(element_type, false, remove_sensitive:)
+                  contains_associations?(element_type, false)
                 end
               end
             elsif type.extends?(BuiltinTypes[:associative_array])
@@ -248,7 +254,7 @@ module Foobara
                 end
 
                 types.any? do |key_or_value_type|
-                  contains_associations?(key_or_value_type, false, remove_sensitive:)
+                  contains_associations?(key_or_value_type, false)
                 end
               end
             end

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

@@ -17,15 +17,15 @@ module Foobara
             types.map(&:target_class).uniq
           end
 
-          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
-            associations = foobara_associations(remove_sensitive:).map do |(path, type)|
+          def foobara_manifest
+            associations = foobara_associations.map do |(path, type)|
               entity_class = type.target_class
               entity_name = entity_class.foobara_type.scoped_full_name
 
               [path, entity_name]
             end.sort.to_h
 
-            deep_associations = foobara_deep_associations(remove_sensitive:).map do |(path, type)|
+            deep_associations = foobara_deep_associations.map do |(path, type)|
               entity_class = type.target_class
               entity_name = entity_class.foobara_type.scoped_full_name
 

data/projects/detached_entity/src/detached_entity_type.rb

@@ -18,11 +18,12 @@ module Foobara
       end
     end
 
-    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+    def foobara_manifest
       manifest = super
 
       if detached_context?
         declaration_data = manifest[:declaration_data]
+
         if self.class.type_requires_conversion?(declaration_data[:type])
           declaration_data = declaration_data.merge(type: :detached_entity)
         end
@@ -31,13 +32,17 @@ module Foobara
           declaration_data = declaration_data.merge(model_base_class: "Foobara::DetachedEntity")
         end
 
+        # TODO: remove private attributes, add delegated attributes
+        # re: delegated attribute type... it can be required if required entire way, can be
+        # allow_nil if allow_nil anywhere along the way.
+        # remove private and delegated from the manifest hash.
         manifest = manifest.merge(declaration_data:)
       end
 
       manifest
     end
 
-    def types_to_add_to_manifest(remove_sensitive: false)
+    def types_to_add_to_manifest
       types = super
 
       if detached_context?
@@ -57,7 +62,7 @@ module Foobara
     end
 
     def detached_context?
-      Thread.foobara_var_get("foobara_manifest_context")&.[](:detached)
+      TypeDeclarations.foobara_manifest_context_detached?
     end
   end
 end

data/projects/detached_entity/src/extensions/builtin_types/detached_entity/validators/{attributes_declaration.rb → model_instance_is_valid.rb}

@@ -2,7 +2,7 @@ module Foobara
   module BuiltinTypes
     module DetachedEntity
       module Validators
-        class AttributesDeclaration < Model::Validators::AttributesDeclaration
+        class ModelInstanceIsValid < Model::Validators::ModelInstanceIsValid
           # Why is this here in entity/ instead of in model/?
           def possible_errors
             return [] if parent_declaration_data == { type: expected_type_symbol }

data/projects/domain/src/domain_module_extension.rb

@@ -431,20 +431,28 @@ module Foobara
         end
 
         # TODO: can we kill this skip concept?
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
+          to_include = TypeDeclarations.foobara_manifest_context_to_include
+
           depends_on = foobara_depends_on.map do |name|
             domain = Domain.to_domain(name)
-            to_include << domain
+            if to_include
+              to_include << domain
+            end
             domain.foobara_manifest_reference
           end.sort
 
           commands = foobara_all_command(mode: Namespace::LookupMode::DIRECT).map do |command_class|
-            to_include << command_class
+            if to_include
+              to_include << command_class
+            end
             command_class.foobara_manifest_reference
           end.sort
 
           types = foobara_all_type(mode: Namespace::LookupMode::DIRECT).map do |type|
-            to_include << type
+            if to_include
+              to_include << type
+            end
             type.foobara_manifest_reference
           end.sort
 

data/projects/domain/src/extensions/foobara.rb

@@ -8,46 +8,49 @@ module Foobara
     # in the http connector.
     def manifest
       to_include = Namespace.global.foobara_all_organization.to_set
-      included = {}
 
-      h = {}
+      TypeDeclarations.with_manifest_context(to_include:) do
+        included = {}
 
-      until to_include.empty?
-        object = to_include.first
-        to_include.delete(object)
+        h = {}
 
-        unless object.scoped_path_set?
-          # :nocov:
-          raise "no scoped path set for #{object}"
-          # :nocov:
-        end
+        until to_include.empty?
+          object = to_include.first
+          to_include.delete(object)
 
-        manifest_reference = object.foobara_manifest_reference.to_sym
-        category_symbol = Namespace.global.foobara_category_symbol_for(object)
+          unless object.scoped_path_set?
+            # :nocov:
+            raise "no scoped path set for #{object}"
+            # :nocov:
+          end
 
-        unless category_symbol
-          # :nocov:
-          raise "no category symbol for #{object}"
-          # :nocov:
-        end
+          manifest_reference = object.foobara_manifest_reference.to_sym
+          category_symbol = Namespace.global.foobara_category_symbol_for(object)
 
-        if included.key?(manifest_reference)
-          if included[manifest_reference] == category_symbol
-            next
-          else
+          unless category_symbol
             # :nocov:
-            raise "Collision for #{manifest_reference}: #{included[manifest_reference]} and #{category_symbol}"
+            raise "no category symbol for #{object}"
             # :nocov:
           end
-        end
 
-        cat = h[category_symbol] ||= {}
-        cat[manifest_reference] = object.foobara_manifest(to_include:)
+          if included.key?(manifest_reference)
+            if included[manifest_reference] == category_symbol
+              next
+            else
+              # :nocov:
+              raise "Collision for #{manifest_reference}: #{included[manifest_reference]} and #{category_symbol}"
+              # :nocov:
+            end
+          end
 
-        included[manifest_reference] = category_symbol
-      end
+          cat = h[category_symbol] ||= {}
+          cat[manifest_reference] = object.foobara_manifest
 
-      h.sort.to_h
+          included[manifest_reference] = category_symbol
+        end
+
+        h.sort.to_h
+      end
     end
 
     def all_organizations

data/projects/domain/src/is_manifestable.rb

@@ -37,7 +37,9 @@ module Foobara
       end
     end
 
-    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+    def foobara_manifest
+      to_include = TypeDeclarations.foobara_manifest_context_to_include
+
       h = {
         scoped_path:,
         scoped_name:,
@@ -57,7 +59,9 @@ module Foobara
         parent_category = Namespace.global.foobara_category_symbol_for(parent)
 
         if parent_category
-          to_include << parent
+          if to_include
+            to_include << parent
+          end
           h[:parent] = [parent_category, parent.foobara_manifest_reference]
         end
       end

data/projects/domain/src/organization_module_extension.rb

@@ -36,9 +36,13 @@ module Foobara
           foobara_all_domain(mode: Namespace::LookupMode::DIRECT)
         end
 
-        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        def foobara_manifest
+          to_include = TypeDeclarations.foobara_manifest_context_to_include
+
           domains = foobara_domains.map do |domain|
-            to_include << domain
+            if to_include
+              to_include << domain
+            end
             domain.foobara_manifest_reference
           end.sort
 

data/projects/entity/src/concerns/queries.rb

@@ -91,7 +91,7 @@ module Foobara
           end
 
           def that_owns(record, filters = [])
-            containing_records = that_own(record, filters)
+            containing_records = that_own(record, filters).to_a
 
             unless containing_records.empty?
               if containing_records.size == 1
@@ -107,42 +107,40 @@ module Foobara
           def that_own(record, filters = [])
             association_key = association_for([record.class, *filters])
 
-            data_path = DataPath.new(association_key)
+            possible_direct_owner_path = DataPath.new(association_key)
 
-            done = false
+            # We need to find the second-to-last entity in the association path
+            attribute_path = []
+            owning_entity_class = nil
 
-            containing_records = Util.array(record)
+            begin
+              attribute_path.unshift(possible_direct_owner_path.last)
+              possible_direct_owner_path = DataPath.new(possible_direct_owner_path.path[0..-2])
 
-            until done
-              last = data_path.path.last
+              owning_entity_class = if possible_direct_owner_path.empty?
+                                      self
+                                    else
+                                      deep_associations[possible_direct_owner_path.to_s]&.target_class
+                                    end
+            end until owning_entity_class
 
-              if last == :"#"
-                method = :find_all_by_attribute_containing_any_of
-                attribute_name = data_path.path[-2]
-                data_path = DataPath.new(data_path.path[0..-3])
-              else
-                method = :find_all_by_attribute_any_of
-                attribute_name = last
-                data_path = DataPath.new(data_path.path[0..-2])
-              end
-
-              containing_entity_class_path = data_path.to_s
-
-              entity_class = if containing_entity_class_path.empty?
-                               done = true
-                               self
-                             else
-                               deep_associations[
-                                 containing_entity_class_path
-                               ].target_class
-                             end
-
-              containing_records = entity_class.send(method, attribute_name, containing_records).to_a
-
-              done = true unless containing_records
+            if attribute_path.size == 1
+              attribute_path = attribute_path.first
             end
 
-            containing_records
+            if owning_entity_class == self
+              owning_entity_class.find_all_by_attribute(attribute_path, record)
+            else
+              Enumerator.new do |yielder|
+                owners = owning_entity_class.find_all_by_attribute(attribute_path, record)
+
+                owners.each do |owner|
+                  that_own(owner, filters).each do |r|
+                    yielder.yield(r)
+                  end
+                end
+              end
+            end
           end
         end
       end

data/projects/entity/src/extensions/builtin_types/entity/validators/{attributes_declaration.rb → model_instance_is_valid.rb}

@@ -2,7 +2,7 @@ module Foobara
   module BuiltinTypes
     module Entity
       module Validators
-        class AttributesDeclaration < DetachedEntity::Validators::AttributesDeclaration
+        class ModelInstanceIsValid < DetachedEntity::Validators::ModelInstanceIsValid
           def applicable?(record)
             record.created? || record.built?
           end