foobara 0.0.29 → 0.0.31

data/projects/entity/src/concerns/attribute_helpers.rb

@@ -1,14 +1,9 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     module Concerns
       module AttributeHelpers
         include Foobara::Concern
 
-        def update_aggregate(value, type = self.class.model_type)
-          # is this a smell?
-          self.class.update_aggregate(self, value, type)
-        end
-
         module ClassMethods
           def attributes_for_update
             attributes_for_aggregate_update
@@ -111,58 +106,6 @@ module Foobara
             )
           end
 
-          def update_aggregate(object, value, type = object.class.model_type)
-            return value if object.nil?
-
-            if type.extends?(BuiltinTypes[:model])
-              element_types = type.element_types.element_types
-
-              value.each_pair do |attribute_name, new_value|
-                current_value = object.read_attribute(attribute_name)
-
-                attribute_type = element_types[attribute_name]
-
-                updated_value = update_aggregate(current_value, new_value, attribute_type)
-
-                object.write_attribute(attribute_name, updated_value)
-              end
-
-              object
-            elsif type.extends?(BuiltinTypes[:attributes])
-              element_types = type.element_types
-
-              object = object.dup
-              object ||= {}
-
-              value.each_pair do |attribute_name, new_value|
-                current_value = object[attribute_name]
-                attribute_type = element_types[attribute_name]
-
-                updated_value = update_aggregate(current_value, new_value, attribute_type)
-
-                object[attribute_name] = updated_value
-              end
-
-              object
-            elsif type.extends?(BuiltinTypes[:tuple])
-              # :nocov:
-              raise "Tuple not yet supported"
-            # :nocov:
-            elsif type.extends?(BuiltinTypes[:associative_array])
-              # :nocov:
-              raise "Associated array not yet supported"
-            # :nocov:
-            elsif type.extends?(BuiltinTypes[:array])
-              element_type = type.element_type
-
-              value.map.with_index do |element, index|
-                update_aggregate(object[index], element, element_type)
-              end
-            else
-              value
-            end
-          end
-
           private
 
           def type_declaration_value_at(declaration, path_parts)

data/projects/entity/src/concerns/attributes.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     module Concerns
       module Attributes
         class UnexpectedPrimaryKeyChangeError < StandardError; end

data/projects/entity/src/concerns/callbacks.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     module Concerns
       module Callbacks
         include Concern

data/projects/entity/src/concerns/initialization.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     class NoCurrentTransactionError < StandardError; end
 
     module Concerns

data/projects/entity/src/concerns/mutations.rb

@@ -0,0 +1,68 @@
+module Foobara
+  class Entity < DetachedEntity
+    module Concerns
+      module Mutations
+        include Concern
+
+        def update_aggregate(value, type = self.class.model_type)
+          # is this a smell?
+          self.class.update_aggregate(self, value, type)
+        end
+
+        module ClassMethods
+          def update_aggregate(object, value, type = object.class.model_type)
+            return value if object.nil?
+
+            if type.extends?(BuiltinTypes[:model])
+              element_types = type.element_types.element_types
+
+              value.each_pair do |attribute_name, new_value|
+                current_value = object.read_attribute(attribute_name)
+
+                attribute_type = element_types[attribute_name]
+
+                updated_value = update_aggregate(current_value, new_value, attribute_type)
+
+                object.write_attribute(attribute_name, updated_value)
+              end
+
+              object
+            elsif type.extends?(BuiltinTypes[:attributes])
+              element_types = type.element_types
+
+              object = object.dup
+              object ||= {}
+
+              value.each_pair do |attribute_name, new_value|
+                current_value = object[attribute_name]
+                attribute_type = element_types[attribute_name]
+
+                updated_value = update_aggregate(current_value, new_value, attribute_type)
+
+                object[attribute_name] = updated_value
+              end
+
+              object
+            elsif type.extends?(BuiltinTypes[:tuple])
+              # :nocov:
+              raise "Tuple not yet supported"
+              # :nocov:
+            elsif type.extends?(BuiltinTypes[:associative_array])
+              # :nocov:
+              raise "Associated array not yet supported"
+              # :nocov:
+            elsif type.extends?(BuiltinTypes[:array])
+              element_type = type.element_type
+
+              value.map.with_index do |element, index|
+                update_aggregate(object[index], element, element_type)
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/entity/src/concerns/persistence.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     module Concerns
       module Persistence
         class CannotUpdateHardDeletedRecordError < StandardError; end

data/projects/entity/src/concerns/queries.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     module Concerns
       module Queries
         include Concern
@@ -89,6 +89,61 @@ module Foobara
           def count
             current_transaction_table.count
           end
