foobara 0.0.92 → 0.0.94

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

@@ -5,20 +5,26 @@ module Foobara
         include Concern
 
         module ClassMethods
-          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+          def foobara_manifest
+            remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+
             attributes_declaration = foobara_attributes_type.declaration_data
 
             if remove_sensitive
               attributes_declaration = TypeDeclarations.remove_sensitive_types(attributes_declaration)
             end
 
+            # TODO: do we really need all this stuff? Can't it be grabbed off of the declaration data to save
+            # space?
             Util.remove_blank(
               attributes_type: attributes_declaration,
               organization_name: foobara_type.foobara_domain.foobara_organization_name,
               domain_name: foobara_type.foobara_domain.foobara_domain_name,
               model_name: foobara_model_name,
               model_base_class: foobara_type.declaration_data[:model_base_class],
-              model_class: foobara_type.declaration_data[:model_class]
+              model_class: foobara_type.declaration_data[:model_class],
+              delegates:,
+              private: private_attribute_names
             )
           end
         end

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

@@ -35,16 +35,10 @@ module Foobara
             end
           end
 
-          def attributes(*args, **opts, &)
-            new_type = domain.foobara_type_from_declaration(*args, **opts, &)
-
-            unless new_type.extends?(BuiltinTypes[:attributes])
-              # :nocov:
-              raise ArgumentError, "Expected #{args} #{opts} to extend :attributes " \
-                                   "but instead it resulted in: #{new_type.declaration_data}"
-              # :nocov:
-            end
+          def attributes(...)
+            private, attributes_type_declaration = extract_private_from_attributes_declaration(...)
 
+            new_type = domain.foobara_type_from_declaration(attributes_type_declaration)
             existing_type = attributes_type
 
             if existing_type
@@ -57,6 +51,7 @@ module Foobara
             end
 
             self.attributes_type = new_type
+            private_attributes(private)
 
             set_model_type
           end
@@ -69,14 +64,12 @@ module Foobara
 
               if model_type
                 unless Foobara::TypeDeclarations.declarations_equal?(declaration, model_type.declaration_data)
-                  domain.foobara_unregister(model_type)
                   self.model_type = nil
                   domain.foobara_type_from_declaration(declaration)
                 end
               else
                 domain.foobara_type_from_declaration(declaration)
               end
-
             end
           end
 
@@ -85,22 +78,22 @@ module Foobara
           end
 
           def type_declaration(attributes_declaration)
-            if name
-              model_base_class = superclass.name
-              model_class = name
+            if model_type
+              model_module_name = model_type.declaration_data[:model_module]
+              model_class = model_type.declaration_data[:model_class]
+              model_name = model_type.scoped_name
+              model_base_class = superclass.name || superclass.model_type.scoped_full_name
+            else
+              model_base_class = superclass.name || superclass.full_model_name
+              model_class = name || full_model_name
 
-              if name.start_with?(closest_namespace_module.name)
+              if model_class.start_with?(closest_namespace_module.name)
                 model_module_name = closest_namespace_module.name
