foobara 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd07a1cd0a343e918e6686086afa86cb0996b04a120a67381d4582bfdfae7171
-  data.tar.gz: cbfd94dde3fbee1846451afabac7ce3bb1b4b2f0ae7c49d2844df17486c18df4
+  metadata.gz: db631f3175aa83feaee1a634560a7086c24e3c46b5c7df0b0a958252b531a377
+  data.tar.gz: 479a5728d5c86fdb689841d8cb422c564330d55a0502acbe3a32c27891573694
 SHA512:
-  metadata.gz: db7af13da7e1b0faff58350ea7953487f856cff45f92beb5edf8249dbeb041dffd1f7ef98cf405b5fd71c1cb6b4d46014256c48dd9432f84ea5b5688fa8cbfbe
-  data.tar.gz: 54563dc01bca8752b202ac61e50909d92794ea80357d4090c4741e27c6db705d498508d8cabee7c6dc40c28c51731cbee6449c8484f732dbb49adf3749c5aebd
+  metadata.gz: de898a650ff1066c7eb4ac304050a77c3a08bbf075bca85e7cf22c448a1ea3a1f128dd8cec36356a0cf1cae7a2590b3a98f547090f94b43674808b62c4178009
+  data.tar.gz: 6d900e6391ebd970950e43c42b106cbc0595480e14c7c594f90ed7be564234235f242b1824117cdc41975056e55763b854acfa4f6e412f02e6371e2b779a44d6

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [0.4.3] - 2026-01-19
+
+- Allow a request to handle auth mapper methods
+
+# [0.4.2] - 2026-01-15
+
+- Fix relaxed lookup bug for a symbol starting with a prefix
+- Allow registered types to be looked up by string and in relaxed mode
+- Create entities_plumbing project and implement auth mapping for entities
+- Implement auth mappers concept
+- Change authenticator to be a TypedTransformer
+- Allow passing a block to a connector to simplify connecting stuff a bit
+- Remove likely-unused automatic creation of Types module constants
+- Support official ruby debug
+
 # [0.4.1] - 2025-12-19
 
 - Add a model_plumbing project and use it to fix up commands when models are reregistered

data/README.md

@@ -1578,7 +1578,9 @@ module FoobaraDemo
 
         alias animal from
 
-        foobara_delegate :first_name, :last_name, :birthday, to: :animal # Deprecated
+        def first_name = animal.first_name
+        def last_name = animal.last_name
+        def birthday = animal.birthday
 
         def birthday_to_age
           today = Date.today

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

@@ -7,6 +7,7 @@ module Foobara
         include Concern
         include NestedTransactionable
 
+        # TODO: move this out of here!
         def relevant_entity_classes
           return @relevant_entity_classes if defined?(@relevant_entity_classes)
 

data/projects/command_connectors/Guardfile

@@ -1,4 +1,4 @@
-guard :rspec, all_after_pass: true, all_on_start: true, cmd: "bundle exec rspec", failed_mode: :focus do
+guard :rspec, all_after_pass: false, all_on_start: true, cmd: "bundle exec rspec", failed_mode: :focus do
   watch(%r{^spec/(.+)_spec\.rb$})
   watch(%r{^src/(.+)\.rb$}) { "spec/" }
   watch(%r{^lib/(.+)\.rb$}) { "spec/" }

data/projects/command_connectors/spec/auth_mappers_spec.rb

