foobara 0.0.86 → 0.0.88

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e400689de8a729a2ed91fc3fd0da0e447e4d773ece5a6efc42e4ee555eb665ef
-  data.tar.gz: 29f503d3d3263ad637add42716b757aba79688f98871a71cf9d011c72af28bd9
+  metadata.gz: 5abb6c21d367251512e93a28585ca52fbef92cbea5bd4b6f102f693ae7e42969
+  data.tar.gz: 2219f04cbb8cd7fa1b4f296fe229416cb344fd30bdd4fe529cb619b820a45f03
 SHA512:
-  metadata.gz: 35490b924e4f50e2752936b26bbafd25e42b88c8be4a404e006befe58fb9b2b60be54eb54f039f4d5b2a455b409e256b5cbc8bc8496cc1a9e9bf94b52e17330f
-  data.tar.gz: 51745cf6ea9e92c93e6c2a944073232cb07126f35c6f0d10574b56f5b46ae2f91aef909008ab09b9d6d49711a9dc31c0b3ef2a74dc1b0cac4fbb1efe26ecf84b
+  metadata.gz: df26075b6ad2825133cd77b08e6c5813756fe130244b4d21ca0c312a734380c40668ce5a066e102a2b321a66f08ddf51a9a2499af1c243a603db40c3057aa60a
+  data.tar.gz: 8c4ef51ae4cb5fc93c31e3b739f0b919c91cad78944cbeeea25d324f607020aff47ff7ae8166e24fd17dc9aff61dab9962b29833d505e77f1833a8af40a56c1e

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# [0.0.88] - 2025-03-28
+
+- Implement response mutator concept
+- Break up #request_to_response for easier overriding/extension
+- Add AttributesTransformers::Reject
+- Fix problem causing downcase/regex processors to explode on allows_nil types
+
+# [0.0.87] - 2025-03-26
+
+- TypedTransformer refactor to reduce confusion and bugs
+
 # [0.0.86] - 2025-03-23
 
 - Add an AttributesTransformer.only method to quickly get a TypedTransformer (helpful with inputs_transformers)

data/projects/builtin_types/src/email/transformers/downcase.rb

@@ -5,9 +5,6 @@ module Foobara
         # Seems like it might be cleaner to just assemble these parts in one place instead of in different files?
         # Hard to say.
         class Downcase < BuiltinTypes::String::SupportedTransformers::Downcase
-          def always_applicable?
-            true
-          end
         end
       end
     end

data/projects/builtin_types/src/email/validator_base.rb

@@ -27,10 +27,6 @@ module Foobara
           end
         end
 
-        def always_applicable?
-          true
-        end
-
         def regex
           # :nocov:
           raise "subclass responsibility"
@@ -76,6 +72,11 @@ module Foobara
             class_name = "#{name}::#{Util.classify(symbol)}"
 
             Util.make_class(class_name, ValidatorBase) do
+              define_method :applicable? do |value|
+                # TODO: hmmm, I wonder how we can short-circuit these checks if :allows_nil matches??
+                value.is_a?(::String)
+              end
+
               define_method :regex do
                 regex
               end

data/projects/builtin_types/src/string/supported_transformers/downcase.rb

@@ -3,7 +3,11 @@ module Foobara
     # TODO: Rename to StringType to avoid needing to remember ::String elsewhere in the code
     module String
       module SupportedTransformers
-        class Downcase < Value::Transformer.subclass(transform: :downcase.to_proc, name: "Downcase")
+        class Downcase < Value::Transformer.subclass(
+          transform: :downcase.to_proc,
+          name: "Downcase",
+          applicable?: ->(value) { value.respond_to?(:downcase) }
+        )
         end
       end
     end

data/projects/command/src/transformed_command.rb

@@ -13,6 +13,10 @@ module Foobara
                     :pre_commit_transformers,
                     # TODO: get at least these serializers out of here...
                     :serializers,
+                    # TODO: probably should also get these mutators out of here. But where should they live?
+                    # On exposed command? On the command registry? On the command connector?
+                    # This is the easiest place to implement them but feels awkward.
+                    :response_mutators,
                     :allowed_rule,
                     :requires_authentication,
                     :authenticator
@@ -27,6 +31,7 @@ module Foobara
         errors_transformers:,
         pre_commit_transformers:,
         serializers:,
+        response_mutators:,
         allowed_rule:,
         requires_authentication:,
         authenticator:,
@@ -40,8 +45,7 @@ module Foobara
 
           remover = Namespace.use scoped_namespace do
             transformed_result_type = result_type_from_transformers(result_type, result_transformers)
