realm-core 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48d73715170e2bfb91f817fe7f09816980939bfd51d56e061a088908af40dd08
-  data.tar.gz: bde68574affd81f8eaecb821921c6dba91fe151eaa9b1703cdf31fff14e934cf
+  metadata.gz: f8388b271b94435bba6f9cdc441ce02ce96d7bdd9814fc46c682e01e9809fd22
+  data.tar.gz: 140b5a6019cf16b4190d7c08280c2d674c708b1df8f299e26a572a2f77fba404
 SHA512:
-  metadata.gz: ff5149ff935de4a9599679f6daf246af8c43a06b3fab9d35f941a5c7d84b05b6557b4ed13487b56f127afaabe7a4868a8900d918004214f0ab13ba359763db5f
-  data.tar.gz: 681487eb34d5d79f090eb505966fda04406f917051b4bd5bd8fc0aa9df7d285b5dd7e5083ffc4bcd3f71d1f93b94c21fc1c8200f6c74aca1883baff2b80ac700
+  metadata.gz: 1fece35f80d41bd49dae18befac98c67b57a342c010d91fd6b5999daf433bd112cf65eaf22b352a924b82a2f87fbd129394fddde8c7700cdbe79f31aa5274e89
+  data.tar.gz: fde494ec4d17db0a0001a27db0ec2c2ebb428fef7e791aff597436b59298cef3a64f235bee9d33701e866ea9cae673e0ebaf2954c347ec33b622420a815eb8bf

data/lib/realm-core.rb

@@ -0,0 +1,11 @@
+# rubocop:disable Naming/FileName
+# frozen_string_literal: true
+
+require 'realm'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore(__FILE__)
+loader.setup
+
+# rubocop:enable Naming/FileName

data/lib/realm.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+
+module Realm
+  class << self
+    # Setup realm in test/console
+    def setup(root_module, **options)
+      config = Realm::Config.new(root_module: root_module, **options)
+      Realm::Builder.setup(config)
+    end
+
+    # Bind realm in service/engine
+    def bind(root_module, **options)
+      setup(root_module, **options).tap do |builder|
+        root_module.define_singleton_method(:realm) { builder.runtime }
+      end
+    end
+  end
+end

data/lib/realm/action_handler.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'dry-validation'
+require 'active_support/core_ext/module/delegation'
+require 'realm/error'
+require 'realm/mixins/context_injection'
+require 'realm/mixins/repository_helper'
+require 'realm/mixins/aggregate_member'
+require_relative 'action_handler/result'
+
+module Realm
+  class ActionHandler
+    extend Mixins::ContextInjection::ClassMethods
+    include Mixins::AggregateMember
+    include Mixins::RepositoryHelper
+
+    class << self
+      attr_reader :contracts
+
+      def call(action: :handle, params: {}, runtime: nil)
+        new(runtime: runtime).(action: action, params: params)
+      end
+
+      protected
+
+      def require_permission(*names)
+        # TODO: implement
+      end
+
+      def contract(&block)
+        @method_contract = Class.new(Dry::Validation::Contract, &block).new
+      end
+
+      def contract_schema(&block)
+        contract { schema(&block) }
+      end
+
+      def contract_params(&block)
+        contract { params(&block) }
+      end
+
+      def contract_json(&block)
+        contract { json(&block) }
+      end
+
+      def method_added(method_name)
+        super
+        return unless defined?(@method_contract)
+
+        @contracts ||= {}
+        @contracts[method_name] = @method_contract
+        remove_instance_variable(:@method_contract)
+      end
+    end
+
+    def initialize(runtime: nil)
+      @runtime = runtime
+    end
+
+    def call(action: :handle, params: {})
+      # TODO: check permissions
+      raise CannotHandleAction.new(self, action) unless respond_to?(action)
+
+      safe_params = validate(action, params.to_h)
+      send(action, **safe_params)
+    end
+
+    protected
+
+    delegate :context, to: :@runtime
+
+    private
+
+    def validate(action, params)
+      contract = self.class.contracts && self.class.contracts[action]
+      return params unless contract
+
+      result = contract.(params)
+      raise Realm::InvalidParams, result if result.failure?
+
+      result.to_h
+    end
+  end
+end

data/lib/realm/action_handler/result.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Realm
+  class ActionHandler
+    # Tuple of label and value
+    class Result < Array
+      def self.[](first, second = nil)
+        return new(first, second).freeze if first.is_a?(Symbol) || first.is_a?(Realm::Event)
+
+        new(second || :ok, first).freeze
+      end
+
+      def label
+        self[0]
+      end
+
+      def event
+        label if label.is_a?(Realm::Event)
+      end
+
+      def value
+        self[1]
+      end
+
+      private
+
+      def initialize(label, value)
+        super([label, value])
+      end
+    end
+  end
+end

data/lib/realm/builder.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Realm
+  class Builder
+    def self.setup(config)
+      new(config).setup
+    end
+
+    def initialize(config)
+      @config = config
+    end
+
+    def setup
+      logger.info("Setting up #{cfg.root_module} realm")
+      register_domain_resolver
+      register_event_router
+      register_runtime
+      register_logger
+      register_dependencies
+      setup_plugins
+      config_persistence
+      self
+    end
+
+    def runtime
+      @container.resolve(Runtime)
+    end
+
+    private
+
+    def register_domain_resolver
+      container.register_factory(DomainResolver, constantize(cfg.domain_module))
+    end
+
+    def register_event_router
+      return if cfg.event_gateways.empty?
+
+      container.register_factory(EventRouter, cfg.event_gateways, prefix: cfg.prefix)
+    end
+
+    def register_runtime
+      container.register_factory(Runtime, container)
+    end
+
+    def register_logger
+      container.register(:logger, logger)
+    end
+
+    def register_dependencies
+      container.register_all(**cfg.dependencies)
+    end
+
+    def setup_plugins
+      Plugin.descendants.each do |plugin|
+        plugin.setup(cfg, container) if cfg.plugins.include?(plugin.plugin_name)
+      end
+    end
+
+    def config_persistence
+      return unless cfg.persistence_gateway.present?
+
+      Persistence.setup(container, cfg.persistence_gateway[:repositories])
+    end
+
+    def constantize(*parts)
+      return parts[0] unless parts[0].is_a?(String)
+
+      parts.join('::').safe_constantize
+    end
+
+    def cfg
+      @config
+    end
+
+    def container
+      @container ||= Container.new
+    end
+
+    def logger
+      @logger ||= cfg.logger || (defined?(Rails) && Rails.logger) ||
+                  Logger.new($stdout, level: ENV.fetch('LOG_LEVEL', :info).to_sym)
+    end
+  end
+end

data/lib/realm/command_handler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Realm
+  class CommandHandler < Realm::ActionHandler
+    include Mixins::Reactive
+
+    def call(*)
+      gateway = context[:rom]&.gateways&.dig(:default)
+      gateway ? gateway.transaction { super } : super
+    end
+
+    protected
+
+    def result(first, second = nil)
+      Result[first, second]
+    end
+  end
+end

data/lib/realm/config.rb

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'dry-container'
+
+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

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

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