@@ -0,0 +1,201 @@
+RSpec.describe Foobara::CommandConnector do
+  after do
+    Foobara.reset_alls
+  end
+
+  let(:command_class) do
+    stub_class(:ComputeExponent, Foobara::Command) do
+      inputs exponent: :integer, base: :integer
+      result :integer
+
+      def execute = base ** exponent
+    end
+  end
+
+  let(:command_connector) do
+    described_class.new(authenticator:, current_user: current_user_mapper)
+  end
+
+  let(:authenticator) do
+    proc { "some_user" }
+  end
+
+  let(:base) { 2 }
+  let(:exponent) { 3 }
+
+  let(:response) { command_connector.run(full_command_name:, action:, inputs:) }
+  let(:errors_hash) { response.body.errors_hash }
+
+  let(:action) { "run" }
+  let(:full_command_name) { "ComputeExponent" }
+  let(:inputs) do
+    { base:, exponent: }
+  end
+
+  describe "#run_command" do
+    class << self
+      def with_current_user_allowed_rule
+        let(:allowed_rule) do
+          -> { current_user == "current_user is some_user" }
+        end
+      end
+
+      def with_current_user_not_allowed_rule
+        let(:allowed_rule) do
+          -> { current_user == "asfdasdf" }
+        end
+      end
+
+      def with_authenticated_user_allowed_rule
+        let(:allowed_rule) do
+          -> { authenticated_user == "some_user" }
+        end
+      end
+
+      def with_authenticated_user_not_allowed_rule
+        let(:allowed_rule) do
+          -> { authenticated_user == "asfdasdf" }
+        end
+      end
+    end
+
+    shared_examples "a connector with auth mappers" do
+      before do
+        command_connector.connect(command_class, allowed_rule:)
+      end
+
+      context "when using current_user in the allowed rule" do
+        context "when allowed" do
+          with_current_user_allowed_rule
+
+          it "runs the command" do
+            expect(response.status).to be(0)
+            expect(response.body).to eq(8)
+          end
+        end
+
+        context "when not allowed" do
+          with_current_user_not_allowed_rule
+
+          it "fails with a relevant error" do
+            expect(response.status).to be(1)
+            expect(errors_hash.key?("runtime.not_allowed")).to be true
+          end
+        end
+
+        context "when calling current_user multiple times" do
+          let(:allowed_rule) do
+            -> { current_user && current_user == "current_user is some_user" }
+          end
+
+          it "runs the command" do
+            expect(response.status).to be(0)
+            expect(response.body).to eq(8)
+          end
+        end
+      end
+
+      context "when using authenticated_user in the allowed rule" do
+        context "when allowed" do
+          with_authenticated_user_allowed_rule
+
+          it "runs the command" do
+            expect(response.status).to be(0)
+            expect(response.body).to eq(8)
+          end
+        end
+
+        context "when not allowed" do
+          with_authenticated_user_not_allowed_rule
+
+          it "fails with a relevant error" do
+            expect(response.status).to be(1)
+            expect(errors_hash.key?("runtime.not_allowed")).to be true
+          end
+        end
+      end
+    end
+
+    context "when auth user mapper is a hash" do
+      let(:current_user_mapper) do
+        {
+          to: :string,
+          map: ->(authenticated_user) { "current_user is #{authenticated_user}" }
+        }
+      end
+
+      it_behaves_like "a connector with auth mappers"
+    end
+
+    context "when auth user mapper is an array" do
+      let(:current_user_mapper) { [:string, ->(authenticated_user) { "current_user is #{authenticated_user}" }] }
+
+      it_behaves_like "a connector with auth mappers"
+    end
+
+    context "when auth user mapper is a typed transformer class" do
+      let(:current_user_mapper) do
+        stub_class("SomeTypedTransformer", Foobara::TypeDeclarations::TypedTransformer) do
+          to :string
+
+          def transform(authenticated_user)
+            "current_user is #{authenticated_user}"
+          end
+        end
+      end
+
+      it_behaves_like "a connector with auth mappers"
+
+      context "when it is an instance" do
+        let(:current_user_mapper) { super().instance }
+
+        it_behaves_like "a connector with auth mappers"
+      end
+    end
+
+    context "when auth user mapper is a domain mapper" do
+      let(:current_user_mapper) do
+        stub_class("SomeDomainMapper", Foobara::DomainMapper) do
+          from :string
+          to :string
+
+          def map = "current_user is #{from}"
+        end
+      end
+
+      it_behaves_like "a connector with auth mappers"
+    end
+
+    context "when auth user mapper is a command" do
+      context "with only one input" do
+        let(:current_user_mapper) do
+          stub_class("SomeCommand", Foobara::Command) do
+            inputs auth_user: :string
+            result :string
+
+            def execute = "current_user is #{auth_user}"
+          end
+        end
+
+        it_behaves_like "a connector with auth mappers"
+      end
+
+      context "with multiple inputs but only one required input" do
+        let(:current_user_mapper) do
+          stub_class("SomeCommand", Foobara::Command) do
+            inputs do
+              foo :string
+              bar :string
+              auth_user :string, :required
+            end
+            result :string
+
+            def execute = "current_user is #{auth_user}"
+          end
+        end
+
+        it_behaves_like "a connector with auth mappers"
+      end
+    end
+  end
+end

data/projects/command_connectors/spec/command_connector_spec.rb

@@ -2201,7 +2201,8 @@ RSpec.describe Foobara::CommandConnector do
         command_connector_b.connect(command_class, :auth)
         command_connector_c.connect(command_class, requires_authentication: true)
         command_connector_d.connect(command_class, requires_authentication: true)