-
-            remover_class.new(transformed_result_type).tap do |r|
+            remover_class.new(from: transformed_result_type).tap do |r|
               r.scoped_path = ["SensitiveValueRemover", *transformed_result_type.scoped_full_path]
             end
           end
@@ -59,6 +63,7 @@ module Foobara
           klass.errors_transformers = Util.array(errors_transformers)
           klass.pre_commit_transformers = Util.array(pre_commit_transformers)
           klass.serializers = Util.array(serializers)
+          klass.response_mutators = Util.array(response_mutators)
           klass.allowed_rule = allowed_rule
           klass.requires_authentication = requires_authentication
           klass.authenticator = authenticator
@@ -71,25 +76,34 @@ module Foobara
                        to: :command_class
 
       def inputs_type
-        type = command_class.inputs_type
-
-        inputs_transformers.reverse.each do |transformer|
-          if transformer.is_a?(Class) && transformer < TypeDeclarations::TypedTransformer
-            new_type = transformer.type(type)
-
-            type = new_type if new_type
-          end
-        end
-
-        type
+        return @inputs_type if defined?(@inputs_type)
+
+        @inputs_type = if inputs_transformer
+                         if inputs_transformer.is_a?(Value::Processor::Pipeline)
+                           inputs_transformer.processors.each do |transformer|
+                             if transformer.is_a?(TypeDeclarations::TypedTransformer)
+                               from_type = transformer.from_type
+                               if from_type
+                                 @inputs_type = from_type
+                                 return from_type
+                               end
+                             end
+                           end
+
+                           command_class.inputs_type
+                         else
+                           inputs_transformer.from_type || command_class.inputs_type
+                         end
+                       else
+                         command_class.inputs_type
+                       end
       end
 
       def result_type_from_transformers(result_type, transformers)
-        Util.array(transformers).each do |transformer|
+        transformers.reverse.each do |transformer|
           if transformer.is_a?(Class) && transformer < TypeDeclarations::TypedTransformer
-            new_type = transformer.type(result_type)
-
-            result_type = new_type if new_type
+            new_type = transformer.to_type
+            return new_type if new_type
           end
         end
 
@@ -100,6 +114,18 @@ module Foobara
         result_type_from_transformers(command_class.result_type, result_transformers)
       end
 
+      def result_type_for_manifest
+        return @result_type_for_manifest if defined?(@result_type_for_manifest)
+
+        mutated_result_type = result_type
+
+        response_mutators&.reverse&.each do |mutator|
+          mutated_result_type = mutator.instance.result_type_from(mutated_result_type)
+        end
+
+        @result_type_for_manifest = mutated_result_type
+      end
+
       def error_context_type_map
         @error_context_type_map ||= begin
           set = {}
@@ -199,12 +225,13 @@ module Foobara
           end
         end
 
+        response_mutators = self.response_mutators.map { |t| t.foobara_manifest(to_include:) }
+
         command_class.foobara_manifest(to_include:, remove_sensitive:).merge(
           Util.remove_blank(
             types_depended_on: types,
             inputs_type: inputs_type&.reference_or_declaration_data,
-            # TODO: we need a way to unmask values in the result type that we want to expose
-            result_type: result_type&.reference_or_declaration_data(remove_sensitive:),
+            result_type: result_type_for_manifest&.reference_or_declaration_data(remove_sensitive:),
             possible_errors: possible_errors_manifest(to_include:, remove_sensitive:),
             capture_unknown_error:,
             inputs_transformers:,
@@ -212,11 +239,94 @@ module Foobara
             errors_transformers:,
             pre_commit_transformers:,
             serializers:,
+            response_mutators:,
             requires_authentication:,
             authenticator: authenticator&.manifest
           )
         )
       end
