foobara 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 497323362ef9b9bcf4a7d17cb9400b84701e73dc464f3ff318e6a52b6ee3bbf6
-  data.tar.gz: ee7bc81ea47e850b90e569c4295bd914832c3604277790edd6db153e143515a6
+  metadata.gz: 71381dfd48bd1ce8c4dd9fd71a0353753a488fd14a61525e19e240bb6d99ad62
+  data.tar.gz: 9c0cb8f97cdee2d089ca751c6517b5af5aacd8a2e540ef974dfa23d726f17208
 SHA512:
-  metadata.gz: acc9a5fed9bdfa6f7c19d74652b6c2bf770a24c17880968dc476289d2231ea51b906c538ee3d10dc65365c74d9d97f9f747ae3c97400789ce30e60babc9ca6b2
-  data.tar.gz: 03225ae2b838efc6816fe072b0f94ea6193552bb1253159aaa749ec471c18d4ea821c399cba711f6f6246cf1c38686d398bb4cd5c6385daebf91014a3ab88436
+  metadata.gz: 4899aec1e7f9378c8ed2e568d1c1f99c851bc505e096f742af8592be7b96fe6695282c04ca7e4edc8a8aa320c378bf734e5ad12d62b3f4e67f5cbe865d6286be
+  data.tar.gz: d9562836258a051022093aee895099b2809e1effd77a4e0eb444c8012fb12f55e1cbd821b570069ee3bd8b7e9e8ee068195638d7df57b53308d9a057fab4f086

data/CHANGELOG.md

@@ -1,4 +1,15 @@
-# [0.1.8] - 2025-08-25
+# [0.1.10] - 2025-09-11
+
+- Add NotFoundError when an entity input doesn't exist
+- Make #add_input_error more flexible
+- Fix an error path array bug
+- Fix a bug that might prevent inherited possible errors
+
+# [0.1.9] - 2025-09-08
+
+- Support passing load_paths: to Entity.load to pre-load certain associations
+
+# [0.1.8] - 2025-09-05
 
 - Memoize various parts of Type
 - Eliminate DoesNotNeedCastIf* processors

data/projects/command/src/command_pattern_implementation/concerns/errors.rb

@@ -78,7 +78,7 @@ module Foobara
                   elsif args.empty? || (args.size == 1 && args.first.is_a?(Hash))
                     error_args = opts.merge(args.first || {})
                     symbol = error_args[:symbol]
-                    path = Util.array(error_args[:input] || error_args[:path])
+                    path = error_args[:input] || error_args[:path]
 
                     error_args = error_args.except(:input)
 
@@ -100,8 +100,14 @@ module Foobara
                     input, symbol, message = args
                     context = opts
 
-                    error_class = self.class.lookup_input_error_class(symbol, input)
-                    error_class.new(path: Util.array(input), symbol:, context:, message:)
+                    if symbol.is_a?(::Class) && symbol < Foobara::Error
+                      error_class = symbol
+                      symbol = error_class.symbol
+                    else
+                      error_class = self.class.lookup_input_error_class(symbol, input)
+                    end
+
+                    error_class.new(path: input, symbol:, context:, message:)
                   else
                     # :nocov:
                     raise ArgumentError,

data/projects/command/src/command_pattern_implementation/concerns/errors_type.rb

@@ -81,6 +81,11 @@ module Foobara
             symbol = error_class.symbol
 
             possible_error = PossibleError.new(error_class, symbol:, data:)
+
+            if path.is_a?(::String) || path.is_a?(::Symbol)
+              path = path.to_s.split(".")
+            end
+
             possible_error.prepend_path!(path)
 
             possible_error.manually_added = true
@@ -93,10 +98,24 @@ module Foobara
 
           # TODO: kill this method in favor of possible_errors
           def error_context_type_map
+            return @error_context_type_map if defined?(@error_context_type_map)
+
             process_error_constants
-            @error_context_type_map ||= if superclass < Foobara::Command
-                                          superclass.error_context_type_map.dup
-                                        end || {}
+            map = if superclass < Foobara::Command
+                    superclass.error_context_type_map.dup
+                  end || {}
+
+            @error_context_type_map = if @error_context_type_map
+                                        map.merge(@error_context_type_map)
+                                      else
+                                        map
+                                      end
+
+            inputs_association_paths&.each do |data_path|
+              possible_input_error(data_path.to_sym, CommandPatternImplementation::NotFoundError)
+            end
+
+            @error_context_type_map
           end
 
           def register_possible_error_class(possible_error)

data/projects/command/src/command_pattern_implementation/concerns/inputs.rb

@@ -6,6 +6,26 @@ module Foobara
 
         include Concern
 