-        command_connector_e.connect(command_class, requires_authentication: true, authenticator: [authenticator_e])
+        command_connector_e.connect(command_class, requires_authentication: true,
+                                                   authenticator: [authenticator_e])
 
         response = command_connector_a.run(full_command_name:, action:, inputs:)
         expect(response.status).to be(0)

data/projects/command_connectors/spec/pre_commit_transformers/load_atoms_pre_commit_transformer_spec.rb

@@ -76,14 +76,17 @@ RSpec.describe Foobara::CommandConnectors::Transformers::LoadAtomsPreCommitTrans
   end
 
   let(:command_connector) do
-    Foobara::CommandConnector.new(default_pre_commit_transformers: described_class)
+    cc = command_class
+    Foobara::CommandConnector.new(default_pre_commit_transformers: described_class) do
+      command cc
+    end
   end
 
   let(:transformer) { described_class.new(to: type) }
 
   describe "#transform" do
     it "gives what was passed in because we expect this data to be cast where needed" do
-      command_connector.connect(command_class)
+      command_connector
       response = command_connector.run(
         full_command_name: command_class.full_command_name,
         inputs: value,

data/projects/command_connectors/spec/request_spec.rb

@@ -92,4 +92,27 @@ RSpec.describe Foobara::CommandConnector::Request do
       end
     end
   end
+
+  context "with an auth-mapped method" do
+    let(:command_class) do
+      stub_class("SomeCommand", Foobara::Command) do
+        def self.requires_authentication = true
+      end
+    end
+
+    let(:request) do
+      foo_mapper = Foobara::TypeDeclarations::TypedTransformer.subclass(to: :symbol) { :bar }.instance
+      # TODO: make a block form of this
+      authenticator = Foobara::CommandConnector.to_authenticator(-> { :some_user })
+
+      described_class.new(authenticator:, auth_mappers: { foo: foo_mapper }).tap do |request|
+        request.command_class = command_class
+        request.authenticate
+      end
+    end
+
+    it "can access the auth-mapped method" do
+      expect(request.foo).to eq(:bar)
+    end
+  end
 end

data/projects/command_connectors/spec/spec_helper.rb

@@ -2,9 +2,11 @@ ENV["FOOBARA_ENV"] = "test"
 
 require "bundler/setup"
 
-unless ENV["SKIP_PRY"] == "true" || ENV["CI"] == "true"
+if ENV["RUBY_DEBUG"] == "true"
+  require "debug"
+elsif ENV["SKIP_PRY"] != "true" && ENV["CI"] != "true"
   require "pry"
-  require "pry-byebug"
+  require "pry-byebug" unless ENV["SKIP_BYEBUG"] == "true"
 end
 
 require "rspec/its"
@@ -22,13 +24,16 @@ end
 
 require "foobara/all"
 require "foobara/command_connectors"
+# TODO: eliminate this require! We should not depend on entities in this project!
+require "foobara/entities_plumbing"
 
 RSpec.configure do |config|
   # Need to do :all instead of :each because for specs that use .around,
   # .after(:each) do |example| here is called after example.run but before any threads created in
   # .around might have been cleaned up.
   config.after(:suite) do
-    expect(Thread.list.size).to eq(1)
+    threads = Thread.list.reject { |t| t.name == "DEBUGGER__::SESSION@server" }
+    expect(threads.size).to eq(1)
   end
   config.filter_run_when_matching :focus
 

data/projects/command_connectors/src/authenticator.rb

@@ -1,28 +1,39 @@
 module Foobara
   class CommandConnector
-    # TODO: should switch to a processor and give errors if the authenticator header is malformed
-    class Authenticator < Value::Transformer
-      attr_reader :block
+    class Authenticator < TypeDeclarations::TypedTransformer
+      class << self
+        attr_writer :default_symbol
+        attr_accessor :default_explanation, :default_block
 
-      def initialize(symbol: nil, explanation: nil, &block)
-        symbol ||= Util.non_full_name_underscore(self.class).to_sym
-        explanation ||= symbol
+        def subclass(to: nil, symbol: nil, explanation: nil, &default_block)
+          klass = super(to:, from: Request, &nil)
 
-        super(symbol:, explanation:)
+          klass.default_symbol = symbol if symbol
+          klass.default_explanation = explanation if explanation
+          klass.default_block = default_block if default_block
 
-        @block = block
-      end
+          klass
+        end
 
-      def relevant_entity_classes(_request)
-        nil
-      end
+        def default_symbol
+          @default_symbol || Util.non_full_name_underscore(self)&.to_sym
+        end
 
-      def symbol
-        declaration_data[:symbol]
+        def instance
+          @instance ||= new
+        end
       end
 
-      def explanation
-        declaration_data[:explanation]
+      attr_accessor :symbol
+      attr_reader :block, :explanation
+
+      def initialize(symbol: nil, explanation: nil, &block)
+        self.symbol = symbol || self.class.default_symbol
+        @explanation = explanation || self.class.default_explanation || self.symbol
+
+        super()
+
+        @block = block || self.class.default_block
       end
 
       def transform(request)

data/projects/command_connectors/src/command_connector/request.rb

@@ -16,10 +16,12 @@ module Foobara
                     :action,
                     :response,
                     :authenticated_user,
-                    :authenticated_credential
+                    :authenticated_credential,
+                    :auth_mappers,
+                    :authenticator
 
       def initialize(**opts)
-        valid_keys = [:inputs, :full_command_name, :action, :serializers]
+        valid_keys = [:inputs, :full_command_name, :action, :serializers, :authenticator, :auth_mappers]
 
         invalid_keys = opts.keys - valid_keys
 
@@ -31,6 +33,8 @@ module Foobara
 
         self.inputs = opts[:inputs] if opts.key?(:inputs)
         self.action = opts[:action] if opts.key?(:action)
+        self.auth_mappers = opts[:auth_mappers] if opts.key?(:auth_mappers)
+        self.authenticator = opts[:authenticator] if opts.key?(:authenticator)
         self.full_command_name = opts[:full_command_name] if opts.key?(:full_command_name)
         self.serializers = Util.array(opts[:serializers]) if opts.key?(:serializers)
       end
@@ -59,8 +63,38 @@ module Foobara
         end
       end
 
-      def authenticator
-        command_class.authenticator
+      def auth_mapped_method?(method_name)
+        auth_mappers&.key?(method_name)
+      end
+
+      def auth_mapper_for(name)
+        auth_mappers&.[](name.to_sym)
+      end
+
+      def auth_mapped_value_for(name)
+        return unless authenticated_user
+
+        @auth_mapper_cache ||= {}
+
+        if @auth_mapper_cache.key?(name)
+          @auth_mapper_cache[name]
+        else
+          @auth_mapper_cache[name] = auth_mapper_for(name)&.process_value!(authenticated_user)
+        end
+      end
+
+      def method_missing(method_name, ...)
+        if auth_mapped_method?(method_name)
+          auth_mapped_value_for(method_name)
+        else
+          # :nocov:
+          super
+          # :nocov:
+        end
+      end
+
+      def respond_to_missing?(method_name, private = false)
+        auth_mapped_method?(method_name) || super
       end
 
       def serializer
@@ -113,11 +147,12 @@ module Foobara
         outcome.error_collection
       end
 
+      # TODO: move this to entity_plumbing
       def relevant_entity_classes
         if command_class.is_a?(::Class) && command_class < TransformedCommand
           entity_classes = authenticator&.relevant_entity_classes(self)
           [*entity_classes, *relevant_entity_classes_from_inputs_transformer]
-        end || []
+        end || EMPTY_ARRAY
       end
 
       private

data/projects/command_connectors/src/command_connector.rb

@@ -63,7 +63,7 @@ module Foobara
         case object
         when Class
           if object < Authenticator
-            object.new
+            object.instance
           else
             # :nocov:
             raise ArgumentError, "Expected a class that inherits from Authenticator"
@@ -116,19 +116,97 @@ module Foobara
           end
         end
       end
+
+      # don't call this auth_user ?
+      def to_auth_user_mapper(object)
+        case object
+        when TypeDeclarations::TypedTransformer
+          object
+        when ::Class
+          if object < TypeDeclarations::TypedTransformer
+            object.instance
+          elsif object < Foobara::DomainMapper
+            build_auth_mapper(object.to_type) { |authenticated_user| object.map!(authenticated_user) }
+          elsif object < Foobara::Command
+            inputs_type = object.inputs_type
+            element_types = inputs_type.element_types
+            size = element_types.size
+
+            first_required_input = if size == 1
+                                     element_types.keys.first
+                                   elsif size > 1
+                                     declaration = inputs_type&.declaration_data
+                                     required_attribute_names = declaration&.[](:required) || EMPTY_ARRAY
+
+                                     if required_attribute_names.size == 1
+                                       required_attribute_names.first
+                                     else
+                                       # :nocov:
+                                       raise ArgumentError,
+                                             "Ambiguous inputs when trying to use #{object} as a mapper. " \
+                                             "Should have either only 1 input or only 1 required input."
+                                       # :nocov:
+                                     end
+                                   else
+                                     # :nocov:
+                                     raise ArgumentError, "To use a command as a mapper it must take an input to map"
+                                     # :nocov:
+                                   end
+
+            build_auth_mapper(object.result_type) do |authenticated_user|
+              object.run!(first_required_input => authenticated_user)
+            end
+          else
+            # :nocov:
+            raise ArgumentError, "not sure how to convert a #{object} to an auth mapper"
+            # :nocov:
+          end
+        when ::Hash
+          object => { to:, map: }
+          build_auth_mapper(to, &map)
+        when ::Array
+          object => [to, map]
+          build_auth_mapper(to, &map)
+        else
+          # :nocov:
+          raise ArgumentError, "Not sure how to convert #{object} to an auth mapper"
+          # :nocov:
+        end
+      end
+
+      # TODO: make private
+      def build_auth_mapper(to_type, &)
+        TypeDeclarations::TypedTransformer.subclass(to: to_type, &).instance
+      end
     end
 
-    attr_accessor :command_registry, :authenticator, :capture_unknown_error, :name
+    attr_accessor :command_registry, :authenticator, :capture_unknown_error, :name,
+                  :auth_map
 
     def initialize(name: nil,
                    authenticator: nil,
                    capture_unknown_error: nil,
                    default_serializers: nil,
-                   default_pre_commit_transformers: nil)
+                   default_pre_commit_transformers: nil,
+                   auth_map: nil,
+                   current_user: nil,
+                   &block)
       authenticator = self.class.to_authenticator(authenticator)
 
