foobara 0.0.135 → 0.0.136

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0560b5378293e0abf5477c545b37e05646ffd31e90160e60dd9f9e107e5307f5
-  data.tar.gz: 1b56363410e7a2af706f001559ee7a43c9ba27683b7a2de163747c8645054e5a
+  metadata.gz: 6f944c52f318016bd2742fb96208d11a2647d4802ee0a1ac4fbb5b353c5d6ad4
+  data.tar.gz: 5c7560766afe430188cd41053ce9f470eae20605dba8dde824432b760e6aa336
 SHA512:
-  metadata.gz: c3af812dd4decf50d37a5080d52299aa6eafe1643846ea92e73fa1acc6bc535f6772e8cb56356fad3065ec3b0dda1ed6be695f0fb826f9fd8cf9956014dd06af
-  data.tar.gz: 8cafe756d10ed613cdb4da5e521a37f8e1c8cd8c40738744898224ff4cb5aadf244ac92c81f9aa608b1666debcd72a3c2ca6776262f2a4d649524dc2f8f2b4b9
+  metadata.gz: 3bf5da1d2282282a3d17eb44a0f8ca815c525800f71de56a05ed1c1b66babf5662293a0549df8a2ba6ee88da6cca7fe334f7a852d82b010afcf05f6d21ba1541
+  data.tar.gz: 1444d194eaa3389270cdd23422ec294a59f523e1a71291a92551951987b54c7e316ce724465f7d0fa1151e5c7c2bad84879435eac2908c402f1c3ee888224c5f

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.0.136] - 2025-07-06
+
+- Do not allow calling Foobara.reset_alls in production
+- Fix an error backtrace bug
+- Separate Atom/Aggregate request versus object behavior in precommit transformers
+- Fix busted command-class-level state machine callbacks
+
 # [0.0.135] - 2025-07-01
 
 - Eliminate Monorepo project

data/projects/callback/src/registry/chained_conditioned.rb

@@ -1,4 +1,4 @@
-Foobara.require_project_file("callback", "registry/conditioned")
+require_relative "joined_conditioned"
 
 module Foobara
   module Callback
@@ -6,8 +6,6 @@ module Foobara
       class ChainedConditioned < Conditioned
         attr_accessor :other_conditions_registry
 
-        class InvalidConditions < StandardError; end
-
         foobara_delegate :possible_conditions, :possible_condition_keys, to: :other_conditions_registry
 
         def initialize(other_conditions_registry)

data/projects/callback/src/registry/joined_conditioned.rb

