foobara 0.0.30 → 0.0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2052d9d5b024d1a47bc58db2e556345569adc23512580280d636dee90e21a624
-  data.tar.gz: baeb2f5c0a5d0f3f9d16e57309246a9e0c188ebf4c2089c7fa61e578fed04940
+  metadata.gz: c792e842511e06c18b7104b2d417b4ba93275266f94257207176f9c6eed4265f
+  data.tar.gz: 4ce865c5dd74d839710bdb4a766e47e645ab07e4a484cf32ede9ed839e3d75a9
 SHA512:
-  metadata.gz: a03fadfd01cc720964f056a826aec7bad39208a974754d919a19654e606013fc772490da495e1317cfdeae8cb3ece6de34e098d1d9710b2718643ffe808edf3f
-  data.tar.gz: b0bb12d7f3b2368676664838a0d54575ded39a61482479cbc31ca9c23b3223fe1210c8fdf48b20c89c7bc72e3977792813d7e249cb94cde3d2a4917ce11fec3e
+  metadata.gz: 5d0d59e0a8bd59703873c845a06a9afb756c8326700f8858eeeff476cde1ad3b20386037008211db6878727eb6585d9d7cd4b8e4892e784d65028c9d19060db1
+  data.tar.gz: a45f976f9a90d78a1f6e4ae2077da4846565a89c2092a0cf7da92ab068dda6ef25b2ec1f8700824ff29c3dc58b53f4ebc0bdf35984b865c6cb91c63136327204

data/CHANGELOG.md

@@ -1,4 +1,9 @@
-## [0.0.29] - 2024-12-07
+## [0.0.32] - 2024-12-09
+
+- Introduce a DetachedEntity concept that sits between Model and Entity
+- Add a detached_to_primary_key flag to EntitiesToPrimaryKeysSerializer
+
+## [0.0.30] - 2024-12-07
 
 - Fix problems with extending models/entities
 - Add a mutable class helper for models and improve mutable

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

@@ -10,11 +10,17 @@ module Foobara
             # TODO: handle polymorphism? Would require iterating over the result type not the object!
             # Is there maybe prior art for this in the associations stuff?
             object.primary_key
+          when DetachedEntity
+            if declaration_data[:detached_to_primary_key]
+              object.primary_key
+            else
+              object.attributes
+            end
           when Model
             object.attributes
-          when Array
+          when ::Array
             object.map { |element| serialize(element) }
-          when Hash
+          when ::Hash
             object.to_h do |key, value|
               [serialize(key), serialize(value)]
             end

data/projects/detached_entity/lib/foobara/detached_entity.rb

@@ -0,0 +1,19 @@
+module Foobara
+  class DetachedEntity < Model
+    abstract
+
+    class << self
+      # Need to override this otherwise we install Model twice
+      def install!
+        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendDetachedEntityTypeDeclaration.new)
+
+        model = Namespace.global.foobara_lookup_type!(:model)
+        BuiltinTypes.build_and_register!(:detached_entity, model, nil)
+      end
+
+      def reset_all
+        install!
+      end
+    end
+  end
+end

data/projects/{entity → detached_entity}/src/concerns/associations.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class DetachedEntity < Model
     module Concerns
       module Associations
         include Concern
@@ -96,7 +96,7 @@ module Foobara
                   key.include?(filter)
                 end
               end
-            elsif filter.is_a?(::Class) && filter < Entity
+            elsif filter.is_a?(::Class) && filter < DetachedEntity
               association_keys.select do |key|
                 type = deep_associations[key]
                 entity_class = type.target_class
@@ -114,7 +114,7 @@ module Foobara
             path = DataPath.new,
             result = {}
           )
-            if type.extends?(BuiltinTypes[:entity])
+            if type.extends?(BuiltinTypes[:detached_entity])
               result[path.to_s] = type
             elsif type.extends?(BuiltinTypes[:tuple])
               element_types = type.element_types
@@ -150,7 +150,7 @@ module Foobara
           end
 
           def contains_associations?(type = entity_type, initial = true)
-            if type.extends?(BuiltinTypes[:entity])
+            if type.extends?(BuiltinTypes[:detached_entity])
               if initial
                 contains_associations?(type.element_types, false)
               else
@@ -179,61 +179,6 @@ module Foobara
               end
             end
           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/detached_entity/src/concerns/equality.rb

@@ -0,0 +1,24 @@
+module Foobara
+  class DetachedEntity
+    module Concerns
+      module Equality
+        include Concern
+
+        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
+      end
+    end
+  end
+end

data/projects/{entity → detached_entity}/src/concerns/primary_key.rb

@@ -1,5 +1,5 @@
 module Foobara
-  class Entity < Model
+  class DetachedEntity < Model
     module Concerns
       module PrimaryKey
         include Concern
@@ -28,7 +28,7 @@ module Foobara
           def primary_key_attribute
             return @primary_key_attribute if @primary_key_attribute
 
-            unless superclass == Entity
+            unless superclass == DetachedEntity
               @primary_key_attribute = superclass.primary_key_attribute
             end
           end

data/projects/{entity → detached_entity}/src/concerns/reflection.rb

@@ -1,9 +1,23 @@
 module Foobara
-  class Entity < Model
+  class DetachedEntity < Model
     module Concerns
       module Reflection
+        class CannotConvertRecordWithoutPrimaryKeyToJsonError < StandardError; end
+
         include Concern
 
+        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
+
         module ClassMethods
           def depends_on
             associations.values.map(&:target_class).uniq

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

