foobara 0.0.48 → 0.0.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c661c32185af433ba2355ce71bf37524893d00901a6e885ab5bd874339e48b6
-  data.tar.gz: 8ab10b8b9191bc81548d07269ca8c4906515164aa87a702ac7b944170e2420a7
+  metadata.gz: 046fdc3bab52559499e744edbde0ef847e26c4e6107423779351a26acc654619
+  data.tar.gz: 56174a565dafcdf3cd03a66e791be3d5a6074bd426c203371b6d7f41fa3a7e12
 SHA512:
-  metadata.gz: 3aaff8aa022ea5cf95ab300430576fbf08d813ccd2344630b035bf54372826fda4de76e5b7d9937e70278fcc7b0c23973d4499be25ad1531401b8b82004c153a
-  data.tar.gz: ffbc1887647b08588f218798cb99ab27af30ece05d4540926cb521a429c3dc9a4d992163802528f9f3a8022a52558e5158ee4b5b13dbe297a2e6036393ec49dd
+  metadata.gz: ca08c711d53d11eb7ee073d040163df8bfe23c69b4b8e4c4f9647c6d216578755388b009b6d67e2cf988cc4e043413bfbe8f4f78ecb7690f713191cf00474255
+  data.tar.gz: a3b1e726a7295d1a0e4d22ef8f7a8130b39d57a1576f07f3f36bb20347ffce4bde07d6205c9c2853b392f47542ef7c696de57ab02c7c11d463484e3f5eebc779

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.0.50] - 2025-01-22
+
+- Fill out more foobara_ model attribute helper methods to further support the ActiveRecordType gem
+
 ## [0.0.48] - 2025-01-17
 
 - Add support for foobara_attributes_type to allow ActiveRecordType gem to work

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_defaults_from_element_types_to_root.rb

@@ -25,7 +25,11 @@ module Foobara
                       end
                     end
 
-                    rawish_type_declaration[:defaults] = defaults unless defaults.empty?
+                    if defaults.empty?
+                      rawish_type_declaration.delete(:defaults)
+                    else
+                      rawish_type_declaration[:defaults] = defaults
+                    end
 
                     rawish_type_declaration
                   end

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_required_from_element_types_to_root.rb

@@ -40,7 +40,11 @@ module Foobara
                       end
                     end
 
-                    rawish_type_declaration[:required] = required_attributes unless required_attributes.empty?
+                    if required_attributes.empty?
+                      rawish_type_declaration.delete(:required)
+                    else
+                      rawish_type_declaration[:required] = required_attributes
+                    end
 
                     rawish_type_declaration
                   end

data/projects/command/src/concerns/inputs_type.rb

@@ -25,6 +25,16 @@ module Foobara
             @inputs_type
           end
 
+          def add_inputs(...)
+            new_type = type_for_declaration(...)
+            new_declaration = TypeDeclarations::Attributes.merge(
+              inputs_type.declaration_data,
+              new_type.declaration_data
+            )
+
+            inputs new_declaration
+          end
+
           def inputs_type
             return @inputs_type if defined?(@inputs_type)
 

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

@@ -5,10 +5,12 @@ module Foobara
         include Concern
 
         module ClassMethods
-          def associations
-            @associations ||= construct_associations
+          def foobara_associations
+            @foobara_associations ||= construct_associations
           end
 
+          alias associations foobara_associations
+
           def deep_associations
             @deep_associations ||= begin
               deep = {}

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

@@ -20,18 +20,20 @@ module Foobara
               # :nocov:
             end
 
-            @primary_key_attribute = attribute_name.to_sym
+            @foobara_primary_key_attribute = attribute_name.to_sym
 
             set_model_type
           end
 
-          def primary_key_attribute
-            return @primary_key_attribute if @primary_key_attribute
+          def foobara_primary_key_attribute
+            return @foobara_primary_key_attribute if @foobara_primary_key_attribute
 
             unless superclass == DetachedEntity
-              @primary_key_attribute = superclass.primary_key_attribute
+              @foobara_primary_key_attribute = superclass.primary_key_attribute
             end
           end
+
+          alias primary_key_attribute foobara_primary_key_attribute
         end
 
         def primary_key

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

@@ -23,10 +23,12 @@ module Foobara
             end
           end
 
-          def primary_key_type
-            @primary_key_type ||= attributes_type.element_types[primary_key_attribute]
+          def foobara_primary_key_type
+            @foobara_primary_key_type ||= attributes_type.element_types[primary_key_attribute]
           end
 
+          alias primary_key_type foobara_primary_key_type
+
           def full_entity_name
             full_model_name
           end

data/projects/entity/src/entity.rb

@@ -7,7 +7,6 @@ module Foobara
     include Concerns::Attributes
     include Concerns::Persistence
     include Concerns::Initialization
