foobara 0.0.131 → 0.0.132

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c95217bebc01ab27c28cdf572b5e19eb2902fd68b1bb4d7328c093b02cfe8dbf
-  data.tar.gz: 76d32046c22f96ebf9e73d738aa4154fea3edb740e66fab71954abbd8594a35c
+  metadata.gz: d4c8a877056c159be9d156cde81dececc246a1dda21e99c39d567603c4b99aca
+  data.tar.gz: 71f5c66811f399c7311b6a13fcd9562b7b11f1e6b3eb34e6cd0298cb6e2e548a
 SHA512:
-  metadata.gz: 148fe1548cc4731673ffa299fe1d5ef96a8377cdbc613e3aeff989b16efbc250beea9b58f1b3b1727d0b399b5f1925186c1ac97908c8e2bf6113f4ff0cba1835
-  data.tar.gz: e49bad06d6f305b4e1716fd56fa47298028c6b699977e95417e9013c95f3a25a90ca8a9b2d96b8a11c9fb5989b56587ee87d7b719d2397b90d95210168a594ce
+  metadata.gz: 97210eac20ace35283b2fdffe8ac36d924c3ac19336a34b914357a7c0cc7ab0a3097a867d78032898cbf8dc21ef57c6c605100919f96cfbbad15a3955cde4d2f
+  data.tar.gz: fb717c26f27f5fb6be91d77ddce128de252198523d4cc535d315fbe1029981951242a845b37460cee4cc3b6b0862a6220463750499e400d4a8d8426c62e776d4

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [0.0.132] - 2025-06-19
+
+- Add/improve the description for primary key types in EntityToPrimaryKeyInputsTransformer
+- Support model and tuple types in .has_associations?
+- Move EntityToPrimaryKeyInputsTransformer over from foobara-agent gem
+- Make sure EntitiesToPrimaryKeysSerializer recurses into models/detached entities
+- Fix bugs impacting use of multiple inputs transformers at a time and other issues with typed transformers
+
 # [0.0.131] - 2025-06-16
 
 - Extract InMemoryMinimal crud driver specs to foobara-crud-driver-spec-helpers gem

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

@@ -14,10 +14,10 @@ module Foobara
             if detached_to_primary_key?
               object.primary_key
             else
-              object.attributes_with_delegates
+              serialize(object.attributes_with_delegates)
             end
           when Model
-            object.attributes_with_delegates
+            serialize(object.attributes_with_delegates)
           when ::Array
             object.map { |element| serialize(element) }
           when ::Hash

data/projects/command_connectors/src/transformed_command.rb

@@ -114,7 +114,9 @@ module Foobara
         inputs_type = command_class.inputs_type
 
         @inputs_transformers = transformers_to_processors(@inputs_transformers, inputs_type, direction: :to)
+        @inputs_transformers = @inputs_transformers.reverse
 
+        # TODO: this block looks pointless...
         @inputs_transformers.each do |transformer|
           if transformer.is_a?(TypeDeclarations::TypedTransformer)
             new_type = transformer.from_type
@@ -442,21 +444,18 @@ module Foobara
       def inputs_transformer
         return @inputs_transformer if defined?(@inputs_transformer)
 
-        if inputs_transformers.empty?
+        transformers = inputs_transformers
+
+        if transformers.empty?
           @inputs_transformer = nil
           return
         end
 
-        @inputs_transformer = begin
-          transformers = transformers_to_processors(inputs_transformers,
-                                                    command_class.inputs_type, direction: :to)
-
-          if transformers.size == 1
-            transformers.first
-          else
-            Value::Processor::Pipeline.new(processors: transformers)
-          end
-        end
+        @inputs_transformer = if transformers.size == 1
+                                transformers.first
+                              else
+                                Value::Processor::Pipeline.new(processors: transformers)
+                              end
       end
 
       def response_mutator

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

