realm-core 0.7.1 → 0.7.3

data/lib/realm/mixins/controller.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/module/introspection'
-require 'active_support/core_ext/class/attribute'
-
-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

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/dependency'
-
-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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/error'
-
-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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/error'
-
-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

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

data/lib/realm/persistence.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-require 'realm/error'
-
-module Realm
-  class Persistence
-    class InvalidPersistanceType < Realm::Error; end
-    class Conflict < Realm::Error; end
-
-    class RelationIsReadOnly < Realm::Error
-      def initialize(relation, msg: "Cannot write using read-only relation #{relation.class}")
-        super(msg)
-      end
-    end
-
-    class RepositoryIsReadOnly < Realm::Error
-      def initialize(repo, msg: "Cannot write using read-only repository #{repo.class}")
-        super(msg)
-      end
-    end
-
-    def self.setup(...)
-      new(...).setup
-    end
-
-    def initialize(container, repositories)
-      @container = container
-      @repositories = repositories
-    end
-
-    def setup
-      register_repos
-    end
-
-    private
-
-    def gateway
-      @gateway ||= @container.resolve('persistence.gateway')
-    end
-
-    def register_repos
-      @repositories.each do |repo_class|
-        @container.register_factory(repo_class, gateway, as: "#{repo_class.name.demodulize.underscore}_repo")
-      end
-    end
-
-    def constantize(*parts)
-      return parts[0] unless parts[0].is_a?(String)
-
-      parts.join('::').safe_constantize
-    end
-  end
-end

data/lib/realm/persistence/repository_query_handler_adapter.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/persistence'
-require 'realm/error'
-
-module Realm
-  class Persistence
-    class QueryCannotModifyState < Realm::Error; end
-
-    class RepositoryQueryHandlerAdapter
-      def initialize(repo)
-        @repo = repo.respond_to?(:readonly) ? repo.readonly : repo
-      end
-
-      def call(action:, params: {}, **)
-        raise CannotHandleAction.new(self, action) unless @repo.respond_to?(action)
-
-        @repo.send(action, **params)
-      rescue RepositoryIsReadOnly
-        raise QueryCannotModifyState
-      end
-    end
-  end
-end

data/lib/realm/plugin.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/class'
-require 'active_support/core_ext/string'
-
-module Realm
-  class Plugin
-    class << self
-      def plugin_name(value = :not_provided)
-        @plugin_name = value.to_sym unless value == :not_provided
-        @plugin_name = name.split('::')[-2].underscore.to_sym unless defined?(@plugin_name)
-        @plugin_name
-      end
-
-      def setup(_config, _container)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/realm/query_handler.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/action_handler'
-
-module Realm
-  class QueryHandler < Realm::ActionHandler
-  end
-end

data/lib/realm/runtime.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/object/try'
-require 'realm/context'
-require 'realm/container'
-require 'realm/dispatcher'
-require 'realm/event_router'
-require 'realm/multi_worker'
-require 'realm/health_status'
-require 'realm/runtime/session'
-
-module Realm
-  class Runtime
-    delegate :query, :run, :run_as_job, :wait_for_jobs, to: :dispatcher
-    delegate :trigger, :add_listener, to: :event_router
-    delegate :[], to: :context
-    attr_reader :container
-
-    def initialize(container = Container.new)
-      @container = Container[container]
-    end
-
-    def context
-      @context ||= Context.new(@container)
-    end
-
-    def session(context = {})
-      context.blank? ? self : Session.new(self, context)
-    end
-
-    def worker(*args)
-      MultiWorker.new(event_router.try(:workers, *args) || [])
-    end
-
-    def health
-      component_statuses = container.each_with_object({}) do |(name, component), map|
-        map[name] = component.health if component.respond_to?(:health) && !component.is_a?(Runtime)
-      end
-      HealthStatus.combine(component_statuses)
-    end
-
-    # Get all active messaging queues. For maintenance purpose only.
-    # TODO: Introduce component container and allow to call those method directly on components instead of
-    # polluting runtime
-    # Example: engine.realm.components.find(type: Realm::EventRouter::SNSGateway).try(:active_queues)
-    def active_queues
-      event_router.try(:active_queues) || []
-    end
-
-    private
-
-    def dispatcher
-      @dispatcher ||= container.create(Dispatcher, self)
-    end
-
-    def event_router
-      @container[EventRouter]
-    end
-  end
-end

data/lib/realm/runtime/session.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/dispatcher'
-
-module Realm
-  class Runtime
-    class Session
-      delegate :query, :run, :run_as_job, :wait_for_jobs, to: :dispatcher
-      delegate :add_listener, :trigger, :worker, to: :@runtime
-      delegate :[], to: :context
-      attr_reader :context
-
-      def initialize(runtime, context)
-        @runtime = runtime
-        @context = runtime.context.merge(context)
-      end
-
-      def session(context = {})
-        context.blank? ? self : self.class.new(self, context)
-      end
-
-      def container
-        @runtime.container
-      end
-
-      private
-
-      def dispatcher
-        @dispatcher ||= container.create(Dispatcher, self)
-      end
-    end
-  end
-end