realm-core 0.7.1 → 0.7.3

data/lib/realm/event_factory.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/error'
-require 'realm/event'
-
-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)
-        if !(const < Event) && const.to_s.start_with?(root_module_str)
-          all.merge!(collect_event_classes(const))
-        elsif const < Event
-          all[const.type] = const
-        end
-      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

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-require 'realm/persistence'
-require 'realm/mixins/context_injection'
-require 'realm/mixins/reactive'
-require 'realm/mixins/repository_helper'
-require 'realm/mixins/aggregate_member'
-
-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 = :undefined)
-        if value == :undefined
-          defined?(@identifier) ? @identifier : name.gsub(/(Domain|(Event)?Handlers?)/, '').underscore.gsub(%r{/+}, '-')
-        else
-          @identifier = value
-        end
-      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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-require 'active_support/core_ext/hash'
-require 'realm/error'
-require 'realm/domain_resolver'
-require 'realm/event_handler'
-require 'realm/event_factory'
-require 'realm/mixins/dependency_injection'
-require_relative 'event_router/internal_loop_gateway'
-
-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

data/lib/realm/event_router/gateway.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Realm
-  class EventRouter
-    class Gateway
-      def self.auto_register_on_init
-        false
-      end
-
-      def initialize(event_factory:, namespace: :default, runtime: nil, **)
-        @namespace = namespace
-        @event_factory = event_factory
-        @runtime = runtime
-      end
-
-      def register(handler_class)
-        # TODO: validate event_types for existence of matching class
-        handler_class.event_types.each do |event_type|
-          add_listener(event_type, handler_class.bind_runtime(@runtime))
-        end
-      end
-
-      def add_listener(event_type, listener)
-        raise NotImplementedError
-      end
-
-      def trigger(event_type, attributes = {})
-        raise NotImplementedError
-      end
-
-      def worker(*)
-        nil
-      end
-
-      def cleanup
-        # do nothing
-      end
-
-      def queues
-        []
-      end
-
-      protected
-
-      def create_event(event_type, attributes = {})
-        @event_factory.create_event(event_type, **attributes)
-      end
-    end
-  end
-end

data/lib/realm/event_router/internal_loop_gateway.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './gateway'
-
-module Realm
-  class EventRouter
-    class InternalLoopGateway < Gateway
-      def self.auto_register_on_init
-        true
-      end
-
-      def initialize(isolated: false, **)
-        super
-        @listener_map = {}
-        @isolated = isolated
-        gateways << self
-      end
-
-      def add_listener(event_type, listener)
-        (@listener_map[event_type.to_sym] ||= []) << listener
-      end
-
-      def trigger(event_type, attributes = {})
-        create_event(event_type, attributes).tap do |event|
-          gateways.each { |gateway| gateway.handle(event_type, event) }
-        end
-      end
-
-      def purge!
-        gateways.clear
-      end
-
-      protected
-
-      def handle(event_type, event)
-        find_listeners(event_type).each { |listener| listener.(event) }
-      end
-
-      private
-
-      def find_listeners(event_type)
-        @listener_map.fetch_values(event_type.to_sym, :any) { [] }.flatten
-      end
-
-      def gateways
-        @isolated ? (@gateways ||= []) : (@@gateways ||= []) # rubocop:disable Style/ClassVars
-      end
-    end
-  end
-end

data/lib/realm/health_status.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object/blank'
-
-module Realm
-  class HealthStatus
-    CODES = %i[green yellow red].freeze
-    attr_reader :code, :issues
-
-    class << self
-      def [](code, *issues)
-        new(code, issues.flatten)
-      end
-
-      def from_issues(issues)
-        new(issues.blank? ? :green : :red, issues)
-      end
-
-      def combine(component_map)
-        code_index = component_map.values.map { |i| CODES.index(i.code) }.max
-        new(CODES[code_index || 0], [], component_map)
-      end
-    end
-
-    def for_component(*names)
-      @component_map.dig(*names)
-    end
-
-    def to_h
-      hash = { status: @code }
-      hash[:issues] = @issues if @issues.present?
-      hash[:components] = @component_map.transform_values(&:to_h) if @component_map.present?
-      hash
-    end
-
-    private
-
-    def initialize(code, issues = [], component_map = {})
-      raise ArgumentError, "Invalid status code #{code}" unless CODES.include?(code)
-
-      @code = code
-      @issues = issues.freeze
-      @component_map = component_map.freeze
-    end
-  end
-end

data/lib/realm/mixins/aggregate_member.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Realm
-  module Mixins
-    module AggregateMember
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      def aggregate
-        self.class.aggregate
-      end
-
-      module ClassMethods
-        def aggregate
-          @aggregate ||= begin
-            module_chain = name.split('::')
-            domain_index = module_chain.index('Domain')
-            domain_index && module_chain[domain_index + 1].underscore.to_sym
-          end
-        end
-      end
-    end
-  end
-end

data/lib/realm/mixins/context_injection.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/error'
-
-module Realm
-  module Mixins
-    module ContextInjection
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.prepend(Initializer)
-      end
-
-      module ClassMethods
-        def inject(*names, &block)
-          names.each do |name|
-            define_method(name) do
-              raise Realm::DependencyMissing, name unless context.key?(name)
-
-              return context[name] unless block
-
-              var = "@#{name}"
-              return instance_variable_get(var) if instance_variable_defined?(var)
-
-              instance_variable_set(var, block.(context[name]))
-            end
-          end
-        end
-      end
-
-      module Initializer
-        def initialize(*args, context: nil, **kwargs)
-          @context = context || context_from_root_module || {}
-          super(*args, **kwargs)
-        end
-
-        private
-
-        def context_from_root_module
-          root_module = self.class.module_parents[-2]
-          root_module.realm.context if root_module.respond_to?(:realm)
-        end
-      end
-
-      protected
-
-      attr_reader :context
-    end
-  end
-end