+
+      def inputs_transformer
+        return @inputs_transformer if defined?(@inputs_transformer)
+
+        if inputs_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
+      end
+
+      def response_mutator
+        return @response_mutator if defined?(@response_mutator)
+
+        if response_mutators.empty?
+          @response_mutator = nil
+          return
+        end
+
+        @response_mutator = begin
+          transformers = transformers_to_processors(response_mutators, result_type, direction: :from)
+
+          if transformers.size == 1
+            transformers.first
+          else
+            Value::Processor::Pipeline.new(processors: transformers)
+          end
+        end
+      end
+
+      def result_transformer
+        return @result_transformer if defined?(@result_transformer)
+
+        if result_transformers.empty?
+          @result_transformer = nil
+          return
+        end
+
+        @result_transformer = begin
+          transformers = transformers_to_processors(result_transformers, command_class.result_type, direction: :from)
+
+          if transformers.size == 1
+            transformers.first
+          else
+            Value::Processor::Pipeline.new(processors: transformers)
+          end
+        end
+      end
+
+      # TODO: this is pretty messy with smells.
+      def transformers_to_processors(transformers, target_type, direction: :from, declaration_data: self)
+        transformers.map do |transformer|
+          if transformer.is_a?(Class)
+            if transformer < TypeDeclarations::TypedTransformer
+              transformer.new(direction => target_type).tap do |tx|
+                new_type = direction == :from ? tx.to_type : tx.from_type
+                target_type = new_type if new_type
+              end
+            else
+              transformer.new(declaration_data)
+            end
+          elsif transformer.is_a?(Value::Processor)
+            transformer
+          elsif transformer.respond_to?(:call)
+            Value::Transformer.create(transform: transformer)
+          else
+            # :nocov:
+            raise "Not sure how to apply #{inputs_transformer}"
+            # :nocov:
+          end
+        end
+      end
     end
 
     attr_accessor :command, :untransformed_inputs, :transformed_inputs, :outcome, :authenticated_user
@@ -259,49 +369,29 @@ module Foobara
     end
 
     def transform_inputs
-      self.transformed_inputs = if inputs_transformer
-                                  inputs_transformer.process_value!(untransformed_inputs)
+      self.transformed_inputs = if self.class.inputs_transformer
+                                  self.class.inputs_transformer.process_value!(untransformed_inputs)
                                 else
                                   untransformed_inputs
                                 end
     end
 
     def transform_result
-      if result_transformer
-        self.outcome = Outcome.success(result_transformer.process_value!(result))
+      if self.class.result_transformer
+        self.outcome = Outcome.success(self.class.result_transformer.process_value!(result))
       end
     end
 
+    def mutate_response(response)
+      self.class.response_mutator&.process_value!(response)
+    end
+
     def transform_errors
       if errors_transformer
         self.outcome = Outcome.errors(errors_transformer.process_value!(errors))
       end
     end
 
-    def inputs_transformer
-      return nil if inputs_transformers.empty?
-
-      transformers = transformers_to_processors(inputs_transformers, command_class.inputs_type)
-
-      if transformers.size == 1
-        transformers.first
-      else
-        Value::Processor::Pipeline.new(processors: transformers)
-      end
-    end
-
-    def result_transformer
-      return nil if result_transformers.empty?
-
-      transformers = transformers_to_processors(result_transformers, command_class.result_type)
-
-      if transformers.size == 1
-        transformers.first
-      else
-        Value::Processor::Pipeline.new(processors: transformers)
-      end
-    end
-
     # TODO: let's get this out of here...
     # we might want to have different serializers for different command instances of the same class.
     # but currently serializers is set on the class. Since this class should not be concerned with serialization, we
@@ -309,7 +399,7 @@ module Foobara
     def serializer
       return nil if serializers.empty?
 
-      transformers = transformers_to_processors(serializers, nil)
+      transformers = self.class.transformers_to_processors(serializers, nil, declaration_data: self)
 
       if transformers.size == 1
         transformers.first
@@ -321,7 +411,8 @@ module Foobara
     def errors_transformer
       return nil if errors_transformers.empty?
 
-      transformers = transformers_to_processors(errors_transformers, nil)
+      transformers = self.class.transformers_to_processors(errors_transformers, nil, direction: :from,
+                                                                                     declaration_data: self)
 
       if transformers.size == 1
         transformers.first
@@ -334,7 +425,11 @@ module Foobara
     def pre_commit_transformer
       return nil if pre_commit_transformers.empty?
 
-      transformers = transformers_to_processors(pre_commit_transformers, nil)
+      transformers = self.class.transformers_to_processors(
+        pre_commit_transformers,
+        nil,
+        declaration_data: self
+      )
 
       if transformers.size == 1
         transformers.first
@@ -343,29 +438,6 @@ module Foobara
       end
     end
 
-    def transformers_to_processors(transformers, from_type)
-      transformers.map do |transformer|
-        if transformer.is_a?(Class)
-          if transformer < TypeDeclarations::TypedTransformer
-            transformer.new(from_type).tap do |tx|
-              new_type = tx.type
-              from_type = new_type if new_type
-            end
-          else
-            transformer.new(self)
-          end
-        elsif transformer.is_a?(Value::Processor)
-          transformer
-        elsif transformer.respond_to?(:call)
-          Value::Transformer.create(transform: transformer)
-        else
-          # :nocov:
-          raise "Not sure how to apply #{inputs_transformer}"
-          # :nocov:
-        end
-      end
-    end
-
     def construct_command
       self.command = command_class.new(transformed_inputs)
     end
