realm-core 0.7.3 → 0.7.4

data/lib/realm/dispatcher.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Realm
+  class Dispatcher
+    include Mixins::DependencyInjection
+    inject DomainResolver
+
+    def initialize(runtime)
+      @runtime = runtime
+      @threads = []
+    end
+
+    def query(identifier, params = {})
+      callable, action = get_callable(QueryHandler, identifier)
+      callable, action = get_repo_adapter(identifier) unless callable
+      raise QueryHandlerMissing, identifier unless callable
+
+      dispatch(callable, action, params)
+    end
+
+    def run(identifier, params = {})
+      callable, action = get_callable(CommandHandler, identifier)
+      raise CommandHandlerMissing, identifier unless callable
+
+      dispatch(callable, action, params)
+    end
+
+    def run_as_job(identifier, params = {})
+      callable, action = get_callable(CommandHandler, identifier)
+      raise CommandHandlerMissing, identifier unless callable
+
+      @threads.delete_if(&:stop?)
+      @threads << Thread.new do # TODO: back by SQS
+        result = dispatch(callable, action, params)
+        yield result if block_given?
+      end
+    end
+
+    # Blocks until all jobs are finished. Useful mainly in tests.
+    def wait_for_jobs
+      @threads.each(&:join)
+    end
+
+    private
+
+    attr_reader :runtime
+
+    def dispatch(callable, action, params)
+      arguments = { action: action, params: params, runtime: runtime }.compact
+      callable.(**arguments)
+    end
+
+    def get_callable(type, identifier)
+      return [identifier, nil] if identifier.respond_to?(:call)
+
+      domain_resolver.get_handler_with_action(type, identifier)
+    end
+
+    def get_repo_adapter(identifier)
+      parts = identifier.to_s.split('.')
+      return [nil, nil] unless parts.size == 2 && runtime&.context&.key?("#{parts[0]}_repo")
+
+      [Persistence::RepositoryQueryHandlerAdapter.new(runtime.context["#{parts[0]}_repo"]), parts[1].to_sym]
+    end
+  end
+end

