yes-core 1.0.0

data/lib/yes/core/aggregate/dsl/class_resolvers/authorizer.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          # Creates and registers authorizer classes for aggregates based on
+          # Yes::Core::Authorization::CommandCerbosAuthorizer.
+          #
+          # This class resolver generates authorizer classes associated with aggregates.
+          # Each authorizer class defines a RESOURCE constant containing the
+          # associated read model class and resource name used for authorization checks.
+          #
+          # @example Generated authorizer class structure
+          #   # Generated for a 'User' aggregate
+          #   class GeneratedAuthorizer < Yes::Core::Authorization::CommandCerbosAuthorizer
+          #     RESOURCE = { read_model: Auth::Resources::User, name: 'user' }.freeze
+          #   end
+          class Authorizer < Base
+            # Initializes a new authorizer class resolver
+            #
+            # @param options [Yes::Core::Aggregate::HasAuthorizer::AuthorizerOptions] Data object containing:
+            #   - authorizer_base_class [Class] The authorizer class to use.
+            #   - context [String] The name of the context (e.g., 'CompanyManagement')
+            #   - aggregate [String] The name of the aggregate (e.g., 'Company')
+            #   - read_model_class [Class, nil] Optional read model class. Defaults to
+            #     `Auth::Resources::<AggregateName>`.
+            #   - resource_name [String, nil] Optional resource name for Cerbos. Defaults to
+            #     aggregate name underscored (e.g., 'company').
+            #   - authorizer_block [Proc, nil] An optional block defining the custom logic for the `call` method
+            #     if `authorizer_base_class` is not `Yes::Core::Authorization::CommandCerbosAuthorizer`.
+            def initialize(options)
+              @resource_name = options.resource_name
+              @read_model_class = options.read_model_class
+              @authorizer_class = options.authorizer_base_class
+              @custom_call_logic = options.authorizer_block
+              @draftable = options.draftable
+              @changes_read_model_class = options.changes_read_model_class
+              # Base class expects context_name and aggregate_name parameters
+              super(options.context, options.aggregate)
+            end
+
+            # Creates and registers the authorizer class in the Yes::Core configuration
+            #
+            # @return [Class] The found or generated authorizer class that was registered
+            def call
+              Yes::Core.configuration.register_aggregate_authorizer_class(
+                context_name,
+                aggregate_name,
+                find_or_generate_class
+              )
+            end
+
+            private
+
+            # @!attribute [r] resource_name
+            #   @return [String] The name of the resource used for authorization.
+            # @!attribute [r] read_model_class
+            #   @return [Class] The read model class associated with the resource.
+            # @!attribute [r] custom_call_logic
+            #   @return [Proc, nil] The custom block provided for the call method logic.
+            # @!attribute [r] changes_read_model_class
+            #   @return [Class, nil] The changes read model class for draftable aggregates.
+            attr_reader :resource_name, :read_model_class, :authorizer_class, :custom_call_logic, :changes_read_model_class
+
+            # @return [Symbol] Returns :authorizer as the class type
+            def class_type
+              :authorizer
+            end
+
+            # Checks if the aggregate is draftable
+            #
+            # @return [Boolean] true if the aggregate is draftable, false otherwise
+            def draftable?
+              @draftable == true
+            end
+
+            # Generates a new authorizer class dynamically.
+            # The generated class inherits from the specified authorizer_class.
+            # If the base class is Yes::Core::Authorization::CommandCerbosAuthorizer, it sets the RESOURCE constant.
+            # Otherwise, if a block was provided during initialization, it defines a `call` method
+            # executing that block's logic.
+            #
+            # @raise [ArgumentError] If the base class is not CommandCerbosAuthorizer and no block was provided.
+            # @return [Class] A new authorizer class.
+            def generate_class
+              klass = Class.new(authorizer_class)
+
+              if authorizer_class == Yes::Core::Authorization::CommandCerbosAuthorizer
+                resource_attributes = { read_model: read_model_class, name: resource_name }
+                resource_attributes[:draft_read_model] = changes_read_model_class if draftable?
+                klass.const_set(:RESOURCE, resource_attributes.freeze)
+              else
+                define_custom_call_logic(klass)
+              end
+
+              klass
+            end
+
+            # Defines custom call logic for an authorizer class when not using CommandCerbosAuthorizer
+            #
+            # @param klass [Class] The dynamically generated authorizer class
+            # @raise [ArgumentError] If no custom_call_logic block was provided during initialization
+            # @return [void]
+            def define_custom_call_logic(klass)
+              _custom_logic = custom_call_logic
+              unless _custom_logic
+                raise ArgumentError,
+                      "A block must be provided to define the 'call' method logic when not using CommandCerbosAuthorizer."
+              end
+
+              # Define call as a class method (matching CommandCerbosAuthorizer pattern)
+              klass.define_singleton_method(:call) do |current_command, current_auth_data|
+                @_exec_command = current_command
+                @_exec_auth_data = current_auth_data
+                define_singleton_method(:command) { @_exec_command }
+                define_singleton_method(:auth_data) { @_exec_auth_data }
+                begin
+                  instance_exec(&_custom_logic)
+                ensure
+                  @_exec_command = nil
+                  @_exec_auth_data = nil
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/base.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          # Base class for creating and registering aggregate-related classes
+          #
+          # This class provides the foundation for resolving and generating various
+          # aggregate-related classes such as commands, events, and handlers.
+          # It handles class registration and provides a template for class generation.
+          #
+          # @abstract Subclass and override {#class_type}, {#class_name}, and {#generate_class}
+          # to implement specific class resolver behavior
+          class Base
+            # Creates and registers the class in the Yes::Core configuration
+            #
+            # @return [Class] The found or generated class that was registered
+            def call
+              Yes::Core.configuration.register_aggregate_class(
+                context_name,
+                aggregate_name,
+                class_name,
+                class_type,
+                find_or_generate_class
+              )
+            end
+
+            private
+
+            # @return [ConstantResolver] The resolver for finding and setting constants
+            # @return [ClassNameConvention] The convention for generating class names
+            # @return [String] The name of the context
+            # @return [String] The name of the aggregate
+            attr_reader :constant_resolver, :class_name_convention, :context_name, :aggregate_name
+
+            # @param context_name [String] The name of the context
+            # @param aggregate_name [String] The name of the aggregate
+            def initialize(context_name, aggregate_name)
+              @context_name = context_name
+              @aggregate_name = aggregate_name
+
+              @class_name_convention = ClassNameConvention.new(
+                context: context_name,
+                aggregate: aggregate_name
+              )
+              @constant_resolver = ConstantResolver.new(class_name_convention)
+            end
+
+            # Finds an existing class or generates a new one based on conventions
+            #
+            # @return [Class] The found or generated class
+            def find_or_generate_class
+              constant_resolver.find_conventional_class(class_type, class_name) ||
+                constant_resolver.set_constant_for(class_type, class_name, generate_class)
+            end
+
+            # @abstract
+            # @return [Symbol] The type of class being resolved (e.g., :command, :event, :handler)
+            def class_type
+              raise NotImplementedError, "#{self.class} must implement #class_type"
+            end
+
+            # @return [String] The name of the class to be generated
+            def class_name
+              nil
+            end
+
+            # @abstract
+            # @return [Class] The generated class
+            def generate_class
+              raise NotImplementedError, "#{self.class} must implement #generate_class"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/command/authorizer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Base class for command authorizers
+            class Authorizer < Base
+              # Common methods for all authorizers
+              def class_type
+                :authorizer
+              end
+
+              def class_name
+                command_data.name
+              end
+
+              # This should be overridden by subclasses
+              def generate_class
+                raise NotImplementedError, "#{self.class} must implement #generate_class"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/command/authorizer_factory.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Factory class for creating appropriate command authorizer resolver
+            # based on the aggregate-level authorizer type
+            class AuthorizerFactory
+              # Creates and returns the appropriate authorizer resolver
+              # based on the aggregate's authorizer class type
+              #
+              # @param command_data [CommandData] Command data with aggregate information
+              # @return [SimpleAuthorizer, CerbosAuthorizer, nil] Appropriate authorizer or nil
+              def self.create(command_data)
+                # Only create command authorizers if there's an aggregate-level authorizer
+                aggregate_authorizer_class = command_data.aggregate_class.authorizer_class
+                return nil unless aggregate_authorizer_class
+
+                if aggregate_authorizer_class <= Yes::Core::Authorization::CommandCerbosAuthorizer
+                  CerbosAuthorizer.new(command_data)
+                else
+                  SimpleAuthorizer.new(command_data)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/command/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Base class for command-related class resolvers
+            #
+            # This class extends the base resolver functionality to handle
+            # command-specific class generation. It provides a foundation for
+            # resolvers that need to work with commands, such as command classes
+            # and their associated events.
+            #
+            # @abstract Subclass and implement the required methods from {ClassResolvers::Base}
+            class Base < ClassResolvers::Base
+              # Initializes a new command-based class resolver
+              #
+              # @param command_data [Yes::Core::Aggregate::Dsl::CommandData] The command data instance
+              #   containing metadata about the command being processed
+              def initialize(command_data)
+                @command_data = command_data
+
+                super(command_data.context_name, command_data.aggregate_name)
+              end
+
+              private
+
+              # @return [Yes::Core::Aggregate::Dsl::CommandData] The command data instance
+              attr_reader :command_data
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/command/cerbos_authorizer.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Command resolver for Cerbos-based authorizers
+            class CerbosAuthorizer < Authorizer
+              private
+
+              # Generates a Cerbos authorizer class with RESOURCE constant
+              # and optional DSL methods for resource_attributes and cerbos_payload
+              #
+              # @return [Class] The generated authorizer class
+              def generate_class
+                klass = Class.new(command_data.aggregate_class.authorizer_class)
+
+                # Apply Cerbos-specific overrides if we have a block
+                apply_cerbos_overrides(klass) if command_data.authorizer_block
+
+                klass
+              end
+
+              # Applies Cerbos-specific DSL overrides to allow customization
+              # of resource_attributes and cerbos_payload methods
+              #
+              # @param klass [Class] the class being generated
+              # rubocop:disable Metrics/MethodLength
+              def apply_cerbos_overrides(klass)
+                # Store the block for later use
+                user_block = command_data.authorizer_block
+
+                # Define instance variables and accessor methods for the DSL
+                klass.class_eval do
+                  # Resource attributes storage
+                  class << self
+                    attr_accessor :_resource_attributes_block, :_cerbos_payload_block
+                  end
+
+                  # Define accessor methods for the DSL
+                  define_method(:command) { @_command }
+                  define_method(:resource) { @_resource }
+                  define_method(:auth_data) { @_auth_data }
+
+                  # Define resource_attributes method that will be called by external code
+                  define_singleton_method(:resource_attributes) do |resource = nil, command = nil, &block|
+                    if block
+                      # Store the block for later use
+                      self._resource_attributes_block = block
+                    elsif _resource_attributes_block
+                      # Execute the previously stored block
+                      instance = new
+                      instance.instance_variable_set(:@_command, command)
+                      instance.instance_variable_set(:@_resource, resource)
+
+                      begin
+                        instance.instance_eval(&_resource_attributes_block)
+                      ensure
+                        instance.remove_instance_variable(:@_command) if instance.instance_variable_defined?(:@_command)
+                        instance.remove_instance_variable(:@_resource) if instance.instance_variable_defined?(:@_resource)
+                      end
+                    elsif defined?(super)
+                      # No block defined, call the original method if available
+                      super(resource, command)
+                    end
+                  end
+
+                  # Define cerbos_payload method that will be called by external code
+                  define_singleton_method(:cerbos_payload) do |command = nil, resource = nil, auth = nil, &block|
+                    if block
+                      # Store the block for later use
+                      self._cerbos_payload_block = block
+                    elsif _cerbos_payload_block
+                      # Execute the previously stored block
+                      instance = new
+                      instance.instance_variable_set(:@_command, command)
+                      instance.instance_variable_set(:@_resource, resource)
+                      instance.instance_variable_set(:@_auth_data, auth)
+
+                      begin
+                        instance.instance_eval(&_cerbos_payload_block)
+                      ensure
+                        instance.remove_instance_variable(:@_command) if instance.instance_variable_defined?(:@_command)
+                        instance.remove_instance_variable(:@_resource) if instance.instance_variable_defined?(:@_resource)
+                        instance.remove_instance_variable(:@_auth_data) if instance.instance_variable_defined?(:@_auth_data)
+                      end
+                    elsif defined?(super)
+                      # No block defined, call the original method if available
+                      super(command, resource, auth)
+                    end
+                  end
+                end
+
+                # We need the resource_attributes and cerbos_payload to be callable from class context
+                # in the user block, but also store blocks for later execution
+                klass.instance_eval do
+                  # Initial setup
+                  self._resource_attributes_block = nil
+                  self._cerbos_payload_block = nil
+
+                  # Execute the user block to define overrides
+                  instance_eval(&user_block)
+                end
+              end
+              # rubocop:enable Metrics/MethodLength
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/command/command.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Resolves or generates a command class for a command
+            class Command < Base
+              private
+
+              # @return [Symbol] The type of class being resolved
+              def class_type
+                :command
+              end
+
+              # @return [String] The name of the class to be generated
+              def class_name
+                command_data.name
+              end
+
+              # Generates a command class
+              #
+              # @return [Class] The generated command class
+              def generate_class
+                context = context_name
+                aggregate = aggregate_name
+                payload_attributes = command_data.payload_attributes || {}
+
+                Class.new(Yes::Core::Command) do
+                  # Define the aggregate_id attribute for the command
+                  attribute :"#{aggregate.underscore}_id", Yes::Core::Types::UUID
+
+                  # Define payload attributes if any
+                  payload_attributes.each do |attr_name, attr_type|
+                    # Handle simple type (not a hash)
+                    unless attr_type.is_a?(Hash)
+                      attribute attr_name, Yes::Core::TypeLookup.type_for(attr_type, context)
+                      next
+                    end
+
+                    resolved_type = Yes::Core::TypeLookup.type_for(attr_type[:type], context)
+
+                    case [attr_type[:optional] == true, attr_type[:nullable] == true]
+                    when [false, false]
+                      # required key, non-nullable value
+                      attribute attr_name, resolved_type
+                    when [false, true]
+                      # required key, nullable value
+                      attribute attr_name, resolved_type.optional
+                    when [true, false]
+                      # optional key, non-nullable value
+                      attribute? attr_name, resolved_type
+                    when [true, true]
+                      # optional key, nullable value
+                      attribute? attr_name, resolved_type.optional
+                    end
+                  end
+
+                  alias_method :aggregate_id, :"#{aggregate.underscore}_id"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/command/event.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Resolves or generates an event class for a command
+            class Event < Base
+              private
+
+              # @return [Symbol] The type of class being resolved
+              def class_type
+                :event
+              end
+
+              # @return [String] The name of the class to be generated
+              def class_name
+                command_data.event_name
+              end
+
+              # Generates an event class
+              #
+              # @return [Class] The generated event class
+              def generate_class
+                aggregate = aggregate_name
+                context = context_name
+                payload_attributes = command_data.payload_attributes || {}
+                encrypted_attributes = command_data.encrypted_attributes || []
+
+                Class.new(Yes::Core::Event) do
+                  define_method :schema do
+                    Dry::Schema.Params do
+                      # Helper to build attribute definition with support for optional key and nullable value
+                      build_attribute = proc do |attr_name, attr_type_config|
+                        # Handle simple type (not a hash)
+                        unless attr_type_config.is_a?(Hash)
+                          required(attr_name).value(Yes::Core::TypeLookup.type_for(attr_type_config, context, :event))
+                          next
+                        end
+
+                        resolved_type = Yes::Core::TypeLookup.type_for(attr_type_config[:type], context, :event)
+
+                        case [attr_type_config[:optional] == true, attr_type_config[:nullable] == true]
+                        when [false, false]
+                          # required key, non-nullable value
+                          required(attr_name).value(resolved_type)
+                        when [false, true]
+                          # required key, nullable value
+                          required(attr_name).maybe(resolved_type)
+                        when [true, false]
+                          # optional key, non-nullable value
+                          optional(attr_name).value(resolved_type)
+                        when [true, true]
+                          # optional key, nullable value
+                          optional(attr_name).maybe(resolved_type)
+                        end
+                      end
+
+                      # Define the aggregate_id attribute for the event
+                      required(:"#{aggregate.underscore}_id").value(Yes::Core::Types::UUID)
+
+                      # Define payload attributes if any
+                      payload_attributes.each do |attr_name, attr_type|
+                        build_attribute.call(attr_name, attr_type)
+                      end
+                    end
+                  end
+
+                  # Add encryption_schema class method if there are encrypted attributes
+                  if encrypted_attributes.any?
+                    define_singleton_method :encryption_schema do
+                      {
+                        key: ->(data) { data[:"#{aggregate.underscore}_id"] },
+                        attributes: encrypted_attributes
+                      }
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/class_resolvers/command/guard_evaluator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Creates and registers guard evaluator classes for aggregate commands
+            #
+            # This class resolver generates plain guard evaluator classes that process
+            # commands in aggregates.
+            #
+            class GuardEvaluator < Base
+              private
+
+              # Returns the class type symbol for the guard evaluator
+              #
+              # @return [Symbol] Returns :guard_evaluator as the class type
+              # @api private
+              def class_type
+                :guard_evaluator
+              end
+
+              # Returns the name for the guard evaluator class
+              #
+              # @return [String] The name of the guard evaluator class derived from the attribute
+              # @api private
+              def class_name
+                command_data.name
+              end
+
+              # Creates a new guard evaluator class
+              #
+              # By default, includes a no_change guard that checks if the command would modify the aggregate's state.
+              # This guard is omitted if the command has a custom state_update block since we cannot rely on the default
+              # attribute update logic.
+              #
+              # @return [Class] A new guard evaluator class inheriting from Yes::Core::CommandHandling::GuardEvaluator
+              # @api private
+              def generate_class
+                command_name = command_data.name
+                context_name = command_data.context_name
+                aggregate_name = command_data.aggregate_name
+
+                # Add the no_change guard to the command data's guard names
+                # This will be added by the GuardEvaluator unless there's an update_state block
+                # or if it was already added by a shortcut expansion
+                command_data.add_guard(:no_change) unless command_data.guard_names.include?(:no_change) || command_data.update_state_block
+
+                Class.new(Yes::Core::CommandHandling::GuardEvaluator) do
+                  guard :no_change do
+                    state_updater_class = Yes::Core.configuration.aggregate_class(
+                      context_name, aggregate_name, command_name, :state_updater
+                    )
+
+                    next true if state_updater_class.update_state_block
+
+                    payload = raw_payload.except(:"#{aggregate_name.underscore}_id")
+
+                    next true if payload.empty?
+
+                    has_changes = false
+                    I18n.with_locale(payload.delete(:locale) || I18n.locale) do
+                      payload.each do |attribute, new_value|
+                        current_value = public_send(attribute)
+                        if current_value != new_value
+                          has_changes = true
+                          break
+                        end
+                      end
+                    end
+
+                    has_changes
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end