foobara 0.0.142 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6defed2fda94d3c5f244f9f24eb9a32f4d06999bc773071dc58667565518499
-  data.tar.gz: 98a0f663a38ce6b105f78fbbefdc1e34328654ec54755daa379df824753f3214
+  metadata.gz: cdaf6b7b731daba3eefc95587311b462b0dcd05372e879410396ce7c3de1624f
+  data.tar.gz: a60835ec80262ed79f24d3dad4189d3f3eacd5516e1e0d137ba1e7dd30d6422e
 SHA512:
-  metadata.gz: 9c42abcbd62eba3583acfd4345df530ec04efdc18d19773ce1ed5dafa9e0d43d09364b2b45355a22874b2aeaf030d476726cbd214ec1a3626812b2a20c35133f
-  data.tar.gz: 7cc3b4e13250e4cc2b3af8468b2f5774861161fcc13972ecc87f17c1682bd8a69170a080b6f9cc72249ff5756d2a7f1ca509dfaeba2ac52bbf9896c8b9a4f3e6
+  metadata.gz: e12bd29804a5ca80e08796d719e023d6aa5daeeae9e5f14296ff61cc3c1833d5ed660da186e8816e3f0c2fa929af5c9b0ff1ddcb4d4f093df8b7fa9ecbd8961e
+  data.tar.gz: 568db83480a82cb3420f9a4286be408a020a02308947759cd6b1115a4e98f2d7af21a9cc2bef41414c1327b15e0de6e4ac836ce879ca2150fa6da054e68f1120

data/.ruby-version

@@ -1 +1 @@
-3.4.3
+3.4.5

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# [0.1.1] - 2025-08-22
+
+- Change type declarations for references to registered types to have a structure of `:some_type` 
+  instead of a `{ type: :some_type }` structure. This makes things faster and also make things less ambiguous.
+- Order entity bases and transaction tables by dependencies to simplify making sure associations
+  already have their primary keys set
+- Add Manifest::Type#primitive? and Manifest::TypeDeclaration#primitive?/#reference?
+- Add Type#primitive? and Type#derived? concepts
+- Add ABSOLUTE_SINGLE_NAMESPACE and refactor #foobara_lookup to be much faster
+- Checking #applicable? is now the caller's responsibility when running value processors
+- Run RSpec and Rubocop in separate jobs in CI
+- Don't load pry by default
+- Introduce TypeDeclaration and use it to eliminate some desugarizers and speed things up significantly
+  while also improving code readability
+- Eliminate `_desugarized` metadata entry from declaration data now that TypeDeclaration can encapsulate
+  such state
+- Lazy load Type#element_type(s) and strictify them
+- Fix bug where .add_inputs is called when .inputs was never called
+
 # [0.0.142] - 2025-08-10
 
 - Add LruCache to IsNamespace to speed up lookups

data/projects/builtin_types/lib/foobara/builtin_types.rb

@@ -3,6 +3,7 @@ require "time"
 require "bigdecimal"
 
 module Foobara
+  # TODO: rename this to PrimitiveTypes and deprecate the name BuiltinTypes
   module BuiltinTypes
     class << self
       def builtin_types

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_defaults_from_element_types_to_root.rb

@@ -8,12 +8,19 @@ module Foobara
               module Desugarizers
                 class MoveDefaultsFromElementTypesToRoot < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes && value.key?(:element_type_declarations)
+                    value.hash? && value[:type] == :attributes && value.key?(:element_type_declarations)
                   end
 
                   def desugarize(rawish_type_declaration)
                     defaults = rawish_type_declaration[:defaults]
-                    defaults = defaults ? defaults.dup : {}
+
+                    if defaults
+                      unless rawish_type_declaration.deep_duped?
+                        defaults = defaults.dup
+                      end
+                    else
+                      defaults = {}
+                    end
 
                     element_type_declarations = rawish_type_declaration[:element_type_declarations]
 

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/symbolize_defaults.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class SymbolizeDefaults < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes && value[:defaults]
+                    value.hash? && value[:type] == :attributes && value[:defaults]
                   end
 
                   def desugarize(rawish_type_declaration)

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/hash_with_symbolic_keys.rb