@@ -453,13 +525,7 @@ module Foobara
     end
 
     # TODO: kill this
-    def serialize_result
-      body = if outcome.success?
-               outcome.result
-             else
-               outcome.errors
-             end
-
+    def serialize_result(body)
       if serializer
         serializer.process_value!(body)
       else

data/projects/command_connectors/src/command_connector/response.rb

@@ -1,14 +1,14 @@
 module Foobara
   class CommandConnector
     class Response
-      attr_accessor :status,
-                    :body,
-                    :request
+      attr_accessor :request,
+                    :status,
+                    :body
 
-      def initialize(status:, body:, request:)
+      def initialize(request:, status: nil, body: nil)
+        self.request = request
         self.status = status
         self.body = body
-        self.request = request
       end
 
       foobara_delegate :command, :error, to: :request

data/projects/command_connectors/src/command_connector.rb

@@ -95,6 +95,7 @@ module Foobara
                      :add_default_errors_transformer,
                      :add_default_pre_commit_transformer,
                      :add_default_serializer,
+                     :add_default_response_mutator,
                      :allowed_rule,
                      :allowed_rules,
                      :transform_command_class,
@@ -232,16 +233,34 @@ module Foobara
     end
 
     def request_to_response(request)
-      command = request.command
-      outcome = command.outcome
+      self.class::Response.new(request:)
+    end
+
+    def set_response_status(response)
+      outcome = response.request.outcome
+      response.status = outcome.success? ? 0 : 1
+    end
 
-      status = outcome.success? ? 0 : 1
+    def set_response_body(response)
+      outcome = response.request.outcome
+      # response.body = outcome.success? ? outcome.result : outcome.error_collection
+      response.body = outcome.success? ? outcome.result : outcome.error_collection
+    end
 
-      # TODO: feels awkward to call this here... Maybe use result/errors transformers instead??
-      # Or call the serializer here??
-      body = command.respond_to?(:serialize_result) ? command.serialize_result : request.response_body
+    def mutate_response(response)
+      command = response.command
 
-      self.class::Response.new(request:, status:, body:)
+      if command.respond_to?(:mutate_response)
+        command.mutate_response(response)
+      end
+    end
+
+    def serialize_response_body(response)
+      command = response.command
+
+      if command.respond_to?(:serialize_result)
+        response.body = command.serialize_result(response.body)
+      end
     end
 
     def initialize(authenticator: nil, default_serializers: nil)
@@ -343,7 +362,12 @@ module Foobara
 
     def build_response(request)
       response = request_to_response(request)
-      response.request = request
+
+      set_response_status(response)
+      set_response_body(response)
+      mutate_response(response)
+      serialize_response_body(response)
+
       response
     end
 
@@ -387,14 +411,28 @@ module Foobara
             additional_to_include.delete(o)
 
             if o.is_a?(::Module)
-              if o.foobara_domain? || o.foobara_organization? || (o.is_a?(::Class) && o < Foobara::Command)
+              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?(Types::Type) && remove_sensitive && o.sensitive?
-              # :nocov:
-              raise UnexpectedSensitiveTypeInManifestError,
-                    "Unexpected sensitive type in manifest: #{o.scoped_full_path}. Make sure these are not included."
+            elsif o.is_a?(Types::Type)
+              if remove_sensitive && o.sensitive?
+                # :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)
+                  domain = command_registry.build_and_register_exposed_domain(domain_name)
+                  additional_to_include << domain
+                  additional_to_include << domain.foobara_organization
+                end
+              end
             end
 
             object = o

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

@@ -12,6 +12,7 @@ module Foobara
                     :errors_transformers,
                     :pre_commit_transformers,
                     :serializers,
+                    :response_mutators,
                     :allowed_rule,
                     :requires_authentication,
                     :authenticator,
@@ -27,6 +28,7 @@ module Foobara
         result_transformers: nil,
         errors_transformers: nil,
         pre_commit_transformers: nil,
+        response_mutators: nil,
         serializers: nil,
         allowed_rule: nil,
         requires_authentication: nil,
@@ -76,6 +78,7 @@ module Foobara
         self.result_transformers = result_transformers
         self.errors_transformers = errors_transformers
         self.pre_commit_transformers = pre_commit_transformers