+      if current_user
+        auth_map ||= {}
+        auth_map[:current_user] = current_user
+      end
+
+      if auth_map
+        self.auth_map = auth_map.transform_values do |mapper|
+          self.class.to_auth_user_mapper(mapper)
+        end
+      end
+
       self.authenticator = authenticator
       self.command_registry = CommandRegistry.new(authenticator:)
+
       self.capture_unknown_error = capture_unknown_error
       self.name = name
 
@@ -143,8 +221,15 @@ module Foobara
       self.class.allowed_rules_to_register.each do |ruleish_args|
         command_registry.allowed_rule(*ruleish_args)
       end
+
+      if block
+        instance_eval(&block)
+      end
     end
 
+    # TODO: should this be the official way to connect a command instead of #connect ?
+    def command(...) = connect(...)
+
     def connect(*args, **opts)
       args, opts = desugarize_connect_args(args, opts)
 
@@ -472,15 +557,24 @@ module Foobara
 
     def build_request(...)
       self.class::Request.new(...).tap do |request|
-        # TODO: feels like a smell
+        # TODO: feels like a smell? Can we deprecate this somehow? Request no longer calls command_connector it seems...
         request.command_connector = self
       end
     end
 
+    # TODO: get all this persistence stuff out of here and into entities plumbing somehow
     def run_request(request)
       command_class = determine_command_class(request)
       request.command_class = command_class
 