+
+          def that_owns(record, filters = [])
+            containing_records = that_own(record, filters)
+
+            unless containing_records.empty?
+              if containing_records.size == 1
+                containing_records.first
+              else
+                # :nocov:
+                raise "Expected only one record to own #{record} but found #{containing_records.size}"
+                # :nocov:
+              end
+            end
+          end
+
+          def that_own(record, filters = [])
+            association_key = association_for([record.class, *filters])
+
+            data_path = DataPath.new(association_key)
+
+            done = false
+
+            containing_records = Util.array(record)
+
+            until done
+              last = data_path.path.last
+
+              if last == :"#"
+                method = :find_all_by_attribute_containing_any_of
+                attribute_name = data_path.path[-2]
+                data_path = DataPath.new(data_path.path[0..-3])
+              else
+                method = :find_all_by_attribute_any_of
+                attribute_name = last
+                data_path = DataPath.new(data_path.path[0..-2])
+              end
+
+              containing_entity_class_path = data_path.to_s
+
+              entity_class = if containing_entity_class_path.empty?
+                               done = true
+                               self
+                             else
+                               deep_associations[
+                                 containing_entity_class_path
+                               ].target_class
+                             end
+
+              containing_records = entity_class.send(method, attribute_name, containing_records).to_a
+
+              done = true unless containing_records
+            end
+
+            containing_records
+          end
         end
       end
     end

data/projects/entity/src/concerns/transactions.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     module Concerns
       module Transactions
         include Concern

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

@@ -1,28 +1,12 @@
 module Foobara
-  class Entity < Model
+  class Entity < DetachedEntity
     module Concerns
       module Types
         include Concern
 
         module ClassMethods
-          def entity_type
-            model_type
-          end
-
           def type_declaration(...)
-            raise "No primary key set yet" unless primary_key_attribute
-
-            super.merge(type: :entity, primary_key: primary_key_attribute)
-          end
-
-          def set_model_type
-            if primary_key_attribute
-              super
-            end
-          end
-
-          def primary_key_type
-            @primary_key_type ||= attributes_type.element_types[primary_key_attribute]
+            super.merge(type: :entity)
           end
         end
       end

data/projects/entity/src/entity.rb

@@ -1,62 +1,17 @@
 module Foobara
-  class Entity < Model
-    class CannotConvertRecordWithoutPrimaryKeyToJsonError < StandardError; end
-
+  class Entity < DetachedEntity
     include Concerns::Callbacks
-    include Concerns::Associations
     include Concerns::Transactions
     include Concerns::Queries
-    include Concerns::Types
+    include Concerns::Mutations
     include Concerns::Attributes
-    include Concerns::PrimaryKey
     include Concerns::Persistence
     include Concerns::Initialization
-    include Concerns::Reflection
     include Concerns::AttributeHelpers
+    include Concerns::Types
 
     class << self
       prepend NewPrepend
-
-      def full_entity_name
-        full_model_name
-      end
-
-      def entity_name
-        model_name
-      end
-
-      def allowed_subclass_opts
-        [:primary_key, *super]
-      end
-    end
-
-    foobara_delegate :full_entity_name, :entity_name, to: :class
-
-    def dup
-      # TODO: Maybe raise instead?
-      self
-    end
-
-    def ==(other)
-      # Should both records be required to be persisted to be considered equal when having matching primary keys?
-      # For now we will consider them equal but it could make sense to consider them not equal.
-      equal?(other) || (self.class == other.class && primary_key && primary_key == other.primary_key)
-    end
-
-    def hash
-      (primary_key || object_id).hash
-    end
-
-    def inspect
-      "<#{entity_name}:#{primary_key}>"
-    end
-
-    def to_json(*_args)
-      primary_key&.to_json || raise(
-        CannotConvertRecordWithoutPrimaryKeyToJsonError,
-        "Cannot call record.to_json on unless record has a primary key. " \
-        "Consider instead calling record.attributes.to_json instead."
-      )
     end
   end
 end

data/projects/entity/src/extensions/builtin_types/entity/casters/hash.rb

@@ -3,35 +3,23 @@ module Foobara
     module Entity
       module Casters
         # TODO: We need a way of disabling/enabling this and it should probably be disabled by default.
-        class Hash < Attributes::Casters::Hash
-          class << self
-            def requires_parent_declaration_data?
-              true
-            end
-          end
-
-          def cast(attributes)
-            symbolized_attributes = super
+        class Hash < DetachedEntity::Casters::Hash
+          def build_method(attributes)
+            outcome = entity_class.attributes_type.process_value(attributes)
 