@@ -16,7 +16,7 @@ module Foobara
                   end
 
                   def applicable?(strict_type_declaration)
-                    strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:defaults)
+                    strict_type_declaration.hash? && strict_type_declaration.key?(:defaults)
                   end
 
                   def validation_errors(strict_type_declaration)

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/alphabetize_required.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class AlphabetizeRequired < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes &&
+                    value.hash? && value[:type] == :attributes &&
                       value.key?(:required) && value[:required].size > 1
                   end
 
@@ -17,11 +17,11 @@ module Foobara
 
                     sorted_required = required.sort
 
-                    if sorted_required == required
-                      rawish_type_declaration
-                    else
-                      rawish_type_declaration.merge(required: sorted_required)
+                    if sorted_required != required
+                      rawish_type_declaration[:required] = sorted_required
                     end
+
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_required_from_element_types_to_root.rb

@@ -8,7 +8,9 @@ module Foobara
               module Desugarizers
                 class MoveRequiredFromElementTypesToRoot < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes && value.key?(:element_type_declarations)
+                    return false if value.strict?
+
+                    value.hash? && value[:type] == :attributes && value.key?(:element_type_declarations)
                   end
 
                   def desugarize(rawish_type_declaration)
@@ -24,13 +26,17 @@ module Foobara
 
                     element_type_declarations = rawish_type_declaration[:element_type_declarations]
 
+                    changed = false
+
                     element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
                       if attribute_type_declaration.is_a?(::Hash) && attribute_type_declaration.key?(:required)
                         is_required = attribute_type_declaration[:required]
 
-                        if [true, false].include?(is_required)
+                        if is_required == true || is_required == false
                           element_type_declarations[attribute_name] = attribute_type_declaration.except(:required)
 
+                          changed = true
+
                           if is_required
                             required_attributes << attribute_name
                           else
@@ -46,6 +52,10 @@ module Foobara
                       rawish_type_declaration[:required] = required_attributes
                     end
 
+                    if changed
+                      rawish_type_declaration[:element_type_declarations] = element_type_declarations
+                    end
+
                     rawish_type_declaration
                   end
                 end

data/projects/builtin_types/src/builtin_types.rb

@@ -16,7 +16,7 @@ module Foobara
         description: "Built-in #{type_symbol} type",
         type_module: nil
       )
-        declaration_data = { type: type_symbol.to_sym }
+        declaration_data = type_symbol.to_sym
 
         module_symbol = Util.classify(type_symbol).to_sym
 

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/class_desugarizer.rb

@@ -8,11 +8,19 @@ module Foobara
               module Desugarizers
                 class ClassDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Class)
+                    rawish_type_declaration.class?
                   end
 
                   def desugarize(rawish_type_declaration)
-                    { type: :duck, instance_of: rawish_type_declaration.name }
+                    rawish_type_declaration.declaration_data = {
+                      type: :duck,
+                      instance_of: rawish_type_declaration.declaration_data.name
+                    }
+                    rawish_type_declaration.is_strict = true
+                    rawish_type_declaration.is_deep_duped = true
+                    rawish_type_declaration.is_duped = true
+
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/class_type_desugarizer.rb

@@ -8,14 +8,19 @@ module Foobara
               module Desugarizers
                 class ClassTypeDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    return false unless rawish_type_declaration.is_a?(::Hash)
+                    return false unless rawish_type_declaration.hash?
 
                     rawish_type_declaration[:type].is_a?(::Class)
                   end
 
                   def desugarize(rawish_type_declaration)
                     klass = rawish_type_declaration[:type]
-                    rawish_type_declaration.merge(type: :duck, instance_of: klass.name)
+
+                    rawish_type_declaration[:type] = :duck
+                    rawish_type_declaration[:instance_of] = klass.name
+                    rawish_type_declaration.is_absolutified = true
+
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/instance_of_class_desugarizer.rb

@@ -8,13 +8,12 @@ module Foobara
               module Desugarizers
                 class InstanceOfClassDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:instance_of].is_a?(::Class)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:instance_of].is_a?(::Class)
                   end
 
                   def desugarize(rawish_type_declaration)
