foobara 0.0.92 → 0.0.93

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad04851e6936963ef7ad60f1d6e7ab34241993abb2107b14a26d8cbc8d73663e
-  data.tar.gz: 178614a7f7b288a13ca290a14f702348e47d43e4d675611c7953bcdd033bdf5f
+  metadata.gz: 447d11c02182fce4303fe2db74bbc322e0589d51161756496b2c5d8390a26eab
+  data.tar.gz: 3a1ce551119b74488a5fe9fc86651ab914eec93f87f1d806da8f4b58135d8de7
 SHA512:
-  metadata.gz: 13112e8c68e48a51e442ce485c5fbcc89ab5974df3f1349012e2e646cecdf1742096bc5d42a9edb4c5dd825b06adabca6302f8a4c9ec44857c98338c8cc4b210
-  data.tar.gz: a48dcd6f4ec1f36feba216fab63711ea37a2378f819cc450a8e08bb15ea62a4f4463970f666b7d61fabd7aee871e01112abe2afceb915fbd0bc2cade4994b4b3
+  metadata.gz: cf4413d689bef2063e5a43d8c88cc8f70b3d6158f722419fb613ee4a2c13560d8fff23addd5cc34d4f18ad7c6437435d5382f205b6aa53904888354e6cb0de04
+  data.tar.gz: 761d8e8de14d04d5ca8c2916c23ead8cc261ca8b641584083ef2cb25e9fc9a621515be5a5524d41c97b0a867d829ae8b8cd802b6935b152b9ae8ef55ec9c6944

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [0.0.93] - 2025-04-06
+
+- Add delegated attributes to models
+- Add private attributes to models
+- Pass manifest construction context through thread_parent instead of passing it everywhere
+- Various namespace lookup bugfixes
+- Various bugfixes for .find_all/many type of methods in both Model and crud drivers
+
 # [0.0.92] - 2025-04-01
 
 - Improve error call stacks in calls like #run!

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

@@ -19,36 +19,48 @@ module Foobara
             remove_instance_variable("@all") if instance_variable_defined?("@all")
           end
 
-          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+          def foobara_manifest
+            to_include = TypeDeclarations.foobara_manifest_context_to_include
+
             depends_on = self.depends_on.map do |command_name|
               other_command = Foobara::Namespace.global.foobara_lookup!(command_name,
                                                                         mode: Foobara::Namespace::LookupMode::ABSOLUTE)
-              to_include << other_command
+              if to_include
+                to_include << other_command
+              end
               other_command.foobara_manifest_reference
             end.sort
 
-            types = types_depended_on(remove_sensitive:).map do |t|
-              to_include << t
+            types = types_depended_on.map do |t|
+              if to_include
+                to_include << t
+              end
               t.foobara_manifest_reference
             end.sort
 
             inputs_types_depended_on = self.inputs_types_depended_on.map do |t|
-              to_include << t
+              if to_include
+                to_include << t
+              end
               t.foobara_manifest_reference
             end.sort
 
             result_types_depended_on = self.result_types_depended_on.map do |t|
-              to_include << t
+              if to_include
+                to_include << t
+              end
               t.foobara_manifest_reference
             end.sort
 
             errors_types_depended_on = self.errors_types_depended_on.map do |t|
-              to_include << t
+              if to_include
+                to_include << t
+              end
               t.foobara_manifest_reference
             end.sort
 
             possible_errors = self.possible_errors.map do |possible_error|
-              [possible_error.key.to_s, possible_error.foobara_manifest(to_include:)]
+              [possible_error.key.to_s, possible_error.foobara_manifest]
             end.sort.to_h
 
             h = Util.remove_blank(
@@ -78,15 +90,18 @@ module Foobara
             Util.non_full_name(self)
           end
 
-          def types_depended_on(remove_sensitive: false)
+          def types_depended_on
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@types_depended_on) && @types_depended_on.key?(remove_sensitive)
               return @types_depended_on[remove_sensitive]
             end
 
             @types_depended_on ||= {}
             @types_depended_on[remove_sensitive] = begin
-              types = inputs_types_depended_on(remove_sensitive:) | result_types_depended_on(remove_sensitive:) |
-                      errors_types_depended_on(remove_sensitive:)
+              types = inputs_types_depended_on |
+                      result_types_depended_on |
+                      errors_types_depended_on
 
               unless depends_on_entities.empty?
                 entity_types = depends_on_entities.map(&:entity_type)
@@ -96,14 +111,16 @@ module Foobara
                 end
 
                 types |= entity_types