-                model_name = name.gsub(/^#{closest_namespace_module.name}::/, "")
+                model_name = model_class.gsub(/^#{closest_namespace_module.name}::/, "")
               else
                 model_module_name = nil
-                model_name = name
+                model_name = model_class
               end
-            else
-              model_module_name = model_type.declaration_data[:model_module]
-              model_class = model_type.declaration_data[:model_class]
-              model_name = model_type.scoped_name
-              model_base_class = superclass.name || superclass.model_type.scoped_full_name
             end
 
             Util.remove_blank(
@@ -112,7 +105,9 @@ module Foobara
               attributes_declaration:,
               description:,
               _desugarized: { type_absolutified: true },
-              mutable:
+              mutable:,
+              delegates:,
+              private: private_attribute_names
             )
           end
 
@@ -131,7 +126,15 @@ module Foobara
           def model_type=(model_type)
             @model_type = model_type
 
+            return if model_type.nil?
+
+            private = model_type.declaration_data[:private]
+
             attributes_type.element_types.each_key do |attribute_name|
+              if delegates.key?(attribute_name)
+                next
+              end
+
               define_method attribute_name do
                 read_attribute(attribute_name)
               end
@@ -140,7 +143,102 @@ module Foobara
               define_method "#{attribute_name}=" do |value|
                 write_attribute(attribute_name, value)
               end
+
+              if private&.include?(attribute_name)
+                private attribute_name
+                private "#{attribute_name}="
+              end
+            end
+          end
+
+          def delegates
+            @delegates ||= {}
+          end
+
+          def private_attribute_names
+            @private_attribute_names ||= []
+          end
+
+          def private_attributes(attribute_names)
+            attribute_names.each do |attribute_name|
+              private_attribute attribute_name
+            end
+          end
+
+          def private_attribute(attribute_name)
+            @private_attribute_names = private_attribute_names | [attribute_name]
+
+            set_model_type
+          end
+
+          def delegate_attributes(delegates)
+            delegates.each_pair do |attribute_name, delegate_info|
+              delegate_attribute(attribute_name, delegate_info[:data_path], writer: delegate_info[:writer])
+            end
+          end
+
+          def delegate_attribute(attribute_name, data_path, writer: false)
+            data_path = DataPath.for(data_path)
+
+            delegate_manifest = { data_path: data_path.to_s }
+
+            if writer
+              delegate_manifest[:writer] = true
+            end
+
+            delegates[attribute_name] = delegate_manifest
+
+            delegated_type_declaration = model_type.type_at_path(data_path).reference_or_declaration_data
+            attributes attribute_name => delegated_type_declaration
+
+            define_method attribute_name do
+              data_path.value_at(self)
+            end
+
+            if writer
+              define_method "#{attribute_name}=" do |value|
+                data_path.set_value_at(self, value)
+              end
+            else
+              method = :"#{attribute_name}="
+
+              if instance_methods.include?(method)
+                # TODO: test this code path
+                # :nocov:
+                remove_method method
+                # :nocov:
+              end
+            end
+
+            set_model_type
+          end
+
+          private
+
+          def extract_private_from_attributes_declaration(...)
+            private = []
+            attributes_type_declaration = TypeDeclarations.args_to_type_declaration(...)
+
+            if attributes_type_declaration.is_a?(::Hash) || attributes_type_declaration.is_a?(Proc)
+              handler = domain.foobara_type_builder.handler_for_class(
+                TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+              )
+              attributes_type_declaration = Namespace.use domain do
+                handler.desugarize(attributes_type_declaration)
+              end
+
+              element_type_declarations = attributes_type_declaration[:element_type_declarations]
+
+              element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
+                is_private = attribute_type_declaration.delete(:private)
+
+                if is_private
+                  private |= [attribute_name]
+                end
+              end
             end
+
+            [private, attributes_type_declaration]
           end
         end
       end

data/projects/model/src/extensions/builtin_types/model/supported_transformers/mutable.rb

@@ -1,8 +1,7 @@
 module Foobara
   module BuiltinTypes
     module Model
-      # TODO: Create Mutations/SupportedMutations concept
-      class SupportedTransformers
+      module SupportedTransformers
         class Mutable < TypeDeclarations::Transformer
           class << self
             def requires_declaration_data?

data/projects/model/src/extensions/builtin_types/model/validators/{attributes_declaration.rb → model_instance_is_valid.rb}

@@ -2,7 +2,7 @@ module Foobara
   module BuiltinTypes
     module Model
       module Validators
-        class AttributesDeclaration < TypeDeclarations::Processor
+        class ModelInstanceIsValid < TypeDeclarations::Processor
           class << self
             def requires_parent_declaration_data?
               true

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/array_with_symbolic_elements.rb

@@ -0,0 +1,29 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ArrayWithSymbolicElements < TypeDeclarations::TypeDeclarationValidator
+          class InvalidPrivateValuesGivenError < Value::DataError
+            class << self
+              def message
+                "Private should be an array with symbolic elements"
+              end
+            end
+          end
+
+          def applicable?(strict_type_declaration)
+            strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:private)
+          end
+
+          def validation_errors(strict_type_declaration)
+            private = strict_type_declaration[:private]
+
+            unless private.is_a?(::Array) && Util.all_symbolic_elements?(private)
+              build_error(context: { attribute_name: :private, value: private })
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/delegates_desugarizer.rb

@@ -0,0 +1,39 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class DelegatesDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration.key?(:delegates) && sugary_type_declaration[:delegates].is_a?(::Hash)
+          end
+
+          def desugarize(sugary_type_declaration)
+            desugarized = Util.deep_dup(sugary_type_declaration)
+            delegates = desugarized[:delegates]
+
+            if delegates.empty?
+              desugarized.delete(:delegates)
+              desugarized
+            else
+              delegates.each_pair do |attribute_name, delegate_info|
+                h = delegate_info.merge(data_path: DataPath.new(delegate_info[:data_path]).to_s)
+
+                no_writer = !delegate_info[:writer]
+
+                if no_writer
+                  h.delete(:writer)
+                else
+                  h[:writer] = true
+                end
+
+                delegates[attribute_name] = h
+              end
+
+              sugary_type_declaration.merge(delegates:)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/delegates_validator.rb

@@ -0,0 +1,44 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class DelegatesValidator < TypeDeclarations::TypeDeclarationValidator
+          class InvalidDelegatesError < TypeDeclarationError
+            context delegates: :duck
+          end
+
+          def applicable?(value)
+            value.key?(:delegates)
+          end
+
+          def validation_errors(strict_type_declaration)
+            delegates = strict_type_declaration[:delegates]
+
+            unless delegates.is_a?(::Hash)
+              return build_error(
+                message: "delegates must be a hash",
+                context: { delegates: }
+              )
+            end
+
+            allowed_keys = %i[data_path writer]
+
+            delegates.each_pair do |attribute_name, delegate_hash|
+              invalid_keys = delegate_hash.keys - allowed_keys
+
+              unless invalid_keys.empty?
+                return build_error(
+                  message: "delegates must only contain data_path and writer but contained " \
+                           "#{invalid_keys} at #{attribute_name}",
+                  context: { delegates: }
+                )
+              end
+            end
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/move_private_from_element_types_to_root.rb

@@ -0,0 +1,48 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class MovePrivateFromElementTypesToRoot < TypeDeclarations::Desugarizer
+          def applicable?(value)
+            if value.is_a?(::Hash) && value.key?(:type) && value.key?(:attributes_declaration)
+              type_symbol = value[:type]
+
+              if type_registered?(type_symbol)
+                type = lookup_type!(type_symbol)
+                type.extends?(BuiltinTypes[:model])
+              end
+            end
+          end
+
+          def desugarize(rawish_type_declaration)
+            private = rawish_type_declaration[:private]
+            private = private ? private.dup : []
+
+            attributes_declaration = rawish_type_declaration[:attributes_declaration]
+            element_type_declarations = attributes_declaration[:element_type_declarations]
+
+            element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
+              if attribute_type_declaration.is_a?(Hash) && attribute_type_declaration.key?(:private)
+                is_private = attribute_type_declaration[:private]
+                element_type_declarations[attribute_name] = attribute_type_declaration.except(:private)
+                if is_private
+                  private |= [attribute_name]
+                end
+              end
+            end
+
+            if private.empty?
+              rawish_type_declaration.except(:private)
+            else
+              rawish_type_declaration.merge(private:)
+            end
+          end
+
+          def priority
+            Priority::MEDIUM + 1
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/symbolize_private.rb

@@ -0,0 +1,34 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class SymbolizePrivate < TypeDeclarations::Desugarizer
+          def applicable?(value)
+            if value.is_a?(::Hash) && value.key?(:type) && value.key?(:attributes_declaration) && value.key?(:private)
+              type_symbol = value[:type]
+
+              if type_registered?(type_symbol)
+                type = lookup_type!(type_symbol)
+                type.extends?(BuiltinTypes[:model])
+              end
+            end
+          end
+
+          def desugarize(rawish_type_declaration)
+            private = rawish_type_declaration[:private]
+
+            if private.any? { |key| key.is_a?(::String) }
+              rawish_type_declaration.merge(private: private.map(&:to_sym))
+            else
+              rawish_type_declaration
+            end
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/to_type_transformer.rb

@@ -22,6 +22,13 @@ module Foobara
                   # :nocov:
                 end
               end
+            else
+              existing_type = Domain.current.foobara_lookup_type(
+                model_class_name,
+                mode: Namespace::LookupMode::ABSOLUTE
+              )
+
+              existing_type&.target_class
             end
           end
 
@@ -53,7 +60,16 @@ module Foobara
           # TODO: create declaration validator for name and the others
           # TODO: seems like a smell that we don't have processors for these?
           def non_processor_keys
-            [:name, :model_class, :model_base_class, :model_module, :attributes_declaration, *super]
+            [
+              :name,
+              :model_class,
+              :model_base_class,
+              :model_module,
+              :attributes_declaration,
+              :delegates,
+              :private,
+              *super
+            ]
           end
 
           def process_value(...)
@@ -84,9 +100,25 @@ module Foobara
                   root_namespace = Namespace.current.foobara_root_namespace
                   domain = root_namespace.foobara_lookup_domain(domain_name)
 
-                  type.type_symbol = type.declaration_data[:name]
+                  type_symbol = type.declaration_data[:name]
+                  type.type_symbol = type_symbol.to_sym
+
                   model_class.description type.declaration_data[:description]
+
+                  if domain.foobara_type_registered?(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
+                    existing_type = domain.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
+                    domain.foobara_unregister(existing_type)
+                  end
+
                   domain.foobara_register_model(model_class)
+
+                  if type.declaration_data[:delegates]
+                    model_class.delegate_attributes type.declaration_data[:delegates]
+                  end
+
+                  if type.declaration_data[:private]
+                    model_class.private_attributes type.declaration_data[:private]
+                  end
                 end
               end
             end

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/valid_attribute_names.rb

@@ -0,0 +1,54 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendModelTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ValidAttributeNames < TypeDeclarations::TypeDeclarationValidator
+          class InvalidPrivateValueGivenError < Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  invalid_attribute_name: :symbol,
+                  valid_attribute_names: [:symbol],
+                  private: :array
+                }
+              end
+
+              def fatal?
+                # Since there could be multiple bad private
+                true
+              end
+            end
+          end
+
+          def applicable?(strict_type_declaration)
+            private = strict_type_declaration[:private]
+
+            private.is_a?(::Array) && Util.all_symbolic_elements?(private)
+          end
+
+          def validation_errors(strict_type_declaration)
+            private = strict_type_declaration[:private]
+
+            attributes_declaration = strict_type_declaration[:attributes_declaration]
+            valid_attribute_names = attributes_declaration[:element_type_declarations].keys
+
+            # TODO: this should be one error instead of multiple
+            private.map do |element|
+              unless valid_attribute_names.include?(element)
+                build_error(
+                  message: "#{element} is not a valid private attribute name, " \
+                           "expected one of #{valid_attribute_names}",
+                  context: {
+                    invalid_attribute_name: element,
+                    valid_attribute_names:,
+                    private:
+                  }
+                )
+              end
+            end.compact
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/model.rb

@@ -146,6 +146,7 @@ module Foobara
 
           p
         else
+          # Hmmm, can't there still be errors even if it's immutable?
           []
         end
       end
@@ -232,6 +233,14 @@ module Foobara
       @attributes ||= {}
     end
 
+    def attributes_with_delegates
+      h = self.class.delegates.keys.to_h do |delegated_attribute_name|
+        [delegated_attribute_name, send(delegated_attribute_name)]
+      end
+
+      attributes.merge(h)
+    end
+
     def write_attribute(attribute_name, value)
       attribute_name = attribute_name.to_sym
 

data/projects/model_attribute_helpers/src/attribute_helpers.rb

@@ -31,13 +31,34 @@ module Foobara
 
           # TODO: we should have metadata on the entity about whether it required a primary key
           # upon creation or not instead of an option here.
-          def foobara_attributes_for_create(includes_primary_key: false)
-            return foobara_attributes_type if includes_primary_key
-            return foobara_attributes_type unless foobara_has_primary_key?
+          def foobara_attributes_for_create(
+            includes_primary_key: false, # usually the underlying data store creates this
+            include_private: true, # we usually need to initialize these values to something but not always
+            include_delegates: false # usually these are already set on the passed-in objects it delegates to
+          )
+            if includes_primary_key && include_private
+              if include_delegates || delegates.empty?
+                return foobara_attributes_type
+              end
+            end
 
             declaration = foobara_attributes_type.declaration_data
 
-            Foobara::TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+            Namespace.use foobara_attributes_type.created_in_namespace do
+              unless includes_primary_key
+                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+              end
+
+              unless include_private
+                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *private_attribute_names)
+              end
+
+              unless include_delegates
+                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *delegates.keys)
+              end
+
+              Domain.current.foobara_type_from_declaration(declaration)
+            end
           end
 
           def foobara_attributes_for_aggregate_update(require_primary_key: true, initial: true)