-                    instance_of = rawish_type_declaration[:instance_of]
-                    instance_of = instance_of.name
-                    rawish_type_declaration.merge(instance_of:)
+                    rawish_type_declaration[:instance_of] = rawish_type_declaration[:instance_of].name
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/instance_of_symbol_desugarizer.rb

@@ -8,13 +8,12 @@ module Foobara
               module Desugarizers
                 class InstanceOfSymbolDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:instance_of].is_a?(::Symbol)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:instance_of].is_a?(::Symbol)
                   end
 
                   def desugarize(rawish_type_declaration)
-                    instance_of = rawish_type_declaration[:instance_of]
-                    instance_of = instance_of.to_s
-                    rawish_type_declaration.merge(instance_of:)
+                    rawish_type_declaration[:instance_of] = rawish_type_declaration[:instance_of].to_s
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/type_declaration_validators/is_valid_class.rb

@@ -16,7 +16,7 @@ module Foobara
                   end
 
                   def applicable?(strict_type_declaration)
-                    strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:instance_of)
+                    strict_type_declaration.hash? && strict_type_declaration.key?(:instance_of)
                   end
 
                   def validation_errors(strict_type_declaration)

data/projects/builtin_types/src/duck/supported_validators/instance_of.rb

@@ -30,6 +30,7 @@ module Foobara
 
           def validation_errors(value)
             klass = Object.const_get(expected_class_name)
+
             unless value.is_a?(klass)
               build_error(value)
             end

data/projects/builtin_types/src/duck/supported_validators/one_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/cast_one_of.rb

@@ -8,19 +8,20 @@ module Foobara
               module Desugarizers
                 class CastOneOf < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:one_of].is_a?(::Array)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:one_of].is_a?(::Array)
                   end
 
                   def desugarize(rawish_type_declaration)
                     one_of = rawish_type_declaration[:one_of]
 
+                    # TODO: for performance, can we just use the type identified by type: when possible?
                     type = type_for_declaration(rawish_type_declaration.except(:one_of))
 
-                    one_of = one_of.map do |value|
+                    rawish_type_declaration[:one_of] = one_of.map do |value|
                       type.process_value!(value)
                     end
 
-                    rawish_type_declaration.merge(one_of:)
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/one_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/module_desugarizer.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class ModuleDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:one_of].is_a?(::Module)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:one_of].is_a?(::Module)
                   end
 
                   def desugarize(rawish_type_declaration)
@@ -16,7 +16,7 @@ module Foobara
 
                     one_of = Util.constant_values(mod)
 
-                    one_of = begin
+                    rawish_type_declaration[:one_of] = begin
                       one_of.sort
                     rescue
                       # :nocov:
@@ -24,7 +24,7 @@ module Foobara
                       # :nocov:
                     end
 
-                    rawish_type_declaration.merge(one_of:)
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/tuple/supported_processors/element_type_declarations/type_declaration_extension/extend_tuple_type_declaration/desugarizers/set_size.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class SetSize < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    if value.is_a?(::Hash)
+                    if value.hash?
                       value.key?(:element_type_declarations) && value[:type] == :tuple && !value.key?(:size)
                     end
                   end

data/projects/builtin_types/src/tuple/supported_processors/element_type_declarations/type_declaration_extension/extend_tuple_type_declaration/type_declaration_validators/size_matches.rb

@@ -12,8 +12,7 @@ module Foobara
                       def context_type_declaration
                         {
                           expected_size: :integer,
-                          actual_size: :integer,
-                          value: :array
+                          actual_size: :integer
                         }
                       end
                     end
@@ -33,8 +32,7 @@ module Foobara
                         message: "Expected tuple to have #{size} elements but it had #{element_type_declarations_size}",
                         context: {
                           expected_size: size,
-                          actual_size: element_type_declarations_size,
-                          value: strict_type_declaration
+                          actual_size: element_type_declarations_size
                         }
                       )
                     end

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

@@ -26,13 +26,17 @@ module Foobara
           end
 
           def add_inputs(...)
