yes-core 1.0.0

data/lib/yes/core/aggregate/has_read_model.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      # Provides read model functionality for aggregates
+      #
+      # @example Include in an aggregate
+      #   class UserAggregate < Yes::Core::Aggregate
+      #     include Yes::Core::Concerns::HasReadModel
+      #   end
+      module HasReadModel
+        extend ActiveSupport::Concern
+
+        included do
+          class << self
+            attr_accessor :_read_model_name, :_read_model_public, :_read_model_class, :_read_model_filter_class,
+                          :_read_model_serializer_class, :_read_model_enabled
+          end
+
+          # Default to enabled
+          self._read_model_enabled = true
+        end
+
+        class_methods do
+          # Returns the read model class associated with the current aggregate.
+          # The class is resolved using ReadModelClassResolver, which either uses an explicitly set
+          # class name or derives it from the current namespace.
+          #
+          # @return [Class] The read model class
+          # @raise [NameError] If the read model class cannot be found
+          def read_model_class
+            _read_model_class
+          end
+
+          # Sets up all read model related classes for the aggregate
+          #
+          # @return [void]
+          # @note This method initializes three components:
+          #   - The read model class itself
+          #   - The read model filter class for querying
+          #   - The read model serializer class for data transformation
+          def setup_read_model_classes
+            setup_read_model
+            setup_read_model_filter
+            setup_read_model_serializer
+          end
+
+          # @return [String] The name of the read model
+          def read_model_name
+            self._read_model_name ||= "#{context}_#{aggregate}".underscore
+          end
+
+          # Sets the read model configuration for this aggregate
+          # @param name [String, false] The name for the read model, or false to disable read models
+          # @param public [Boolean] Whether the read model should be public via read API
+          def read_model(name, public: true)
+            if name == false
+              self._read_model_enabled = false
+              return
+            end
+
+            self._read_model_name = name.to_s.underscore
+            self._read_model_public = public
+          end
+
+          # @return [Boolean] Whether the read model is public
+          def read_model_public?
+            _read_model_public.nil? || _read_model_public
+          end
+
+          # @return [Boolean] Whether the read model is enabled
+          def read_model_enabled?
+            _read_model_enabled != false
+          end
+
+          private
+
+          def setup_read_model
+            self._read_model_class = resolve_read_model_class
+          end
+
+          def setup_read_model_filter
+            self._read_model_filter_class = resolve_read_model_filter_class
+          end
+
+          def setup_read_model_serializer
+            self._read_model_serializer_class = resolve_read_model_serializer_class
+          end
+
+          def resolve_read_model_class
+            Yes::Core::Aggregate::Dsl::ClassResolvers::ReadModel.new(read_model_name, context, aggregate).call
+          end
+
+          def resolve_read_model_filter_class
+            Yes::Core::Aggregate::Dsl::ClassResolvers::ReadModelFilter.new(read_model_name, context, aggregate).call
+          end
+
+          def resolve_read_model_serializer_class
+            Yes::Core::Aggregate::Dsl::ClassResolvers::ReadModelSerializer.new(
+              read_model_name, context, aggregate, attributes.keys
+            ).call
+          end
+        end
+
+        # Updates or creates a read model with the given attributes
+        #
+        # @param attributes [Hash] The attributes to update the read model with
+        # @return [Boolean] Returns true if the record is saved successfully
+        # @raise [ActiveRecord::RecordInvalid] If the record is invalid
+        def update_read_model(attributes)
+          locale = attributes.delete(:locale) || I18n.locale
+          I18n.with_locale(locale) do
+            read_model.update!(attributes)
+          end
+        end
+
+        # Retrieves or creates a read model instance for this aggregate
+        #
+        # @return [ApplicationRecord, nil] The read model instance associated with this aggregate's ID, or nil if disabled
+        # @example
+        #   user_aggregate = UserAggregate.new(1)
+        #   user_aggregate.read_model #=> #<User id: 1>
+        def read_model
+          return nil unless self.class.read_model_enabled?
+
+          @read_model ||= self.class.read_model_class.find_or_create_by(id:)
+        end
+
+        # Removes the read model instance for this aggregate
+        def remove_read_model
+          read_model.destroy
+          @read_model = nil
+        end
+
+        # Rebuilds the read model by processing all events
+        # @param remove [Boolean] Whether to remove the read model before rebuilding
+        # @return [void]
+        def rebuild_read_model(remove: true)
+          Yes::Core::Aggregate::ReadModelRebuilder.new(self).call(remove:)
+        end
+
+        def revision_column
+          return :revision unless self.class.read_model_enabled?
+
+          aggregate_revision_column = "#{self.class.context.underscore}_#{self.class.aggregate.underscore}_revision"
+          return aggregate_revision_column.to_sym if read_model.class.column_names.include?(aggregate_revision_column)
+
+          :revision
+        end
+
+        # Returns the current revision number from the read model
+        # @return [Integer, nil] The revision number stored in the read model, or -1 if read models are disabled
+        def revision
+          return -1 unless self.class.read_model_enabled?
+
+          read_model.send(revision_column)
+        end
+
+        # Initializes the read model's revision column with the current event stream revision
+        # @return [Boolean] True if the update was successful
+        # @note This method bypasses validations and callbacks by using update_column
+        def init_revision_from_stream
+          read_model.update_column(revision_column, event_revision)
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/read_model_rebuilder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      # Handles rebuilding of read models for aggregates
+      #
+      # @example Using the rebuilder
+      #   rebuilder = ReadModelRebuilder.new(aggregate)
+      #   rebuilder.call
+      class ReadModelRebuilder
+        attr_reader :aggregate
+        private :aggregate
+
+        delegate :events, :remove_read_model, :read_model, :revision_column, to: :aggregate
+
+        # @param aggregate [Yes::Core::Aggregate] The aggregate whose read model needs rebuilding
+        def initialize(aggregate)
+          @aggregate = aggregate
+        end
+
+        # Rebuilds the read model by processing all events
+        # @param remove [Boolean] Whether to remove the read model before rebuilding
+        # @return [void]
+        def call(remove: true)
+          remove ? remove_read_model : read_model.update(revision_column => -1)
+          events.each { |events_page| events_page.each { |event| process_event(event) } }
+        end
+
+        private
+
+        # @param event [Object] The event to process for read model rebuilding
+        # @return [void]
+        def process_event(event)
+          CommandHandling::ReadModelUpdater.new(aggregate).call(event, nil, resolve_payload: true)
+        end
+      end
+    end
+  end
+end