-                types |= entity_types.map { |t| t.types_depended_on(remove_sensitive:) }.inject(:|)
+                types |= entity_types.map(&:types_depended_on).inject(:|)
               end
 
               types
             end
           end
 
-          def inputs_types_depended_on(remove_sensitive: false)
+          def inputs_types_depended_on
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@inputs_types_depended_on) && @inputs_types_depended_on.key?(remove_sensitive)
               return @inputs_types_depended_on[remove_sensitive]
             end
@@ -121,14 +138,16 @@ module Foobara
                                                               end
                                                               # :nocov:
                                                             else
-                                                              inputs_type.types_depended_on(remove_sensitive:)
+                                                              inputs_type.types_depended_on
                                                             end
                                                           else
                                                             Set.new
                                                           end
           end
 
-          def result_types_depended_on(remove_sensitive: false)
+          def result_types_depended_on
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@result_types_depended_on) && @result_types_depended_on.key?(remove_sensitive)
               return @result_types_depended_on[remove_sensitive]
             end
@@ -138,14 +157,16 @@ module Foobara
                                                             if result_type.registered?
                                                               Set[result_type]
                                                             else
-                                                              result_type.types_depended_on(remove_sensitive:)
+                                                              result_type.types_depended_on
                                                             end
                                                           else
                                                             Set.new
                                                           end
           end
 
-          def errors_types_depended_on(remove_sensitive: false)
+          def errors_types_depended_on
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             if defined?(@errors_types_depended_on) && @errors_types_depended_on.key?(remove_sensitive)
               return @errors_types_depended_on[remove_sensitive]
             end
@@ -153,7 +174,7 @@ module Foobara
             @errors_types_depended_on ||= {}
             @errors_types_depended_on[remove_sensitive] = begin
               error_classes = possible_errors.map(&:error_class)
-              error_classes.map { |e| e.types_depended_on(remove_sensitive:) }.inject(:|) || Set.new
+              error_classes.map(&:types_depended_on).inject(:|) || Set.new
             end
           end
         end

data/projects/command/src/transformed_command.rb

@@ -174,28 +174,48 @@ module Foobara
         @possible_errors ||= error_context_type_map.values
       end
 
-      def possible_errors_manifest(to_include:, remove_sensitive: true)
-        possible_errors.map do |possible_error|
-          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:, remove_sensitive:)]
-        end.sort.to_h
+      def possible_errors_manifest
+        errors_proc = -> do
+          possible_errors.map do |possible_error|
+            [possible_error.key.to_s, possible_error.foobara_manifest]
+          end.sort.to_h
+        end
+
+        if TypeDeclarations.manifest_context_set?(:remove_sensitive)
+          errors_proc.call
+        else
+          TypeDeclarations.with_manifest_context(remove_sensitive: true, &errors_proc)
+        end
       end
 
       def inputs_types_depended_on
-        inputs_type_for_manifest&.types_depended_on || []
+        TypeDeclarations.with_manifest_context(remove_sensitive: false) do
+          inputs_type_for_manifest&.types_depended_on || []
+        end
       end
 
-      def result_types_depended_on(remove_sensitive: true)
-        result_type_for_manifest&.types_depended_on(remove_sensitive:) || []
+      def result_types_depended_on
+        type_proc = -> { result_type_for_manifest&.types_depended_on || [] }
+
+        if TypeDeclarations.manifest_context_set?(:remove_sensitive)
+          type_proc.call
+        else
+          TypeDeclarations.with_manifest_context(remove_sensitive: true, &type_proc)
+        end
       end
 
-      def types_depended_on(remove_sensitive: true)
+      def types_depended_on
+        # Seems to be not necessary?
+        # types = command_class.types_depended_on
+
+        types = Set.new
+
         # TODO: memoize this
         # TODO: this should not delegate to command since transformers are in play
-        types = command_class.types_depended_on(remove_sensitive:)
 
         type = inputs_type
 
-        if type != command_class.inputs_type
+        if type
           if type.registered?
             # TODO: if we ever change from attributes-only inputs type
             # then this will be handy
@@ -207,75 +227,98 @@ module Foobara
           types |= type.types_depended_on
         end
 
-        type = result_type
+        types_proc = proc do
+          type = result_type
 
-        if type != command_class.result_type
-          if type.registered?
-            # TODO: if we ever change from attributes-only inputs type
-            # then this will be handy
-            # :nocov:
-            types |= [type]
-            # :nocov:
+          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(remove_sensitive:)
-        end
+          possible_errors.each do |possible_error|
+            error_class = possible_error.error_class
+            types |= error_class.types_depended_on
+          end
 
