realm-core 0.7.3 → 0.7.4

data/lib/realm/event_router/gateway.rb

@@ -0,0 +1,50 @@
+# 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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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

data/lib/realm/mixins/controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Realm
+  module Mixins
+    module Controller
+      def self.included(base)
+        base.class_attribute(:aggregate_name)
+        base.extend(ClassMethods)
+      end
+
+      def domain_runtime
+        @domain_runtime ||= root_domain_runtime.session(domain_context)
+      end
+
+      def domain_context
+        {}
+      end
+
+      def query(identifier, params = {})
+        domain_runtime.query(get_dispatchable(identifier), params)
+      end
+
+      def run(identifier, params = {})
+        domain_runtime.run(get_dispatchable(identifier), params)
+      end
+
+      def run_as_job(identifier, params = {})
+        domain_runtime.run_as_job(get_dispatchable(identifier), params)
+      end
+
+      private
+
+      def get_dispatchable(identifier)
+        return identifier if identifier.respond_to?(:call)
+
+        [aggregate_name, identifier].compact.join('.')
+      end
+
+      def root_domain_runtime
+        self.class.module_parents[-2].realm
+      end
+
+      module ClassMethods
+        def with_aggregate(name)
+          self.aggregate_name = name
+        end
+      end
+    end
+  end
+end

data/lib/realm/mixins/decorator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Realm
+  module Mixins
+    module Decorator
+      def self.[](decorated) # rubocop:disable Metrics/MethodLength
+        Module.new do
+          def method_missing(...)
+            _decorated.send(...)
+          end
+
+          def respond_to_missing?(...)
+            _decorated.respond_to?(...)
+          end
+
+          if decorated.to_s[0] == '@'
+            define_method :initialize do |value|
+              instance_variable_set(decorated, value)
+            end
+
+            define_method :_decorated do
+              instance_variable_get(decorated)
+            end
+          else
+            define_method :_decorated do
+              send(decorated)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/realm/mixins/dependency_injection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Realm
+  module Mixins
+    module DependencyInjection
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def new(*args, **kwargs, &block)
+          instance = allocate
+          deps.each { |d| define_dependency_method(instance, kwargs, d) }
+          kwargs_without_dependencies = kwargs.reject { |k, _| deps.any? { |d| d.name == k } }
+          instance.send(:initialize, *args, **kwargs_without_dependencies, &block)
+          instance
+        end
+
+        def inject(*dependables, **options)
+          deps.concat(dependables.map { |d| Dependency.new(d, **options) })
+        end
+
+        def dependencies
+          deps.freeze
+        end
+
+        private
+
+        def deps
+          @deps ||= []
+        end
+
+        def define_dependency_method(instance, kwargs, spec)
+          dependency = kwargs[spec.name]
+          instance.singleton_class.class_eval do
+            define_method(spec.name) do
+              return dependency unless spec.lazy?
+
+              var = "@#{spec.name}"
+              return instance_variable_get(var) if instance_variable_defined?(var)
+
+              instance_variable_set(var, dependency.respond_to?(:call) ? dependency.call : dependency)
+            end
+            protected spec.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/realm/mixins/reactive.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Realm
+  module Mixins
+    module Reactive
+      protected
+
+      def run(command, params = {})
+        parts = command.to_s.split('.')
+        parts.prepend(aggregate) if parts.size == 1 && respond_to?(:aggregate) && aggregate
+        @runtime.run(parts.join('.'), params.to_h)
+      end
+
+      def trigger(event_type, attributes = {})
+        attributes = attributes.to_h
+        head = { origin: origin(caller_locations(1, 1)) }.merge(attributes.fetch(:head, {}))
+        final_attrs = attributes.merge(head: head)
+        final_attrs[:cause] ||= context[:cause] if context.key?(:cause)
+        @runtime.trigger(event_type, final_attrs)
+      end
+
+      private
+
+      # Detects the class and method from which this event is triggered
+      def origin(backtrace)
+        [self.class.name, backtrace[0].to_s.match(/`([^']+)'/)&.then { |m| "##{m[1]}" }].join
+      end
+    end
+  end
+end

data/lib/realm/mixins/repository_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Realm
+  module Mixins
+    module RepositoryHelper
+      class OnlyOneWriteRepo < Realm::Error['You can have only one read/write repo per handler']; end
+      class InjectingRepoOutsideAggregate < Realm::Error['Cannot auto inject repository outside of an aggregate']; end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        protected
+
+        def use_repo(*names, readonly: self < Realm::QueryHandler)
+          raise OnlyOneWriteRepo if !readonly && (names.size > 1 || defined?(@write_repo_injected))
+
+          names << default_repo_name if names.empty?
+          names.each { |name| inject_repo(name, readonly) }
+          @write_repo_injected = true unless readonly
+        end
+
+        private
+
+        def inject_repo(name, readonly)
+          repo_name = "#{name}_repo"
+          return inject(repo_name) unless readonly
+
+          inject(repo_name) { |repo| repo.respond_to?(:readonly) ? repo.readonly : repo }
+        end
+
+        def default_repo_name
+          raise InjectingRepoOutsideAggregate unless respond_to?(:aggregate)
+
+          aggregate
+        end
+      end
+    end
+  end
+end

data/lib/realm/multi_worker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Realm
+  class MultiWorker
+    def initialize(workers = [])
+      @workers = workers
+    end
+
+    def start(*args)
+      @workers.each { |w| w.start(*args) }
+      self
+    end
+
+    def stop(timeout: 30)
+      @workers.each { |w| w.stop(timeout: timeout) }
+    end
+
+    def join
+      @workers.each(&:join)
+    end
+
+    def run
+      %w[INT TERM].each do |signal|
+        Signal.trap(signal) { stop }
+      end
+      start
+      join
+    end
+  end
+end