foobara 0.3.0 → 0.4.2

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/commands/describe.rb

@@ -4,8 +4,10 @@ module Foobara
   class CommandConnector
     module Commands
       class Describe < Foobara::Command
-        inputs manifestable: :duck,
-               request: :duck
+        inputs do
+          manifestable :duck, :required
+          request :duck
+        end
         result :associative_array
 
         def execute

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

@@ -63,6 +63,31 @@ module Foobara
         command_class.authenticator
       end
 
+      def auth_mappers
+        # TODO: make this consistent?
+        command_connector.auth_map
+      end
+
+      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 serializer
         return @serializer if defined?(@serializer)
 
@@ -113,11 +138,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,17 +116,94 @@ 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
@@ -143,8 +220,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)
 
@@ -211,19 +295,55 @@ module Foobara
       self.class.find_builtin_command_class(command_class_name)
     end
 
-    foobara_delegate :add_default_inputs_transformer,
-                     :add_default_result_transformer,
-                     :add_default_errors_transformer,
-                     :add_default_pre_commit_transformer,
-                     :add_default_serializer,
-                     :add_default_response_mutator,
-                     :allowed_rule,
-                     :allowed_rules,
-                     :transform_command_class,
-                     :transformed_command_from_name,
-                     :each_transformed_command_class,
-                     :all_transformed_command_classes,
-                     to: :command_registry
+    def add_default_inputs_transformer(transformer)
+      command_registry.add_default_inputs_transformer(transformer)
+    end
+
+    def add_default_result_transformer(transformer)
+      command_registry.add_default_result_transformer(transformer)
+    end
+
+    def add_default_errors_transformer(transformer)
+      command_registry.add_default_errors_transformer(transformer)
+    end
+
+    def add_default_pre_commit_transformer(transformer)
+      command_registry.add_default_pre_commit_transformer(transformer)
+    end
+
+    def add_default_serializer(serializer)
+      command_registry.add_default_serializer(serializer)
+    end
+
+    def add_default_response_mutator(mutator)
+      # :nocov:
+      command_registry.add_default_response_mutator(mutator)
+      # :nocov:
+    end
+
+    def allowed_rule(*)
+      # :nocov:
+      command_registry.allowed_rule(*)
+      # :nocov:
+    end
+
+    def allowed_rules(*)
+      command_registry.allowed_rules(*)
+    end
+
+    def transformed_command_from_name(*)
+      command_registry.transformed_command_from_name(*)
+    end
+
+    def each_transformed_command_class(&)
+      # :nocov:
+      command_registry.each_transformed_command_class(&)
+      # :nocov:
+    end
+
+    def all_transformed_command_classes
+      command_registry.all_transformed_command_classes
+    end
 
     def lookup_command(name)
       command_registry.foobara_lookup_command(name)
@@ -295,12 +415,15 @@ module Foobara
       when "run"
         request.inputs
       when "describe"
-        manifestable = transformed_command_from_name(full_command_name) || type_from_name(full_command_name)
+        manifestable_name = full_command_name || request.inputs[:manifestable]
+        manifestable = if manifestable_name
+                         transformed_command_from_name(manifestable_name) || type_from_name(manifestable_name)
+                       end
 
         unless manifestable
           # :nocov:
           raise NoCommandOrTypeFoundError.new(
-            message: "Could not find command or type registered for #{full_command_name}"
+            message: "Could not find command or type registered for #{manifestable_name}"
           )
           # :nocov:
         end
@@ -438,6 +561,7 @@ module Foobara
       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

data/projects/command_connectors/src/transformed_command.rb

@@ -61,7 +61,17 @@ module Foobara
         end
       end
 
-      foobara_delegate :domain, :organization, to: :command_class
+      def domain
+        # :nocov:
+        command_class.domain
+        # :nocov:
+      end
+
+      def organization
+        # :nocov:
+        command_class.organization
+        # :nocov:
+      end
 
       def description
         command_class.description
@@ -594,19 +604,57 @@ module Foobara
       construct_command
     end
 
