foobara 0.4.1 → 0.4.3

data/projects/entities_plumbing/Guardfile

@@ -0,0 +1,6 @@
+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/" }
+  watch(%r{^spec/spec_helper.rb$}) { "spec/" }
+end

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

@@ -0,0 +1,12 @@
+require "foobara/command_connectors"
+
+module Foobara
+  module EntitiesPlumbing
+  end
+end
+
+Foobara.project("entities_plumbing", project_path: "#{__dir__}/../..")
+
+Foobara::CommandConnector.singleton_class.prepend(
+  Foobara::EntitiesPlumbing::CommandConnectorsExtension::ClassMethods
+)

data/projects/entities_plumbing/spec/auth_mappers_spec.rb

@@ -0,0 +1,159 @@
+RSpec.describe Foobara::CommandConnector do
+  before do
+    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+  end
+
+  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: domain_user_class)
+  end
+
+  let(:auth_user_class) do
+    stub_class "AuthUser", Foobara::Entity do
+      attributes id: :integer, name: :string
+      primary_key :id
+    end
+  end
+  let(:domain_user_class) do
+    auth_user_class
+    stub_class "User", Foobara::Entity do
+      attributes id: :integer, auth_user: AuthUser
+      primary_key :id
+    end
+  end
+
+  let(:auth_user) do
+    auth_user_class.transaction { AuthUser.create(name: "Fumiko") }
+  end
+  let(:domain_user) do
+    au = auth_user
+    domain_user_class.transaction do
+      User.create(auth_user: au)
+    end
+  end
+
+  let(:authenticator) do
+    user = auth_user
+    Foobara::CommandConnector::Authenticator.subclass(to: AuthUser) { 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
+          user = domain_user
+          -> { current_user == 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
+          user = auth_user
+          -> { authenticated_user == 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
+            user = domain_user
+            -> { current_user && current_user == 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 an entity class" do
+      before do
+        domain_user
+      end
+
+      it_behaves_like "a connector with auth mappers"
+    end
+  end
+end

data/projects/entities_plumbing/spec/spec_helper.rb

@@ -0,0 +1,54 @@
+ENV["FOOBARA_ENV"] = "test"
+
+require "bundler/setup"
+
+if ENV["RUBY_DEBUG"] == "true"
+  require "debug"
+elsif ENV["SKIP_PRY"] != "true" && ENV["CI"] != "true"
+  require "pry"
+  require "pry-byebug" unless ENV["SKIP_BYEBUG"] == "true"
+end
+
+require "rspec/its"
+require "simplecov"
+
+SimpleCov.root "#{__dir__}/../../../"
+SimpleCov.command_name "entities_plumbing"
+SimpleCov.coverage_dir "coverage/entities_plumbing"
+
+SimpleCov.start do
+  add_filter "spec/support/"
+  # This avoids printing out info about coverage generated by HTTPFormatter
+  formatter Class.new { def format(_result) = nil }
+end
+
+require "foobara/all"
+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
+    threads = Thread.list.reject { |t| t.name == "DEBUGGER__::SESSION@server" }
+    expect(threads.size).to eq(1)
+  end
+  config.filter_run_when_matching :focus
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.order = :defined
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # config.raise_errors_for_deprecations!
+end
+
+require "foobara/spec_helpers/all"
+Dir["#{__dir__}/support/**/*.rb"].each { |f| require f }

data/projects/entities_plumbing/spec/support/rubyprof.rb

@@ -0,0 +1,32 @@
+RSpec.configure do |config|
+  # TODO: move this to foobara-spec-helpers project
+  config.around(:each, :profile) do |example|
+    require "ruby-prof"
+    RubyProf.start
+
+    example.run
+
+    result = RubyProf.stop
+    printer = RubyProf::GraphHtmlPrinter.new(result)
+    File.open("tmp/profile-out.html", "w+") do |file|
+      printer.print(file)
+    end
+  end
+
+  if ENV["RUBY_PROF"] == "true"
+    config.before(:suite) do
+      require "ruby-prof"
+      require "ruby-prof/profile"
+      RubyProf.start
+    end
+
+    config.after(:suite) do
+      result = RubyProf.stop
+
+      printer = RubyProf::GraphHtmlPrinter.new(result)
+      File.open("tmp/profile-out.html", "w+") do |file|
+        printer.print(file)
+      end
+    end
+  end
+end

data/projects/entities_plumbing/spec/support/term_trap.rb

@@ -0,0 +1,6 @@
+# Convenient whenever running into an infinite loop
+Signal.trap("TERM") do
+  puts "SIGTERM received, printing backtrace:"
+  puts caller.join("\n")
+  exit
+end

data/projects/entities_plumbing/src/command_connectors_extension.rb

@@ -0,0 +1,17 @@
+module Foobara
+  module EntitiesPlumbing
+    module CommandConnectorsExtension
+      module ClassMethods
+        def to_auth_user_mapper(object)
+          if object.is_a?(::Class) && object < Foobara::Entity
+            TypeDeclarations::TypedTransformer.subclass(to: object) do |authenticated_user|
+              object.that_owns(authenticated_user)
+            end.instance
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/projects/entities_plumbing/src/extensions/authenticator.rb

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

data/projects/manifest/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"
@@ -27,7 +29,8 @@ RSpec.configure do |config|
   # .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/typesystem/projects/builtin_types/src/builtin_types.rb

@@ -154,12 +154,6 @@ module Foobara
         type
       end
 
-      private
-
-      def global_type_declaration_handler_registry
-        TypeDeclarations.global_type_declaration_handler_registry
-      end
-
       def install_type_declaration_extensions_for(processor_class)
         extension_module = Util.constant_value(processor_class, :TypeDeclarationExtension)
 
@@ -210,6 +204,12 @@ module Foobara
           end
         end
       end
+
+      private
+
+      def global_type_declaration_handler_registry
+        TypeDeclarations.global_type_declaration_handler_registry
+      end
     end
   end
 end

data/projects/typesystem/projects/domain/src/domain.rb

@@ -91,21 +91,6 @@ module Foobara
             new_class.const_set(const_name, value)
           end
         end
-
-        lower_case_constants = old_mod.instance_variable_get(:@foobara_lowercase_constants)
-
-        if lower_case_constants && !lower_case_constants.empty?
-          lower_case_constants&.each do |lower_case_constant|
-            new_class.singleton_class.define_method lower_case_constant do
-              old_mod.send(lower_case_constant)
-            end
-          end
-
-          new_lowercase_constants = new_class.instance_variable_get(:@foobara_lowercase_constants) || []
-          new_lowercase_constants += lower_case_constants
-
-          new_class.instance_variable_set(:@foobara_lowercase_constants, new_lowercase_constants)
-        end
       end
     end
   end

data/projects/typesystem/projects/domain/src/domain_module_extension.rb

@@ -17,80 +17,6 @@ module Foobara
       module ClassMethods
         attr_writer :foobara_domain_name, :foobara_full_domain_name
 
-        def foobara_unregister(scoped)
-          scoped = to_scoped(scoped)
-
-          if scoped.is_a?(Foobara::Types::Type)
-            parent_mod = nil
-
-            if const_defined?(:Types, false)
-              parent_path = ["Foobara::GlobalDomain"]
-              unless scoped.type_symbol.to_s.start_with?("Types::")
-                parent_path << "Types"
-              end
-              parent_path += scoped.type_symbol.to_s.split("::")[..-2]
-
-              parent_name = parent_path.join("::")
-              child_name = [*parent_path, scoped.type_symbol.to_s.split("::").last].join("::")
-              removed = false
-
-              if Object.const_defined?(parent_name)
-                parent_mod = Object.const_get(parent_name)
-
-                if scoped.scoped_short_name =~ /^[a-z]/
-                  lower_case_constants = parent_mod.instance_variable_get(:@foobara_lowercase_constants)
-
-                  if lower_case_constants&.include?(scoped.scoped_short_name)
-                    parent_mod.singleton_class.undef_method scoped.scoped_short_name
-                    lower_case_constants.delete(scoped.scoped_short_name)
-                  end
-
-                  removed = true
-                elsif parent_mod.const_defined?(scoped.scoped_short_name, false)
-                  parent_mod.send(:remove_const, scoped.scoped_short_name)
-                  removed = true
-                end
-              end
-
-              if removed
-                child_name = parent_name
-
-                while child_name
-                  child = Object.const_get(child_name)
-
-                  break if child.foobara_domain?
-                  break if child.foobara_organization?
-
-                  # TODO: unclear why we need this check, hmmm, figure it out and document it (or delete if not needed)
-                  break if child.constants(false).any? do |constant|
-                    # TODO: a clue: this stopped being entered by the test suite after deleting GlobalDomain::Types
-                    # in .reset_alls hmmmmmm...
-                    # :nocov:
-                    value = child.const_get(constant)
-                    value.is_a?(Types::Type) || (value.is_a?(::Class) && value.respond_to?(:foobara_type?))
-                    # :nocov:
-                  end
-
-                  lower_case_constants = child.instance_variable_get(:@foobara_lowercase_constants)
-                  break if lower_case_constants && !lower_case_constants.empty?
-
-                  parent_name = Util.parent_module_name_for(child_name)
-                  break unless Object.const_defined?(parent_name)
-
-                  parent = Object.const_get(parent_name)
-
-                  child_sym = Util.non_full_name(child).to_sym
-                  parent.send(:remove_const, child_sym)
-
-                  child_name = parent_name
-                end
-              end
-            end
-          end
-
-          super
-        end
-
         def foobara_domain_map(*args, to: nil, strict: false, criteria: nil, should_raise: false, **opts)
           case args.size
           when 1
@@ -261,8 +187,6 @@ module Foobara
             foobara_register(type)
           end
 
-          _set_type_constant(type)
-
           type
         end
 
@@ -325,83 +249,6 @@ module Foobara
 
           manifest
         end
-
-        private
-
-        def _set_type_constant(type)
-          domain = if scoped_full_path.empty?
-                     GlobalDomain
-                   else
-                     self
-                   end
-
-          path = type.scoped_path
-          if path.first == "Types"
-            path = path[1..]
-          end
-
-          types_mod = if domain.const_defined?(:Types)
-                        domain.const_get(:Types)
-                      else
-                        domain.const_set(:Types, Module.new)
-                      end
-
-          if type.scoped_prefix
-            const_name = [types_mod.name, *path[0..-2]].join("::")
-            types_mod = Util.make_module_p(const_name, tag: true)
-          end
-
-          # TODO: dry this up
-          if type.scoped_short_name =~ /\A[a-z]/
-            unless types_mod.respond_to?(type.scoped_short_name)
-              types_mod.singleton_class.define_method type.scoped_short_name do
-                type
-              end
-
-              unless types_mod.instance_variable_defined?(:@foobara_lowercase_constants)
-                types_mod.instance_variable_set(:@foobara_lowercase_constants, [])
-              end
-
-              types_mod.instance_variable_get(:@foobara_lowercase_constants) << type.scoped_short_name
-            end
-          elsif types_mod.const_defined?(type.scoped_short_name, false)
-            existing_value = types_mod.const_get(type.scoped_short_name)
-            existing_value_type = if existing_value.is_a?(::Class) && existing_value < Foobara::Model
-                                    # TODO: test this code path
-                                    # :nocov:
-                                    existing_value.model_type
-                                    # :nocov:
-                                  else
-                                    existing_value
-                                  end
-
-            if existing_value_type != type
-              if existing_value.is_a?(::Module) && !existing_value.is_a?(::Class) &&
-                 existing_value.instance_variable_get(:@foobara_created_via_make_class) &&
-                 # not allowing lower-case "constants" to be namespaces
-                 type.extends?("::model")
-
-                types_mod.send(:remove_const, type.scoped_short_name)
-                types_mod.const_set(type.scoped_short_name, type.target_class)
-
-                Domain.copy_constants(existing_value, type.target_class)
-              else
-                # :nocov:
-                raise CannotSetTypeConstantError,
-                      "Already defined constant #{types_mod.name}::#{type.scoped_short_name}"
-                # :nocov:
-              end
-            end
-          else
-            symbol = type.scoped_short_name
-
-            if type.extends?("::model")
-              type = type.target_class
-            end
-
-            types_mod.const_set(symbol, type)
-          end
-        end
       end
     end
   end

data/projects/typesystem/projects/domain/src/module_extension.rb

@@ -26,54 +26,6 @@ module Foobara
         end
 
         include(DomainModuleExtension)
-
-        children = foobara_children
-        children = children.sort_by { |child| child.scoped_path.size }
-
-        # see if we are upgrading from prefix to domain and copy over types to Types module
-        children.each do |child|
-          next unless child.is_a?(Types::Type)
-
-          types_mod_path = scoped_full_path.dup
-          unless child.scoped_path.first == "Types"
-            types_mod_path << "Types"
-          end
-
-          types_mod_path += child.scoped_path[..-2]
-          types_mod = Util.make_module_p(types_mod_path.join("::"))
-
-          # TODO: dry this up
-          # TODO: this doesn't handle a type nested under a lower-case type for now
-          if child.scoped_short_name =~ /^[a-z]/
-            unless types_mod.respond_to?(child.scoped_short_name)
-              types_mod.singleton_class.define_method child.scoped_short_name do
-                child
-              end
-
-              unless types_mod.instance_variable_defined?(:@foobara_lowercase_constants)
-                # TODO: test this path or delete it if unreachable
-                # :nocov:
-                types_mod.instance_variable_set(:@foobara_lowercase_constants, [])
-                # :nocov:
-              end
-
-              types_mod.instance_variable_get(:@foobara_lowercase_constants) << child.scoped_short_name
-            end
-          else
-            value = if types_mod.const_defined?(child.scoped_short_name, false)
-                      # TODO: test this path or delete it if unreachable
-                      # :nocov:
-                      types_mod.const_get(child.scoped_short_name, false)
-                      # :nocov:
-                    end
-
-            if value != child
-              types_mod.send(:remove_const, child.scoped_short_name) if value
-
-              foobara_set_types_mod_constant(types_mod, child.scoped_short_name, child)
-            end
-          end
-        end
       end
 
       def foobara_organization!
@@ -101,16 +53,6 @@ module Foobara
       def foobara_organization?
         false
       end
-
-      private
-
-      # Unclear if we actually need this but putting it here to allow entities project
-      # to override this to set the constant to the target class
-      def foobara_set_types_mod_constant(types_mod, name, value)
-        # :nocov:
-        types_mod.const_set(types_mod, name, value)
-        # :nocov:
-      end
     end
   end
 end

data/projects/typesystem/projects/namespace/src/is_namespace.rb

@@ -156,6 +156,7 @@ module Foobara
 
       def foobara_lookup(path, filter: nil, mode: LookupMode::GENERAL)
         LookupMode.validate!(mode)
+
         path = Namespace.to_registry_path(path)
 
         lru_cache.cached([self, path, mode, *filter]) do
@@ -189,6 +190,13 @@ module Foobara
           scoped = candidates.first ||
                    foobara_parent_namespace&.foobara_lookup_without_cache(path, filter:, mode:, visited:)
 
+          scoped ||= foobara_lookup_without_cache(
+            [*scoped_full_path, *path],
+            filter:,
+            mode: LookupMode::GENERAL,
+            visited:
+          )
+
           return scoped
         end
 

data/projects/typesystem/projects/type_declarations/lib/foobara/type_declarations.rb

@@ -35,14 +35,6 @@ module Foobara
           end
         end
 
-        if GlobalDomain.const_defined?(:Types, false)
-          GlobalDomain::Types.instance_variable_set(
-            :@foobara_lowercase_constants,
-            @original_foobara_lowercase_constants || []
-          )
-          GlobalDomain.send(:remove_const, :Types)
-        end
-
         @original_scoped.each do |scoped|
           Namespace.global.foobara_register(scoped)
         end
@@ -126,13 +118,6 @@ module Foobara
         # most important
         @original_scoped = Namespace.global.foobara_registry.all_scoped.dup
         @original_children = Namespace.global.foobara_children.dup
-
-        if GlobalDomain.const_defined?(:Types, false)
-          # :nocov:
-          @original_foobara_lowercase_constants =
-            GlobalDomain::Types.instance_variable_get(:@foobara_lowercase_constants).dup
-          # :nocov:
-        end
       end
     end
   end