-            outcome = entity_class.attributes_type.process_value(symbolized_attributes)
+            outcome.result
 
             if outcome.success?
-              entity_class.create(symbolized_attributes)
+              :create
             else
               # we build an instance so that it can fail a validator later. But we already know we don't want to
               # persist this thing. So use build instead of create.
-              entity_class.build(outcome.result)
+              :build
             end
           end
 
-          def entity_class
-            type = parent_declaration_data[:type]
-
-            if type == :entity
-              Object.const_get(parent_declaration_data[:model_class])
-            else
-              Foobara::Namespace.current.foobara_lookup_type!(type).target_class
-            end
+          def expected_type_symbol
+            :entity
           end
         end
       end

data/projects/entity/src/extensions/builtin_types/entity/validators/attributes_declaration.rb

@@ -2,28 +2,13 @@ module Foobara
   module BuiltinTypes
     module Entity
       module Validators
-        class AttributesDeclaration < Model::Validators::AttributesDeclaration
+        class AttributesDeclaration < DetachedEntity::Validators::AttributesDeclaration
           def applicable?(record)
             record.created? || record.built?
           end
 
-          # Why is this here in entity/ instead of in model/?
-          def possible_errors
-            return [] if parent_declaration_data == { type: :entity }
-
-            mutable = parent_declaration_data.key?(:mutable) ? parent_declaration_data[:mutable] : false
-
-            if parent_declaration_data.key?(:model_class)
-              Object.const_get(parent_declaration_data[:model_class]).possible_errors(mutable:)
-            elsif parent_declaration_data[:type] != :entity
-              model_type = type_for_declaration(parent_declaration_data[:type])
-              model_class = model_type.target_class
-              model_class.possible_errors(mutable:)
-            else
-              # :nocov:
-              raise "Missing :model_class in parent_declaration_data for #{parent_declaration_data}"
-              # :nocov:
-            end
+          def expected_type_symbol
+            :entity
           end
         end
       end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/attributes_handler_desugarizer.rb

@@ -1,9 +1,8 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        # TODO: need primary key type declaration validator!
-        class AttributesHandlerDesugarizer < ExtendModelTypeDeclaration::AttributesHandlerDesugarizer
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class AttributesHandlerDesugarizer < ExtendDetachedEntityTypeDeclaration::AttributesHandlerDesugarizer
           def expected_type_symbol
             :entity
           end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/hash_desugarizer.rb

@@ -1,41 +1,11 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        class HashDesugarizer < TypeDeclarations::Desugarizer
-          def applicable?(sugary_type_declaration)
-            return false unless sugary_type_declaration.is_a?(::Hash)
-            return false unless Util.all_symbolizable_keys?(sugary_type_declaration)
-
-            sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
-
-            type_symbol = sugary_type_declaration[:type] || sugary_type_declaration["type"]
-            return false unless type_symbol
-
-            type_symbol = type_symbol.to_sym if type_symbol.is_a?(::String)
-
-            return true if type_symbol == expected_type_symbol
-
-            if type_symbol.is_a?(::Symbol) && type_registered?(type_symbol)
-              type = Foobara.foobara_root_namespace.foobara_lookup_type(
-                type_symbol, mode: Namespace::LookupMode::ABSOLUTE
-              )
-
-              type&.extends?(BuiltinTypes[expected_type_symbol])
-            end
-          end
-
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class HashDesugarizer < ExtendDetachedEntityTypeDeclaration::HashDesugarizer
           def expected_type_symbol
             :entity
           end
-
-          def desugarize(sugary_type_declaration)
-            Util.symbolize_keys(sugary_type_declaration)
-          end
-
-          def priority
-            Priority::FIRST + 1
-          end
         end
       end
     end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/model_class_desugarizer.rb

@@ -1,8 +1,8 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        class ModelClassDesugarizer < ExtendModelTypeDeclaration::ModelClassDesugarizer
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class ModelClassDesugarizer < ExtendDetachedEntityTypeDeclaration::ModelClassDesugarizer
           def expected_type_symbol
             :entity
           end
@@ -10,10 +10,6 @@ module Foobara
           def default_model_base_class
             Foobara::Entity
           end
-
-          def create_model_class_args(model_module:, type_declaration:)
-            super.merge(primary_key: type_declaration[:primary_key])
-          end
         end
       end
     end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/primary_key_desugarizer.rb