-    include Concerns::AttributeHelpers
     include Concerns::Types
 
     class << self

data/projects/foobara/lib/foobara/all.rb

@@ -30,6 +30,7 @@ module Foobara
              "model",
              "detached_entity",
              "entity",
+             "model_attribute_helpers",
              "command",
              "domain_mapper",
              "persistence",

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

@@ -102,7 +102,7 @@ module Foobara
             )
           end
 
-          def attributes_type
+          def foobara_attributes_type
             return @attributes_type if @attributes_type
 
             @attributes_type = if model_type
@@ -112,6 +112,8 @@ module Foobara
                                end
           end
 
+          alias attributes_type foobara_attributes_type
+
           def model_type=(model_type)
             @model_type = model_type
 

data/projects/model_attribute_helpers/lib/foobara/model_attribute_helpers.rb

@@ -0,0 +1,16 @@
+require "date"
+require "time"
+require "bigdecimal"
+
+module Foobara
+  module ModelAttributeHelpers
+    class << self
+      def install!
+        Model.include Concerns::AttributeHelpers
+        Model.include Concerns::AttributeHelperAliases
+        Entity.include Concerns::AttributeHelpers
+        Entity.include Concerns::AttributeHelperAliases
+      end
+    end
+  end
+end

data/projects/model_attribute_helpers/src/attribute_helper_aliases.rb