+        self.response_mutators = response_mutators
         self.serializers = serializers
         self.allowed_rule = allowed_rule
         self.requires_authentication = requires_authentication
@@ -111,6 +114,7 @@ module Foobara
             result_transformers,
             errors_transformers,
             pre_commit_transformers,
+            response_mutators,
             serializers,
             allowed_rule,
             requires_authentication,
@@ -130,6 +134,7 @@ module Foobara
                                            result_transformers:,
                                            errors_transformers:,
                                            pre_commit_transformers:,
+                                           response_mutators:,
                                            serializers:,
                                            allowed_rule:,
                                            requires_authentication:,

data/projects/command_connectors/src/response_mutator.rb

@@ -0,0 +1,24 @@
+module Foobara
+  module CommandConnectors
+    class ResponseMutator < Foobara::Value::Mutator
+      def result_type_declaration_from(_result_type)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def result_type_from(result_type)
+        declaration = result_type_declaration_from(result_type)
+        Domain.current.foobara_type_from_declaration(declaration)
+      end
+
+      def mutate
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      alias response declaration_data
+    end
+  end
+end

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

@@ -4,12 +4,12 @@ module Foobara
   module CommandConnectors
     module Serializers
       class ErrorsSerializer < Serializer
-        # TODO: always_applicable? instead?
         def always_applicable?
           !request.outcome.success?
         end
 
-        def serialize(errors)
+        def serialize(error_collection)
+          errors = error_collection.errors
           errors.map(&:to_h)
         end
       end

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

@@ -123,6 +123,29 @@ module Foobara
             end
           end
 