-            new_type = type_for_declaration(...)
-            new_declaration = TypeDeclarations::Attributes.merge(
-              inputs_type.declaration_data,
-              new_type.declaration_data
-            )
-
-            inputs new_declaration
+            if inputs_type
+              new_type = type_for_declaration(...)
+              new_declaration = TypeDeclarations::Attributes.merge(
+                inputs_type.declaration_data,
+                new_type.declaration_data
+              )
+
+              inputs new_declaration
+            else
+              inputs(...)
+            end
           end
 
           def inputs_type
@@ -43,10 +47,6 @@ module Foobara
                            end
           end
 
-          def raw_inputs_type_declaration
-            inputs_type.raw_declaration_data
-          end
-
           def inputs_type_declaration
             inputs_type.declaration_data
           end
@@ -61,7 +61,7 @@ module Foobara
           end
         end
 
-        foobara_delegate :inputs_type, :raw_inputs_type_declaration, to: :class
+        foobara_delegate :inputs_type, to: :class
       end
     end
   end

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

@@ -24,8 +24,10 @@ module Foobara
             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)
+              other_command = Foobara::Namespace.global.foobara_lookup!(
+                command_name,
+                mode: Foobara::Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+              )
               if to_include
                 to_include << other_command
               end

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

@@ -16,10 +16,6 @@ module Foobara
                              superclass.result_type
                            end
           end
-
-          def raw_result_type_declaration
-            result_type.raw_declaration_data
-          end
         end
 
         foobara_delegate :result_type, :raw_result_type_declaration, to: :class

data/projects/command_connectors/src/command_connector.rb

@@ -494,8 +494,7 @@ module Foobara
       to_include << command_registry.global_organization
       to_include << command_registry.global_domain
 
-      # ABSOLUTE lets us get all of the children but not include dependent domains (GlobalDomain)
-      command_registry.foobara_each(mode: Namespace::LookupMode::ABSOLUTE) do |exposed_whatever|
+      command_registry.foobara_each(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) do |exposed_whatever|
         to_include << exposed_whatever
       end
 
@@ -539,19 +538,20 @@ module Foobara
                 else
                   domain_name = o.foobara_domain.scoped_full_name
 