-    foobara_delegate :description, to: :command_class
-    foobara_delegate :full_command_name,
-                     :command_name,
-                     :command_class,
-                     :capture_unknown_error,
-                     :inputs_transformers,
-                     :result_transformers,
-                     :errors_transformers,
-                     :pre_commit_transformers,
-                     :serializers,
-                     :allowed_rule,
-                     :authenticator,
-                     to: :class
+    def full_command_name
+      # :nocov:
+      self.class.full_command_name
+      # :nocov:
+    end
+
+    def command_name
+      # :nocov:
+      self.class.command_name
+      # :nocov:
+    end
+
+    def command_class
+      self.class.command_class
+    end
+
+    def capture_unknown_error
+      self.class.capture_unknown_error
+    end
+
+    def inputs_transformers
+      # :nocov:
+      self.class.inputs_transformers
+      # :nocov:
+    end
+
+    def result_transformers
+      # :nocov:
+      self.class.result_transformers
+      # :nocov:
+    end
+
+    def errors_transformers
+      self.class.errors_transformers
+    end
+
+    def pre_commit_transformers
+      self.class.pre_commit_transformers
+    end
+
+    def serializers
+      self.class.serializers
+    end
+
+    def allowed_rule
+      self.class.allowed_rule
+    end
+
+    def authenticator
+      self.class.authenticator
+    end
 
     def run
       apply_allowed_rule
@@ -734,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:
@@ -743,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/domain_mapper/lib/foobara/domain_mapper.rb

@@ -1,3 +1,5 @@
+require "foobara/command"
+
 module Foobara
   class DomainMapper
     class << self
@@ -8,3 +10,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("domain_mapper", project_path: "#{__dir__}/../..")

data/projects/domain_mapper/src/domain_mapper.rb

@@ -52,6 +52,8 @@ module Foobara
         [*match_score(from_type, from_value), *match_score(to_type, to_value)].sum
       end
 
+      private
+
       def match_score(type_indicator, value)
         return 1 if type_indicator.nil? || value.nil?
         return 20 if type_indicator == value

data/projects/{detached_entity → entities/projects/detached_entity}/lib/foobara/detached_entity.rb

@@ -1,3 +1,5 @@
+require "foobara/model"
+
 module Foobara
   class DetachedEntity < Model
     abstract
@@ -24,3 +26,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("detached_entity", project_path: "#{__dir__}/../..")

data/projects/{detached_entity → entities/projects/detached_entity}/src/concerns/primary_key.rb

@@ -4,7 +4,9 @@ module Foobara
       module PrimaryKey
         include Concern
 
-        foobara_delegate :primary_key_attribute, to: :class
+        def primary_key_attribute
+          self.class.primary_key_attribute
+        end
 
         module ClassMethods
           def primary_key(attribute_name)

data/projects/{detached_entity → entities/projects/detached_entity}/src/concerns/types.rb

@@ -4,7 +4,15 @@ module Foobara
       module Types
         include Concern
 
-        foobara_delegate :full_entity_name, :entity_name, to: :class
+        def full_entity_name
+          # :nocov:
+          self.class.full_entity_name
+          # :nocov:
+        end
+
+        def entity_name
+          self.class.entity_name
+        end
 
         module ClassMethods
           def entity_type

data/projects/{detached_entity → entities/projects/detached_entity}/src/extensions/builtin_types/detached_entity/validators/model_instance_is_valid.rb

@@ -5,7 +5,7 @@ module Foobara
         class ModelInstanceIsValid < Model::Validators::ModelInstanceIsValid
           # Why is this here in entity/ instead of in model/?
           def possible_errors
-            return [] if parent_declaration_data == expected_type_symbol
+            return EMPTY_ARRAY if parent_declaration_data == expected_type_symbol
 
             # TODO: we should also ask the class if it is mutable...
             mutable = parent_declaration_data.key?(:mutable) ? parent_declaration_data[:mutable] : false

data/projects/{entity → entities/projects/entity}/lib/foobara/entity.rb

@@ -1,3 +1,5 @@
+require "foobara/detached_entity"
+
 module Foobara
   # 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
