realm-core 0.7.1 → 0.7.3

data/lib/realm/config.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-require 'dry-initializer'
-
-module Realm
-  class Config
-    extend Dry::Initializer
-
-    option :root_module
-    option :database_url,         default: proc {}
-    option :prefix,               default: proc {}
-    option :namespace,            default: proc { root_module.to_s.underscore }
-    option :domain_module,        default: proc { "#{root_module}::Domain" }
-    option :engine_class,         default: proc { "#{root_module}::Engine" }
-    option :engine_path,          default: proc { engine_class&.to_s&.safe_constantize&.root }
-    option :logger,               default: proc {}
-    option :plugins,              default: proc { [] }, reader: false
-    option :dependencies,         default: proc { {} }
-    option :persistence_gateway,  default: proc { database_url && { type: :rom, url: database_url } }, reader: false
-    option :event_gateway,        default: proc {}, reader: false
-    option :event_gateways,       default: proc {
-      @event_gateway ? { default: { **@event_gateway, default: true } } : {}
-    }
-
-    def plugins
-      Array(@plugins)
-    end
-
-    def persistence_gateway
-      return {} unless @persistence_gateway
-
-      class_path = engine_path && "#{engine_path}/app/persistence/#{namespace}"
-      repos_path = class_path && "#{class_path}/repositories"
-      repos_module = "#{root_module}::Repositories"
-      {
-        root_module: root_module,
-        class_path: class_path,
-        repos_path: repos_path,
-        repos_module: repos_module,
-        migration_path: engine_path && "#{engine_path}/db/migrate",
-        repositories: repositories(repos_path, repos_module),
-      }.merge(@persistence_gateway)
-    end
-
-    private
-
-    def repositories(repos_path, repos_module)
-      return [] unless repos_path
-
-      Dir[File.join(repos_path, '**', '*.rb')].each_with_object([]) do |filename, all|
-        matches = %r{^#{repos_path}/(.+)\.rb$}.match(filename)
-        all << "#{repos_module}::#{matches[1].camelize}".constantize if matches
-      end
-    end
-  end
-end

data/lib/realm/container.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry-container'
-require 'active_support/core_ext/string'
-require 'active_support/core_ext/object/try'
-require 'realm/error'
-
-module Realm
-  class Container
-    include Dry::Container::Mixin
-    include Enumerable
-
-    def self.[](object)
-      object.is_a?(Container) ? object : Container.new(object)
-    end
-
-    def initialize(hash = {})
-      register_all(hash)
-    end
-
-    def register(key, contents = nil, options = {}, &block)
-      options[:klass] ||= contents.class if contents && !contents.is_a?(::Hash)
-      super(key, contents, options, &block)
-    end
-
-    def register_all(hash)
-      hash.each_pair do |key, value|
-        register(key, value)
-      end
-    end
-
-    def register_factory(klass, *args, as: nil, memoize: true, **kwargs) # rubocop:disable Naming/MethodParameterName
-      register(as || klass, klass: klass, memoize: memoize) do
-        create(klass, *args, **kwargs)
-      end
-    end
-
-    def create(klass, *args, **kwargs)
-      (klass.try(:dependencies) || []).each do |d|
-        fn = -> { resolve_dependable(sanitize_dependable(d.dependable), d.optional?) }
-        kwargs[d.name] = d.lazy? ? fn : fn.call
-      end
-      klass.new(*args, **kwargs)
-    end
-
-    def [](key)
-      resolve(key) if key?(key)
-    end
-
-    def resolve_all(klass)
-      _container.each_with_object([]) do |(_, item), all|
-        all << item.call if item.options[:klass] <= klass
-      end
-    end
-
-    private
-
-    def sanitize_dependable(dependable)
-      dependable.is_a?(String) && dependable.match(/^[A-Z]/) ? dependable.constantize : dependable
-    end
-
-    def resolve_dependable(dependable, optional)
-      raise DependencyMissing, dependable unless optional || key?(dependable)
-
-      self[dependable]
-    end
-  end
-end

data/lib/realm/context.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'realm/container'
-
-module Realm
-  class Context
-    include Enumerable
-
-    def initialize(*containers)
-      @containers = containers.map { |c| Container[c] }
-    end
-
-    def [](name)
-      @containers.each do |container|
-        return container[name] if container.key?(name)
-      end
-      nil
-    end
-
-    def key?(name)
-      @containers.any? { |container| container.key?(name) }
-    end
-
-    def merge(container_like)
-      container_like.blank? ? self : self.class.new(container_like, *@containers)
-    end
-
-    def each(&block)
-      @containers.each { |container| container.each(&block) }
-    end
-
-    # Just for testing
-    def override!(container)
-      @containers.prepend(container)
-    end
-  end
-end

data/lib/realm/dependency.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-
-module Realm
-  class Dependency
-    attr_reader :dependable, :name
-
-    def initialize(dependable, as: nil, optional: false, lazy: false) # rubocop:disable Naming/MethodParameterName
-      @dependable = dependable
-      @name = as || dependable.to_s.demodulize.underscore.to_sym
-      @optional = optional
-      @lazy = lazy
-    end
-
-    def optional?
-      @optional
-    end
-
-    def lazy?
-      @lazy
-    end
-  end
-end

data/lib/realm/dispatcher.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-require 'realm/query_handler'
-require 'realm/command_handler'
-require 'realm/domain_resolver'
-require 'realm/error'
-require 'realm/mixins/dependency_injection'
-require 'realm/persistence/repository_query_handler_adapter'
-
-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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-require 'realm/command_handler'
-require 'realm/query_handler'
-require 'realm/event_handler'
-require 'realm/event'
-
-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 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

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-require 'active_support/core_ext/hash'
-require 'active_support/core_ext/string'
-require 'dry-struct'
-require 'realm/types'
-
-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
-        @type ||= name.demodulize.sub('Event', '').underscore
-      end
-
-      protected
-
-      def body_struct(&block)
-        attribute(:body, &block)
-      end
-    end
-
-    def type
-      self.class.type
-    end
-
-    def to_json(*args)
-      JSON.generate(to_h, *args)
-    end
-  end
-end