-        possible_errors.each do |possible_error|
-          error_class = possible_error.error_class
-          types |= error_class.types_depended_on(remove_sensitive:)
+          types
         end
 
-        types
+        if TypeDeclarations.manifest_context_set?(:remove_sensitive)
+          types_proc.call
+        else
+          TypeDeclarations.with_manifest_context(remove_sensitive: true, &types_proc)
+        end
       end
 
-      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
+      def foobara_manifest
+        to_include = TypeDeclarations.foobara_manifest_context_to_include
+
         types = types_depended_on.select(&:registered?).map do |t|
-          to_include << t
+          if to_include
+            to_include << t
+          end
           t.foobara_manifest_reference
         end.sort
 
-        inputs_transformers = self.inputs_transformers.map { |t| t.foobara_manifest(to_include:) }
-        result_transformers = self.result_transformers.map { |t| t.foobara_manifest(to_include:) }
-        errors_transformers = self.errors_transformers.map { |t| t.foobara_manifest(to_include:) }
-        pre_commit_transformers = self.pre_commit_transformers.map { |t| t.foobara_manifest(to_include:) }
+        inputs_transformers = TypeDeclarations.with_manifest_context(remove_sensitive: false) do
+          self.inputs_transformers.map(&:foobara_manifest)
+        end
+        result_transformers = self.result_transformers.map(&:foobara_manifest)
+        errors_transformers = self.errors_transformers.map(&:foobara_manifest)
+        pre_commit_transformers = self.pre_commit_transformers.map(&:foobara_manifest)
         serializers = self.serializers.map do |s|
           if s.respond_to?(:foobara_manifest)
-            to_include << s
+            if to_include
+              to_include << s
+            end
             s.foobara_manifest_reference
           else
             { proc: s.to_s }
           end
         end
 
-        response_mutators = self.response_mutators.map { |t| t.foobara_manifest(to_include:) }
-        request_mutators = self.request_mutators.map { |t| t.foobara_manifest(to_include:) }
+        response_mutators = self.response_mutators.map(&:foobara_manifest)
+        request_mutators = TypeDeclarations.with_manifest_context(remove_sensitive: false) do
+          self.request_mutators.map(&:foobara_manifest)
+        end
 
         authenticator_manifest = if authenticator
                                    if authenticator.respond_to?(:foobara_manifest)
                                      # TODO: test this path
                                      # :nocov:
-                                     authenticator.foobara_manifest(to_include:)
+                                     authenticator.foobara_manifest
                                      # :nocov:
                                    else
                                      true
                                    end
                                  end
 
