foobara 0.0.1

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

@@ -0,0 +1,51 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module Reflection
+        include Concern
+
+        module ClassMethods
+          def depends_on
+            associations.values.map(&:target_class).uniq
+          end
+
+          def deep_depends_on
+            types = deep_associations.sort_by do |path, _type|
+              [DataPath.new(path).path.size, path]
+            end.map(&:last)
+
+            types.map(&:target_class).uniq
+          end
+
+          def foobara_manifest(to_include:)
+            associations = self.associations.map do |(path, type)|
+              entity_class = type.target_class
+              entity_name = entity_class.full_entity_name
+
+              [path, entity_name]
+            end.sort.to_h
+
+            deep_associations = self.deep_associations.map do |(path, type)|
+              entity_class = type.target_class
+              entity_name = entity_class.full_entity_name
+
+              [path, entity_name]
+            end.sort.to_h
+
+            super.merge(
+              Util.remove_blank(
+                depends_on: depends_on.map(&:full_entity_name),
+                deep_depends_on: deep_depends_on.map(&:full_entity_name),
+                associations:,
+                deep_associations:,
+                entity_name:,
+                primary_key_attribute:,
+                primary_key_type: attributes_type.declaration_data[:element_type_declarations][primary_key_attribute]
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module Transactions
+        include Concern
+
+        module ClassMethods
+          def current_transaction_table
+            Foobara::Persistence.current_transaction_table!(self)
+          end
+
+          def current_transaction
+            Foobara::Persistence.current_transaction!(self)
+          end
+
+          def transaction(mode: nil, skip_dependent_transactions: false, &)
+            if skip_dependent_transactions
+              entity_base.transaction(mode, &)
+            else
+              Foobara::Persistence.transaction(
+                self, *deep_depends_on,
+                mode:,
+                &
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Foobara
+  class Entity < Model
+    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]
+          end
+        end
+      end
+    end
+  end
+end

data/projects/entity/src/entity.rb

@@ -0,0 +1,61 @@
+module Foobara
+  class Entity < Model
+    class CannotConvertRecordWithoutPrimaryKeyToJsonError < StandardError; end
+
+    include Concerns::Callbacks
+    include Concerns::Associations
+    include Concerns::Transactions
+    include Concerns::Queries
+    include Concerns::Types
+    include Concerns::Attributes
+    include Concerns::PrimaryKey
+    include Concerns::Persistence
+    include Concerns::Initialization
+    include Concerns::Reflection
+
+    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

@@ -0,0 +1,33 @@
+module Foobara
+  module BuiltinTypes
+    module Entity
+      module Casters
+        class Hash < Attributes::Casters::Hash
+          class << self
+            def requires_parent_declaration_data?
+              true
+            end
+          end
+
+          def cast(attributes)
+            symbolized_attributes = super
+
+            outcome = entity_class.attributes_type.process_value(symbolized_attributes)
+
+            if outcome.success?
+              entity_class.create(symbolized_attributes)
+            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)
+            end
+          end
+
+          def entity_class
+            Object.const_get(parent_declaration_data[:model_class])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Foobara
+  module BuiltinTypes
+    module Entity
+      module Validators
+        class AttributesDeclaration < Model::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
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,43 @@
+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
+
+          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
+  end
+end

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

@@ -0,0 +1,21 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
+        class ModelClassDesugarizer < ExtendModelTypeDeclaration::ModelClassDesugarizer
+          def expected_type_symbol
+            :entity
+          end
+
+          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
+  end
+end

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

@@ -0,0 +1,19 @@
+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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
+        class ToTypeTransformer < ExtendModelTypeDeclaration::ToTypeTransformer
+          # TODO: move this to a more appropriate place
+          class EntityPrimaryKeyCaster < Value::Caster
+            class << self
+              def requires_declaration_data?
+                true
+              end
+            end
+
+            def entity_class
+              declaration_data
+            end
+
+            def primary_key_type
+              entity_class.primary_key_type
+            end
+
+            def applicable?(value)
+              primary_key_type.applicable?(value)
+            end
+
+            def transform(primary_key)
+              entity_class.thunk(primary_key)
+            end
+
+            def applies_message
+              primary_key_type.value_caster.applies_message
+            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)
+                  end
+                end
+
+                type.casters << EntityPrimaryKeyCaster.new(entity_class)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendEntityTypeDeclaration < ExtendModelTypeDeclaration
+        def expected_type_symbol
+          :entity
+        end
+      end
+    end
+  end
+end

data/projects/entity/src/new_prepend.rb

@@ -0,0 +1,21 @@
+module Foobara
+  class Entity < Model
+    module NewPrepend
+      # rubocop:disable Lint/UselessMethodDefinition
+      def new(...)
+        super
+      end
+      # rubocop:enable Lint/UselessMethodDefinition
+
+      alias __private_new__ new
+
+      # rubocop:disable Lint/DuplicateMethods
+      def new(...)
+        # :nocov:
+        raise "Cannot initialize a #{name}. Use .create, .thunk, .loaded, or .build instead."
+        # :nocov:
+      end
+      # rubocop:enable Lint/DuplicateMethods
+    end
+  end
+end

data/projects/entity/src/not_found_error.rb

@@ -0,0 +1,72 @@
+module Foobara
+  class Entity < Model
+    class NotFoundError < Foobara::RuntimeError
+      class << self
+        def not_found_error_class_name(data_path)
+          error_class_name = data_path.path.map { |part| part == :"#" ? "Collection" : Util.classify(part) }.join
+          "#{error_class_name}NotFoundError"
+        end
+
+        def subclass(mod, entity_class, data_path)
+          error_class_name = not_found_error_class_name(data_path)
+
+          # TODO: how would we avoid name collisions here??
+          Util.make_class("#{mod.name}::#{error_class_name}", self) do
+            # TODO: use Concern to change these into attr_accessor instead
+            singleton_class.define_method :data_path do
+              data_path
+            end
+
+            singleton_class.define_method :entity_class do
+              entity_class
+            end
+
+            singleton_class.define_method :context_type_declaration do
+              {
+                entity_class: :string, # TODO: we don't have a way to specify an exact value for a type
+                criteria: :duck, # TODO: find_by attributes unioned with primary key
+                data_path: :string # TODO: we don't have a way to specify an exact value for a type
+              }
+            end
+          end
+        end
+
+        def data_path
+          nil
+        end
+
+        def context_type_declaration
+          {
+            entity_class: :string, # TODO: we don't have a way to specify an exact value for a type
+            criteria: :duck, # TODO: probably should be integer or string but no union types yet
+            data_path: :string # TODO: we don't have a way to specify an exact value for a type
+          }
+        end
+      end
+
+      attr_accessor :data_path, :entity_class, :criteria
+
+      foobara_delegate :primary_key_attribute, :full_entity_name, to: :entity_class
+
+      def initialize(criteria, entity_class: self.class.entity_class, data_path: self.class.data_path)
+        self.criteria = criteria
+        self.entity_class = entity_class
+        self.data_path = data_path || ""
+
+        super(context:, message:)
+      end
+
+      def context
+        {
+          entity_class: full_entity_name,
+          criteria:,
+          data_path: data_path.to_s
+        }
+      end
+
+      def message
+        "Could not find #{entity_class} for #{criteria}"
+      end
+    end
+  end
+end

data/projects/enumerated/lib/foobara/enumerated.rb

@@ -0,0 +1 @@
+module Foobara::Enumerated; end