@@ -1,17 +1,8 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        class PrimaryKeyDesugarizer < Desugarizer
-          def applicable?(sugary_type_declaration)
-            primary_key = sugary_type_declaration[:primary_key]
-
-            primary_key.is_a?(::String)
-          end
-
-          def desugarize(sugary_type_declaration)
-            sugary_type_declaration.merge(primary_key: sugary_type_declaration[:primary_key].to_sym)
-          end
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class PrimaryKeyDesugarizer < ExtendDetachedEntityTypeDeclaration::PrimaryKeyDesugarizer
         end
       end
     end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/to_type_transformer.rb

@@ -1,8 +1,8 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        class ToTypeTransformer < ExtendModelTypeDeclaration::ToTypeTransformer
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class ToTypeTransformer < ExtendDetachedEntityTypeDeclaration::ToTypeTransformer
           # TODO: move this to a more appropriate place
           class EntityPrimaryKeyCaster < Value::Caster
             class << self
@@ -32,21 +32,12 @@ module Foobara
             end
           end
 
-          def non_processor_keys
-            [:primary_key, *super]
-          end
-
           def process_value(strict_declaration_type)
             super.tap do |outcome|
               if outcome.success?
                 type = outcome.result
-
                 entity_class = type.target_class
 
-                unless entity_class.primary_key_attribute
-                  entity_class.primary_key(strict_declaration_type[:primary_key])
-                end
-
                 unless entity_class.can_be_created_through_casting?
                   type.casters = type.casters.reject do |caster|
                     caster.is_a?(Foobara::BuiltinTypes::Entity::Casters::Hash)

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/validate_primary_key_is_symbol.rb

@@ -1,33 +1,8 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        class ValidatePrimaryKeyIsSymbol < TypeDeclarations::TypeDeclarationValidator
-          class PrimaryKeyNotSymbolError < TypeDeclarationError
-            class << self
-              def context_type_declaration
-                {
-                  primary_key: :duck
-                }
-              end
-            end
-          end
-
-          def applicable?(strict_type_declaration)
-            strict_type_declaration.key?(:primary_key)
-          end
-
-          def validation_errors(strict_type_declaration)
-            primary_key = strict_type_declaration[:primary_key]
-            unless primary_key.is_a?(::Symbol)
-              build_error(
-                message: "Expected #{primary_key} to be a symbol but it was a #{primary_key.class}",
-                context: {
-                  primary_key:
-                }
-              )
-            end
-          end
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class ValidatePrimaryKeyIsSymbol < ExtendDetachedEntityTypeDeclaration::ValidatePrimaryKeyIsSymbol
         end
       end
     end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/validate_primary_key_present.rb

@@ -1,25 +1,8 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        class ValidatePrimaryKeyPresent < TypeDeclarations::TypeDeclarationValidator
-          # TODO: seems like maybe we could actually check against types now...
-          # like make a type for primary_key: :symbol ??
-          class MissingPrimaryKeyError < TypeDeclarationError; end
-
-          def validation_errors(strict_type_declaration)
-            unless strict_type_declaration.key?(:primary_key)
-              build_error
-            end
-          end
-
-          def error_message(_value)
-            "Missing required :primary_key to state which attribute is the primary key"
-          end
-
-          def error_context(_value)
-            {}
-          end
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class ValidatePrimaryKeyPresent < ExtendDetachedEntityTypeDeclaration::ValidatePrimaryKeyPresent
         end
       end
     end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/validate_primary_key_references_attribute.rb

@@ -1,34 +1,9 @@
 module Foobara
   module TypeDeclarations
     module Handlers
-      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
-        class ValidatePrimaryKeyReferencesAttribute < TypeDeclarations::TypeDeclarationValidator
-          class InvalidPrimaryKeyError < TypeDeclarationError
-            class << self
-              def context_type_declaration
-                {
-                  allowed_primary_keys: [:symbol],
-                  primary_key: :symbol
-                }
-              end
-            end
-          end
-
-          def applicable?(strict_type_declaration)
-            strict_type_declaration.key?(:primary_key) && strict_type_declaration[:primary_key].is_a?(::Symbol)
-          end
-
-          def validation_errors(strict_type_declaration)
-            allowed_primary_keys = strict_type_declaration[:attributes_declaration][:element_type_declarations].keys
-
-            primary_key = strict_type_declaration[:primary_key]
-            unless allowed_primary_keys.include?(primary_key)
-              build_error(
-                message: "Invalid primary key. Expected #{primary_key} to be one of #{allowed_primary_keys}",
-                context: { allowed_primary_keys:, primary_key: }
-              )
-            end
-          end
+      class ExtendEntityTypeDeclaration < ExtendDetachedEntityTypeDeclaration
+        class ValidatePrimaryKeyReferencesAttribute <
+          ExtendDetachedEntityTypeDeclaration::ValidatePrimaryKeyReferencesAttribute
         end
       end
     end