yes-core 1.0.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Command resolver for simple non-Cerbos authorizers
+            class SimpleAuthorizer < Authorizer
+              private
+
+              # Generates a simple authorizer class with a call method
+              #
+              # @return [Class] The generated authorizer class
+              def generate_class
+                klass = Class.new(command_data.aggregate_class.authorizer_class)
+
+                # Only add call method if we have a block
+                apply_call_override(klass) if command_data.authorizer_block
+
+                klass
+              end
+
+              # Adds a `call` class method that executes the user-provided block
+              #
+              # @param klass [Class] the class being generated
+              def apply_call_override(klass)
+                user_block = command_data.authorizer_block
+
+                klass.define_singleton_method(:call) do |cmd, auth|
+                  @_cmd = cmd
+                  @_auth = auth
+                  define_singleton_method(:command) { @_cmd }
+                  define_singleton_method(:auth_data) { @_auth }
+                  begin
+                    instance_exec(&user_block)
+                  ensure
+                    @_cmd = nil
+                    @_auth = nil
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          module Command
+            # Creates and registers state updater classes for aggregate commands
+            #
+            # This class resolver generates plain state updater class that process
+            # custom state updates in aggregates.
+            #
+            class StateUpdater < Base
+              private
+
+              # Returns the class type symbol for the state updater
+              #
+              # @return [Symbol] Returns :state_updater as the class type
+              # @api private
+              def class_type
+                :state_updater
+              end
+
+              # Returns the name for the state updater class
+              #
+              # @return [String] The name of the state updater class derived from the command
+              # @api private
+              def class_name
+                command_data.name
+              end
+
+              # Creates a new state updater class
+              #
+              # @return [Class] A new state updater class inheriting from Yes::Core::CommandHandling::StateUpdater
+              # @api private
+              def generate_class
+                Class.new(Yes::Core::CommandHandling::StateUpdater)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          # Creates and registers read model classes for aggregates
+          #
+          # This class resolver generates ActiveRecord-based read model classes
+          # that represent the queryable state of aggregates. Each read model class
+          # is automatically configured with basic scopes and table name conventions.
+          #
+          # @example Generated read model class structure
+          #   class User < ApplicationRecord
+          #     self.table_name = 'users'
+          #     scope :by_ids, ->(ids) { where(id: ids) }
+          #   end
+          class ReadModel < Base
+            # Initializes a new read model class resolver
+            #
+            # @param read_model_name [String] The name of the read model
+            # @param context_name [String] The name of the context
+            # @param aggregate_name [String] The name of the aggregate
+            def initialize(read_model_name, context_name, aggregate_name, draft: false)
+              @read_model_name = read_model_name
+              @draft = draft
+
+              super(context_name, aggregate_name)
+            end
+
+            # Creates and registers the read model class in the Yes::Core configuration
+            #
+            # @return [Class] The found or generated read model class that was registered
+            def call
+              Yes::Core.configuration.register_read_model_class(
+                context_name,
+                aggregate_name,
+                find_or_generate_class,
+                draft:
+              )
+            end
+
+            private
+
+            # @return [String] The name of the read model
+            attr_reader :read_model_name, :draft
+
+            # @return [Symbol] Returns :read_model as the class type
+            def class_type
+              :read_model
+            end
+
+            # @return [String] The name of the read model class
+            def class_name
+              read_model_name
+            end
+
+            # Generates a new read model class with the required configuration
+            #
+            # @return [Class] A new read model class inheriting from ApplicationRecord
+            def generate_class
+              table_name = class_name.tableize
+
+              Class.new(ApplicationRecord) do
+                self.table_name = table_name
+                scope :by_ids, ->(ids) { where(id: ids) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          # Creates and registers read model filter classes for aggregates
+          #
+          # This class resolver generates filter classes that provide query scopes
+          # for read models. Each filter class is automatically configured with
+          # basic scopes and a reference to its corresponding read model class.
+          #
+          # @example Generated read model filter class structure
+          #   class UserFilter < Yes::Core::ReadModel::Filter
+          #     has_scope :ids do |_, scope, value|
+          #       scope.by_ids(value.split(','))
+          #     end
+          #
+          #     private
+          #
+          #     def read_model_class
+          #       Test::User::Aggregate.read_model_class
+          #     end
+          #   end
+          class ReadModelFilter < Base
+            # Initializes a new read model filter class resolver
+            #
+            # @param read_model_name [String] The name of the read model
+            # @param context_name [String] The name of the context
+            # @param aggregate_name [String] The name of the aggregate
+            def initialize(read_model_name, context_name, aggregate_name)
+              @read_model_name = read_model_name
+
+              super(context_name, aggregate_name)
+            end
+
+            # Creates and registers the read model filter class in the Yes::Core configuration
+            #
+            # @return [Class] The found or generated read model filter class that was registered
+            def call
+              Yes::Core.configuration.register_read_model_filter_class(
+                context_name,
+                aggregate_name,
+                find_or_generate_class
+              )
+            end
+
+            private
+
+            # @return [String] The name of the read model
+            attr_reader :read_model_name
+
+            # @return [Symbol] Returns :read_model_filter as the class type
+            def class_type
+              :read_model_filter
+            end
+
+            # @return [String] The name of the read model filter class
+            def class_name
+              read_model_name
+            end
+
+            # Generates a new read model filter class with the required scopes and configuration
+            #
+            # @return [Class] A new filter class inheriting from Yes::Core::ReadModel::Filter
+            def generate_class
+              klass = Class.new(Yes::Core::ReadModel::Filter)
+
+              klass.has_scope :ids do |_, scope, value|
+                scope.by_ids(value.split(','))
+              end
+
+              # Define read_model_class method
+              aggregate_class_name = "#{context_name}::#{aggregate_name}::Aggregate"
+              klass.define_method(:read_model_class) do
+                aggregate_class_name.constantize.read_model_class
+              end
+              klass.send :private, :read_model_class
+
+              klass
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        module ClassResolvers
+          # Creates and registers read model serializer classes for aggregates
+          #
+          # This class resolver generates JSON:API compliant serializer classes
+          # for read models. Each serializer class is automatically configured with
+          # the specified attributes and type naming conventions.
+          #
+          # @example Generated read model serializer class structure
+          #   class UserSerializer < Yes::Core::Serializer
+          #     set_type 'users'
+          #     attributes :id, :email, :first_name, :last_name
+          #   end
+          class ReadModelSerializer < Base
+            # Initializes a new read model serializer class resolver
+            #
+            # @param read_model_name [String] The name of the read model
+            # @param context_name [String] The name of the context
+            # @param aggregate_name [String] The name of the aggregate
+            # @param read_model_attributes [Array<Symbol>] The attributes to be serialized
+            def initialize(read_model_name, context_name, aggregate_name, read_model_attributes)
+              @read_model_name = read_model_name
+              @read_model_attributes = read_model_attributes
+
+              super(context_name, aggregate_name)
+            end
+
+            # Creates and registers the read model serializer class in the Yes::Core configuration
+            #
+            # @return [Class] The found or generated read model serializer class that was registered
+            def call
+              Yes::Core.configuration.register_read_model_filter_class(
+                context_name,
+                aggregate_name,
+                find_or_generate_class
+              )
+            end
+
+            private
+
+            # @return [String] The name of the read model
+            # @return [Array<Symbol>] The attributes to be serialized
+            attr_reader :read_model_name, :read_model_attributes
+
+            # @return [Symbol] Returns :read_model_serializer as the class type
+            def class_type
+              :read_model_serializer
+            end
+
+            # @return [String] The name of the read model serializer class
+            def class_name
+              read_model_name
+            end
+
+            # Generates a new read model serializer class with the required configuration
+            #
+            # @return [Class] A new serializer class inheriting from Yes::Core::Serializer
+            def generate_class
+              klass = Class.new(Yes::Core::Serializer)
+
+              klass.set_type read_model_name.pluralize
+              klass.attributes(*read_model_attributes)
+
+              klass
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/command_data.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        # Data object that holds information about a command definition in an aggregate
+        #
+        # @example
+        #   CommandData.new(:assign_user, UserAggregate, context: 'Users', aggregate: 'User')
+        #
+        class CommandData
+          attr_reader :name, :context_name, :aggregate_name, :aggregate_class
+          attr_accessor :event_name, :payload_attributes, :update_state_block, :guard_names, :authorizer_block,
+                        :encrypted_attributes
+
+          # @param name [Symbol] The name of the command
+          # @param aggregate_class [Class] The aggregate class this command belongs to
+          # @param options [Hash] Additional options for the command
+          # @option options [String] :context The context name for the command
+          # @option options [String] :aggregate The aggregate name
+          # @option options [String] :event_name The event name for the command
+          # @option options [Hash] :payload_attributes The payload attributes for the command
+          def initialize(name, aggregate_class, options = {})
+            @name = name
+            @aggregate_class = aggregate_class
+            @context_name = options.delete(:context)
+            @aggregate_name = options.delete(:aggregate)
+
+            # Default event name based on command name (will be overridden if specified in DSL)
+            @event_name = options.delete(:event_name) || Yes::Core::Utils::EventNameResolver.call(name)
+
+            # Default payload is just the aggregate_id
+            @payload_attributes = options.delete(:payload_attributes) || {}
+
+            # Store guard names
+            @guard_names = []
+
+            # Track encrypted attributes for event schema generation
+            @encrypted_attributes = []
+          end
+
+          # Add a guard name to the list of guards
+          #
+          # @param name [Symbol] The name of the guard
+          # @return [void]
+          def add_guard(name)
+            @guard_names << name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/dsl/command_definer.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      module Dsl
+        # Factory class that creates and defines commands on aggregates.
+        # Handles the creation and registration of all necessary command-related classes,
+        # including validation of attributes and DSL evaluation.
+        #
+        # @example
+        #   command_data = CommandData.new(name: :assign_user, aggregate_class: Company)
+        #   CommandDefiner.new(command_data).call do
+        #     payload user_id: :uuid
+        #
+        #     guard :user_already_assigned do
+        #       user_id.present?
+        #     end
+        #
+        #     update_state do
+        #       some_attribute { payload.xyz }
+        #       another_attribute { "#{payload.abc}_#{email}" }
+        #     end
+        #   end
+        #
+        class CommandDefiner
+          # Error raised when attributes are used in the command that are not defined on the aggregate
+          class UndefinedAttributeError < Yes::Core::Error; end
+
+          # Error raised when event name cannot be resolved
+          class EventNameResolverError < Yes::Core::Error; end
+
+          # @return [CommandData] The data object containing command configuration
+          attr_reader :command_data
+          private :command_data
+
+          # Initializes a new CommandDefiner instance
+          #
+          # @param command_data [CommandData] The data object containing command configuration
+          # @return [CommandDefiner] A new instance of CommandDefiner
+          def initialize(command_data)
+            @command_data = command_data
+          end
+
+          # Generates and registers all necessary classes for the command.
+          # This includes command classes, event classes, a guard evaluator class,
+          # a state updater class, as well as defining related methods on the aggregate class.
+          #
+          # @yield Block for defining payload, guards and other command configurations
+          # @yieldreturn [void]
+          # @return [void]
+          # @raise [UndefinedAttributeError] If attributes used in the command are not defined on the aggregate
+          def call(&block)
+            create_and_register_block_evaluator_classes
+            evaluate_dsl_block(&block) if block
+            validate_event_name
+            validate_accessed_attributes
+            create_and_register_command_classes
+            register_command_events
+          end
+
+          private
+
+          # Validates that the event name is present (either because it was specified explicitly or because it was
+          # resolved from the command name).
+          #
+          # @return [void]
+          # @raise [EventNameResolverError] If the event name is not specified explicitly
+          def validate_event_name
+            return if command_data.event_name
+
+            raise EventNameResolverError,
+                  "Event name for command #{command_data.context_name}::#{command_data.aggregate_name} " \
+                  "#{command_data.name} cannot be resolved, please specify explicitly."
+          end
+
+          # Creates and registers the guard evaluator and state updater classes
+          #
+          # @return [void]
+          def create_and_register_block_evaluator_classes
+            @guard_evaluator_class = ClassResolvers::Command::GuardEvaluator.new(command_data).call
+            @state_updater_class = ClassResolvers::Command::StateUpdater.new(command_data).call
+          end
+
+          # Creates and registers command-related classes and defines their methods
+          #
+          # @return [void]
+          def create_and_register_command_classes
+            @command_class = ClassResolvers::Command::Command.new(command_data).call
+            @event_class = ClassResolvers::Command::Event.new(command_data).call
+
+            MethodDefiners::Command::Command.new(command_data).call
+            MethodDefiners::Command::CanCommand.new(command_data).call
+          end
+
+          # Validates attributes based on whether the command uses update_state or payload
+          #
+          # @return [void]
+          # @raise [UndefinedAttributeError] If any attributes are not defined on the aggregate
+          def validate_accessed_attributes
+            if command_data.update_state_block
+              validate_attributes!(
+                @state_updater_class.updated_attributes,
+                'update_state block uses attributes'
+              )
+            else
+              validate_attributes!(
+                extract_payload_attribute_names,
+                'payload attributes'
+              )
+            end
+          end
+
+          # Extract attribute names from payload_attributes, handling the new format for optional attributes
+          #
+          # @return [Array<Symbol>] The attribute names
+          def extract_payload_attribute_names
+            command_data.payload_attributes.keys.without(:locale)
+          end
+
+          # Validates that all given attributes are defined on the aggregate
+          #
+          # @param attributes [Array<Symbol>] The attributes to validate
+          # @param context [String] The context in which these attributes are being used
+          # @return [void]
+          # @raise [UndefinedAttributeError] If any of the attributes are not defined on the aggregate
+          def validate_attributes!(attributes, context)
+            return if attributes.empty?
+
+            aggregate_attributes = command_data.aggregate_class.attributes
+            aggregate_type_aggregate_attributes = aggregate_attributes.select { _2 == :aggregate }
+            undefined_attributes = attributes.reject do |attr_name|
+              aggregate_attributes.key?(attr_name) ||
+                aggregate_type_aggregate_attributes.key?(attr_name.to_s.delete_suffix('_id').to_sym)
+            end
+
+            return if undefined_attributes.empty?
+
+            raise UndefinedAttributeError, "Command '#{command_data.name}' #{context} " \
+                                           "that are not defined on the aggregate: #{undefined_attributes.join(', ')}. " \
+                                           "Please define these attributes using the 'attribute' method first."
+          end
+
+          def register_command_events
+            Yes::Core.configuration.register_command_events(
+              command_data.context_name,
+              command_data.aggregate_name,
+              command_data.name,
+              [command_data.event_name]
+            )
+          end
+
+          # Evaluates the DSL block in the context of a DslEvaluator
+          #
+          # @yield The block to evaluate
+          # @yieldreturn [void]
+          # @return [void]
+          def evaluate_dsl_block(&block)
+            return unless block
+
+            dsl_evaluator = DslEvaluator.new(command_data, @guard_evaluator_class, @state_updater_class)
+            dsl_evaluator.instance_eval(&block)
+          end
+
+          # DSL evaluator class for command configuration blocks
+          class DslEvaluator
+            # @return [CommandData] The command data being configured
+            # @return [Class] The guard evaluator class for this command
+            # @return [Class] The state updater class for this command
+            attr_reader :command_data, :guard_evaluator_class, :state_updater_class
+
+            # @param command_data [CommandData] The command data to configure
+            # @param guard_evaluator_class [Class] The guard evaluator class for this command
+            # @param state_updater_class [Class] The state updater class for this command
+            def initialize(command_data, guard_evaluator_class, state_updater_class)
+              @command_data = command_data
+              @guard_evaluator_class = guard_evaluator_class
+              @state_updater_class = state_updater_class
+            end
+
+            # Defines a guard for the command
+            #
+            # @param name [Symbol] The name of the guard
+            # @param error_extra [Hash, Proc] The extra information to be added to the error message payload
+            # @yield The guard evaluation block
+            # @yieldreturn [Boolean] True if the guard passes, false otherwise
+            # @return [void]
+            def guard(name, error_extra: {}, &)
+              command_data.add_guard(name)
+              guard_evaluator_class.guard(name, error_extra:, &)
+            end
+
+            # Defines the payload for the command
+            # Supports inline encryption declaration: payload email: { type: :email, encrypt: true }
+            #
+            # @param attributes [Hash] The attributes for the payload
+            # @return [void]
+            def payload(attributes)
+              normalized = attributes.transform_values do |value|
+                case value
+                when Hash
+                  # Extract encrypt flag if present, pass everything else through
+                  value.except(:encrypt)
+                else
+                  # Handle simple syntax: :email or :string
+                  value
+                end
+              end
+
+              # Collect encrypted attributes
+              attributes.each do |key, value|
+                command_data.encrypted_attributes << key if value.is_a?(Hash) && value[:encrypt]
+              end
+
+              command_data.payload_attributes = normalized
+            end
+
+            # Declares which payload attributes should be encrypted in the generated event
+            #
+            # @param attribute_names [Array<Symbol>] The names of payload attributes to encrypt
+            # @return [void]
+            # @example
+            #   command :update_contact_info do
+            #     payload email: :email, phone: :phone
+            #     encrypt :email, :phone
+            #   end
+            def encrypt(*attribute_names)
+              command_data.encrypted_attributes.concat(attribute_names)
+            end
+
+            # Defines how the state should be updated
+            #
+            # @param custom [Boolean] Whether the state should be updated using a custom block
+            # @yield Block defining how to update the state
+            # @yieldreturn [void]
+            # @return [void]
+            def update_state(custom: false, &block)
+              command_data.update_state_block = block
+              state_updater_class.update_state(custom:, &block)
+            end
+
+            # Defines the event name for the command
+            #
+            # @param name [Symbol] The name of the event
+            # @return [void]
+            def event(name)
+              command_data.event_name = name
+            end
+
+            # Overwrites the authorizer for the command
+            #
+            # @yield The authorizer block
+            # @yieldreturn [void]
+            # @return [void]
+            def authorize(&block)
+              command_data.authorizer_block = block
+            end
+          end
+        end
+      end
+    end
+  end
+end