data/lib/realm/domain_resolver.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Realm
+  class DomainResolver
+    DOMAIN_CLASS_TYPES = [CommandHandler, QueryHandler, EventHandler].freeze
+
+    def initialize(domain_module = nil)
+      # nil domain resolver is useful in tests
+      @domain_module = domain_module
+      @index = DOMAIN_CLASS_TYPES.map { |t| [t, {}] }.to_h
+      scan(domain_module) if domain_module
+    end
+
+    def get_handler_with_action(type, identifier)
+      handlers = @index[type]
+      return [handlers[identifier], :handle] if handlers.key?(identifier)
+
+      # The last part of the identifier can be action method name inside the handler
+      parts = identifier.split('.')
+      handler_part = parts[..-2].join('.')
+      action = parts[-1]
+      return [handlers[handler_part], action.to_sym] if handlers.key?(handler_part)
+
+      [nil, nil]
+    end
+
+    def all_event_handlers
+      @index[EventHandler].values
+    end
+
+    private
+
+    def scan(root_module)
+      root_module_str = root_module.to_s
+      root_module.constants.each do |const_sym|
+        const = root_module.const_get(const_sym)
+        next unless const.is_a?(Module) && !(const < Event) && const.to_s.start_with?(root_module_str)
+
+        type = DOMAIN_CLASS_TYPES.find { |t| const < t }
+        next scan(const) unless type
+
+        register(type, const)
+      end
+    end
+
+    def register(type, const)
+      # Remove domain module prefix and handler type suffixes
+      operation_type = type.to_s.demodulize.sub('Handler', '')
+      identifier = const.to_s.gsub(/(^#{@domain_module})|((#{operation_type})?Handlers?)/, '')
+      @index[type][identifier.underscore.gsub(%r{(^/+)|(/+$)}, '').gsub(%r{/+}, '.')] = const
+    end
+  end
+end

data/lib/realm/error.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Realm
+  class Error < StandardError
+    def self.[](default_msg)
+      Class.new(Realm::Error) do
+        define_method(:initialize) do |msg = default_msg|
+          super(msg)
+        end
+      end
+    end
+  end
+
+  class QueryHandlerMissing < Error
+    def initialize(query_name, msg: "Cannot find handler for query '#{query_name}'")
+      super(msg)
+    end
+  end
+
+  class CommandHandlerMissing < Error
+    def initialize(command_name, msg: "Cannot find handler for command '#{command_name}'")
+      super(msg)
+    end
+  end
+
+  class CannotHandleAction < Error
+    def initialize(handler, action, msg: "#{handler} cannot handle action '#{action}'")
+      super(msg)
+    end
+  end
+
+  class DependencyMissing < Error
+    def initialize(dependency_name, msg: "Dependency '#{dependency_name}' missing in container")
+      super(msg)
+    end
+  end
+
+  class EventClassMissing < Error
+    def initialize(identifier, events_module, msg: "Cannot find event class for #{identifier} in #{events_module}")
+      super(msg)
+    end
+  end
+
+  class InvalidParams < Error
+    def initialize(validation_result, msg: "Validation failed: #{validation_result.errors.to_h}")
+      @validation_result = validation_result
+      super(msg)
+    end
+
+    def params
+      @validation_result.to_h
+    end
+
+    def messages
+      @validation_result.errors.to_h
+    end
+
+    def full_messages
+      @validation_result.errors(full: true).to_h
+    end
+  end
+end

data/lib/realm/event.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'dry/core/constants'
+require 'dry-struct'
+
+module Realm
+  class Event < Dry::Struct
+    T = Realm::Types
+
+    transform_keys(&:to_sym)
+
+    attribute :head do
+      attribute :id, T::Strict::String
+      attribute :triggered_at, T::JSON::Time
+      attribute? :version, T::Coercible::String
+      attribute? :origin, T::Strict::String
+      attribute :correlation_id, T::Strict::String
+      attribute? :cause_event_id, T::Strict::String
+      attribute? :cause, T::Strict::String
+    end
+
+    class << self
+      def new(attributes = {})
+        head = {
+          id: SecureRandom.uuid,
+          correlation_id: SecureRandom.uuid,
+          triggered_at: Time.now,
+          version: 1, # until we need breaking change (anything except adding attribute) all events are version 1
+        }.merge(attributes.fetch(:head, {}))
+        body = attributes[:body] || attributes.except(:head)
+        super({ head: head }.merge(body.empty? ? {} : { body: body }))
+      end
+
+      def type(value = :not_provided)
+        @type = value unless value == :not_provided
+        @type ||= name.demodulize.sub('Event', '').underscore
+      end
+
+      protected
+
+      def body_struct(type = Dry::Core::Constants::Undefined, &block)
+        attribute(:body, type, &block)
+      end
+    end
+
+    def type
+      self.class.type
+    end
+
+    def to_json(*args)
+      JSON.generate(to_h, *args)
+    end
+  end
+end

data/lib/realm/event_factory.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Realm
+  class EventFactory
+    def initialize(events_module)
+      @events_module = events_module
+      @event_class_map = collect_event_classes(events_module)
+    end
+
+    def create_event(event_type, correlate: nil, cause: nil, **attributes)
+      head = enhance_head(attributes.fetch(:head, {}), correlate: correlate, cause: cause)
+      body = attributes.fetch(:body, attributes.except(:head))
+
+      event_class_for(event_type).new(head: head, body: body)
+    end
+
+    def event_class_for(event_type)
+      return event_type if event_type.respond_to?(:new)
+
+      @event_class_map.fetch(event_type.to_s) do
+        raise EventClassMissing.new(event_type, @events_module)
+      end
+    end
+
+    private
+
+    def collect_event_classes(root_module)
+      root_module_str = root_module.to_s
+      root_module.constants.each_with_object({}) do |const_sym, all|
+        const = root_module.const_get(const_sym)
+        next unless const.is_a?(Module) && const.to_s.start_with?(root_module_str)
+
+        all[const.type] = const if const < Event
+        all.merge!(collect_event_classes(const))
+      end
+    end
+
+    def enhance_head(head, correlate:, cause:)
+      head[:correlation_id] = correlate.head.correlation_id if correlate
+      if cause.is_a?(Event)
+        head[:cause_event_id] = cause.head.id
+        head[:correlation_id] ||= cause.head.correlation_id
+      elsif cause
+        head[:cause] = cause
+      end
+      head
+    end
+  end
+end

data/lib/realm/event_handler.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Realm
+  class EventHandler
+    extend Mixins::ContextInjection::ClassMethods
+    include Mixins::AggregateMember
+    include Mixins::Reactive
+    include Mixins::RepositoryHelper
+
+    class RuntimeBound
+      delegate :identifier, :event_types, to: :@handler_class
+
+      def initialize(handler_class, runtime)
+        @handler_class = handler_class
+        @runtime = runtime
+      end
+
+      def call(event)
+        @handler_class.(event, runtime: @runtime.session(cause: event))
+      end
+    end
+
+    class << self
+      attr_reader :trigger_mapping, :event_namespace
+
+      def bind_runtime(runtime)
+        RuntimeBound.new(self, runtime)
+      end
+
+      def call(event, runtime:)
+        new(runtime: runtime).(event)
+      end
+
+      def identifier(value = :not_provided)
+        @identifier = value unless value == :not_provided
+        return @identifier if defined?(@identifier)
+
+        @identifier = name.gsub(/(Domain|(::)?(Event)?Handlers?)/, '').underscore.gsub(%r{/+}, '-')
+      end
+
+      def event_types
+        defined?(@trigger_mapping) ? @trigger_mapping.keys.uniq : []
+      end
+
+      protected
+
+      def namespace(value)
+        @event_namespace = value
+      end
+
+      def on(*triggers, run: nil, **options, &block)
+        @method_triggers = triggers
+        @method_trigger_options = options # TODO: store and pass to gateway
+        return unless run || block
+
+        block = ->(event) { self.run(run, event.body) } if run
+        define_method("handle_#{triggers.join('_or_')}", &block)
+      end
+
+      def method_added(method_name)
+        super
+        return unless defined?(@method_triggers)
+
+        @trigger_mapping ||= {}
+        @method_triggers.each do |trigger|
+          (@trigger_mapping[trigger.to_sym] ||= []) << method_name
+        end
+        remove_instance_variable(:@method_triggers)
+      end
+    end
+
+    def initialize(runtime: nil)
+      @runtime = runtime
+    end
+
+    def call(event)
+      event_to_methods(event).each do |method_name|
+        send(method_name, event)
+      rescue Realm::Persistence::Conflict => e
+        context[:logger]&.warn(e.full_message)
+      end
+    end
+
+    protected
+
+    delegate :context, to: :@runtime
+
+    private
+
+    def event_to_methods(event)
+      self.class.trigger_mapping.fetch_values(event.type.to_sym, :any) { [] }.flatten
+    end
+  end
+end

data/lib/realm/event_router.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Realm
+  class EventRouter
+    include Mixins::DependencyInjection
+    inject DomainResolver
+    inject 'Realm::Runtime', lazy: true
+
+    def initialize(gateways_spec, prefix: nil)
+      @prefix = prefix
+      @auto_registered = false
+      @default_namespace = nil
+      init_gateways(gateways_spec)
+    end
+
+    def register(handler_class)
+      gateway_for(handler_class.try(:event_namespace)).register(handler_class)
+    end
+
+    def add_listener(event_type, listener, namespace: nil)
+      gateway_for(namespace).add_listener(event_type, listener)
+    end
+
+    def trigger(identifier, attributes = {})
+      namespace, event_type = identifier.to_s.include?('/') ? identifier.split('/') : [nil, identifier]
+      gateway_for(namespace).trigger(event_type, attributes)
+    end
+
+    def workers(*namespaces, **options)
+      auto_register_handlers
+      @gateways.filter_map do |(namespace, gateway)|
+        gateway.worker(**options) if namespaces.empty? || namespaces.include?(namespace)
+      end
+    end
+
+    def active_queues
+      auto_register_handlers
+      @gateways.values.reduce([]) do |queues, gateway|
+        queues + gateway.queues
+      end
+    end
+
+    private
+
+    def init_gateways(gateways_spec)
+      auto_register_on_init = false
+      @gateways = gateways_spec.each_with_object({}) do |(namespace, config), gateways|
+        gateway_class = gateway_class(config.fetch(:type))
+        auto_register_on_init ||= gateway_class.auto_register_on_init
+        gateways[namespace] = instantiate_gateway(namespace, gateway_class, config)
+        @default_namespace = namespace if config[:default]
+      end
+      auto_register_handlers if auto_register_on_init
+    end
+
+    def gateway_class(type)
+      return InternalLoopGateway if type.to_s == 'internal_loop'
+
+      runtime.container.resolve("event_router.gateway_classes.#{type}")
+    end
+
+    def instantiate_gateway(namespace, klass, config)
+      klass.new(
+        namespace: namespace,
+        queue_prefix: @prefix,
+        event_factory: EventFactory.new(config.fetch(:events_module)),
+        runtime: runtime,
+        **config.except(:type, :default, :events_module),
+      )
+    end
+
+    def auto_register_handlers
+      return if @auto_registered || !domain_resolver
+
+      @auto_registered = true
+      domain_resolver.all_event_handlers.each { |klass| register(klass) }
+    end
+
+    def gateway_for(namespace)
+      @gateways.fetch(namespace.try(:to_sym) || default_namespace) do
+        raise "No event gateway for #{namespace || 'default'} namespace" # TODO: extract error class
+      end
+    end
+
+    def default_namespace
+      return @default_namespace if @default_namespace
+
+      @gateways.keys[0] if @gateways.keys.size == 1
+    end
+  end
+end