-                  unless command_registry.foobara_registered?(domain_name, mode: Namespace::LookupMode::ABSOLUTE)
+                  unless command_registry.foobara_registered?(domain_name,
+                                                              mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
                     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(
-                      mode: Namespace::LookupMode::ABSOLUTE
+                      mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
                     ).each do |exposed_domain|
                       additional_to_include << exposed_domain
                     end
 
                     command_registry.foobara_all_organization(
-                      mode: Namespace::LookupMode::ABSOLUTE
+                      mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
                     ).each do |exposed_organization|
                       additional_to_include << exposed_organization
                     end
@@ -649,7 +649,7 @@ module Foobara
     def all_exposed_commands
       process_delayed_connections
 
-      command_registry.foobara_all_command(mode: Namespace::LookupMode::ABSOLUTE)
+      command_registry.foobara_all_command(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
     end
 
     def all_exposed_type_names

data/projects/command_connectors/src/command_registry.rb

@@ -34,7 +34,8 @@ module Foobara
 
     def create_exposed_command(command_class, **)
       full_domain_name = command_class.domain.scoped_full_name
-      exposed_domain = foobara_lookup_domain(full_domain_name, mode: Namespace::LookupMode::ABSOLUTE) ||
+      exposed_domain = foobara_lookup_domain(full_domain_name,
+                                             mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
                        build_and_register_exposed_domain(full_domain_name)
 
       exposed_command = create_exposed_command_without_domain(command_class, **)
@@ -81,7 +82,7 @@ module Foobara
 
       exposed_organization = foobara_lookup_organization(
         full_organization_name,
-        mode: Namespace::LookupMode::ABSOLUTE
+        mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
       ) || build_and_register_exposed_organization(full_organization_name)
 
       exposed_domain = Module.new
@@ -108,13 +109,15 @@ module Foobara
     end
 
     def global_domain
-      foobara_lookup_domain("") || build_and_register_exposed_domain("")
+      foobara_lookup_domain("", mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
+        build_and_register_exposed_domain("")
     end
 
     def global_organization
       # TODO: test this
       # :nocov:
-      foobara_lookup_organization("") || build_and_register_exposed_organization("")
+      foobara_lookup_organization("", mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
+        build_and_register_exposed_organization("")
       # :nocov:
     end
 

data/projects/command_connectors/src/transformed_command.rb

@@ -502,7 +502,9 @@ module Foobara
       end
 
       def mutate_request(request)
-        request_mutator&.process_value!(request)
+        if request_mutator&.applicable?(request)
+          request_mutator.process_value!(request)
+        end
       end
 
       def result_transformer
@@ -594,8 +596,10 @@ module Foobara
     end
 
     def transform_inputs
-      self.transformed_inputs = if self.class.inputs_transformer
-                                  outcome = self.class.inputs_transformer.process_value(untransformed_inputs)
+      transformer = self.class.inputs_transformer
+
+      self.transformed_inputs = if transformer&.applicable?(untransformed_inputs)
+                                  outcome = transformer.process_value(untransformed_inputs)
 
                                   if outcome.success?
                                     outcome.result
@@ -625,17 +629,23 @@ module Foobara
     end
 
     def transform_result
-      if self.class.result_transformer
-        self.outcome = Outcome.success(self.class.result_transformer.process_value!(result))
+      transformer = self.class.result_transformer
+
+      if transformer&.applicable?(result)
+        self.outcome = Outcome.success(transformer.process_value!(result))
       end
     end
 
     def mutate_response(response)
-      self.class.response_mutator&.process_value!(response)
+      mutator = self.class.response_mutator
+
+      if mutator&.applicable?(response)
+        mutator.process_value!(response)
+      end
     end
 
     def transform_errors
-      if errors_transformer
+      if errors_transformer&.applicable?(errors)
         self.outcome = Outcome.errors(errors_transformer.process_value!(errors))
       end
     end
@@ -708,7 +718,9 @@ module Foobara
               source = if allowed_rule.block.respond_to?("source") && defined?(MethodSource)
                          begin
                            # This only works when pry is loaded
+                           # :nocov:
                            allowed_rule.block.source
+                           # :nocov:
                          rescue MethodSource::SourceNotFoundError
                            # This path is hit if the way the source code is extracted
                            # doesn't result in valid Ruby, for example, as part of a hash such as:
@@ -733,7 +745,9 @@ module Foobara
     def apply_pre_commit_transformers
       if pre_commit_transformer
         command.before_commit_transaction do |**|
-          pre_commit_transformer.process_value!(self)
+          if pre_commit_transformer.applicable?(self)
+            pre_commit_transformer.process_value!(self)
+          end
         end
       end
     end

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

@@ -20,6 +20,7 @@ module Foobara
             map
           end
         end
+
         def applicable?(_request)
           false
         end

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

@@ -48,6 +48,10 @@ module Foobara
             elsif to_type.extends?(Foobara::BuiltinTypes[:detached_entity])
               declaration = to_type.target_class.primary_key_type.reference_or_declaration_data
 
+              if declaration.is_a?(::Symbol)
+                declaration = { type: declaration  }
+              end
+
               description = "#{to_type.target_class.model_name} #{to_type.target_class.primary_key_attribute}"
 
               unless to_type.extends_directly?(Foobara::BuiltinTypes[:detached_entity]) ||

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

@@ -20,7 +20,13 @@ module Foobara
           def type_declaration(...)
             raise "No primary key set yet" unless primary_key_attribute
 
-            super.merge(type: :detached_entity, primary_key: primary_key_attribute)
+            declaration = super
+
+            declaration[:type] = :detached_entity
+            declaration[:primary_key] = primary_key_attribute
+            declaration.is_absolutified = true
+
+            declaration
           end
 
           def set_model_type

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

@@ -5,7 +5,7 @@ module Foobara
         class ModelInstanceIsValid < Model::Validators::ModelInstanceIsValid
           # Why is this here in entity/ instead of in model/?
           def possible_errors
-            return [] if parent_declaration_data == { type: expected_type_symbol }
+            return [] if parent_declaration_data == expected_type_symbol
 
             # TODO: we should also ask the class if it is mutable...
             mutable = parent_declaration_data.key?(:mutable) ? parent_declaration_data[:mutable] : false