orfeas_lyra 0.6.0

data/lib/lyra/event_store_adapter.rb

@@ -0,0 +1,72 @@
+module Lyra
+  # Pluggable event store adapter
+  class EventStoreAdapter
+    class << self
+      def build(backend = nil)
+        backend ||= Lyra.config.event_backend
+
+        case backend
+        when :rails_event_store, :res
+          RailsEventStoreAdapter.new
+        when :custom
+          CustomEventStoreAdapter.new
+        else
+          raise "Unknown event backend: #{backend}"
+        end
+      end
+    end
+  end
+
+  class RailsEventStoreAdapter
+    def initialize
+      @client = build_client
+    end
+
+    def publish(event, stream_name:)
+      @client.publish(event, stream_name: stream_name)
+    end
+
+    def read_stream(stream_name)
+      @client.read.stream(stream_name).to_a
+    end
+
+    def read_all_streams
+      @client.read.to_a
+    end
+
+    def subscribe(subscriber, to:)
+      @client.subscribe(subscriber, to: to)
+    end
+
+    private
+
+    def build_client
+      RailsEventStore::Client.new(
+        repository: RailsEventStoreActiveRecord::EventRepository.new(
+          serializer: RailsEventStore::Serializers::YAML
+        )
+      )
+    end
+  end
+
+  class CustomEventStoreAdapter
+    # Placeholder for custom event store implementations
+    # Users can implement their own adapter by extending this class
+
+    def publish(event, stream_name:)
+      raise NotImplementedError, "Custom event store adapter must implement #publish"
+    end
+
+    def read_stream(stream_name)
+      raise NotImplementedError, "Custom event store adapter must implement #read_stream"
+    end
+
+    def read_all_streams
+      raise NotImplementedError, "Custom event store adapter must implement #read_all_streams"
+    end
+
+    def subscribe(subscriber, to:)
+      raise NotImplementedError, "Custom event store adapter must implement #subscribe"
+    end
+  end
+end

data/lib/lyra/id_generator.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Lyra
+  # Generates IDs for new records before event storage in event_sourcing mode.
+  #
+  # In event_sourcing mode, we need the record ID before the event is stored
+  # (since we abort the actual database save). This class handles ID generation
+  # for different database adapters and primary key types.
+  #
+  # Strategies:
+  # - PostgreSQL: Use nextval() to reserve sequence value
+  # - SQLite: Use max(id) + 1 (less safe for concurrent writes)
+  # - MySQL/Other: Hi-Lo algorithm with configurable block size
+  # - UUID columns: Generate SecureRandom.uuid
+  #
+  class IdGenerator
+    # Thread-safe Hi-Lo state storage
+    @hilo_mutex = Mutex.new
+    @hilo_state = {}
+
+    class << self
+      # Generate the next ID for a model class
+      #
+      # @param model_class [Class] The ActiveRecord model class
+      # @return [Integer, String] The generated ID
+      def next_id(model_class)
+        pk_column = model_class.columns_hash[model_class.primary_key]
+
+        case pk_column&.type
+        when :uuid
+          SecureRandom.uuid
+        when :integer, :bigint, nil
+          next_integer_id(model_class)
+        else
+          # Default to UUID for unknown types
+          SecureRandom.uuid
+        end
+      end
+
+      private
+
+      def next_integer_id(model_class)
+        case adapter_name(model_class)
+        when /postgresql/i
+          next_postgresql_id(model_class)
+        when /mysql/i, /trilogy/i
+          next_hilo_id(model_class)
+        when /sqlite/i
+          next_sqlite_id(model_class)
+        else
+          next_hilo_id(model_class)
+        end
+      end
+
+      def adapter_name(model_class)
+        model_class.connection.adapter_name
+      end
+
+      # PostgreSQL: Reserve next sequence value atomically
+      def next_postgresql_id(model_class)
+        table = model_class.table_name
+        pk = model_class.primary_key
+
+        # Get the sequence name for this table's primary key
+        result = model_class.connection.execute(
+          "SELECT pg_get_serial_sequence('#{table}', '#{pk}')"
+        )
+        sequence = result.first&.values&.first
+
+        if sequence
+          # Reserve the next value from the sequence
+          result = model_class.connection.execute("SELECT nextval('#{sequence}')")
+          result.first["nextval"].to_i
+        else
+          # No sequence (maybe not a serial column), fall back to Hi-Lo
+          next_hilo_id(model_class)
+        end
+      rescue StandardError => e
+        Rails.logger.warn("Lyra::IdGenerator: PostgreSQL sequence failed (#{e.message}), using Hi-Lo")
+        next_hilo_id(model_class)
+      end
+
+      # SQLite: Use max(id) + 1 (not ideal for concurrency)
+      def next_sqlite_id(model_class)
+        table = model_class.table_name
+        pk = model_class.primary_key
+
+        result = model_class.connection.execute(
+          "SELECT MAX(#{pk}) as max_id FROM #{table}"
+        )
+        max_id = result.first&.fetch("max_id", 0) || 0
+        max_id.to_i + 1
+      rescue StandardError => e
+        Rails.logger.warn("Lyra::IdGenerator: SQLite max failed (#{e.message}), using Hi-Lo")
+        next_hilo_id(model_class)
+      end
+
+      # Hi-Lo Algorithm: Reserve blocks of IDs to minimize DB queries
+      #
+      # This algorithm reserves a block of IDs at once, reducing DB roundtrips.
+      # Thread-safe implementation using mutex.
+      #
+      # @param model_class [Class] The model class
+      # @param block_size [Integer] Number of IDs to reserve per hi value (default: 100)
+      # @return [Integer] The next ID
+      def next_hilo_id(model_class, block_size: 100)
+        key = model_class.name
+
+        @hilo_mutex.synchronize do
+          @hilo_state[key] ||= { hi: nil, lo: 0, max_lo: block_size }
+          state = @hilo_state[key]
+
+          # Need to fetch new hi value?
+          if state[:hi].nil? || state[:lo] >= state[:max_lo]
+            state[:hi] = fetch_next_hi(model_class, block_size)
+            state[:lo] = 0
+          end
+
+          # Calculate ID: hi * block_size + lo
+          id = (state[:hi] * state[:max_lo]) + state[:lo]
+          state[:lo] += 1
+          id
+        end
+      end
+
+      # Fetch the next hi value based on current max ID
+      def fetch_next_hi(model_class, block_size)
+        max_id = model_class.unscoped.maximum(model_class.primary_key) || 0
+        # Calculate hi value that puts us above any existing ID
+        (max_id / block_size) + 1
+      rescue StandardError
+        # If query fails, use timestamp-based hi to avoid collisions
+        (Time.current.to_i / 100) % 1_000_000
+      end
+    end
+  end
+end