@@ -0,0 +1,88 @@
+module Foobara
+  module CommandConnectors
+    module Transformers
+      class EntityToPrimaryKeyInputsTransformer < TypeDeclarations::TypedTransformer
+        def from_type_declaration
+          return nil unless to_type
+
+          if contains_associations_or_is_entity?(to_type)
+            if to_type.extends?(Foobara::BuiltinTypes[:attributes])
+              to_fix = {}
+
+              to_type.element_types.each_pair do |attribute_name, attribute_type|
+                if contains_associations_or_is_entity?(attribute_type)
+                  to_fix[attribute_name] = attribute_type
+                end
+              end
+
+              element_type_declarations = to_type.declaration_data[:element_type_declarations].dup
+
+              to_fix.each_pair do |attribute_name, attribute_type|
+                transformer = EntityToPrimaryKeyInputsTransformer.new(to: attribute_type)
+                element_type_declarations[attribute_name] = transformer.from_type_declaration
+              end
+
+              to_type.declaration_data.merge(element_type_declarations:)
+            elsif to_type.extends?(Foobara::BuiltinTypes[:tuple])
+              indexes_to_fix = []
+
+              to_type.element_types.each.with_index do |element_type, index|
+                if contains_associations_or_is_entity?(element_type)
+                  indexes_to_fix << index
+                end
+              end
+
+              element_type_declarations = to_type.declaration_data[:element_type_declarations].dup
+
+              indexes_to_fix.each do |index|
+                transformer = EntityToPrimaryKeyInputsTransformer.new(to: to_type.element_types[index])
+                element_type_declarations[index] = transformer.from_type_declaration
+              end
+
+              to_type.declaration_data.merge(element_type_declarations:)
+            elsif to_type.extends?(Foobara::BuiltinTypes[:array])
+              transformer = EntityToPrimaryKeyInputsTransformer.new(to: to_type.element_type)
+              element_type_declaration = transformer.from_type_declaration
+
+              to_type.declaration_data.merge(element_type_declaration:)
+            elsif to_type.extends?(Foobara::BuiltinTypes[:detached_entity])
+              declaration = to_type.target_class.primary_key_type.reference_or_declaration_data
+
+              description = "#{to_type.target_class.model_name} #{to_type.target_class.primary_key_attribute}"
+
+              unless to_type.extends_directly?(Foobara::BuiltinTypes[:detached_entity]) ||
+                     to_type.extends_directly?(Foobara::BuiltinTypes[:entity])
+                description = [
+                  description,
+                  to_type.description
+                ].join(" : ")
+              end
+              declaration[:description] = description
+
+              declaration
+            elsif to_type.extends?(Foobara::BuiltinTypes[:model])
+              attributes_type = to_type.target_class.attributes_type
+              EntityToPrimaryKeyInputsTransformer.new(to: attributes_type).from_type_declaration
+            else
+              # :nocov:
+              raise "Not sure how to handle #{to_type}"
+              # :nocov:
+            end
+          else
+            to_type
+          end
+        end
+
+        def transform(inputs)
+          inputs
+        end
+
+        private
+
+        def contains_associations_or_is_entity?(type)
+          DetachedEntity.contains_associations?(type) || type.extends?(Foobara::BuiltinTypes[:detached_entity])
+        end
+      end
+    end
+  end
+end

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

@@ -221,19 +221,29 @@ module Foobara
 
             if type.extends?(BuiltinTypes[:detached_entity])
               if initial
-                element_types = type.element_types
-
-                if remove_sensitive
-                  # TODO: test this code path
-                  # :nocov:
-                  element_types = element_types&.reject(&:sensitive?)
-                  # :nocov:
-                end
-
-                contains_associations?(element_types, false)
+                contains_associations?(type.element_types, false)
               else
                 true
               end
+            elsif type.extends?(BuiltinTypes[:model])
+              element_types = type.element_types
+
+              if remove_sensitive
+                # TODO: test this code path
+                # :nocov:
+                element_types = element_types&.reject(&:sensitive?)
+                # :nocov:
+              end
+
+              contains_associations?(element_types, false)
+            elsif type.extends?(BuiltinTypes[:tuple])
+              element_types = type.element_types
+
+              element_types&.any? do |element_type|
+                if !remove_sensitive || !element_type.sensitive?
+                  contains_associations?(element_type, false)
+                end
+              end
             elsif type.extends?(BuiltinTypes[:array])
               # TODO: what to do about an associative array type?? Unclear how to make a key from that...
               # TODO: raise if associative array contains a non-persisted record to handle this edge case for now.

data/projects/model/src/extensions/builtin_types/model/validators/model_instance_is_valid.rb

@@ -14,7 +14,7 @@ module Foobara
           end
 
           def applicable?(model_instance)
-            !model_instance.skip_validations
+            model_instance && !model_instance.skip_validations
           end
 
           def process_value(model_instance)

data/projects/type_declarations/src/typed_transformer.rb

@@ -22,6 +22,10 @@ module Foobara
         attr_reader :from_type, :to_type
       end
 
+      def always_applicable?
+        true
+      end
+
       def from_type_declaration
         nil
       end

data/projects/types/src/type.rb

@@ -232,6 +232,27 @@ module Foobara
         end
       end
 
+      def extends_directly?(type)
+        case type
+        when Type
+          base_type == type
+        when Symbol, String
+          concrete_type = created_in_namespace.foobara_lookup_type(type)
+
+          if concrete_type.nil?
+            # :nocov:
+            raise "No type found for #{type}"
+            # :nocov:
+          end
+
+          extends_directly?(concrete_type)
+        else
+          # :nocov:
+          raise ArgumentError, "Expected a Type or a Symbol/String, but got #{type.inspect}"
+          # :nocov:
+        end
+      end
+
       def extends_type?(type)
         return true if self == type
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.131
+  version: 0.0.132
 platform: ruby
 authors:
 - Miles Georgi
@@ -229,6 +229,7 @@ files:
 - projects/command_connectors/src/serializers/yaml_serializer.rb
 - projects/command_connectors/src/transformed_command.rb
 - projects/command_connectors/src/transformers/auth_errors_transformer.rb
+- projects/command_connectors/src/transformers/entity_to_primary_key_inputs_transformer.rb
 - projects/command_connectors/src/transformers/load_aggregates_pre_commit_transformer.rb
 - projects/command_connectors/src/transformers/load_delegated_attributes_entities_pre_commit_transformer.rb
 - projects/common/lib/foobara/common.rb