@@ -0,0 +1,30 @@
+# This is currently the working file, fix this up/move it
+
+module Foobara
+  module ModelAttributeHelpers
+    module Concerns
+      module AttributeHelperAliases
+        include Foobara::Concern
+
+        module ClassMethods
+          %i[
+            attributes_for_update
+            type_from_foobara_model_class
+            attributes_type_from_foobara_model_class
+            primary_key_attribute_from_foobara_model_class
+            foobara_model_class_has_primary_key
+            attributes_for_create
+            attributes_for_aggregate_update
+            attributes_for_atom_update
+            attributes_for_find_by
+            type_declaration_value_at
+          ].each do |method_name|
+            define_method method_name do |*args, **opts, &block|
+              send("foobara_#{method_name}", *args, **opts, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model_attribute_helpers/src/attribute_helpers.rb

@@ -0,0 +1,143 @@
+# delete this file
+
+module Foobara
+  module ModelAttributeHelpers
+    module Concerns
+      # TODO: This concern is retroactively designed to be mixed into any entity-like class that can hold an
+      # entity-like foobara type.
+      # Because we want a subclass of ActiveRecord::Base to be such a target in the case of the
+      # foobara-active-record-type class, but because we can't make ActiveRecord::Base a subclass of Entity or
+      # DetachedEntity, and also because it makes sense to extend such behavior to foobara model classes,
+      # we will implement this as a Concern/mixin with a published expected interface and prefixed methods.
+      # This also means it should live in its own project, not here in the entity project.
+      # required methods:
+      #
+      # foobara_type
+      # foobara_attributes_type
+      # foobara_primary_key_attribute (nil if not an entity type)
+      # foobara_primary_key_type (nil if not an entity type)
+      # foobara_associations
+      module AttributeHelpers
+        include Foobara::Concern
+
+        module ClassMethods
+          def foobara_has_primary_key?
+            respond_to?(:foobara_primary_key_attribute)
+          end
+
+          def foobara_attributes_for_update(require_primary_key: false)
+            foobara_attributes_for_aggregate_update(require_primary_key:)
+          end
+
+          # 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?
+
+            declaration = foobara_attributes_type.declaration_data
+
+            Foobara::TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+          end
+
+          def foobara_attributes_for_aggregate_update(require_primary_key: false, initial: true)
+            declaration = foobara_attributes_type.declaration_data
+            declaration = Util.deep_dup(declaration)
+
+            declaration.delete(:defaults)
+            declaration.delete(:required)
+
+            if initial && foobara_has_primary_key?
+              if require_primary_key
+                declaration[:required] = [foobara_primary_key_attribute]
+              else
+                TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+              end
+            end
+
+            foobara_associations.each_pair do |data_path, type|
+              if type.extends?(BuiltinTypes[:entity])
+                target_class = type.target_class
+
+                entry = foobara_type_declaration_value_at(declaration, DataPath.new(data_path).path)
+                entry.clear
+                entry.merge!(target_class.foobara_attributes_for_aggregate_update(initial: false))
+              end
+            end
+
+            declaration
+          end
+
+          def foobara_attributes_for_atom_update(require_primary_key: false)
+            declaration = foobara_attributes_type.declaration_data
+            declaration = Util.deep_dup(declaration)
+
+            declaration.delete(:defaults)
+
+            if foobara_has_primary_key?
+              if require_primary_key
+                declaration[:required] = [foobara_primary_key_attribute]
+              else
+                declaration = TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+              end
+            end
+
+            # expect all associations to be expressed as primary key values
+            # TODO: should we have a special type for encapsulating primary keys types??
+            foobara_associations.each_pair do |data_path, type|
+              if type.extends?(BuiltinTypes[:entity])
+                target_class = type.target_class
+                # TODO: do we really need declaration_data? Why cant we use the type directly?
+                # TODO: make this work with the type directly for performance reasons.
+                primary_key_type_declaration = target_class.foobara_primary_key_type.declaration_data
+                entry = foobara_type_declaration_value_at(declaration, DataPath.new(data_path).path)
+                entry.clear
+                entry.merge!(primary_key_type_declaration)
+              end
+            end
+
+            declaration
+          end
+
+          def foobara_attributes_for_find_by
+            element_type_declarations = {}
+
+            foobara_attributes_type.element_types.each_pair do |attribute_name, attribute_type|
+              element_type_declarations[attribute_name] = attribute_type.reference_or_declaration_data
+            end
+
+            handler = Domain.global.foobara_type_builder.handler_for_class(
+              TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+            )
+
+            handler.desugarize(
+              type: "::attributes",
+              element_type_declarations:
+            )
+          end
+
+          private
+
+          def foobara_type_declaration_value_at(declaration, path_parts)
+            return declaration if path_parts.empty?
+
+            path_part, *path_parts = path_parts
+
+            declaration = case path_part
+                          when :"#"
+                            declaration[:element_type_declaration]
+                          when Symbol, Integer
+                            declaration[:element_type_declarations][path_part]
+                          else
+                            # :nocov:
+                            raise "Bad path part #{path_part}"
+                            # :nocov:
+                          end
+
+            foobara_type_declaration_value_at(declaration, path_parts)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/attributes.rb

@@ -21,12 +21,55 @@ module Foobara
             end
           end
 
-          {
+          handler = Domain.global.foobara_type_builder.handler_for_class(
+            TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+          )
+
+          handler.desugarize(
             type: "::attributes",
             element_type_declarations:,
             required:,
             defaults:
-          }
+          )
+        end
+
+        def reject(declaration, *keys)
+          declaration = Util.deep_dup(declaration)
+
+          element_type_declarations = declaration[:element_type_declarations]
+          required = declaration[:required]
+          defaults = declaration[:defaults]
+
+          changed = false
+
+          keys.flatten.each do |key|
+            key = key.to_sym
+
+            if element_type_declarations.key?(key)
+              changed = true
+              element_type_declarations.delete(key)
+            end
+
+            if required&.include?(key)
+              changed = true
+              required.delete(key)
+            end
+
+            if defaults&.key?(key)
+              changed = true
+              defaults.delete(key)
+            end
+          end
+
+          if changed
+            handler = Domain.global.foobara_type_builder.handler_for_class(
+              TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+            )
+
+            handler.desugarize(declaration)
+          else
+            declaration
+          end
         end
       end
     end

data/projects/type_declarations/src/dsl/attributes.rb

@@ -47,7 +47,6 @@ module Foobara
 
         def _to_declaration(&)
           instance_eval(&)
-          _prune_type_declaration
           _type_declaration
         end
 
@@ -163,30 +162,20 @@ module Foobara
         end
 
         def _add_to_required(attribute_name)
+          _type_declaration[:required] ||= []
           _type_declaration[:required] << attribute_name.to_sym
         end
 
         def _add_to_defaults(attribute_name, value)
+          _type_declaration[:defaults] ||= {}
           _type_declaration[:defaults][attribute_name.to_sym] = value
         end
 
-        def _prune_type_declaration
-          if _type_declaration[:required].empty?
-            _type_declaration.delete(:required)
-          end
-
-          if _type_declaration[:defaults].empty?
-            _type_declaration.delete(:defaults)
-          end
-        end
-
         def _type_declaration
           @_type_declaration ||= begin
             sugar = {
               type: "::attributes",
-              element_type_declarations: {},
-              required: [],
-              defaults: {}
+              element_type_declarations: {}
             }
 
             handler = Domain.current.foobara_type_builder.handler_for_class(Handlers::ExtendAttributesTypeDeclaration)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.48
+  version: 0.0.50
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-01-18 00:00:00.000000000 Z
+date: 2025-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -219,7 +219,6 @@ files:
 - projects/domain_mapper/src/domain_mapper.rb
 - projects/domain_mapper/src/domain_mapper_lookups.rb
 - projects/entity/lib/foobara/entity.rb
-- projects/entity/src/concerns/attribute_helpers.rb
 - projects/entity/src/concerns/attributes.rb
 - projects/entity/src/concerns/callbacks.rb
 - projects/entity/src/concerns/initialization.rb
@@ -289,6 +288,9 @@ files:
 - projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration/to_type_transformer.rb
 - projects/model/src/extensions/type_declarations/handlers/registered_type_declaration/model_class_desugarizer.rb
 - projects/model/src/model.rb
+- projects/model_attribute_helpers/lib/foobara/model_attribute_helpers.rb
+- projects/model_attribute_helpers/src/attribute_helper_aliases.rb
+- projects/model_attribute_helpers/src/attribute_helpers.rb
 - projects/monorepo/lib/foobara/monorepo.rb
 - projects/monorepo/lib/foobara/monorepo/project.rb
 - projects/namespace/lib/foobara/namespace.rb
@@ -415,6 +417,7 @@ require_paths:
 - "./projects/in_memory_crud_driver_minimal/lib"
 - "./projects/manifest/lib"
 - "./projects/model/lib"
+- "./projects/model_attribute_helpers/lib"
 - "./projects/monorepo/lib"
 - "./projects/namespace/lib"
 - "./projects/persistence/lib"

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

@@ -1,133 +0,0 @@
-module Foobara
-  class Entity < DetachedEntity
-    module Concerns
-      module AttributeHelpers
-        include Foobara::Concern
-
-        module ClassMethods
-          def attributes_for_update
-            attributes_for_aggregate_update
-          end
-
-          # 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 attributes_for_create(includes_primary_key: false)
-            return attributes_type if includes_primary_key
-
-            declaration = attributes_type.declaration_data
-            # TODO: just slice out the element type declarations
-            declaration = Util.deep_dup(declaration)
-
-            if declaration.key?(:required) && declaration[:required].include?(primary_key_attribute)
-              declaration[:required].delete(primary_key_attribute)
-            end
-
-            if declaration.key?(:defaults) && declaration[:defaults].include?(primary_key_attribute)
-              declaration[:defaults].delete(primary_key_attribute)
-            end
-
-            if declaration.key?(:element_type_declarations)
-              if declaration[:element_type_declarations].key?(primary_key_attribute)
-                declaration[:element_type_declarations].delete(primary_key_attribute)
-              end
-            end
-
-            handler = Domain.global.foobara_type_builder.handler_for_class(
-              TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
-            )
-
-            handler.desugarize(declaration)
-          end
-
-          def attributes_for_aggregate_update(initial = true)
-            declaration = attributes_type.declaration_data
-            # TODO: just slice out the element type declarations
-            declaration = Util.deep_dup(declaration)
-
-            declaration.delete(:defaults)
-            declaration.delete(:required)
-
-            if initial
-              declaration[:required] = [primary_key_attribute]
-            end
-
-            associations.each_pair do |data_path, type|
-              if type.extends?(BuiltinTypes[:entity])
-                target_class = type.target_class
-
-                entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
-                entry.clear
-                entry.merge!(target_class.attributes_for_aggregate_update(false))
-              end
-            end
-
-            declaration
-          end
-
-          def attributes_for_atom_update
-            declaration = attributes_type.declaration_data
-            # TODO: just slice out the element type declarations
-            declaration = Util.deep_dup(declaration)
-
-            declaration.delete(:defaults)
-            declaration[:required] = [primary_key_attribute]
-
-            # expect all associations to be expressed as primary key values
-            # TODO: should we have a special type for encapsulating primary keys types??
-            associations.each_pair do |data_path, type|
-              if type.extends?(BuiltinTypes[:entity])
-                target_class = type.target_class
-                # TODO: do we really need declaration_data? Why cant we use the type directly?
-                # TODO: make this work with the type directly for performance reasons.
-                primary_key_type_declaration = target_class.primary_key_type.declaration_data
-                entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
-                entry.clear
-                entry.merge!(primary_key_type_declaration)
-              end
-            end
-
-            declaration
-          end
-
-          def attributes_for_find_by
-            element_type_declarations = {}
-
-            attributes_type.element_types.each_pair do |attribute_name, attribute_type|
-              element_type_declarations[attribute_name] = attribute_type.reference_or_declaration_data
-            end
-
-            handler = Domain.global.foobara_type_builder.handler_for_class(
-              TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
-            )
-
-            handler.desugarize(
-              type: "::attributes",
-              element_type_declarations:
-            )
-          end
-
-          private
-
-          def type_declaration_value_at(declaration, path_parts)
-            return declaration if path_parts.empty?
-
-            path_part, *path_parts = path_parts
-
-            declaration = case path_part
-                          when :"#"
-                            declaration[:element_type_declaration]
-                          when Symbol, Integer
-                            declaration[:element_type_declarations][path_part]
-                          else
-                            # :nocov:
-                            raise "Bad path part #{path_part}"
-                            # :nocov:
-                          end
-
-            type_declaration_value_at(declaration, path_parts)
-          end
-        end
-      end
-    end
-  end
-end