@@ -0,0 +1,28 @@
+require_relative "conditioned"
+
+module Foobara
+  module Callback
+    module Registry
+      class JoinedConditioned < Conditioned
+        attr_accessor :first, :second
+
+        foobara_delegate :possible_conditions, :possible_condition_keys, to: :first
+
+        def initialize(first, second)
+          self.first = first
+          self.second = second
+
+          super(possible_conditions)
+        end
+
+        def unioned_callback_set_for(...)
+          super.union(
+            first.unioned_callback_set_for(...).union(
+              second.unioned_callback_set_for(...)
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require_relative "../../state_machine"
+
 module Foobara
   module CommandPatternImplementation
     module Concerns
@@ -17,75 +19,90 @@ module Foobara
             subclass_defined_callbacks.register_callback(:after, &)
           end
 
-          def callback_state_machine_target
-            Foobara::Command::StateMachine
+          def state_machine_callback_registry
+            return @state_machine_callback_registry if defined?(@state_machine_callback_registry)
+
+            @state_machine_callback_registry = if superclass.respond_to?(:state_machine_callback_registry)
+                                                 Callback::Registry::ChainedConditioned.new(
+                                                   superclass.state_machine_callback_registry
+                                                 )
+                                               else
+                                                 Callback::Registry::Conditioned.new(
+                                                   from: Foobara::Command::StateMachine.states,
+                                                   transition: Foobara::Command::StateMachine.transitions,
+                                                   to: Foobara::Command::StateMachine.states
+                                                 )
+                                               end
           end
 
-          foobara_delegate :remove_all_callbacks, to: :callback_state_machine_target
+          def remove_all_callbacks
+            Foobara::Command::StateMachine.remove_all_callbacks
+            if defined?(@state_machine_callback_registry)
+              remove_instance_variable(:@state_machine_callback_registry)
+            end
+          end
         end
 
-        on_include do
-          self.subclass_defined_callbacks ||= Foobara::Callback::Registry::SingleAction.new
-
-          [self, singleton_class].each do |target|
-            [:before, :after].each do |type|
-              target.define_method "#{type}_any_transition" do |&block|
-                callback_state_machine_target.register_transition_callback(type) do |state_machine:, **args|
-                  block.call(command: state_machine.owner, **args)
-                end
+        [self, ClassMethods].each do |target|
+          [:before, :after].each do |type|
+            target.define_method "#{type}_any_transition" do |&block|
+              state_machine_callback_registry.register_callback(type) do |state_machine:, **args|
+                block.call(command: state_machine.owner, **args)
               end
             end
+          end
 
-            target.define_method "around_any_transition" do |&block|
-              callback_state_machine_target.register_transition_callback(
-                :around
-              ) do |state_machine:, **args, &do_transition_block|
-                block.call(command: state_machine.owner, **args, &do_transition_block)
-              end
+          target.define_method "around_any_transition" do |&block|
+            state_machine_callback_registry.register_callback(
+              :around
+            ) do |state_machine:, **args, &do_transition_block|
+              block.call(command: state_machine.owner, **args, &do_transition_block)
             end
+          end
 
-            target.define_method :error_any_transition do |&block|
-              callback_state_machine_target.register_transition_callback(:error) do |error|
-                callback_data = error.callback_data
+          target.define_method :error_any_transition do |&block|
+            state_machine_callback_registry.register_callback(:error) do |error|
+              callback_data = error.callback_data
 
-                state_machine = callback_data[:state_machine]
-                command = state_machine.owner
-                from = callback_data[:from]
-                transition = callback_data[:transition]
-                to = callback_data[:to]
+              state_machine = callback_data[:state_machine]
+              command = state_machine.owner
+              from = callback_data[:from]
+              transition = callback_data[:transition]
+              to = callback_data[:to]
 
-                block.call(error:, command:, state_machine:, from:, to:, transition:)
-              end
+              block.call(error:, command:, state_machine:, from:, to:, transition:)
             end
           end
+        end
 
-          Foobara::Command::StateMachine.transitions.each do |transition|
-            [self, singleton_class].each do |target|
-              [:before, :after].each do |type|
-                target.define_method "#{type}_#{transition}" do |&block|
-                  callback_state_machine_target.register_transition_callback(
-                    type, transition:
-                  ) do |state_machine:, **args|
-                    block.call(command: state_machine.owner, **args)
-                  end
+        Foobara::Command::StateMachine.transitions.each do |transition|
+          [self, ClassMethods].each do |target|
+            [:before, :after].each do |type|
+              target.define_method "#{type}_#{transition}" do |&block|
+                state_machine_callback_registry.register_callback(
+                  type, transition:
+                ) do |state_machine:, **args|
+                  block.call(command: state_machine.owner, **args)
                 end
               end
+            end
 
-              target.define_method "around_#{transition}" do |&block|
-                callback_state_machine_target.register_transition_callback(
-                  :around, transition:
-                ) do |state_machine:, **args, &do_transition_block|
-                  block.call(command: state_machine.owner, **args, &do_transition_block)
-                end
+            target.define_method "around_#{transition}" do |&block|
+              state_machine_callback_registry.register_callback(
+                :around, transition:
+              ) do |state_machine:, **args, &do_transition_block|
+                block.call(command: state_machine.owner, **args, &do_transition_block)
               end
             end
           end
         end
 
-        private
+        def state_machine_callback_registry
+          state_machine.callback_registry
+        end
 
-        def callback_state_machine_target
-          state_machine
+        on_include do
+          self.subclass_defined_callbacks ||= Foobara::Callback::Registry::SingleAction.new
         end
       end
     end

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

@@ -3,8 +3,17 @@ module Foobara
     module Concerns
       module StateMachine
         def state_machine
+          return @state_machine if defined?(@state_machine)
+
           # It makes me nervous to pass self around. Seems like a design smell.
-          @state_machine ||= Foobara::Command::StateMachine.new(owner: self)
+          @state_machine = Foobara::Command::StateMachine.new(owner: self)
+
+          @state_machine.callback_registry = Callback::Registry::JoinedConditioned.new(
+            @state_machine.callback_registry,
+            self.class.state_machine_callback_registry
+          )
+
+          @state_machine
         end
       end
     end

data/projects/command_connectors/src/transformed_command.rb

@@ -1,6 +1,5 @@
 module Foobara
   # TODO: feels so strange that this doesn't inherit from command
-  # TODO: move this to command connectors project
   class TransformedCommand
     class << self
       # TODO: handle errors_transformers!
@@ -752,7 +751,6 @@ module Foobara
       self.outcome = outcome if outcome
     rescue => e
       if capture_unknown_error
-        # TODO: move to superclass?
         self.outcome = Outcome.error(CommandConnector::UnknownError.for(e))
       else
         # :nocov:

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

@@ -1,35 +1,18 @@
+require_relative "load_aggregates_transformer"
+
 module Foobara
   module CommandConnectors
     module Transformers
-      class LoadAggregatesPreCommitTransformer < Value::Transformer
+      class LoadAggregatesPreCommitTransformer < LoadAggregatesTransformer
         def applicable?(request)
           request.command.outcome.success?
         end
 
         def transform(request)
-          load_aggregates(request.command.outcome.result)
+          super(request.command.outcome.result)
 
           request
         end
-
-        def load_aggregates(object)
-          case object
-          when Entity
-            object.class.load_aggregate(object)
-          when Array
-            object.each do |element|
-              load_aggregates(element)
-            end
-          when Hash
-            object.each_key do |key|
-              load_aggregates(key)
-            end
-
-            object.each_value do |value|
-              load_aggregates(value)
-            end
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,30 @@
+module Foobara
+  module CommandConnectors
+    module Transformers
+      class LoadAggregatesTransformer < Value::Transformer
+        def transform(object)
+          load_aggregates(object)
+        end
+
+        def load_aggregates(object)
+          case object
+          when Entity
+            object.class.load_aggregate(object)
+          when Array
+            object.each do |element|
+              load_aggregates(element)
+            end
+          when Hash
+            object.each_key do |key|
+              load_aggregates(key)
+            end
+
+            object.each_value do |value|
+              load_aggregates(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,36 +1,18 @@
+require_relative "load_atoms_transformer"
+
 module Foobara
   module CommandConnectors
     module Transformers
-      class LoadAtomsPreCommitTransformer < Value::Transformer
+      class LoadAtomsPreCommitTransformer < LoadAtomsTransformer
         def applicable?(request)
           request.command.outcome.success?
         end
 
         def transform(request)
-          load_atoms(request.command.outcome.result)
+          super(request.command.outcome.result)
 
           request
         end
-
-        def load_atoms(object)
-          case object
-          when Entity
-            if object.persisted? && !object.loaded?
-              object.class.load(object)
-            end
-          when Model
-            load_atoms(object.attributes)
-          when Array
-            object.each do |element|
-              load_atoms(element)
-            end
-          when Hash
-            object.each_pair do |key, value|
-              load_atoms(key)
-              load_atoms(value)
-            end
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,31 @@
+module Foobara
+  module CommandConnectors
+    module Transformers
+      class LoadAtomsTransformer < Value::Transformer
+        def transform(object)
+          load_atoms(object)
+        end
+
+        def load_atoms(object)
+          case object
+          when Entity
+            if object.persisted? && !object.loaded?
+              object.class.load(object)
+            end
+          when Model
+            load_atoms(object.attributes)
+          when Array
+            object.each do |element|
+              load_atoms(element)
+            end
+          when Hash
+            object.each_pair do |key, value|
+              load_atoms(key)
+              load_atoms(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/common/src/error.rb

@@ -231,6 +231,10 @@ module Foobara
       has_build_error = false
 
       1.upto(10) do |i|
+        backtrace_line = backtrace_when_initialized[i]
+
+        break unless backtrace_line
+
         if backtrace_when_initialized[i].end_with?("#build_error'")
           index = i + 1
           has_build_error = true

data/projects/common/src/error_key.rb

@@ -1,5 +1,5 @@
 module Foobara
-  # TODO: path's have use outside of errors. Make this more general.
+  # TODO: paths have use outside of errors. Make this more general.
   class ErrorKey
     # TODO: use this wherever it makes sense
     EMPTY_PATH = [].freeze

data/projects/domain/src/domain_module_extension.rb

@@ -430,7 +430,6 @@ module Foobara
           end
         end
 
-        # TODO: can we kill this skip concept?
         def foobara_manifest
           to_include = TypeDeclarations.foobara_manifest_context_to_include
 

data/projects/domain/src/organization.rb

@@ -4,7 +4,6 @@ module Foobara
     class NoSuchOrganization < StandardError; end
 
     class << self
-      # TODO: move this to organization.rb
       def to_organization(object)
         case object
         when nil

data/projects/entity/lib/foobara/entity.rb

@@ -1,5 +1,5 @@
 module Foobara
-  # TODO: I think we should have a configuration that indicates if created records can have primary keys past to them
+  # TODO: I think we should have a configuration that indicates if created records can have primary keys passed to them
   # or not. That is, do primary keys get issued by the database upon insertion? Or are they generated externally
   # and passed in? Would be nice to have programmatic clarification via explicit configuration.
   class Entity < DetachedEntity

data/projects/entity/src/association_depth.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module AssociationDepth
+    ATOM = :atom
+    AGGREGATE = :aggregate
+    PRIMARY_KEY_ONLY = :primary_key
+  end
+end

data/projects/foobara/src/foobara.rb

@@ -1,6 +1,8 @@
 require_relative "project"
 
 module Foobara
+  class MethodCantBeCalledInProductionError < StandardError; end
+
   class << self
     def require_project_file(project, path)
       require_relative("../../#{project}/src/#{path}")
@@ -47,7 +49,14 @@ module Foobara
     end
 
     def reset_alls
+      raise_if_production!("reset_alls")
       all_projects.each_value(&:reset_all)
     end
+
+    def raise_if_production!(*)
+      if ENV["FOOBARA_ENV"].nil? || ENV["FOOBARA_ENV"] == "production"
+        raise MethodCantBeCalledInProductionError
+      end
+    end
   end
 end

data/projects/manifest/src/foobara/manifest/possible_error.rb

@@ -19,8 +19,6 @@ module Foobara
         self[:manually_added]
       end
 
-      # TODO: this has to die
-
       # oops, shadowed the convenience method
       def _path
         method_missing(:path)

data/projects/model/src/model.rb

@@ -1,9 +1,6 @@
 require "inheritable_thread_vars"
 
 module Foobara
-  # TODO: either make this an abstract base class of ValueModel and Entity or rename it to ValueModel
-  # and have Entity inherit from it...
-  # TODO: also, why is this at the root level instead of in a project??
   class Model
     class NoSuchAttributeError < StandardError; end
     class AttributeIsImmutableError < StandardError; end

data/projects/namespace/src/namespace.rb

@@ -11,7 +11,6 @@ module Foobara
         Thread.current[:foobara_current_namespace] || global
       end
 
-      # TODO: eliminate deprecated_namespace and yield instead
       def use(namespace)
         unless namespace.is_a?(Namespace::IsNamespace)
           # :nocov:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.135
+  version: 0.0.136
 platform: ruby
 authors:
 - Miles Georgi
@@ -155,6 +155,7 @@ files:
 - projects/callback/src/registry/chained_conditioned.rb
 - projects/callback/src/registry/chained_multiple_action.rb
 - projects/callback/src/registry/conditioned.rb
+- projects/callback/src/registry/joined_conditioned.rb
 - projects/callback/src/registry/multiple_action.rb
 - projects/callback/src/registry/single_action.rb
 - projects/callback/src/runner.rb
@@ -231,7 +232,9 @@ files:
 - projects/command_connectors/src/transformers/auth_errors_transformer.rb
 - projects/command_connectors/src/transformers/entity_to_primary_key_inputs_transformer.rb
 - projects/command_connectors/src/transformers/load_aggregates_pre_commit_transformer.rb
+- projects/command_connectors/src/transformers/load_aggregates_transformer.rb
 - projects/command_connectors/src/transformers/load_atoms_pre_commit_transformer.rb
+- projects/command_connectors/src/transformers/load_atoms_transformer.rb
 - projects/command_connectors/src/transformers/load_delegated_attributes_entities_pre_commit_transformer.rb
 - projects/common/lib/foobara/common.rb
 - projects/common/src/data_path.rb
@@ -288,6 +291,7 @@ 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/association_depth.rb
 - projects/entity/src/concerns/attributes.rb
 - projects/entity/src/concerns/callbacks.rb
 - projects/entity/src/concerns/initialization.rb