foobara 0.0.85 → 0.0.87

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3447ac0c4910cce965172cfdeaa22c16558bde49b0b0bcd533e2d5dba7b27188
-  data.tar.gz: 67797d30549979ba6ef227d8c61bae996408d598b77edac19b4210a6e4e0edc6
+  metadata.gz: 45093221881afa7419b208493f3787403c664a149f77728ac64daaea00c7b083
+  data.tar.gz: 4103467f677825cd70e2d8d468cc9845511789c32e4a2f69c3cc4901fb9704c5
 SHA512:
-  metadata.gz: 2c1b45ecd837fe9f66bb5dcd7d97d3f07dcbb8876a2c913386837378197b4ba0f33fac885283806adf9afea80cef65e3445ce13aff0e491005add424353e2475
-  data.tar.gz: 4270856b98fb68dd813b3bde8e7284995f1293ec0f310122a4d136da4e2c02c094e5110c8e1363b80a8a6d699d0efec49148d4284302494f714e11edbbdd84b6
+  metadata.gz: e655dc065c7b923be1d76742e9fc651f8d7581cdfd3ad9130cc20e474ca42bb15791ebc35238bc52d8b255cef440237234c01eda4189b850287ecd142141271e
+  data.tar.gz: 54893503e3dfed78a608590f44a9673aca2b8c208094a306c7b10634afea59380caee6a0998cd283c1ecb7097b227705b9a3644186d2f3afe561ee0676170717

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [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)
+
 # [0.0.85] - 2025-03-22
 
 - Add Manifest::TypeDeclaration#sensitive?

data/projects/command/src/transformed_command.rb

@@ -36,12 +36,12 @@ module Foobara
         result_type = command_class.result_type
 
         if result_type&.has_sensitive_types?
+
           remover_class = Foobara::TypeDeclarations.sensitive_value_remover_class_for_type(result_type)
 
           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
@@ -71,25 +71,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
 
@@ -217,6 +226,69 @@ module Foobara
           )
         )
       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 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,16 +331,16 @@ 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
 
@@ -278,30 +350,6 @@ module Foobara
       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 +357,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 +369,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 +383,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 +396,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

data/projects/command_connectors/src/command_connector.rb

@@ -387,14 +387,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/serializers/errors_serializer.rb

@@ -4,7 +4,6 @@ module Foobara
   module CommandConnectors
     module Serializers
       class ErrorsSerializer < Serializer
-        # TODO: always_applicable? instead?
         def always_applicable?
           !request.outcome.success?
         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/manifest/src/foobara/manifest/type_declaration.rb

@@ -92,7 +92,6 @@ module Foobara
 
       def to_model
         raise "not an model" unless model?
-        raise "model extension instead of an model" unless relevant_manifest.size == 1
 
         type = to_type
 

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/namespace/src/namespace_helpers.rb

@@ -164,7 +164,20 @@ module Foobara
         def foobara_autoset_scoped_path(mod, make_top_level: false)
           return if mod.scoped_path_set?
 
-          scoped_path = mod.name.split("::")
+          mod_name = mod.name
+
+          if mod_name.nil?
+            parent = mod.superclass
+            super_name = nil
+
+            begin
+              super_name = parent.scoped_path_set? ? parent.scoped_full_name : parent.name
+            end until super_name
+
+            mod_name = [super_name, mod.object_id.to_s(16)].join("::")
+          end
+
+          scoped_path = mod_name.split("::")
 
           adjusted_scoped_path = []
 

data/projects/type_declarations/src/attributes.rb

@@ -33,6 +33,22 @@ module Foobara
           )
         end
 
+        def only(declaration, *keys)
+          valid_keys = declaration[:element_type_declarations].keys
+          keys_to_keep = keys.map(&:to_sym)
+          invalid_keys = keys_to_keep - valid_keys
+
+          if invalid_keys.any?
+            # :nocov:
+            raise ArgumentError, "Invalid keys: #{invalid_keys} expected only #{valid_keys}"
+            # :nocov:
+          end
+
+          keys_to_reject = valid_keys - keys_to_keep
+
+          reject(declaration, keys_to_reject)
+        end
+
         def reject(declaration, *keys)
           # TODO: do we really need a deep dup?
           declaration = Util.deep_dup(declaration)

data/projects/type_declarations/src/attributes_transformer.rb

@@ -0,0 +1,27 @@
+module Foobara
+  class AttributesTransformer < TypeDeclarations::TypedTransformer
+    class << self
+      attr_accessor :only_attributes
+
+      def only(*attribute_names)
+        transformer_class = Class.new(self)
+        transformer_class.only_attributes = attribute_names
+
+        transformer_class
+      end
+    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.slice(*allowed_keys)
+    end
+
+    def allowed_keys
+      to_type.element_types.keys
+    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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.85
+  version: 0.0.87
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-03-23 00:00:00.000000000 Z
+date: 2025-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -359,6 +359,7 @@ 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/caster.rb
 - projects/type_declarations/src/desugarizer.rb
 - projects/type_declarations/src/dsl/attributes.rb