foobara 0.0.29 → 0.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8722f293cfd3487965f3863448b8cf175481df41f364fe9c8a880c19430cbd86
-  data.tar.gz: 14aafe8e69546446ec65694d6f48ea14b44af2e94bbd2a05a0cd71209831bfd8
+  metadata.gz: 8d39eaab1139573fba75d906c51de6091e81d77a1af812f60262bca2ff2064ab
+  data.tar.gz: da9a2b06e850ac495edc2f06a79969b75896b2c28134c91e724bca4c13397182
 SHA512:
-  metadata.gz: 024d6d200f25cef54f5aa8a719af536d6f5e8fbf767fa6e9aa30ac04ba6f6c2f30815964cf1e0a079944e7a588c4afb91aaadbabe6c47ca9e001f0f3b01e8649
-  data.tar.gz: a31f5904edef9faf390075de61229dd0890e0251a1b9e5e5d870a900f7ef1744d0cf4dbedf2812e9f9559773cc8f9dc5cbec89518a237adbfc82b4dace2d5642
+  metadata.gz: ce7d43c817996c3301bdbc332875d7bd73dad8f29c64f12c7c070d89cc95a88974cd05bb84aa9f94bb7af2d9181f16e3a4cace92f04d8233486c12b8a25876ca
+  data.tar.gz: 6b6f82a0620e369c2a071f0e3ff33b648243abba31b3e0dc8c59c824a4f10d771add1f7bfbd6f802b4d7ce6a7536fc1f87f77ec9bba052f920229593e10418e2

data/CHANGELOG.md

@@ -1,8 +1,13 @@
-## [0.0.29] - 2024-12-07
+## [0.0.31] - 2024-12-09
+
+- Introduce a DetachedEntity concept that sits between Model and Entity
+
+## [0.0.30] - 2024-12-07
 
 - Fix problems with extending models/entities
 - Add a mutable class helper for models and improve mutable
   use a bit
+- Fix bug when passing an unregistered Type instance to .foobara_registered?
 
 ## [0.0.28] - 2024-12-05
 

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

@@ -6,6 +6,8 @@ module Foobara
       class EntitiesToPrimaryKeysSerializer < SuccessSerializer
         def serialize(object)
           case object
+          # What of DetachedEntity? I guess we should treat it as a model since we can't cast from primary key value to
+          # a record?
           when Entity
             # TODO: handle polymorphism? Would require iterating over the result type not the object!
             # Is there maybe prior art for this in the associations stuff?

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