foobara 0.5.8 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f3a7dee25a0ab1d7598ec72bbd71ec8807113d417cc758842cf4edd7b214d2a
-  data.tar.gz: f81bd84c70a9d41a8db414ee9424d5c2e2d9533887cfaa1ea0b436094873bc9a
+  metadata.gz: 23083c50349b64586fcc01d57460032c08ab51eaf90af20591a49dfa16c477f2
+  data.tar.gz: '04495cb4fbf6f6c93bc24da26a7f889792a4b17498a04416b539b107b0aa2158'
 SHA512:
-  metadata.gz: 8819827dfdffb0ae2bef29f3bbbeb944cd3270cfd1a7938037d487373123ce50e2a8f832c5687c6b75ef8fd6e2ebd2016689e4b7208752a1f4a15bafa6eac10d
-  data.tar.gz: ba81595289f961c7c5f639d85fb16f7d05fe5b3d0aa3fcbeec1499030b7e56bbab75afc1cef58b6eafd5e6f115c3f2c4dbfb15ab29de8bc081095ccb4a8bd089
+  metadata.gz: 23af9c5f5cd3ac5bdfe282151b13d412377c8ff9b9fa87f2a9093e3bbe6d748d6e40845cdd7ef5062710e8db892c28dcccb6e8c358f087a68e785ef9953d6a7b
+  data.tar.gz: 3669d063aa1f94ff023464841e9b5cab65fafb82290aeaae170564d13aa3659f6b012fc5ec71471f781e6b236f78e33aa5643d465aa0687f9bfcabfe4df2dfaf

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [0.5.10] - 2026-04-17
+
+- Add a ignore_unexpected_attributes transformer to builtin attributes type
+
+# [0.5.9] - 2026-03-06
+
+- Do not require an allowed rule for builtin-in commands when using requires_allowed_rule: true
+
 # [0.5.8] - 2026-03-04
 
 - Provide a way for allowed rules to be declared independently of connecting commands

data/lib/foobara/all.rb

@@ -11,8 +11,15 @@ module Foobara
     # TODO: delete this and make Rubocop exception in .rubocop.yml
   end
 
+  require "foobara/delegate"
+  require "foobara/state_machine"
+  require "foobara/builtin_types"
+  require "foobara/domain"
+  require "foobara/command"
+  # TODO: make it so these are fully decoupled, optional, and not required here
   require "foobara/model_attribute_helpers"
   require "foobara/model_plumbing"
+  require "foobara/entities_plumbing"
   # Shouldn't this be optional? Maybe use autoload feature somehow?
   require "foobara/in_memory_crud_driver"
   require "foobara/domain_mapper"

data/projects/command/lib/foobara/command.rb

@@ -1,3 +1,5 @@
+require "foobara/common"
+
 module Foobara
   class Command
     class << self

data/projects/command/src/command_pattern_implementation.rb

@@ -30,7 +30,6 @@ module Foobara
     include CommandPatternImplementation::Concerns::Callbacks
     include CommandPatternImplementation::Concerns::StateMachine
     include CommandPatternImplementation::Concerns::Transactions
-    include CommandPatternImplementation::Concerns::Entities
     include CommandPatternImplementation::Concerns::Subcommands
     include CommandPatternImplementation::Concerns::DomainMappers
     include CommandPatternImplementation::Concerns::Reflection

data/projects/command_connectors/src/command_connector.rb

@@ -413,8 +413,6 @@ module Foobara
           raise NoCommandFoundError.new(message: "Could not find command registered for #{full_command_name}")
           # :nocov:
         end
-
-        transformed_command_class
       else
         action = case action
                  when "describe_type", "manifest", "describe_command"
@@ -433,8 +431,15 @@ module Foobara
         command_class = find_builtin_command_class(command_name)
         full_command_name = command_class.full_command_name
 
-        transformed_command_from_name(full_command_name) || transform_command_class(command_class)
+        transformed_command_class = transformed_command_from_name(full_command_name) ||
+                                    transform_command_class(command_class)
+
+        if transformed_command_class < TransformedCommand
+          transformed_command_class.builtin = true
+        end
       end