+      if command_class.respond_to?(:requires_authentication) && command_class.requires_authentication
+        request.authenticator ||= command_class.authenticator || authenticator
+
+        if auth_map
+          request.auth_mappers ||= auth_map
+        end
+      end
+
       return build_response(request) unless command_class
 
       begin

data/projects/command_connectors/src/transformed_command.rb

@@ -782,7 +782,9 @@ module Foobara
     end
 
     def method_missing(method_name, ...)
-      if command.respond_to?(method_name)
+      if auth_mapped_method?(method_name)
+        auth_mapped_value_for(method_name)
+      elsif command.respond_to?(method_name)
         command.send(method_name, ...)
       else
         # :nocov:
@@ -791,8 +793,16 @@ module Foobara
       end
     end
 
+    def auth_mapped_value_for(name)
+      request.auth_mapped_value_for(name)
+    end
+
+    def auth_mapped_method?(method_name)
+      request&.auth_mapped_method?(method_name)
+    end
+
     def respond_to_missing?(method_name, private = false)
-      command.respond_to?(method_name, private) || super
+      command.respond_to?(method_name, private) || auth_mapped_method?(method_name) || super
     end
 
     private

data/projects/entities/spec/spec_helper.rb

@@ -2,9 +2,11 @@ ENV["FOOBARA_ENV"] = "test"
 
 require "bundler/setup"
 
-unless ENV["SKIP_PRY"] == "true" || ENV["CI"] == "true"
+if ENV["RUBY_DEBUG"] == "true"
+  require "debug"
+elsif ENV["SKIP_PRY"] != "true" && ENV["CI"] != "true"
   require "pry"
-  require "pry-byebug"
+  require "pry-byebug" unless ENV["SKIP_BYEBUG"] == "true"
 end
 
 require "rspec/its"