+        module ClassMethods
+          def inputs_association_paths
+            return @inputs_association_paths if defined?(@inputs_association_paths)
+
+            @inputs_association_paths = if inputs_type.nil?
+                                          nil
+                                        else
+                                          keys = Entity.construct_associations(inputs_type).keys
+
+                                          if keys.empty?
+                                            nil
+                                          else
+                                            keys.map do |key|
+                                              DataPath.new(key)
+                                            end
+                                          end
+                                        end
+          end
+        end
+
         attr_reader :inputs, :raw_inputs
 
         def initialize(inputs = {})

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

@@ -12,6 +12,10 @@ module Foobara
               unregister_possible_error_if_registered(possible_error)
             end
 
+            if defined?(@inputs_association_paths)
+              remove_instance_variable(:@inputs_association_paths)
+            end
+
             type = type_for_declaration(...)
 
             if type.extends?(BuiltinTypes[:model]) && !type.extends?(BuiltinTypes[:entity])

data/projects/command/src/command_pattern_implementation/concerns/runtime.rb

@@ -7,6 +7,13 @@ module Foobara
         class CannotHaltWithoutAddingErrors < StandardError; end
         class Halt < StandardError; end
 
+        class NotFoundError < Foobara::DataError
+          context do
+            entity_class :string, :required
+            criteria :duck
+          end
+        end
+
         module ClassMethods
           def run(...)
             new(...).run
@@ -81,7 +88,41 @@ module Foobara
         end
 
         def validate_records
-          # noop
+          self.class.inputs_association_paths&.each do |data_path|
+            if data_path.last == :"#"
+              records = data_path.values_at(@inputs)
+
+              records.each.with_index do |record, index|
+                if record&.persisted? && !record.loaded?
+                  begin
+                    record.class.load(record)
+                  rescue Foobara::Entity::NotFoundError => e
+                    add_input_error(
+                      [*data_path.path[..-2], index],
+                      CommandPatternImplementation::NotFoundError,
+                      criteria: e.criteria,
+                      entity_class: record.class.model_type.scoped_full_name
+                    )
+                  end
+                end
+              end
+            else
+              record = data_path.value_at(@inputs)
+
+              if record&.persisted? && !record.loaded?
+                begin
+                  record.class.load(record)
+                rescue Foobara::Entity::NotFoundError => e
+                  add_input_error(
+                    data_path.to_s,
+                    CommandPatternImplementation::NotFoundError,
+                    criteria: e.criteria,
+                    entity_class: record.class.model_type.scoped_full_name
+                  )
+                end
+              end
+            end
+          end
         end
 
         def validate

data/projects/common/src/data_path.rb

@@ -31,6 +31,7 @@ module Foobara
         key.to_s_type
       end
 
+      # TODO: flip these arguments?
       def values_at(data_path, object)
         unless data_path.is_a?(DataPath)
           data_path = new(data_path)

data/projects/common/src/error.rb

@@ -215,6 +215,11 @@ module Foobara
       self.message = message
       self.context = context
       self.category = category
+
+      if path.is_a?(::String) || path.is_a?(::Symbol)
+        path = path.to_s.split(".").map(&:to_sym)
+      end
+
       self.path = path
       self.runtime_path = runtime_path
       self.is_fatal = is_fatal

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

@@ -44,16 +44,40 @@ module Foobara
             current_transaction_table.find_many_by(attributes)
           end
 
-          def load(record)
-            if record.is_a?(Foobara::Entity)
-              if record.loaded?
-                record
+          def load(record, load_paths: nil)
+            record = if record.is_a?(Foobara::Entity)
+                       if record.loaded?
+                         record
+                       else
+                         current_transaction_table.load(record)
+                       end
+                     else
+                       current_transaction_table.load(record)
+                     end
+
+            if load_paths
+              if load_paths.is_a?(::Array)
+                first = load_paths.first
+
+                if first.is_a?(::Symbol) || (first.is_a?(::String) && !first.include?("."))
+                  load_paths = [load_paths]
+                end
               else
-                current_transaction_table.load(record)
+                load_paths = [load_paths]
+              end
+
+              load_paths.each do |data_path|
+                DataPath.values_at(data_path, record).each do |value|
+                  if value.is_a?(Foobara::Entity)
+                    value.class.load(value)
+                  elsif value.is_a?(::Array)
+                    value.each { |r| r.class.load(r) }
+                  end
+                end
               end
-            else
-              current_transaction_table.load(record)
             end
+
+            record
           rescue ::Foobara::Persistence::EntityAttributesCrudDriver::Table::CannotFindError
             primary_key = if record.is_a?(Foobara::Entity)
                             record.primary_key

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.1.8".freeze
+    VERSION = "0.1.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.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Miles Georgi