data/lib/yes/core/aggregate/shared_read_model_rebuilder.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Yes
+  module Core
+    class Aggregate
+      # Handles rebuilding of read models that are shared by multiple aggregates
+      #
+      # @example Using the shared rebuilder
+      #   rebuilder = SharedReadModelRebuilder.new(SharedUserReadModel)
+      #   rebuilder.call
+      class SharedReadModelRebuilder
+        # Value object to hold event data with aggregate information
+        EventWithAggregate = Struct.new(:event, :aggregate, keyword_init: true) do
+          # @return [Time] The creation timestamp of the event
+          delegate :created_at, to: :event
+        end
+
+        # @param read_model_class [Class] The Active Record read model class to rebuild
+        # @param ids [Array<String>] Array of IDs to rebuild
+        # @example
+        #   rebuilder = SharedReadModelRebuilder.new(SharedUserProfile, ['user-1', 'user-2'])
+        #   rebuilder.call
+        def initialize(read_model_class, ids)
+          @read_model_class = read_model_class
+          @ids = ids
+          @aggregate_types = find_aggregates_using_read_model
+        end
+
+        # Rebuilds the shared read model by processing all events from all aggregates
+        # @return [void]
+        def call
+          ids.each do |id|
+            rebuild_read_model_for_id(id)
+          end
+        end
+
+        private
+
+        # @return [Class] The read model class being rebuilt
+        # @return [Array<String>] The IDs to rebuild
+        # @return [Array<Array<String>>] The aggregate types that use this read model
+        attr_reader :read_model_class, :ids, :aggregate_types
+
+        # Finds all aggregates that use the given read model class
+        # @return [Array<Array<String>>] Array of [context_name, aggregate_name] pairs
+        def find_aggregates_using_read_model
+          aggregates = []
+
+          Yes::Core.configuration.list_all_registered_classes.each do |key, classes|
+            next unless classes[:read_model] == read_model_class
+
+            context_name, aggregate_name = key
+            aggregates << [context_name, aggregate_name]
+          end
+
+          aggregates
+        end
+
+        # Rebuilds the read model for a single ID
+        # @param id [String] The ID to rebuild
+        # @return [void]
+        def rebuild_read_model_for_id(id)
+          remove_read_model_for_id(id)
+
+          aggregates = instantiate_aggregates_for_id(id)
+          events_with_aggregates = collect_events_from_aggregates(aggregates)
+          sorted_events = events_with_aggregates.sort_by(&:created_at)
+
+          sorted_events.each do |event_with_aggregate|
+            process_event_with_aggregate(event_with_aggregate)
+          end
+        end
+
+        # Removes the read model instance for a specific ID
+        # @param id [String] The ID to remove
+        # @return [void]
+        def remove_read_model_for_id(id)
+          read_model_class.find_by(id: id)&.destroy
+        end
+
+        # Instantiates all aggregate instances for a given ID
+        # @param id [String] The ID to instantiate aggregates for
+        # @return [Array<Aggregate>] The instantiated aggregates
+        def instantiate_aggregates_for_id(id)
+          aggregate_types.map do |context_name, aggregate_name|
+            aggregate_class = build_aggregate_class(context_name, aggregate_name)
+            aggregate_class.new(id)
+          end
+        end
+
+        # Collects all events from the given aggregates
+        # @param aggregates [Array<Aggregate>] The aggregates to collect events from
+        # @return [Array<EventWithAggregate>] All events with their aggregate references
+        def collect_events_from_aggregates(aggregates)
+          events_with_aggregates = []
+
+          aggregates.each do |aggregate|
+            aggregate.events.each do |events_page|
+              events_page.each do |event|
+                events_with_aggregates << EventWithAggregate.new(
+                  event: event,
+                  aggregate: aggregate
+                )
+              end
+            end
+          end
+
+          events_with_aggregates
+        end
+
+        # Builds the aggregate class from context and aggregate names
+        # @param context_name [String] The context name
+        # @param aggregate_name [String] The aggregate name
+        # @return [Class] The aggregate class
+        def build_aggregate_class(context_name, aggregate_name)
+          "#{context_name}::#{aggregate_name}::Aggregate".constantize
+        end
+
+        # Processes a single event with its aggregate information
+        # @param event_with_aggregate [EventWithAggregate] The event with aggregate data
+        # @return [void]
+        def process_event_with_aggregate(event_with_aggregate)
+          aggregate = event_with_aggregate.aggregate
+          command_utilities = aggregate.send(:command_utilities)
+
+          command_name = command_utilities.command_name_from_event(
+            event_with_aggregate.event,
+            aggregate.class
+          )
+
+          payload = event_with_aggregate.event.data
+          locale = payload.delete(:locale)
+
+          state_updater = command_utilities.fetch_state_updater_class(command_name).new(
+            payload: payload,
+            aggregate: aggregate
+          )
+
+          # Determine which revision column to use
+          context_revision_column =
+            "#{aggregate.class.context.underscore}_#{aggregate.class.aggregate.underscore}_revision"
+          revision_column = if aggregate.read_model.class.column_names.include?(context_revision_column)
+                              context_revision_column.to_sym
+                            else
+                              :revision
+                            end
+
+          aggregate.update_read_model(
+            state_updater.call.merge(
+              revision_column => event_with_aggregate.event.stream_revision,
+              locale: locale
+            )
+          )
+        end
+      end
+    end
+  end
+end