@@ -0,0 +1,41 @@
+module Foobara
+  class DetachedEntity < Model
+    module Concerns
+      module Types
+        include Concern
+
+        foobara_delegate :full_entity_name, :entity_name, to: :class
+
+        module ClassMethods
+          def entity_type
+            model_type
+          end
+
+          def type_declaration(...)
+            raise "No primary key set yet" unless primary_key_attribute
+
+            super.merge(type: :detached_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]
+          end
+
+          def full_entity_name
+            full_model_name
+          end
+
+          def entity_name
+            model_name
+          end
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/detached_entity.rb

@@ -0,0 +1,15 @@
+module Foobara
+  class DetachedEntity < Model
+    include Concerns::Equality
+    include Concerns::Associations
+    include Concerns::PrimaryKey
+    include Concerns::Reflection
+    include Concerns::Types
+
+    class << self
+      def allowed_subclass_opts
+        [:primary_key, *super]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Foobara
+  module BuiltinTypes
+    module DetachedEntity
+      module Casters
+        class Hash < Attributes::Casters::Hash
+          class << self
+            def requires_parent_declaration_data?
+              true
+            end
+          end
+
+          def cast(attributes)
+            symbolized_attributes = super
+
+            entity_class.send(build_method(symbolized_attributes), symbolized_attributes)
+          end
+
+          def build_method(_symbolized_attributes)
+            :new
+          end
+
+          def entity_class
+            type = parent_declaration_data[:type]
+
+            if type == expected_type_symbol
+              Object.const_get(parent_declaration_data[:model_class])
+            else
+              Foobara::Namespace.current.foobara_lookup_type!(type).target_class
+            end
+          end
+
+          def expected_type_symbol
+            :detached_entity
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Foobara
+  module BuiltinTypes
+    module DetachedEntity
+      module Validators
+        class AttributesDeclaration < Model::Validators::AttributesDeclaration
+          # Why is this here in entity/ instead of in model/?
+          def possible_errors
+            return [] if parent_declaration_data == { type: 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
+
+            entity_class.possible_errors(mutable:)
+          end
+
+          def entity_class
+            if parent_declaration_data.key?(:model_class)
+              Object.const_get(parent_declaration_data[:model_class])
+            elsif parent_declaration_data[:type] != expected_type_symbol
+              model_type = type_for_declaration(parent_declaration_data[:type])
+              model_type.target_class
+            else
+              # :nocov:
+              raise "Missing :model_class in parent_declaration_data for #{parent_declaration_data}"
+              # :nocov:
+            end
+          end
+
+          def expected_type_symbol
+            :detached_entity
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Foobara
+  module BuiltinTypes
+    module DetachedEntity
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/attributes_handler_desugarizer.rb

@@ -0,0 +1,13 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < ExtendModelTypeDeclaration
+        class AttributesHandlerDesugarizer < ExtendModelTypeDeclaration::AttributesHandlerDesugarizer
+          def expected_type_symbol
+            :detached_entity
+          end
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/hash_desugarizer.rb

@@ -0,0 +1,43 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < 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
+
+          def expected_type_symbol
+            :detached_entity
+          end
+
+          def desugarize(sugary_type_declaration)
+            Util.symbolize_keys(sugary_type_declaration)
+          end
+
+          def priority
+            Priority::FIRST + 1
+          end
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/model_class_desugarizer.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < ExtendModelTypeDeclaration
+        class ModelClassDesugarizer < ExtendModelTypeDeclaration::ModelClassDesugarizer
+          def expected_type_symbol
+            :detached_entity
+          end
+
+          def default_model_base_class
+            Foobara::DetachedEntity
+          end
+
+          def create_model_class_args(model_module:, type_declaration:)
+            super.merge(primary_key: type_declaration[:primary_key])
+          end
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/primary_key_desugarizer.rb

@@ -0,0 +1,19 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < 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
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/to_type_transformer.rb

@@ -0,0 +1,26 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < ExtendModelTypeDeclaration
+        class ToTypeTransformer < ExtendModelTypeDeclaration::ToTypeTransformer
+          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
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_is_symbol.rb

@@ -0,0 +1,35 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < 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
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_present.rb

@@ -0,0 +1,27 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < 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
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_references_attribute.rb

@@ -0,0 +1,36 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < 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
+        end
+      end
+    end
+  end
+end

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration.rb

@@ -0,0 +1,15 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendDetachedEntityTypeDeclaration < ExtendModelTypeDeclaration
+        def expected_type_symbol
+          :detached_entity
+        end
+
+        def priority
+          super - 1
+        end
+      end
+    end
+  end
+end

data/projects/entity/lib/foobara/entity.rb

@@ -1,20 +1,16 @@
-require "date"
-require "time"
-require "bigdecimal"
-
 module Foobara
   # TODO: I think we should have a configuration that indicates if created records can have primary keys past to them
   # or not. That is, do primary keys get issued by the database upon insertion? Or are they generated externally
   # and passed in? Would be nice to have programmatic clarification via explicit configuration.
-  class Entity < Model
+  class Entity < DetachedEntity
     abstract
 
     class << self
       def install!
         TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendEntityTypeDeclaration.new)
 
-        model = Namespace.global.foobara_lookup_type!(:model)
-        BuiltinTypes.build_and_register!(:entity, model, nil)
+        detached_entity = Namespace.global.foobara_lookup_type!(:detached_entity)
+        BuiltinTypes.build_and_register!(:entity, detached_entity, nil)
       end
 
       def reset_all