-        inputs_types_depended_on = self.inputs_types_depended_on.map(&:foobara_manifest_reference).sort
-        result_types_depended_on = self.result_types_depended_on(remove_sensitive:).map(&:foobara_manifest_reference)
+        inputs_types_depended_on =  TypeDeclarations.with_manifest_context(remove_sensitive: false) do
+          self.inputs_types_depended_on.map(&:foobara_manifest_reference).sort
+        end
+
+        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(to_include:, remove_sensitive:).merge(
+        command_class.foobara_manifest.merge(
           Util.remove_blank(
             inputs_types_depended_on:,
             result_types_depended_on:,
             types_depended_on: types,
-            inputs_type: inputs_type_for_manifest&.reference_or_declaration_data,
-            result_type: result_type_for_manifest&.reference_or_declaration_data(remove_sensitive:),
-            possible_errors: possible_errors_manifest(to_include:, remove_sensitive:),
+            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,
+            possible_errors: possible_errors_manifest,
             capture_unknown_error:,
             inputs_transformers:,
             result_transformers:,

data/projects/command_connectors/src/command_connector/commands/describe.rb

@@ -16,11 +16,7 @@ module Foobara
         attr_accessor :manifest
 
         def build_manifest
-          self.manifest = if manifestable.is_a?(CommandConnector)
-                            manifestable.foobara_manifest
-                          else
-                            manifestable.foobara_manifest(to_include: Set.new)
-                          end
+          self.manifest = manifestable.foobara_manifest
         end
 
         def stamp_request_metadata

data/projects/command_connectors/src/command_connector.rb

@@ -396,10 +396,9 @@ module Foobara
       Foobara.foobara_lookup_type(name, mode: Namespace::LookupMode::RELAXED)
     end
 
-    def foobara_manifest(remove_sensitive: true)
+    def foobara_manifest
       process_delayed_connections
 
-      # Drive all of this off of the list of exposed commands...
       to_include = Set.new
 
       to_include << command_registry.global_organization
@@ -423,81 +422,84 @@ module Foobara
         processor_class: {}
       }
 
-      until to_include.empty? && additional_to_include.empty?
-        object = nil
+      TypeDeclarations.with_manifest_context(to_include: additional_to_include, remove_sensitive: true) do
+        until to_include.empty? && additional_to_include.empty?
+          object = nil
 
-        if to_include.empty?
-          until additional_to_include.empty?
-            o = additional_to_include.first
-            additional_to_include.delete(o)
+          if to_include.empty?
+            until additional_to_include.empty?
+              o = additional_to_include.first
+              additional_to_include.delete(o)
 
-            if o.is_a?(::Module)
-              if o.foobara_domain? || o.foobara_organization?
-                unless o.foobara_root_namespace == command_registry
+              if o.is_a?(::Module)
+                if o.foobara_domain? || o.foobara_organization?
+                  unless o.foobara_root_namespace == command_registry
+                    next
+                  end
+                elsif o.is_a?(::Class) && o < Foobara::Command
                   next
                 end
-              elsif o.is_a?(::Class) && o < Foobara::Command
-                next
-              end
-            elsif o.is_a?(Types::Type)
-              if remove_sensitive && o.sensitive?
+              elsif o.is_a?(Types::Type)
+                if o.sensitive?
+                  # :nocov:
+                  raise UnexpectedSensitiveTypeInManifestError,
+                        "Unexpected sensitive type in manifest: #{o.scoped_full_path}. " \
+                        "Make sure these are not included."
                 # :nocov:
-                raise UnexpectedSensitiveTypeInManifestError,
-                      "Unexpected sensitive type in manifest: #{o.scoped_full_path}. Make sure these are not included."
-              # :nocov:
-              else
-                domain_name = o.foobara_domain.scoped_full_name
-
-                unless command_registry.foobara_registered?(domain_name)
-                  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|
-                    additional_to_include << exposed_domain
-                  end
+                else
+                  domain_name = o.foobara_domain.scoped_full_name
+
+                  unless command_registry.foobara_registered?(domain_name)
+                    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|
+                      additional_to_include << exposed_domain
+                    end
 
-                  command_registry.foobara_all_organization.each do |exposed_organization|
-                    additional_to_include << exposed_organization
+                    command_registry.foobara_all_organization.each do |exposed_organization|
+                      additional_to_include << exposed_organization
+                    end
                   end
                 end
               end
-            end
 
-            object = o
-            break
+              object = o
+              break
+            end
+          else
+            object = to_include.first
+            to_include.delete(object)
           end
-        else
-          object = to_include.first
-          to_include.delete(object)
-        end
 
-        break unless object
-        next if included.include?(object)
+          break unless object
+          next if included.include?(object)
 
-        manifest_reference = object.foobara_manifest_reference.to_sym
+          manifest_reference = object.foobara_manifest_reference.to_sym
 
-        category_symbol = command_registry.foobara_category_symbol_for(object)
+          category_symbol = command_registry.foobara_category_symbol_for(object)
 
-        unless category_symbol
-          # :nocov:
-          raise "no category symbol for #{object}"
-          # :nocov:
-        end
+          unless category_symbol
+            # :nocov:
+            raise "no category symbol for #{object}"
+            # :nocov:
+          end
 
-        namespace = if object.is_a?(Types::Type)
-                      object.created_in_namespace
-                    else
-                      Foobara::Namespace.current
-                    end
+          namespace = if object.is_a?(Types::Type)
+                        object.created_in_namespace
+                      else
+                        Foobara::Namespace.current
+                      end
 
-        cat = h[category_symbol] ||= {}
-        # TODO: do we really need to enter the namespace here for this?
-        cat[manifest_reference] = Foobara::Namespace.use namespace do
-          object.foobara_manifest(to_include: additional_to_include, remove_sensitive:)
-        end
+          cat = h[category_symbol] ||= {}
+          # TODO: do we really need to enter the namespace here for this?
+          cat[manifest_reference] = Foobara::Namespace.use namespace do
+            object.foobara_manifest
+          end
 
-        included << object
+          included << object
+        end
       end
 
       h[:domain].each_value do |domain_manifest|

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

@@ -100,8 +100,8 @@ module Foobara
         @full_command_symbol ||= Util.underscore_sym(full_command_name)
       end
 
-      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
-        transformed_command_class.foobara_manifest(to_include:, remove_sensitive:).merge(super).merge(
+      def foobara_manifest
+        transformed_command_class.foobara_manifest.merge(super).merge(
           Util.remove_blank(
             scoped_category: :command,
             domain: command_class.domain.foobara_manifest_reference,

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/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)