@@ -29,3 +31,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("entity", project_path: "#{__dir__}/../..")

data/projects/{entity → entities/projects/entity}/src/concerns/callbacks.rb

@@ -1,3 +1,5 @@
+require "foobara/callback"
+
 module Foobara
   class Entity < DetachedEntity
     module Concerns

data/projects/{entity → entities/projects/entity}/src/concerns/transactions.rb

@@ -17,11 +17,7 @@ module Foobara
             if skip_dependent_transactions
               entity_base.transaction(mode, &)
             else
-              Foobara::Persistence.transaction(
-                self, *deep_depends_on,
-                mode:,
-                &
-              )
+              Foobara::Persistence.transaction(self, *deep_depends_on, mode:, &)
             end
           end
         end

data/projects/entities/projects/entity/src/extensions/domain/domain_module_extension.rb

@@ -0,0 +1,111 @@
+module Foobara
+  module Domain
+    module DomainModuleExtension
+      module ClassMethods
+        attr_reader :foobara_default_entity_base
+
+        def foobara_set_entity_base(*, name: nil, table_prefix: nil)
+          name ||= Util.underscore(scoped_full_name).gsub("::", "_")
+          base = Persistence.register_base(*, name:, table_prefix:)
+          @foobara_default_entity_base = base
+        end
+
+        def foobara_register_and_deanonymize_entity(name, *, &)
+          entity_class = foobara_register_entity(name, *, &)
+          Foobara::Model.deanonymize_class(entity_class)
+        end
+
+        # TODO: kill this off
+        def foobara_register_entity(name, *args, &block)
+          # TODO: introduce a Namespace#scope method to simplify this a bit
+          Foobara::Namespace.use self do
+            if block
+              args = [
+                TypeDeclarations::Dsl::Attributes.to_declaration(&block).declaration_data,
+                *args
+              ]
+            end
+
+            attributes_type_declaration, *args = args
+
+            model_base_class, description = case args.size
+                                            when 0
+                                              []
+                                            when 1, 2
+                                              arg, other = args
+
+                                              if args.first.is_a?(::String)
+                                                [other, arg]
+                                              else
+                                                args
+                                              end
+                                            else
+                                              # :nocov:
+                                              raise ArgumentError, "Too many arguments"
+                                              # :nocov:
+                                            end
+
+            if model_base_class
+              attributes_type_declaration = TypeDeclarations::Attributes.merge(
+                model_base_class.attributes_type.declaration_data,
+                attributes_type_declaration
+              )
+            end
+
+            handler = foobara_type_builder.handler_for_class(
+              Foobara::TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+            )
+
+            attributes_type = handler.type_for_declaration(attributes_type_declaration)
+
+            # TODO: reuse the model_base_class primary key if it has one...
+            primary_key = attributes_type.element_types.keys.first
+
+            model_module = unless scoped_full_path.empty?
+                             scoped_full_name
+                           end
+
+            declaration = TypeDeclaration.new(
+              Util.remove_blank(
+                type: :entity,
+                name:,
+                model_base_class:,
+                model_module:,
+                attributes_declaration: attributes_type_declaration,
+                primary_key:,
+                description:
+              )
+            )
+
+            declaration.is_absolutified = true
+            declaration.is_duped = true
+
+            entity_type = foobara_type_builder.type_for_declaration(declaration)
+
+            entity_type.target_class
+          end
+        end
+
+        def foobara_register_and_deanonymize_entities(entity_names_to_attributes)
+          entities = []
+
+          entity_names_to_attributes.each_pair do |entity_name, attributes_declaration|
+            entities << foobara_register_and_deanonymize_entity(entity_name, attributes_declaration)
+          end
+
+          entities
+        end
+
+        def foobara_register_entities(entity_names_to_attributes)
+          entities = []
+
+          entity_names_to_attributes.each_pair do |entity_name, attributes_type_declaration|
+            entities << foobara_register_entity(entity_name, attributes_type_declaration)
+          end
+
+          entities
+        end
+      end
+    end
+  end
+end