+          def construct_deep_associations(
+            type = attributes_type,
+            path = DataPath.new,
+            result = {},
+            remove_sensitive: false
+          )
+            associations = construct_associations(type, path, result, remove_sensitive:)
+
+            deep = {}
+
+            associations.each_pair do |data_path, association_type|
+              deep[data_path] = association_type
+
+              entity_class = association_type.target_class
+
+              entity_class.deep_associations(remove_sensitive:).each_pair do |sub_data_path, sub_type|
+                deep["#{data_path}.#{sub_data_path}"] = sub_type
+              end
+            end
+
+            deep
+          end
+
           # TODO: this big switch is a problem. Hard to create new types in other projects without being able
           # to modify this switch.  Figure out what to do.
           def construct_associations(
@@ -224,8 +247,8 @@ module Foobara
                   types = types&.reject(&:sensitive?)
                 end
 
-                types.any? do |type|
-                  contains_associations?(type, false, remove_sensitive:)
+                types.any? do |key_or_value_type|
+                  contains_associations?(key_or_value_type, false, remove_sensitive:)
                 end
               end
             end

data/projects/domain/src/domain_module_extension.rb

@@ -231,9 +231,13 @@ module Foobara
           end
         end
 
-        def foobara_type_from_declaration(...)
+        def foobara_type_from_declaration(*args, **opts, &block)
+          if opts.empty? && block.nil? && args.size == 1 && args.first.is_a?(Types::Type)
+            return args.first
+          end
+
           Foobara::Namespace.use self do
-            foobara_type_builder.type_for_declaration(...)
+            foobara_type_builder.type_for_declaration(*args, **opts, &block)
           end
         end
 

data/projects/entity/src/sensitive_value_removers/entity.rb

@@ -3,12 +3,28 @@ module Foobara
     module SensitiveValueRemovers
       class Entity < DetachedEntity::SensitiveValueRemovers::DetachedEntity
         def transform(record)
-          sanitized_record = super
+          if record.loaded? || record.created?
+            sanitized_record = super
 
-          sanitized_record.is_loaded = record.loaded?
-          sanitized_record.is_persisted = record.persisted?
+            sanitized_record.is_loaded = record.loaded?
+            sanitized_record.is_persisted = record.persisted?
 
-          sanitized_record
+            sanitized_record
+          elsif record.persisted?
+            # We will assume that we do not need to clean up the primary key itself as
+            # we will assume we don't allow sensitive primary keys for now.
+            sanitized_record = to_type.target_class.build(record.class.primary_key_attribute => record.primary_key)
+
+            sanitized_record.is_persisted = true
+            sanitized_record.is_loaded = false
+            sanitized_record.is_built = false
+
+            sanitized_record
+          else
+            # :nocov:
+            raise "Not sure what to do with a record that isn't loaded, created, or persisted"
+            # :nocov:
+          end
         end
 
         def build_method

data/projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration.rb

@@ -12,7 +12,7 @@ module Foobara
             return false if type_symbol == expected_type_symbol
 
             if type_registered?(type_symbol)
-              type = type_for_declaration(type_symbol)
+              type = lookup_type!(type_symbol)
               type.extends?(BuiltinTypes[expected_type_symbol])
             end
           end

data/projects/model/src/sensitive_value_removers/model.rb

@@ -5,12 +5,10 @@ module Foobara
         def transform(record)
           attributes_type = from_type.element_types
 
-          sanitized_attributes, changed = sanitize_value(attributes_type, record.attributes)
+          sanitized_attributes, _changed = sanitize_value(attributes_type, record.attributes)
 
-          if changed
-            type.target_class.send(build_method, sanitized_attributes)
-          else
-            record
+          Namespace.use(to_type.created_in_namespace) do
+            to_type.target_class.send(build_method, sanitized_attributes)
           end
         end
 

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

@@ -0,0 +1,32 @@
+module Foobara
+  class AttributesTransformers < TypeDeclarations::TypedTransformer
+    class << self
+      def only(*attribute_names)
+        transformer_class = Class.new(Only)
+        transformer_class.only_attributes = attribute_names
+
+        transformer_class
+      end
+    end
+
+    class Only < AttributesTransformers
+      class << self
+        attr_accessor :only_attributes
+      end
+
+      def to_type_declaration
+        from_declaration = from_type.declaration_data
+        TypeDeclarations::Attributes.only(from_declaration, *self.class.only_attributes)
+      end
+
+      def transform(inputs)
+        inputs = Util.symbolize_keys(inputs)
+        inputs.slice(*allowed_keys)
+      end
+
+      def allowed_keys
+        to_type.element_types.keys
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Foobara
+  class AttributesTransformers < TypeDeclarations::TypedTransformer
+    class << self
+      def reject(*attribute_names)
+        transformer_class = Class.new(Reject)
+        transformer_class.reject_attributes = attribute_names
+
+        transformer_class
+      end
+    end
+
+    class Reject < AttributesTransformers
+      class << self
+        attr_accessor :reject_attributes
+      end
+
+      def to_type_declaration
+        from_declaration = from_type.declaration_data
+        TypeDeclarations::Attributes.reject(from_declaration, *self.class.reject_attributes)
+      end
+
+      def transform(inputs)
+        inputs = Util.symbolize_keys(inputs)
+        inputs.slice(*allowed_keys)
+      end
+
+      def allowed_keys
+        to_type.element_types.keys
+      end
+    end
+  end
+end

data/projects/type_declarations/src/handlers/registered_type_declaration/to_type_transformer.rb

@@ -15,7 +15,7 @@ module Foobara
           end
 
           def registered_type(strict_type_declaration)
-            lookup_absolute_type!(type_symbol(strict_type_declaration), mode: Namespace::LookupMode::ABSOLUTE)
+            lookup_type!(type_symbol(strict_type_declaration))
           end
 
           def target_classes(strict_type_declaration)

data/projects/type_declarations/src/remove_sensitive_values_transformer.rb

@@ -3,24 +3,21 @@ require_relative "typed_transformer"
 module Foobara
   module TypeDeclarations
     class RemoveSensitiveValuesTransformer < TypedTransformer
-      class << self
-        def type_declaration(type_declaration)
-          if type_declaration.is_a?(Types::Type)
-            type_declaration = type_declaration.declaration_data
-          end
+      def from(...)
+        super.tap do
+          associations = Foobara::DetachedEntity.construct_deep_associations(from_type)
+
+          associations&.values&.reverse&.each do |entity_type|
+            declaration = entity_type.declaration_data
+            sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
 
-          TypeDeclarations.remove_sensitive_types(type_declaration)
+            Domain.current.foobara_type_from_declaration(sanitized_type_declaration)
+          end
         end
       end
 
-      attr_accessor :namespace
-
-      def initialize(...)
-        super
-
-        self.namespace = Namespace.current
-
-        type
+      def to_type_declaration
+        TypeDeclarations.remove_sensitive_types(from_type.declaration_data)
       end
 
       def transform(_value)
@@ -31,9 +28,11 @@ module Foobara
 
       def sanitize_value(type, value)
         if type.has_sensitive_types?
-          remover_class = TypeDeclarations.sensitive_value_remover_class_for_type(type)
-          remover = Namespace.use(namespace) { remover_class.new(type) }
-          sanitized_value = remover.process_value!(value)
+          sanitized_value = Namespace.use to_type.created_in_namespace do
+            remover_class = TypeDeclarations.sensitive_value_remover_class_for_type(type)
+            remover = remover_class.new(from: type)
+            remover.process_value!(value)
+          end
 
           [sanitized_value, sanitized_value != value]
         else

data/projects/type_declarations/src/typed_transformer.rb

@@ -3,87 +3,101 @@ module Foobara
     # TODO: this should instead be a processor and have its own possible_errors
     class TypedTransformer < Value::Transformer
       class << self
-        # A,B,C,D
-        # let's say this transformer is C...
-        # If we are a noop, then we are going to output D.type and we expect B.type
-        # We obviously have a problem if D is incompatible with our output type.
-        # We need to know B.output_type in order to say what we are going to output.
-        #
-        # Conversely, we need to know what D expects in order to say what we expect to receive (sometimes)
-        #
-        # So logic is... For C to say what its type is, it must know B's output_type.
-        # or... I guess for an inputs transformer, we need to know what D expects as its type, right?
-        # since we have an obligation be compatible with it.
-        #
-        # Use case 1: command line interface gets awkward with models
-        # 1. Command takes model A
-        # 2. we want an inputs transformer that takes A.attributes_type
-        # 3. Therefore its type is A.attributes_type
-        # 4. And also, its output type is A.attributes_type in this case since there's no need to actually create the
-        #    models.
-        # 5. So to tell our type, we must know the type of what comes next.
-        #
-        # Use case 2:
-        # 1. Command takes foo: :integer but we want to take bar: :string
-        # 2. transformer has this hard-coded knowledge.
-        # 3. we don't need to receive either types to answer our input and output types.
-        #
-        # Use case 3: Changing a record into its primary key
-        # 1. Command has result type of A which is an Entity
-        # 2. transformer takes an A record and returns record.primary_key
-        # 3. To know the output type, we need to know the result type of the previous type.
-        # 4. To know the input type, we need to know the type of the previous transformer since they are the same.
-        #    (however, by convention we can just use nil in this case.)
-        #
-        # Use case 4: document upload
-        # 1. Command takes input stream plus some document info
-        # 2. controller action receives temporary file path
-        # 3. transformer opens input stream and replaces file path with input stream
-        # 4. In this case, we have hard-coded types.
-        #
-        # Challenge: we seem to not know in advance if the transformer needs to know what comes before it or what comes
-        # after it. Unless we are writing a one-off transformer then we have hard-coded knowledge.
-        #
-        # Seems like input transformer really needs to know what comes next, the target type.
-        # Seems like output transformer might require to know what came previously
-        #
-        # Plan:
-        # 1. Both inputs transformer and result have similar structure... they have a relevant type that they transform.
-        # The difference is that the result takes previous steps output and transforms it to a different type, whereas
-        # the input transformer needs to know what comes next in order to communicate its types.
-        # So we might be able to get away with a transformed_type that accepts the from_type. And the calling code can
-        # interpret how it goes. This might create some awkwardness or confusion at least when creating one of the
-        # two types of transformer.
-        def type_declaration(_from_type)
-          # :nocov:
-          nil
-          # :nocov:
+        def requires_declaration_data?
+          false
         end
 
-        def type(from_type)
-          dec = type_declaration(from_type)
+        def requires_parent_declaration_data?
+          false
+        end
 
-          if dec
-            if dec.is_a?(Types::Type)
-              dec
-            else
-              Domain.current.foobara_type_from_declaration(dec)
-            end
-          end
+        def from(...)
+          @from_type = Domain.current.foobara_type_from_declaration(...)
         end
+
+        def to(...)
+          @to_type = Domain.current.foobara_type_from_declaration(...)
+        end
+
+        attr_reader :from_type, :to_type
+      end
+
+      def from_type_declaration
+        nil
+      end
+
+      def to_type_declaration
+        nil
+      end
+
+      def from_type
+        return @from_type if defined?(@from_type)
+
+        @from_type = self.class.from_type || if from_type_declaration
+                                               Domain.current.foobara_type_from_declaration(from_type_declaration)
+                                             end
+      end
+
+      def to_type
+        return @to_type if defined?(@to_type)
+
+        @to_type = self.class.to_type || if to_type_declaration
+                                           Domain.current.foobara_type_from_declaration(to_type_declaration)
+                                         end
+      end
+
+      def has_to_type?
+        !!to_type
       end
 
-      alias from_type declaration_data
+      def has_from_type?
+        !!from_type
+      end
+
+      def from(...)
+        @from_type = Domain.current.foobara_type_from_declaration(...)
+      end
+
+      def to(...)
+        @to_type = Domain.current.foobara_type_from_declaration(...)
+      end
 
-      def type
-        return @type if @type
+      def initialize(from: nil, to: nil)
+        super()
+
+        if from
+          self.from from
+        end
+
+        if to
+          self.to to
+        end
 
-        @type = self.class.type(from_type)
+        # we want to force these to be created now in the current name space if they are declarations
+        from_type
+        to_type
       end
 
       def process_value(value)
+        if has_from_type?
+          outcome = Namespace.use from_type.created_in_namespace do
+            from_type.process_value(value)
+          end
+
+          return outcome unless outcome.success?
+
+          value = outcome.result
+        end
+
         output = transform(value)
-        Outcome.success(output)
+
+        if has_to_type?
+          Namespace.use to_type.created_in_namespace do
+            to_type.process_value(output)
+          end
+        else
+          Outcome.success(output)
+        end
       end
     end
   end

data/projects/type_declarations/src/with_registries.rb

@@ -12,10 +12,6 @@ module Foobara
           Domain.current.foobara_type_builder.type_declaration_handler_for(...)
         end
 
-        def lookup_absolute_type!(*, **opts, &)
-          Foobara::Namespace.global.foobara_lookup_type!(*, **opts.merge(mode: Namespace::LookupMode::ABSOLUTE), &)
-        end
-
         def lookup_type!(...)
           Foobara::Namespace.current.foobara_lookup_type!(...)
         end

data/projects/value/src/mutator.rb

@@ -0,0 +1,29 @@
+module Foobara
+  module Value
+    class Mutator < Processor
+      class << self
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+          super.merge(processor_type: :mutator)
+        end
+
+        def error_classes
+          []
+        end
+      end
+
+      def mutate(_value)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def process_value(value)
+        if applicable?(value)
+          mutate(value)
+        end
+
+        Outcome.success(value)
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.86
+  version: 0.0.88
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-03-23 00:00:00.000000000 Z
+date: 2025-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -27,30 +27,30 @@ dependencies:
   name: foobara-lru-cache
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.2
 - !ruby/object:Gem::Dependency
   name: foobara-util
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.11
 description: A command-centric and discoverable software framework with a focus on
   domain concepts and abstracting away integration code
 email:
@@ -179,6 +179,7 @@ files:
 - projects/command_connectors/src/command_registry/exposed_command.rb
 - projects/command_connectors/src/command_registry/exposed_domain.rb
 - projects/command_connectors/src/command_registry/exposed_organization.rb
+- projects/command_connectors/src/response_mutator.rb
 - projects/command_connectors/src/serializer.rb
 - projects/command_connectors/src/serializers/aggregate_serializer.rb
 - projects/command_connectors/src/serializers/atomic_serializer.rb
@@ -359,7 +360,8 @@ files:
 - projects/thread_parent/src/thread_parent.rb
 - projects/type_declarations/lib/foobara/type_declarations.rb
 - projects/type_declarations/src/attributes.rb
-- projects/type_declarations/src/attributes_transformer.rb
+- projects/type_declarations/src/attributes_transformers/only.rb
+- projects/type_declarations/src/attributes_transformers/reject.rb
 - projects/type_declarations/src/caster.rb
 - projects/type_declarations/src/desugarizer.rb
 - projects/type_declarations/src/dsl/attributes.rb
@@ -418,6 +420,7 @@ files:
 - projects/value/lib/foobara/value.rb
 - projects/value/src/caster.rb
 - projects/value/src/data_error.rb
+- projects/value/src/mutator.rb
 - projects/value/src/processor.rb
 - projects/value/src/processor/casting.rb
 - projects/value/src/processor/multi.rb

data/projects/type_declarations/src/attributes_transformer.rb

@@ -1,33 +0,0 @@
-module Foobara
-  class AttributesTransformer < TypeDeclarations::TypedTransformer
-    class << self
-      attr_accessor :only_attributes
-
-      def type_declaration(from_type)
-        from_declaration = from_type.declaration_data
-        to_declaration = TypeDeclarations::Attributes.only(from_declaration, *only_attributes)
-
-        if TypeDeclarations.declarations_equal?(from_declaration, to_declaration)
-          from_type
-        else
-          from_type.foobara_domain.foobara_type_from_declaration(to_declaration)
-        end
-      end
-
-      def only(*attribute_names)
-        transformer_class = Class.new(self)
-        transformer_class.only_attributes = attribute_names
-
-        transformer_class
-      end
-    end
-
-    def transform(inputs)
-      inputs.slice(*allowed_keys)
-    end
-
-    def allowed_keys
-      type.element_types.keys
-    end
-  end
-end