+
+      transformed_command_class
     end
 
     def request_to_command_inputs(request)
@@ -640,8 +645,14 @@ module Foobara
 
     def run_command(request)
       command = request.command
+      command_class = request.command_class
 
-      if requires_allowed_rule && command.is_a?(TransformedCommand) && command.class.requires_authentication != false
+      if requires_allowed_rule &&
+         command.is_a?(TransformedCommand) &&
+         # The != false looks odd and must be that we want to distinguish between the default (nil)
+         # and explicitly not requiring auth
+         command.class.requires_authentication != false &&
+         !command_class.builtin?
         unless command.allowed_rule
           raise NoAllowedRuleGivenError,
                 "Must connect #{command.full_command_name} with an `allowed_if:` " \

data/projects/command_connectors/src/transformed_command.rb

@@ -21,7 +21,8 @@ module Foobara
                     :requires_authentication,
                     :authenticator,
                     :subclassed_in_namespace,
-                    :suffix
+                    :suffix,
+                    :builtin
 
       def subclass(
         command_class,
@@ -546,6 +547,10 @@ module Foobara
         end
       end
 
+      def builtin?
+        builtin
+      end
+
       private
 
       def processors_to_manifest_symbols(processors)

data/projects/command_connectors/src/transformers/auth_errors_transformer.rb

@@ -12,7 +12,7 @@ module Foobara
               map = map.merge(possible_error.key.to_s => possible_error)
             end
 
-            if transformed_command.allowed_rule
+            if transformed_command.allowed_rule && transformed_command.allowed_rule.symbol != :always
               possible_error = PossibleError.new(CommandConnector::NotAllowedError)
               map = map.merge(possible_error.key.to_s => possible_error)
             end

data/projects/domain_mapper/src/domain_mapper.rb

@@ -95,9 +95,7 @@ module Foobara
       def object_to_type(object)
         if object
           if object.is_a?(::Class)
-            if object < Foobara::Model
-              object.model_type
-            elsif object < Foobara::Command
+            if object < Foobara::Command
               object.inputs_type
             else
               domain.foobara_type_from_declaration(object)

data/projects/entities_plumbing/lib/foobara/entities_plumbing.rb

@@ -1,12 +1,31 @@
-require "foobara/command_connectors"
-
 module Foobara
   module EntitiesPlumbing
+    class << self
+      def install!
+        CommandPatternImplementation.include CommandPatternImplementation::Concerns::Entities
+
+        if Foobara.project_installed?("command_connectors")
+          # :nocov:
+          install_command_connector_extension
+          # :nocov:
+        end
+      end
+
+      def new_project_added(new_project)
+        if new_project.symbol == "command_connectors"
+          install_command_connector_extension
+        end
+      end
+
+      def install_command_connector_extension
+        CommandConnector.singleton_class.prepend(
+          Foobara::EntitiesPlumbing::CommandConnectorsExtension::ClassMethods
+        )
+
+        CommandConnector::Authenticator.include CommandConnector::AuthenticatorMethods
+      end
+    end
   end
 end
 
 Foobara.project("entities_plumbing", project_path: "#{__dir__}/../..")
-
-Foobara::CommandConnector.singleton_class.prepend(
-  Foobara::EntitiesPlumbing::CommandConnectorsExtension::ClassMethods
-)

data/projects/entities_plumbing/spec/spec_helper.rb

@@ -23,6 +23,7 @@ SimpleCov.start do
 end
 
 require "foobara/all"
+require "foobara/command_connectors"
 require "foobara/entities_plumbing"
 
 RSpec.configure do |config|

data/projects/entities_plumbing/spec/transaction_spec.rb

@@ -0,0 +1,534 @@
+RSpec.describe Foobara::CommandPatternImplementation::Concerns::Entities do
+  describe "#run" do
+    after do
+      Foobara.reset_alls
+    end
+
+    let(:user_base) do
+      Foobara::Persistence::EntityBase.new(
+        "user_base",
+        entity_attributes_crud_driver: Foobara::Persistence::CrudDrivers::InMemory.new
+      ).tap do |base|
+        Foobara::Persistence.register_base(base)
+      end
+    end
+
+    let(:read_command) do
+      stub_class(:ReadEmployee, Foobara::Command) do
+        # TODO: does this work with Employee instead of :Employee ?
+        inputs employee: { type: :Employee, required: true }
+
+        load_all
+
+        result Employee
+
+        def execute
+          employee
+        end
+      end
+    end
+
+    let(:employee_id) do
+      Foobara::Persistence.transaction(Employee, User, mode: :use_existing) do
+        Employee.all[0].id
+      end
+    end
+
+    before do
+      Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+
+      stub_class :Base, Foobara::Entity do
+        abstract
+
+        attributes id: :integer
+
+        primary_key :id
+      end
+
+      stub_class :User, Base do
+        attributes name: { type: :string, required: true }
+      end
+
+      Foobara::Persistence.register_entity(user_base, User, table_name: "users")
+
+      stub_class(:Person, Base) do
+        abstract
+
+        attributes user: User
+      end
+
+      # TODO: how to support self-referential models??
+      stub_class(:Applicant, Person) do
+        attributes do
+          is_active :boolean, default: true
+          friends [User]
+          attrs do
+            foo :symbol
+            bar [:integer]
+            duckfoo :duck
+            duckbar [:duck]
+          end
+        end
+      end
+
+      stub_class(:Package, Base) do
+        attributes applicants: [Applicant],
+                   is_active: :boolean
+      end
+
+      stub_class(:Assignment, Base) do
+        attributes package: Package
+      end
+
+      stub_class(:Employee, Person) do
+        attributes do
+          assignments [Assignment], default: []
+          past_assignments [Assignment]
+          priority_assignment Assignment
+        end
+
+        association :past_users, "past_assignments.#.package.applicants.#.user"
+        association :priority_package, :"priority_assignment.package"
+      end
+
+      applicant_users = []
+      employee_users = []
+
+      User.transaction do
+        5.times do |i|
+          applicant_users << User.create(name: "applicant user#{i}")
+        end
+
+        5.times do |i|
+          employee_users << User.create(name: "employee user#{i}")
+        end
+      end
+
+      Foobara::Persistence.transaction(Employee, User) do
+        applicants = []
+        employees = []
+
+        5.times do |i|
+          applicants << Applicant.create(user: applicant_users[i])
+        end
+
+        5.times do |i|
+          employees << Employee.create(user: employee_users[i])
+        end
+
+        7.times do |i|
+          package = Package.create(is_active: i < 3, applicants: [applicants[i % 3]])
+
+          assignment = Assignment.create(package:)
+
+          if i < 5
+            employees[i % 4].assignments += [assignment]
+
+            if i.even?
+              employees[(i % 4) + 1].assignments += [assignment]
+            end
+          else
+            employees[0].past_assignments ||= []
+            employees[0].past_assignments += [assignment]
+          end
+        end
+      end
+    end
+
+    it "can find the record" do
+      expect(read_command.run!(employee: employee_id).id).to eq(employee_id)
+    end
+
+    context "with multiple records" do
+      let(:read_command) do
+        stub_class(:ReadEmployee, Foobara::Command) do
+          # TODO: does this work with Employee instead of :Employee ?
+          inputs employee: { type: :Employee, required: true },
+                 employee_array: [Employee]
+
+          load_all
+
+          result [Employee]
+
+          def execute
+            [employee, *employee_array]
+          end
+        end
+      end
+
+      let!(:employee2_id) do
+        Employee.transaction do
+          Employee.create
+        end.id
+      end
+
+      let!(:employee3_id) do
+        Employee.transaction do
+          Employee.create
+        end.id
+      end
+
+      it "can find the records" do
+        inputs = { employee: employee_id, employee_array: [employee2_id, employee3_id] }
+        expect(read_command.run!(inputs).map(&:id)).to eq([employee_id, employee2_id, employee3_id])
+      end
+    end
+
+    context "when given primary key for record that doesnt exist" do
+      it "is not success" do
+        outcome = read_command.run(employee: 100)
+        expect(outcome).to_not be_success
+
+        errors = outcome.errors
+
+        expect(errors.size).to eq(1)
+
+        error = errors.first
+
+        expect(error.class.name).to eq("ReadEmployee::EmployeeNotFoundError")
+        expect(error.key).to eq("runtime.employee_not_found")
+
+        expect(error.symbol).to be(:employee_not_found)
+
+        context = error.context
+
+        expect(context[:entity_class]).to eq("Employee")
+        expect(context[:criteria]).to eq(100)
+        expect(context[:data_path]).to eq("employee")
+
+        expect(error.entity_class).to eq("Employee")
+        expect(error.criteria).to eq(100)
+        expect(error.data_path).to eq("employee")
+      end
+    end
+
+    context "when given non-castable primary key" do
+      it "is not success" do
+        outcome = read_command.run(employee: "asdf")
+        expect(outcome).to_not be_success
+
+        errors = outcome.errors
+
+        expect(errors.size).to eq(1)
+
+        error = errors.first
+
+        expect(error.key).to eq("data.employee.cannot_cast")
+      end
+    end
+
+    context "when input is good but a different runtime error occurs" do
+      let(:read_command) do
+        error_class = stub_class(:SomeRuntimeError, Foobara::RuntimeError) do
+          class << self
+            def context_type_declaration
+              {}
+            end
+          end
+        end
+
+        stub_class(:ReadEmployee, Foobara::Command) do
+          # TODO: does this work with Employee instead of :Employee ?
+          inputs employee: { type: :Employee, required: true }
+
+          load_all
+
+          possible_error error_class
+
+          result Employee
+
+          define_method :execute do
+            employee.assignments = []
+            add_runtime_error(error_class.new(message: "asdf", context: {}))
+          end
+        end
+      end
+
+      it "is not success and rolls back" do
+        old_assignments = Foobara::Persistence.transaction(Employee, User, mode: :use_existing) do
+          Employee.load(employee_id).assignments
+        end
+
+        expect(old_assignments).to_not be_empty
+
+        outcome = read_command.run(employee: employee_id)
+        expect(outcome).to_not be_success
+
+        errors = outcome.error_collection
+
+        expect(errors.size).to eq(1)
+
+        error = errors.first
+
+        expect(error.class.name).to eq("SomeRuntimeError")
+
+        Foobara::Persistence.transaction(Employee, User, mode: :use_existing) do
+          expect(Employee.load(employee_id).assignments).to eq(old_assignments)
+        end
+      end
+    end
+
+    describe "manifest" do
+      it "includes entity dependencies" do
+        expect(Foobara.manifest[:type][:Employee][:deep_depends_on]).to eq(
+          [
+            "Assignment",
+            "User",
+            "Package",
+            "Applicant"
+          ]
+        )
+      end
+    end
+
+    describe "create command" do
+      context "with entity class as inputs" do
+        let(:create_command) do
+          stub_class(:CreateUser, Foobara::Command) do
+            inputs User.attributes_type
+            result User
+
+            # TODO: automatically include result type if it's an entity to avoid this in such cases
+            depends_on_entities User
+
+            def execute
+              create_user
+
+              user
+            end
+
+            attr_accessor :user
+
+            def create_user
+              self.user = User.create(inputs)
+            end
+          end
+        end
+
+        it "can create an user" do
+          expect(create_command.types_depended_on).to include(User.entity_type)
+          command = create_command.new(name: "Some Name")
+          outcome = command.run
+
+          expect(outcome).to be_success
+          expect(command.user).to be_a(User)
+
+          result = outcome.result
+          expect(result.name).to eq("Some Name")
+          expect(result.id).to be_a(Integer)
+        end
+      end
+
+      context "with normal attributes inputs" do
+        let(:create_command) do
+          stub_class(:CreateUser, Foobara::Command) do
+            # TODO: does this work with User instead of :User ?
+            # We can't come up with a cleaner way to do this?
+            inputs user: User
+            result User.entity_type
+
+            def execute
+              user
+            end
+          end
+        end
+
+        it "can create an user" do
+          command = create_command.new(user: { name: "Some Name" })
+          outcome = Foobara::Persistence.transaction(Employee, User, mode: :use_existing) do
+            command.run
+          end
+          expect(outcome).to be_success
+          expect(command.user).to be_a(User)
+
+          result = outcome.result
+          expect(result.name).to eq("Some Name")
+          expect(result.id).to be_a(Integer)
+        end
+      end
+    end
+
+    describe "update atom command" do
+      context "with helper method result for inputs" do
+        let(:update_command) do
+          stub_class(:UpdateApplicant, Foobara::Command) do
+            # TODO: does this work with User instead of :User ?
+            # We can't come up with a cleaner way to do this?
+            inputs Applicant.attributes_for_atom_update(require_primary_key: true)
+            result Applicant # seems like we should just use nil?
+
+            def execute
+              update_applicant
+
+              applicant
+            end
+
+            attr_accessor :applicant
+
+            def load_records
+              self.applicant = Applicant.load(id)
+            end
+
+            def update_applicant
+              inputs.each_pair do |attribute_name, value|
+                applicant.write_attribute(attribute_name, value)
+              end
+            end
+          end
+        end
+
+        let(:applicant) { Applicant.create(user:, is_active: true) }
+        let(:user) { User.create(name: "first user") }
+
+        it "can update an applicant" do
+          applicant_id = Applicant.transaction { applicant }.id
+
+          Applicant.transaction do
+            expect {
+              update_command.run!(id: applicant_id, is_active: false)
+            }.to change { Applicant.load_aggregate(applicant_id).is_active }.from(true).to(false)
+
+            expect {
+              update_command.run!(id: applicant_id, is_active: true)
+            }.to change { Applicant.load(applicant_id).is_active }.from(false).to(true)
+          end
+
+          new_user_id = User.transaction(skip_dependent_transactions: true) { User.create(name: "second user") }.id
+
+          Applicant.transaction do
+            expect {
+              update_command.run!(id: applicant_id, user: new_user_id)
+            }.to change { Applicant.load(applicant_id).user.name }.from("first user").to("second user")
+          end
+        end
+      end
+    end
+
+    describe "update aggregate command" do
+      context "with helper method result for inputs" do
+        let(:update_command) do
+          stub_class(:UpdateApplicantAggregate, Foobara::Command) do
+            # TODO: does this work with User instead of :User ?
+            # We can't come up with a cleaner way to do this?
+            inputs Applicant.attributes_for_aggregate_update(require_primary_key: true)
+            result Applicant # seems like we should just use nil?
+
+            def execute
+              update_applicant
+
+              applicant
+            end
+
+            attr_accessor :applicant
+
+            def load_records
+              self.applicant = Applicant.load(id)
+            end
+
+            def update_applicant
+              applicant.update_aggregate(inputs)
+            end
+          end
+        end
+
+        let(:applicant) do
+          Applicant.create(
+            user:,
+            is_active: true,
+            attrs: {
+              foo: :fooooo,
+              bar: [1, 2, 3, 4],
+              duckfoo: "asdfasdf",
+              duckbar: ["asdf", 5]
+            }
+          )
+        end
+        let(:user) { User.create(name: "old name") }
+
+        it "can update an applicant" do
+          applicant_id = Applicant.transaction { applicant }.id
+          user_id = User.transaction { user }.id
+
+          expect {
+            update_command.run!(id: applicant_id, is_active: false)
+          }.to change {
+            Applicant.transaction { Applicant.load(applicant_id).is_active }
+          }.from(true).to(false)
+
+          expect {
+            update_command.run!(id: applicant_id, is_active: true)
+          }.to change {
+            Applicant.transaction { Applicant.load(applicant_id).is_active }
+          }.from(false).to(true)
+
+          Applicant.transaction do
+            update_command.run!(
+              id: applicant_id,
+              user: { name: "new name" },
+              attrs: {
+                foo: :food,
+                bar: [10, 11],
+                duckfoo: "df",
+                duckbar: ["db", "asdf"]
+              }
+            )
+          end
+
+          Applicant.transaction do
+            applicant = Applicant.load(applicant_id)
+            expect(applicant.user.name).to eq("new name")
+            expect(applicant.user.id).to eq(user_id)
+            expect(applicant.attrs).to eq(
+              foo: :food,
+              bar: [10, 11],
+              duckfoo: "df",
+              duckbar: ["db", "asdf"]
+            )
+          end
+        end
+      end
+    end
+
+    describe "delete command" do
+      let(:delete_command) do
+        stub_class(:DeleteApplicant, Foobara::Command) do
+          # TODO: does this work with User instead of :User ?
+          # We can't come up with a cleaner way to do this?
+          inputs applicant: Applicant
+          result Applicant
+
+          load_all
+
+          def execute
+            delete_applicant
+
+            applicant
+          end
+
+          def delete_applicant
+            applicant.hard_delete!
+          end
+        end
+      end
+
+      let(:applicant) { Applicant.create(user:) }
+      let(:user) { User.create(name: "old name") }
+
+      it "deletes the applicant" do
+        applicant_id = Applicant.transaction { applicant }.id
+
+        Applicant.transaction do
+          expect {
+            delete_command.run!(applicant: applicant_id)
+          }.to change(Applicant, :count).by(-1)
+        end
+
+        Applicant.transaction do
+          expect {
+            Applicant.load(applicant_id)
+          }.to raise_error(Foobara::Entity::NotFoundError)
+        end
+      end
+    end
+  end
+end

data/projects/entities_plumbing/src/extensions/{authenticator.rb → authenticator_methods.rb}

@@ -1,6 +1,6 @@
 module Foobara
   class CommandConnector
-    class Authenticator
+    module AuthenticatorMethods
       def relevant_entity_classes(_request)
         if to_type&.extends?(BuiltinTypes[:entity])
           NestedTransactionable.relevant_entity_classes_for_type(to_type)

data/projects/manifest/spec/spec_helper.rb

@@ -23,6 +23,7 @@ SimpleCov.start do
 end
 
 require "foobara/all"
+require "foobara/command_connectors"
 
 RSpec.configure do |config|
   # Need to do :all instead of :each because for specs that use .around,

data/projects/model_plumbing/lib/foobara/model_plumbing.rb

@@ -5,6 +5,7 @@ module Foobara
         Model.on_reregister do
           GlobalDomain.foobara_each_command(&:handle_reregistered_types!)
         end
+        Foobara::DomainMapper.singleton_class.prepend(Foobara::ModelPlumbing::DomainMapperExtension)
       end
     end
   end

data/projects/model_plumbing/src/domain_mapper_extension.rb

@@ -0,0 +1,13 @@
+module Foobara
+  module ModelPlumbing
+    module DomainMapperExtension
+      def object_to_type(object)
+        if object.is_a?(::Class) && object < Foobara::Model
+          object.model_type
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/projects/typesystem/projects/builtin_types/src/attributes/supported_transformers/ignore_unexpected_attributes.rb

@@ -0,0 +1,25 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedTransformers
+        class IgnoreUnexpectedAttributes < Value::Transformer
+          class << self
+            def requires_parent_declaration_data?
+              true
+            end
+          end
+
+          def transform(attributes_hash)
+            element_type_declarations = parent_declaration_data[:element_type_declarations]
+            expected_attributes = element_type_declarations.keys
+            unexpected_attributes = attributes_hash.keys - expected_attributes
+
+            return attributes_hash if unexpected_attributes.empty?
+
+            attributes_hash.slice(*expected_attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/typesystem/projects/project/src/foobara.rb

@@ -41,6 +41,10 @@ module Foobara
       end
     end
 
+    def project_installed?(project_symbol)
+      all_projects.key?(project_symbol)
+    end
+
     def install!
       self.is_installed = true
       all_projects.each_value(&:install!)

data/projects/typesystem/projects/type_declarations/src/type_builder.rb

@@ -15,9 +15,23 @@ module Foobara
             type_declaration.is_deep_duped = true
             type_declaration
           else
-            # :nocov:
-            raise ArgumentError, "Cannot provide both block and declaration of #{args}"
-            # :nocov:
+            args -= [:attributes]
+            supported_processor_symbols = BuiltinTypes[:attributes].all_supported_processor_classes.map(&:symbol)
+
+            if args.all? { supported_processor_symbols.include?(it) }
+              handler = Foobara::GlobalDomain.foobara_type_builder.handler_for_class(
+                TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+              )
+              type_declaration = handler.desugarize(TypeDeclaration.new(block))
+
+              args.each { |processor_symbol| type_declaration[processor_symbol] = true }
+
+              type_declaration
+            else
+              # :nocov:
+              raise ArgumentError, "Cannot provide both block and declaration of #{args}"
+              # :nocov:
+            end
           end
         else
           case args.size

data/projects/typesystem/spec/builtin_types/attributes_spec.rb

@@ -472,4 +472,19 @@ RSpec.describe Foobara::BuiltinTypes::Attributes do
       end
     end
   end
+
+  describe "ignore_unexpected_attributes" do
+    let(:type) do
+      Foobara::Domain.current.foobara_type_from_declaration :ignore_unexpected_attributes do
+        a :integer, :required
+        b :string
+      end
+    end
+
+    it "excludes unexpected attributes" do
+      h = { a: "1", b: "2", c: "3" }
+
+      expect(type.process_value!(h)).to eq(a: 1, b: "2")
+    end
+  end
 end

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.5.8".freeze
+    VERSION = "0.5.10".freeze
     MINIMUM_RUBY_VERSION = ">= 3.4.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.10
 platform: ruby
 authors:
 - Miles Georgi
@@ -86,7 +86,6 @@ files:
 - projects/command/src/command_pattern_implementation/concerns/callbacks.rb
 - projects/command/src/command_pattern_implementation/concerns/command_data.rb
 - projects/command/src/command_pattern_implementation/concerns/domain_mappers.rb
-- projects/command/src/command_pattern_implementation/concerns/entities.rb
 - projects/command/src/command_pattern_implementation/concerns/errors.rb
 - projects/command/src/command_pattern_implementation/concerns/errors_type.rb
 - projects/command/src/command_pattern_implementation/concerns/inputs.rb
@@ -337,8 +336,10 @@ files:
 - projects/entities_plumbing/spec/spec_helper.rb
 - projects/entities_plumbing/spec/support/rubyprof.rb
 - projects/entities_plumbing/spec/support/term_trap.rb
+- projects/entities_plumbing/spec/transaction_spec.rb
 - projects/entities_plumbing/src/command_connectors_extension.rb
-- projects/entities_plumbing/src/extensions/authenticator.rb
+- projects/entities_plumbing/src/extensions/authenticator_methods.rb
+- projects/entities_plumbing/src/extensions/command_pattern_implementation/concerns/entities.rb
 - projects/manifest/Guardfile
 - projects/manifest/lib/foobara/manifest.rb
 - projects/manifest/spec/associations_spec.rb
@@ -365,6 +366,7 @@ files:
 - projects/manifest/src/type.rb
 - projects/manifest/src/type_declaration.rb
 - projects/model_plumbing/lib/foobara/model_plumbing.rb
+- projects/model_plumbing/src/domain_mapper_extension.rb
 - projects/model_plumbing/src/model_plumbing.rb
 - projects/typesystem/projects/builtin_types/lib/foobara/builtin_types.rb
 - projects/typesystem/projects/builtin_types/src/README.md
@@ -383,6 +385,7 @@ files:
 - projects/typesystem/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/symbolize_defaults.rb
 - projects/typesystem/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/hash_with_symbolic_keys.rb
 - projects/typesystem/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/valid_attribute_names.rb
+- projects/typesystem/projects/builtin_types/src/attributes/supported_transformers/ignore_unexpected_attributes.rb
 - projects/typesystem/projects/builtin_types/src/attributes/supported_validators/required.rb
 - projects/typesystem/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/alphabetize_required.rb
 - projects/typesystem/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_required_from_element_types_to_root.rb