data/lib/lyra/interceptors/association_interceptor.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Lyra
+  module Interceptors
+    # Patches AR association loading to use cached projections when:
+    # - The target model is monitored by Lyra
+    # - Lyra is in event_sourcing mode
+    # - projection_mode is :disabled
+    #
+    # This allows belongs_to/has_one associations to work transparently
+    # even when the target record only exists in the cache, not the DB.
+    #
+    module AssociationInterceptor
+      module BelongsToAssociationPatch
+        # Rails 8+ passes async: keyword argument to find_target
+        def find_target(async: false)
+          if lyra_should_use_cache?
+            lyra_find_target_from_cache
+          else
+            super
+          end
+        end
+
+        private
+
+        def lyra_should_use_cache?
+          return false unless Lyra.event_sourcing_mode? && Lyra.config.projection_mode == :disabled
+
+          target_klass = lyra_resolve_target_class
+          return false unless target_klass
+
+          target_klass.respond_to?(:lyra_monitored) && target_klass.lyra_monitored
+        end
+
+        def lyra_resolve_target_class
+          if reflection.polymorphic?
+            # For polymorphic associations, get class from the type column
+            type_column = reflection.foreign_type
+            type_name = owner.read_attribute(type_column)
+            return nil if type_name.blank?
+            type_name.safe_constantize
+          else
+            reflection.klass
+          end
+        rescue => e
+          # If class resolution fails, fall back to AR's normal loading
+          nil
+        end
+
+        def lyra_find_target_from_cache
+          foreign_key_value = owner.read_attribute(reflection.foreign_key)
+          return nil if foreign_key_value.nil?
+
+          target_klass = lyra_resolve_target_class
+          return nil unless target_klass
+
+          Lyra::Projections::EventStoreReader.find(target_klass, foreign_key_value)
+        end
+      end
+
+      module HasOneAssociationPatch
+        # Rails 8+ passes async: keyword argument to find_target
+        def find_target(async: false)
+          if lyra_should_use_cache?
+            lyra_find_target_from_cache
+          else
+            super
+          end
+        end
+
+        private
+
+        def lyra_should_use_cache?
+          klass = reflection.klass
+          klass.respond_to?(:lyra_monitored) &&
+            klass.lyra_monitored &&
+            Lyra.event_sourcing_mode? &&
+            Lyra.config.projection_mode == :disabled
+        end
+
+        def lyra_find_target_from_cache
+          owner_key_value = owner.read_attribute(reflection.active_record_primary_key)
+          return nil if owner_key_value.nil?
+
+          Lyra::Projections::EventStoreReader.find_by(
+            reflection.klass,
+            { reflection.foreign_key => owner_key_value }
+          )
+        end
+      end
+
+      module HasManyAssociationPatch
+        # Rails 8+ passes async: keyword argument to find_target
+        def find_target(async: false)
+          if lyra_should_use_cache?
+            lyra_find_target_from_cache
+          else
+            super
+          end
+        end
+
+        # Override count_records to use cache
+        def count_records
+          if lyra_should_use_cache?
+            lyra_get_cached_relation.count
+          else
+            super
+          end
+        end
+
+        # Override size to use cache (used by any?, empty?, etc.)
+        def size
+          if lyra_should_use_cache?
+            if loaded?
+              target.size
+            else
+              lyra_get_cached_relation.count
+            end
+          else
+            super
+          end
+        end
+
+        # Override empty? directly
+        def empty?
+          if lyra_should_use_cache?
+            size == 0
+          else
+            super
+          end
+        end
+
+        private
+
+        def lyra_should_use_cache?
+          klass = reflection.klass
+          klass.respond_to?(:lyra_monitored) &&
+            klass.lyra_monitored &&
+            Lyra.event_sourcing_mode? &&
+            Lyra.config.projection_mode == :disabled
+        end
+
+        def lyra_get_cached_relation
+          owner_key_value = owner.read_attribute(reflection.active_record_primary_key)
+          return Lyra::Projections::CachedRelation.new(reflection.klass, []) if owner_key_value.nil?
+
+          Lyra::Projections::EventStoreReader.where(
+            reflection.klass,
+            { reflection.foreign_key => owner_key_value }
+          )
+        end
+
+        def lyra_find_target_from_cache
+          lyra_get_cached_relation.to_a
+        end
+      end
+
+      def self.install!
+        return if @installed
+
+        ActiveRecord::Associations::BelongsToAssociation.prepend(BelongsToAssociationPatch)
+        ActiveRecord::Associations::HasOneAssociation.prepend(HasOneAssociationPatch)
+        ActiveRecord::Associations::HasManyAssociation.prepend(HasManyAssociationPatch)
+
+        @installed = true
+      end
+    end
+  end
+end